src/ppu/communication/moc_issend_ppu.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.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_core_ppu.h>

int MOC_ISsend(void* buf, int count, MOC_Datatype datatype, int dest, int tag,
        MOC_Comm comm, MOC_Request *request)
    {
    int queue_index, msg_id, bytecount, err;
    moc_message_envelope_t queue_copy[node_handle.queue_size] __attribute__((__aligned__(16)));

    uint32_t dmastatus;

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

    request->request_data.issend_request.isFinished = 1;
    request->request_type = MOC_REQ_TYPE_ISSEND;
    request->request_data.issend_request.source = node_handle.rank;
    request->request_data.issend_request.tag = tag;
    request->request_data.issend_request.message_size = bytecount;

    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), queue_copy, 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(queue_copy, (void*) IMOC_EA_REMOTE_QUEUE(dest),
                node_handle.queue_size * sizeof(moc_message_envelope_t));
        }

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

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

    /* small messages are directly sent instead of their address */
    if (bytecount <= 8)
        {
        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
        {
        IMOC_TEST_ALIGNMENT(buf)
        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 = 1;
        queue_copy[queue_index].message_address = (uint64_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 = 1;

    /* 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;

    request->request_data.issend_request.isFinished = 0;
    request->request_data.issend_request.mid = msg_id;

    /* write message-envelope into queue, because transfer-size is always 16-byte,
     * memcpy is fastest method */
    memcpy((void*) IMOC_EA_REMOTE_QUEUE_ENTRY(dest, queue_index),
            &queue_copy[queue_index], sizeof(moc_message_envelope_t));

    return MOC_SUCCESS;
    }

---