src/ppu/communication/moc_recv_ppu.c

Go to the documentation of this file.

#include <string.h>
#include <stdio.h>

#include <moc.h>
#include <ppu/moc_datatype_ppu.h>
#include <internal/imoc.h>
#include <internal/ppu/imoc_macros_ppu.h>
#include <internal/ppu/imoc_dma_ppu.h>
#include <internal/ppu/imoc_core_ppu.h>

int MOC_Recv(void* buf, int count, MOC_Datatype datatype, int source, int tag,
        MOC_Comm comm, MOC_Status *status)
    {

    moc_message_envelope_t* sourceQueueEntry;
    moc_message_status_t sourceMessageStatus __attribute__((__aligned__(16)));
    int bytecount, err;

    err = 0;
    if (((datatype & 0xF0) >> 4) == 0)
        bytecount = count;
    else
        bytecount = count * (((datatype & 0xF0) >> 4) * 2);

    status->MOC_SOURCE = source;
    status->message_size = bytecount;

    IMOC_TEST_PROC_NULL(source)
    IMOC_TEST_PROC_SELF(source)
    IMOC_TEST_BYTECOUNT(bytecount)
    // if there is no data, permit Null-Buffer-Pointer
    if (bytecount != 0)
        {
        IMOC_TEST_BUFFER(buf)
        }
    IMOC_TEST_RANK_RECV(source)
    IMOC_TEST_TAG_RECV(tag)
    IMOC_TEST_COMM_RECV(comm)

    /*looking for data to receive*/
    sourceQueueEntry = NULL;
    while (sourceQueueEntry == NULL)
        {
        sourceQueueEntry = IMOC_get_entry(source, tag, comm, 0, status);
        }
    /*set status MOC_TAG and mid*/
    status->MOC_TAG = tag;
    status->mid = sourceQueueEntry->id;

    /*check if datatype from send and recv is the same*/
    if (sourceQueueEntry->datatype != datatype && sourceQueueEntry->datatype
            !=MOC_BYTE && datatype != MOC_BYTE)
        {
        status->MOC_ERROR = MOC_ERR_TYPE;
        return MOC_ERR_TYPE;
        }

    /*check if the data is in the envelope or if data has to be loaded with dma*/
    if (sourceQueueEntry->flags.bits.channel == IMOC_MESSAGE_CHANNEL_ENV)
        {
        /*get data from envelope*/
        memcpy(buf, (void*) &sourceQueueEntry->message_address, (bytecount
                < sourceQueueEntry->size) ? bytecount : sourceQueueEntry->size);
        }
    else
        if (sourceQueueEntry->flags.bits.channel == IMOC_MESSAGE_CHANNEL_DMA)
            {
            /*lookup if data is in memory*/
            if (sourceQueueEntry->flags.bits.in_mm == 1)
                /*copy data from memory*/
                memcpy(buf, (void*) sourceQueueEntry->message_address,
                        bytecount);
            else
                {
                /*get data via IMOC_get_data*/
                uint32_t lsa =
                        sourceQueueEntry->message_address
                                - moc_spu_thread_list[source
                                        - moc_ppu_thread_count].ls_base;
                if (bytecount != 0)
                    {
                    IMOC_TEST_ALIGNMENT(buf)
                    }

                err = IMOC_get_data(buf, lsa, bytecount, source);
                if (err)
                    {
                    return err;
                    }
                }
            }
        else
            {
            /*an error occourred*/
            status->MOC_ERROR = MOC_ERR_INTERN;
            return MOC_ERR_INTERN;
            }
    /* look if send needs answer*/
    if (sourceQueueEntry->flags.bits.signal_back == 1)
        {
        /*set message status*/
        sourceMessageStatus.buffer_offset = 0;
        sourceMessageStatus.flags.value = 0;
        if (sourceQueueEntry->flags.bits.keep_valid)
            sourceMessageStatus.flags.bits.valid = 1;

        /*send back message_status, because transfer-size is always 16-byte,
         * memcpy is fastest method */
        memcpy(
                (void*) IMOC_EA_REMOTE_STATUS_ENTRY(sourceQueueEntry->id,status->MOC_SOURCE),
                &sourceMessageStatus, sizeof(moc_message_status_t));
        }

    sourceQueueEntry->flags.value = 0;

    status->MOC_ERROR = 0;
    return 0;
    }

---