Virtual Data Processor (VDP) implementation. More...

#include "prt_vdp.h"

Include dependency graph for prt_vdp.c:

Functions
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)
	VDP constructor. More...

void	prt_vdp_delete (prt_vdp_t *vdp)
	VDP destructor Delete all local output channels. All local input channels are destroyed as output channels of other VDPs. More...

void	prt_vdp_channel_insert (prt_vdp_t vdp, prt_channel_t channel, prt_channel_direction_t direction, int slot)
	Insert a new channel into a VDP. More...

int	prt_vdp_ready (prt_vdp_t *vdp)
	Check if a VDP is ready to fire. Only checks established channels. (NULL channels don't prevent firing.) More...

Detailed Description

Virtual Data Processor (VDP) implementation.

Author: Jakub Kurzak

Definition in file prt_vdp.c.

Function Documentation

void prt_vdp_channel_insert	(	prt_vdp_t *	vdp,
		prt_channel_t *	channel,
		prt_channel_direction_t	direction,
		int	slot
	)

Insert a new channel into a VDP.

Parameters

vdp
channel
direction	direction of the channel
slot	slot number

Definition at line 119 of file prt_vdp.c.

References prt_channel_s::dst_tuple, prt_vdp_s::input, prt_vdp_s::output, prt_assert, prt_tuple_compare(), PrtInputChannel, PrtOutputChannel, prt_channel_s::src_tuple, prt_vdp_s::tuple, and prt_channel_s::vdp.

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

Here is the call graph for this function:

void prt_vdp_delete ( prt_vdp_t * vdp )

VDP destructor Delete all local output channels. All local input channels are destroyed as output channels of other VDPs.

Parameters

vdp

Definition at line 77 of file prt_vdp.c.

References prt_channel_s::dst_node, prt_vdp_s::input, prt_vdp_s::local_store, prt_vsa_s::node_rank, prt_vdp_s::num_inputs, prt_vdp_s::num_outputs, prt_vdp_s::output, prt_assert, prt_channel_delete(), prt_tuple_delete(), prt_vdp_s::thread, prt_vdp_s::tuple, prt_channel_s::vdp, and prt_thread_s::vsa.

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

Here is the call graph for this function:

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
	)

VDP constructor.

Parameters

tuple	VDP's unique identificator
counter	number of times to fire the VDP
function	function implementing VDP's actions
local_store_size	size of VDP's persistent local store in bytes
num_inputs	number of input channels
num_outputs	number of output channels

Returns: new VDP

Definition at line 26 of file prt_vdp.c.

References prt_vdp_s::color, prt_vdp_s::counter, prt_vdp_s::function, prt_vdp_s::input, prt_vdp_s::local_store, prt_vdp_s::num_inputs, prt_vdp_s::num_outputs, prt_vdp_s::output, prt_assert, prt_vdp_s::thread, and prt_vdp_s::tuple.

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

int prt_vdp_ready ( prt_vdp_t * vdp )

Check if a VDP is ready to fire. Only checks established channels. (NULL channels don't prevent firing.)

Parameters

vdp

Return values

0	not ready
1	ready

Definition at line 170 of file prt_vdp.c.

References prt_vdp_s::input, prt_vdp_s::num_inputs, prt_assert, and prt_channel_empty().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Detailed Description

Function Documentation