src/ppu/communication/moc_barrier_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_core_ppu.h>

#define IMOC_BARRIER_TAG        1

int MOC_Barrier(MOC_Comm comm)
    {
    moc_message_envelope_t tempQueue[node_handle.queue_size] __attribute__((__aligned__(16)));
    moc_message_envelope_t *sourceQueueEntry;
    MOC_Status status;
    int err, qindex;
    unsigned int dmastatus;

    //if (comm == MOC_COMM_SELF && node_handle.rank == node_handle.comm_size - 1)
    if (comm == MOC_COMM_SELF)
        return 0;
    else
        if (comm != MOC_COMM_WORLD)
            return MOC_ERR_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[node_handle.comm_size - 1
                - moc_ppu_thread_count].speid, IMOC_LS_REMOTE_QUEUE(
                node_handle.comm_size - 1), 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[node_handle.comm_size - 1
                        - moc_ppu_thread_count].speid, 0, SPE_TAG_ALL,
                &dmastatus);
        if (err)
            return MOC_ERR_INTERN;
        }
    else
        {
        memcpy(tempQueue, (void*) IMOC_EA_REMOTE_QUEUE(node_handle.comm_size
                - 1), node_handle.queue_size * sizeof(moc_message_envelope_t));
        }

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

    tempQueue[qindex].communicator = comm;
    tempQueue[qindex].flags.bits.special = 1;
    tempQueue[qindex].flags.bits.valid = 1;
    tempQueue[qindex].tag = IMOC_BARRIER_TAG;

    /* write message-envelope into queue, because transfer-size is always 16-byte,
     * memcpy is fastest method */
    memcpy((void*) IMOC_EA_REMOTE_QUEUE_ENTRY(node_handle.comm_size - 1,
            qindex), &tempQueue[qindex], sizeof(moc_message_envelope_t));

    //look up if there is data here
    sourceQueueEntry = 0;
    while (sourceQueueEntry == 0)
        {
        sourceQueueEntry = IMOC_get_entry(node_handle.comm_size - 1,
                IMOC_BARRIER_TAG, comm, 1, &status);
        }
    sourceQueueEntry->flags.value = 0;

    return 0;
    }

---