src/spu/communication/moc_barrier_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_core_spu.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;
    unsigned int tag_id;
    int err, qindex;

    if (comm == MOC_COMM_SELF)
        return 0;

    if (node_handle.rank == node_handle.comm_size - 1)
        {
        int t;
        for (t = 0; t < node_handle.comm_size - 1; t++)
            {
            //look up if there is data here
            sourceQueueEntry = 0;
            while (sourceQueueEntry == 0)
                {
                sourceQueueEntry = IMOC_get_entry(t, IMOC_BARRIER_TAG, comm, 1,
                        &status);
                }
            sourceQueueEntry->flags.value = 0;
            }
        for (t = 0; t < node_handle.comm_size - 1; t++)
            {
            /* 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(t), 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, 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 */
            if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
                return MOC_ERR_INTERN;
            mfc_put(&tempQueue[qindex], IMOC_EA_REMOTE_QUEUE_ENTRY(t, 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);
            }
        }
    else
        {
        /* 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(node_handle.comm_size - 1),
                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, 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 */
        if ((tag_id = mfc_tag_reserve()) == MFC_TAG_INVALID)
            return MOC_ERR_INTERN;
        mfc_put(&tempQueue[qindex],
                IMOC_EA_REMOTE_QUEUE_ENTRY(node_handle.comm_size - 1, 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);

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

---