src/ppu/communication/moc_bsend_ppu.c

Go to the documentation of this file.

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

#include <moc.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_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 dmastatus;
    void* 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, choose fastest method depending on transfer-size */
    if (node_handle.queue_size * sizeof(moc_message_envelope_t)
            > MEMCPY_GET_TRESHOLD)
        {
        err = spe_mfcio_put(
                moc_spu_thread_list[dest - moc_ppu_thread_count].speid,
                IMOC_LS_REMOTE_QUEUE(dest), tempQueue, node_handle.queue_size
                        * sizeof(moc_message_envelope_t), 15, 0, 0);
        if (err)
            return MOC_ERR_INTERN;
        err = spe_mfcio_tag_status_read(moc_spu_thread_list[dest
                - moc_ppu_thread_count].speid, 0, SPE_TAG_ALL, &dmastatus);
        if (err)
            return MOC_ERR_INTERN;
        }
    else
        {
        memcpy(tempQueue, (void*) IMOC_EA_REMOTE_QUEUE(dest),
                node_handle.queue_size * sizeof(moc_message_envelope_t));
        }

    /* 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 */
        {
        IMOC_TEST_ALIGNMENT(buf)
        /* search free message-ID */
        err = IMOC_getFreeMID(&mid);
        if (err)
            return err;

        /* search free buffer-space */
        ea_buffer = (void*) IMOC_bmalloc(bytecount, mid);
        if (!ea_buffer)
            return MOC_ERR_NO_BUFFER;

        tempQueue[qindex].flags.bits.channel = IMOC_MESSAGE_CHANNEL_DMA;
        tempQueue[qindex].flags.bits.signal_back = 1;
        tempQueue[qindex].flags.bits.in_mm = 1;
        tempQueue[qindex].message_address = (uint64_t) ea_buffer;
        /* copy data into buffer */
        memcpy(ea_buffer, buf, bytecount);

        /* 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, because transfer-size is always 16-byte,
     * memcpy is fastest method */
    memcpy((void*) IMOC_EA_REMOTE_QUEUE_ENTRY(dest, qindex),
            &tempQueue[qindex], sizeof(moc_message_envelope_t));

    return 0;
    }

---