src/spu/communication/moc_bsend_spu.c

Go to the documentation of this file.

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

#include <moc.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_Bsend(void* buf, int count, MOC_Datatype datatype, int dest, int tag,
        MOC_Comm comm)
    {
    moc_message_envelope_t tempQueue[node_handle.queue_size] __attribute__((__aligned__(16)));
    int err, qindex, mid, bytecount;
    unsigned int tag_id;
    uint64_t ea_buffer;

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

    IMOC_TEST_PROC_NULL(dest)
    IMOC_TEST_PROC_SELF(dest)
    IMOC_TEST_BYTECOUNT(bytecount)
    // if there is no data, permit Null-Buffer-Pointer
    if (bytecount != 0)
        {
        IMOC_TEST_BUFFER(buf)
        }
    IMOC_TEST_RANK(dest)
    IMOC_TEST_TAG_SEND(tag)
    IMOC_TEST_COMM_SEND(comm)

    /* Get queue from remote-node */
    if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
        return MOC_ERR_INTERN;
    mfc_get(tempQueue, IMOC_EA_REMOTE_QUEUE(dest), node_handle.queue_size
            * sizeof(moc_message_envelope_t), tag_id, 0, 0);
    mfc_write_tag_mask(1 << tag_id);
    mfc_read_tag_status_all();
    mfc_tag_release(tag_id);

    /* search free entry in message-queue */
    err = IMOC_getFreeEntry(tempQueue, tag, comm, 0, &qindex);
    if (err)
        return err;

    /* messages smaller-equal 8 bytes are stored directly into the message-envelope
     instead of the data's effective address */
    if (bytecount <= 8)
        {
        tempQueue[qindex].flags.bits.channel = IMOC_MESSAGE_CHANNEL_ENV;
        tempQueue[qindex].flags.bits.signal_back = 0;
        tempQueue[qindex].flags.bits.in_mm = 0;
        memcpy(&tempQueue[qindex].message_address, buf, bytecount);
        }
    else /* normal delivery of messages */
        {
        uint32_t buffer_padding = 16 - (bytecount % 16);
        IMOC_TEST_ALIGNMENT(buf)
        if (buffer_padding == 16)
            buffer_padding = 0;

        /* search free message-ID */
        err = IMOC_getFreeMID(&mid);
        if (err)
            return err;

        /* search free buffer-space (buffer padded to be a multiple of 16) */
        ea_buffer = IMOC_bmalloc(bytecount + buffer_padding, mid);
        if (!ea_buffer)
            return MOC_ERR_NO_BUFFER;

        tempQueue[qindex].flags.bits.channel = IMOC_MESSAGE_CHANNEL_DMA;
        tempQueue[qindex].flags.bits.in_mm = 1;
        tempQueue[qindex].flags.bits.signal_back = 1;
        tempQueue[qindex].message_address = ea_buffer;

        /* copy data into buffer */
        IMOC_put_data(buf, ea_buffer, bytecount + buffer_padding);

        /* fill message-status-entry */
        node_handle.status_array_base[mid].flags.bits.valid = 1;
        node_handle.status_array_base[mid].flags.bits.outstanding = 1;
        }

    /* fill missing message-envelope-entries */
    tempQueue[qindex].communicator = comm;
    tempQueue[qindex].datatype = datatype;
    tempQueue[qindex].id = mid;
    tempQueue[qindex].size = bytecount;
    tempQueue[qindex].tag = tag;
    tempQueue[qindex].flags.bits.collaborative = 0;
    tempQueue[qindex].flags.bits.special = 0;
    tempQueue[qindex].flags.bits.valid = 1;
    tempQueue[qindex].flags.bits.keep_valid = 0;

    /* write message-envelope into queue */
    if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
        return MOC_ERR_INTERN;
    mfc_put(&tempQueue[qindex], IMOC_EA_REMOTE_QUEUE_ENTRY(dest, qindex),
            sizeof(moc_message_envelope_t), tag_id, 0, 0);
    mfc_write_tag_mask(1 << tag_id);
    mfc_read_tag_status_all();
    mfc_tag_release(tag_id);

    return 0;
    }

---