src/spu/communication/moc_recv_spu.c

Go to the documentation of this file.

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

#include <moc.h>
#include <spu/moc_datatype_spu.h>
#include <internal/imoc.h>
#include <internal/imoc_macros.h>
#include <internal/spu/imoc_dma_spu.h>
#include <internal/spu/imoc_core_spu.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)));
    unsigned int tag_id;
    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, &sourceQueueEntry->message_address, (bytecount
                < sourceQueueEntry->size) ? bytecount : sourceQueueEntry->size);
        }
    else
        if (sourceQueueEntry->flags.bits.channel == IMOC_MESSAGE_CHANNEL_DMA)
            {
            if (bytecount != 0)
                {
                IMOC_TEST_ALIGNMENT(buf)
                }
            /*get data with dma*/
            err = IMOC_get_data(buf, sourceQueueEntry->message_address,
                    bytecount);
            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*/
        if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
            return MOC_ERR_INTERN;
        mfc_put(
                &sourceMessageStatus,
                IMOC_EA_REMOTE_STATUS_ENTRY(sourceQueueEntry->id,status->MOC_SOURCE),
                sizeof(moc_message_status_t), tag_id, 0, 0);
        mfc_write_tag_mask(1 << tag_id);
        mfc_read_tag_status_all();
        mfc_tag_release(tag_id);

        }
    sourceQueueEntry->flags.value = 0;

    status->MOC_ERROR = 0;
    return 0;
    }

---