src/spu/communication/moc_ssend_spu.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.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_Ssend(void* buf, int count, MOC_Datatype datatype, int dest, int tag,
        MOC_Comm comm)
    {
    int queue_index, msg_id, bytecount, err;
    moc_message_envelope_t queue_copy[node_handle.queue_size] __attribute__((__aligned__(16)));

    uint32_t tag_id;

    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)
        if (bytecount > 16)
            IMOC_TEST_ALIGNMENT(buf)
        }
    IMOC_TEST_RANK(dest)
    IMOC_TEST_TAG_SEND(tag)
    IMOC_TEST_COMM_SEND(comm)

    if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
        {
        return MOC_ERR_INTERN;
        }

    mfc_get(queue_copy, IMOC_EA_REMOTE_QUEUE(dest),
            sizeof(moc_message_envelope_t) * node_handle.queue_size, tag_id, 0,
            0);
    mfc_write_tag_mask(1 << tag_id);
    mfc_read_tag_status_all();

    err = IMOC_getFreeEntry(queue_copy, tag, comm, 0, &queue_index);
    if (err)
        return err;

    err = IMOC_getFreeMID(&msg_id);
    if (err)
        return err;

    /* small messages are directly sent instead of their address */
    if (bytecount <= 8)
        {
        //printf("SPU: sending in message-envelope\n");
        queue_copy[queue_index].flags.bits.channel = IMOC_MESSAGE_CHANNEL_ENV;
        // synchronous send waits till the message has been received (meaning
        // recv has copied the message), so we need a signal-back.
        queue_copy[queue_index].flags.bits.signal_back = 1;
        queue_copy[queue_index].flags.bits.in_mm = 0;
        memcpy(&queue_copy[queue_index].message_address, buf, bytecount);
        }
    else
        {
        queue_copy[queue_index].flags.bits.channel = IMOC_MESSAGE_CHANNEL_DMA;
        queue_copy[queue_index].flags.bits.signal_back = 1;
        queue_copy[queue_index].flags.bits.in_mm = 0;
        queue_copy[queue_index].message_address = node_handle.ls_base
                + (uint32_t) buf;
        }

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

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

    mfc_put(&queue_copy[queue_index], IMOC_EA_REMOTE_QUEUE_ENTRY(dest,
            queue_index), 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);

    IMOC_waitForMessageCompletion(msg_id);
    return MOC_SUCCESS;
    }

---