/*****************************************************************************
* setup_pkt_channels
*****************************************************************************/
int setup_pkt_channels(int task_id)
{
mcapi_status_t status;
mcapi_request_t request;
size_t dummy;
/* create/ get endpoints */
if (setup_echo_endpoints(task_id) != 0) {
return -1;
}
/* connect the write channel only */
mcapi_pktchan_connect_i(local_endpts[task_id].endpts[WRITE_IDX],
remote_endpts[task_id],
&request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize (1): %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &dummy, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize (2): %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* open the write channel */
mcapi_pktchan_send_open_i(&(pkt_hndls[task_id].send),
local_endpts[task_id].endpts[WRITE_IDX],
&request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize (3) : %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &dummy, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize (4) : %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* open the read channel */
/* the read channel may not yet be connected */
mcapi_pktchan_recv_open_i(&(pkt_hndls[task_id].recv),
local_endpts[task_id].endpts[READ_IDX],
&request, &status);
mcapi_wait(&request, &dummy, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize (5) : %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
return 0;
}
/*****************************************************************************
* read_mcapi_pkt_a
*****************************************************************************/
int read_mcapi_pkt_a(int index, char* buf, int buf_size)
{
mcapi_status_t status;
mcapi_request_t request;
size_t pktsize = 0;
char* tmpbuf;
mcapi_pktchan_recv_i(pkt_hndls[index].recv, (void**)((void*)&tmpbuf), &request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to recv pkt (recv): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &pktsize, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to recv pkt (wait): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
} else {
strncpy(buf, tmpbuf, pktsize);
mcapi_pktchan_release((void *)tmpbuf, &status);
if (status != MCAPI_SUCCESS){
th_log_error("Task id %d failed to free a buffer: %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
}
return (int) pktsize;
}
/*****************************************************************************
* write_mcapi_pkt_a
*****************************************************************************/
int write_mcapi_pkt_a(int index, char* buf, int write_size)
{
mcapi_status_t status;
mcapi_request_t request;
size_t pktsize = 0;
mcapi_pktchan_send_i(pkt_hndls[index].send, buf, write_size, &request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to send pkt (send): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &pktsize, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to send pkt (wait): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
return (int) pktsize;
}
void sender(mcapi_endpoint_t send_endpt,mcapi_endpoint_t recv_endpt,int start,int end)
{
int i;
size_t size;
mcapi_priority_t priority = 1;
for (i=start; i <= end; i++) {
sprintf(send_requests[i].buffer,"Sending: %d",i);
send_requests[i].size=strlen(send_requests[i].buffer);
if (start > 0) {printf ("sent: index=%i data=%s **",i,send_requests[i].buffer);}
send_requests[i].status = MCAPI_ERR_MEM_LIMIT;
// retry if we run out of memory/buffer entries
while ( send_requests[i].status == MCAPI_ERR_MEM_LIMIT) {
do {
mcapi_msg_send_i(send_endpt,recv_endpt,send_requests[i].buffer,send_requests[i].size,priority, &send_requests[i].request,&send_requests[i].status);
//retry if all request handles are in-use
} while (send_requests[i].status == MCAPI_ERR_REQUEST_LIMIT);
mcapi_wait(&send_requests[i].request,&size,0xffff,&send_requests[i].status);
if (send_requests[i].status != MCAPI_SUCCESS) {
fprintf(stderr, "sender ERROR: status=%s\n",mcapi_display_status(send_requests[i].status,status_buff,sizeof(status_buff)));
}
}
}
}
/*****************************************************************************
* read_mcapi_msg_a
*****************************************************************************/
int read_mcapi_msg_a(int index, char* buf, int buf_size)
{
mcapi_status_t status;
mcapi_request_t request;
size_t msgsize = 0;
mcapi_msg_recv_i(local_endpts[index].endpts[READ_IDX],
(void *) buf, buf_size, &request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to recv msg (recv): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &msgsize, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to recv msg (wait): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
return (int) msgsize;
}
/*****************************************************************************
* write_mcapi_msg_a
*****************************************************************************/
int write_mcapi_msg_a(int index, char* buf, int write_size)
{
mcapi_status_t status;
mcapi_request_t request;
size_t msgsize = 0;
mcapi_priority_t priority = 1;
mcapi_msg_send_i(local_endpts[index].endpts[WRITE_IDX],
remote_endpts[index], buf, write_size, priority,&request, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to send msg (send): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
mcapi_wait(&request, &msgsize, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to send msg (wait): %s\n",
index, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
return (int) msgsize;
}
int main(int argc, char** argv)
{
mcapi_endpoint_t recv_endpt;
mcapi_endpoint_t send_endpt;
mca_status_t status;
mcapi_request_t request;
int i;
mcapi_sclchan_recv_hndl_t recv_handle; /* r1 = ep1->ep2 */
mcapi_sclchan_send_hndl_t send_handle; /* r1 = ep1->ep2 */
size_t size;
mcapi_param_t parms;
mcapi_info_t version;
mcapi_set_debug_level(6);
/* create a node */
mcapi_initialize(DOMAIN,NODE,NULL,&parms,&version,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to initialize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* create the endpoints */
send_endpt = mcapi_endpoint_create(1,&status);
recv_endpt = mcapi_endpoint_create(2,&status);
/* connect the channel */
/* connect the channel */
do {
mcapi_sclchan_connect_i(send_endpt,recv_endpt,&request,&status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
mcapi_wait(&request,&size,TIMEOUT,&status);
if (status == MCAPI_ERR_CHAN_CONNECTED) {
fprintf(stderr,"\nokay, already connected: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
}
else if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to connect: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
fail();
}
/* open the endpoint handles */
do {
mcapi_sclchan_send_open_i(&send_handle /*send_handle*/,send_endpt, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
mcapi_wait(&request,&size,TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to open send handle: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
fail();
}
do {
mcapi_sclchan_recv_open_i(&recv_handle /*recv_handle*/,recv_endpt, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
mcapi_wait(&request,&size,TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to open recv handle: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
fail();
}
/* issue sends */
for (i = 0; i < MCAPI_MAX_QUEUE_ELEMENTS; i++) {
if (!sender(send_handle,MCAPI_SUCCESS)) {
fail();
}
}
/* queue should be full */
if (!sender(send_handle,MCAPI_ERR_MEM_LIMIT)) {
fail();
}
/* issue receives */
for (i = 0; i < MCAPI_MAX_QUEUE_ELEMENTS; i++) {
if (!receiver(recv_handle,MCAPI_SUCCESS)) {
fail();
}
}
/* check results */
if (! check_results()) {
fail();
}
/* close handles */
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
fail();
}
printf(" Test PASSED\n");
return 0;
}
int main(int argc, char *argv[])
{
//the endpoints used in message-oriented communication
mcapi_endpoint_t red_msg_point;
mcapi_endpoint_t yellow_msg_point;
mcapi_endpoint_t green_msg_point;
//the endpoints used in channel-oriented communication
mcapi_endpoint_t yellow_sin_chan;
mcapi_endpoint_t yellow_cos_chan;
mcapi_endpoint_t yellow_pkt_chan;
//status message received in almost all MCAPI-calls
mcapi_status_t status;
//info-struct received in initialization
mcapi_info_t info;
//buffer for incoming messages
char recv_buf[MAX_MSG_LEN];
//the status code converted to string
char status_msg[MCAPI_MAX_STATUS_MSG_LEN];
//size parameter required in some calls
size_t size = 1;
//an iterator used in loops
unsigned int i = 0;
//request handle is used to operate wait-calls
mcapi_request_t request;
//a second request handle! just so that we see it works :)
mcapi_request_t request2;
//sandles used in channel-messaging
mcapi_sclchan_recv_hndl_t sin_handle;
mcapi_sclchan_recv_hndl_t cos_handle;
mcapi_pktchan_send_hndl_t pkt_handle;
//how many scalars we are expecting
char count = 0;
//buffer of data sent in messages
unsigned char* send_buf;
printf(COLOR "here\n");
//We are yellow! initialize accordingly
mcapi_initialize( THE_DOMAIN, YELLOW_NODE, 0, 0, &info, &status );
check( MCAPI_SUCCESS, status );
//create our side of messaging
yellow_msg_point = mcapi_endpoint_create( YELLOW_MSG, &status );
check( MCAPI_SUCCESS, status );
//obtain the red message point
red_msg_point = mcapi_endpoint_get( THE_DOMAIN,
RED_NODE, RED_MSG, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "start-up messaging\n");
//wait for the amount to come
mcapi_msg_recv( yellow_msg_point, recv_buf, MAX_MSG_LEN, &size,
&status );
check( MCAPI_SUCCESS, status );
//read the count from first byte
count = recv_buf[0];
//surprise! this process reserves the buffer with malloc
send_buf = (char*)malloc(count*2);
//send ack
send_buf[0] = 'a';
mcapi_msg_send( yellow_msg_point, red_msg_point, send_buf, 1,
0, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "start-up messaged with %u bytes. expecting %u scalars\n",
size, count );
//open our channel endpoint to sin
yellow_sin_chan = mcapi_endpoint_create( YELLOW_SIN, &status );
check( MCAPI_SUCCESS, status );
//open our channel endpoint to cos
yellow_cos_chan = mcapi_endpoint_create( YELLOW_COS, &status );
check( MCAPI_SUCCESS, status );
//open our ends, let senders form connection
mcapi_sclchan_recv_open_i( &sin_handle, yellow_sin_chan, &request,
&status );
check( MCAPI_PENDING, status );
mcapi_sclchan_recv_open_i( &cos_handle, yellow_cos_chan, &request2,
&status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
mcapi_wait( &request2, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "beginning the receive value\n");
for ( i = 0; i < 15000; ++i )
{
//an iterator used in loops
unsigned int j = 0;
//start to receveive stuff
//i+=2 because our values are two bytes while buf is one byte
for ( j = 0; j < count; ++j )
{
//receive cos scalar
short cval = mcapi_sclchan_recv_uint16( cos_handle, &status );
check( MCAPI_SUCCESS, status );
//receive sin scalar
short sval = mcapi_sclchan_recv_uint16( sin_handle, &status );
check( MCAPI_SUCCESS, status );
//addition
short sumval = sval + cval;
//put to buf
send_buf[j*2] = sumval;
send_buf[j*2+1] = sumval >> 8;
//printf( COLOR "%hX %hhX %hhX\n", sumval, send_buf[j*2],
//send_buf[j*2+1] );
}
}
printf(COLOR "receiving done, closing scalar channels\n");
//close our ends
mcapi_sclchan_recv_close_i( sin_handle, &request, &status );
check( MCAPI_PENDING, status );
mcapi_sclchan_recv_close_i( cos_handle, &request2, &status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
mcapi_wait( &request2, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "closed, informing green\n");
//obtain their endpoint
green_msg_point = mcapi_endpoint_get( THE_DOMAIN,
GREEN_NODE, GREEN_MSG, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//send the message
mcapi_msg_send( yellow_msg_point, green_msg_point, send_buf, 1,
0, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "informed, opening packet channel\n");
//open our channel endpoint to green
yellow_pkt_chan = mcapi_endpoint_create( YELLOW_PKT, &status );
check( MCAPI_SUCCESS, status );
//open our end, let receiver form connection
mcapi_pktchan_send_open_i( &pkt_handle, yellow_pkt_chan, &request,
&status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//now send
printf(COLOR "sending the packet\n");
mcapi_pktchan_send( pkt_handle, send_buf, count, &status );
//and now close
printf(COLOR "sent the packet, closing\n");
mcapi_pktchan_send_close_i( pkt_handle, &request, &status );
check( MCAPI_PENDING, status );
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "closed, shutdown\n");
//free buf
free( send_buf );
//shut-down
mcapi_finalize( &status );
check( MCAPI_SUCCESS, status );
return EXIT_SUCCESS;
}
int main()
{
//status message received in almost all MCAPI-calls
mcapi_status_t status;
//info-struct received in initialization
mcapi_info_t info;
//the status code converted to string
char status_msg[MCAPI_MAX_STATUS_MSG_LEN];
//an iterator used in loops
unsigned int i = 0;
//request handle is used to operate wait-calls
mcapi_request_t request;
//size parameter required in some calls
size_t size = 1;
//send-handle used in channel-messaging
mcapi_pktchan_send_hndl_t handy;
//a separate receive buffer used for messages
char recv_msg[MAX_MSG_LEN];
//get our stuff here. tip: if signed were used, it bastardized the values
unsigned char* recv_buf;
//the endpoints used in channel-oriented communication
mcapi_endpoint_t green_chan;
mcapi_endpoint_t yellow_chan;
mcapi_endpoint_t green_msg_point;
printf( COLOR "here\n");
//we are the green
mcapi_initialize( THE_DOMAIN, GREEN_NODE, 0, 0, &info, &status );
check( MCAPI_SUCCESS, status );
//create our message endpoint
green_msg_point = mcapi_endpoint_create( GREEN_MSG, &status );
check( MCAPI_SUCCESS, status );
//wait for the start signal
mcapi_msg_recv(green_msg_point, recv_msg, MAX_MSG_LEN, &size,
&status );
check( MCAPI_SUCCESS, status );
printf(COLOR "signal received, starting to connect & open\n");
//create our channel message endpoint
green_chan = mcapi_endpoint_create( GREEN_PKT, &status );
check( MCAPI_SUCCESS, status );
//get their channel message endpoint
yellow_chan = mcapi_endpoint_get( THE_DOMAIN,
YELLOW_NODE, YELLOW_PKT, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//form the channel
mcapi_pktchan_connect_i( yellow_chan, green_chan, &request, &status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//open our end
mcapi_pktchan_recv_open_i( &handy, green_chan, &request, &status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "beginning the receive\n");
//start to receive our stuff
mcapi_pktchan_recv( handy, (void*)&recv_buf, &size, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "retrieval done, closing\n");
//close our end
mcapi_pktchan_recv_close_i( handy, &request, &status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "closed, go over the values\n");
//go through that stuff
//i+=2 because our values are two bytes while buf is one byte
for ( i = 0; i < size; i+=2 )
{
//reconstruct the short
short sumval = recv_buf[i+1] << 8 | recv_buf[i];
//printf( COLOR "%hX %hhX %hhX\n", sumval, recv_buf[i], recv_buf[i+1] );
}
printf(COLOR "buffer release and shut down\n");
//release
mcapi_pktchan_release( recv_buf, &status );
check( MCAPI_SUCCESS, status );
//finalize at the end, regardless of which process we are
mcapi_finalize( &status );
check( MCAPI_SUCCESS, status );
return EXIT_SUCCESS;
}
