prt_vdp.c

Go to the documentation of this file.

#include "prt_vdp.h"


prt_vdp_t* prt_vdp_new(
    int *tuple, int counter,
    prt_vdp_function_t function,
    size_t local_store_size,
    int num_inputs, int num_outputs, int color)
{
    // Allocate the VDP.
    prt_vdp_t *vdp = (prt_vdp_t*)malloc(sizeof(prt_vdp_t));
    prt_assert(vdp != NULL, "malloc failed");

    // Check parameters.
    prt_assert(tuple != NULL, "NULL tuple");
    prt_assert(function != NULL, "NULL function");
    prt_assert(counter > 0, "counter less or equal zero");

    // Initialize the VDP.
    vdp->thread = NULL;
    vdp->tuple = tuple;
    vdp->counter = counter;
    vdp->function = function;
    vdp->color = color;

    // Initialize input channels.
    vdp->num_inputs = num_inputs;
    if (vdp->num_inputs > 0) {
        vdp->input = (prt_channel_t**)calloc(vdp->num_inputs, sizeof(prt_channel_t*));
        prt_assert(vdp->input != NULL, "malloc failed");
    }
    // Initialize output channels.
    vdp->num_outputs = num_outputs;
    if (vdp->num_outputs > 0) {
        vdp->output = (prt_channel_t**)calloc(vdp->num_outputs, sizeof(prt_channel_t*));
        prt_assert(vdp->output != NULL, "malloc failed");
    }
    // Allocate local store.
    if (local_store_size > 0) {
        vdp->local_store = (void*)malloc(local_store_size);
        prt_assert(vdp->local_store != NULL, "malloc failed");
    }
    // Return the VDP.
    return vdp;
}


void prt_vdp_delete(prt_vdp_t *vdp)
{
    // Check for a NULL VDP.
    prt_assert(vdp != NULL, "NULL VDP");

    // Delete the tuple.
    prt_assert(vdp->tuple != NULL, "NULL tuple");
    prt_tuple_delete(vdp->tuple);

    int i;
    // Delete local output channels.
    for (i = 0; i < vdp->num_outputs; i++) {
        prt_channel_t *channel = vdp->output[i];
        if (channel != NULL)
            if (channel->dst_node == channel->vdp->thread->vsa->node_rank)
                prt_channel_delete(channel);
    }
    // Free array of inputs.
    if (vdp->num_inputs > 0)
        free(vdp->input);

    // Free array of outputs.
    if (vdp->num_outputs > 0)
        free(vdp->output);

    // Free local store.
    if (vdp->local_store != NULL)
        free(vdp->local_store);

    // Free the VDP.
    free(vdp);
}


void prt_vdp_channel_insert(
    prt_vdp_t *vdp, prt_channel_t *channel,
    prt_channel_direction_t direction, int slot)
{
    // Check input parameters.
    prt_assert(vdp != NULL, "inserting in a NULL VDP");
    prt_assert(channel != NULL, "inserting a NULL channel");
    prt_assert(direction == PrtInputChannel || direction == PrtOutputChannel,
        "wrong channel direction");

    if (direction == PrtInputChannel) {
        // Check if channel destination tuple equals VDP's tuple.
        int cmp = prt_tuple_compare(channel->dst_tuple, vdp->tuple);
        prt_assert(cmp == 0,
            "input channel destination tuple does not match VDP tuple");
        // Check if channel slot empty.
        prt_assert(vdp->input[slot] == NULL,
            "inserting channel in occupied input slot");
        // Check the slot.
        // Link the channel.
        prt_assert(slot >= 0 && slot < vdp->num_inputs, "slot out of range");
        vdp->input[slot] = channel;
        channel->vdp = vdp;
    }
    else {
        // Check if channel source tuple equals VDP's tuple.
        int cmp = prt_tuple_compare(channel->src_tuple, vdp->tuple);
        prt_assert(cmp == 0,
            "output channel source tuple does not match VDP tuple");
        // Check if channel slot empty.
        prt_assert(vdp->output[slot] == NULL,
            "inserting channel in occupied output slot");
        // Check the slot.
        // Link the channel.
        prt_assert(slot >= 0 && slot < vdp->num_outputs, "slot out of range");
        vdp->output[slot] = channel;
        channel->vdp = vdp;
    }
}


int prt_vdp_ready(prt_vdp_t *vdp)
{
    // Check for a NULL VDP.
    prt_assert(vdp != NULL, "NULL VDP");

    int i;
    // FOR each input channel.
    for (i = 0; i < vdp->num_inputs; i++)
        // IF the channel was established.
        if (vdp->input[i] != NULL)
            // IF the list of packets is empty.
            if (prt_channel_empty(vdp->input[i]))
                // Return "not ready".
                return 0;

    // Return "ready".
    return 1;
}