/**
* Create endpoints and connection for DSP
* @return MCAPI_SUCCESS/Error Code
*/
mcapi_status_t dsp_initialize(void) {
mcapi_status_t status = MCAPI_ERR_GENERAL;
/**
* Create end-point for data and command transfer
*/
dsp_command_endpoint = mcapi_endpoint_create(PORT_COMMAND, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
dsp_data_endpoint = mcapi_endpoint_create(PORT_DATA, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
dsp_data_send_endpoint = mcapi_endpoint_create(PORT_DATA_RECV, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
/**
* Get the remote endpoints for communication
*/
remote_data_recv_endpoint = mcapi_endpoint_get(DOMAIN, NODE_CORE_0,
PORT_DATA_RECV, MCAPI_TIMEOUT_INFINITE, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_get failure\n", __FILE__,
__LINE__, status);
exit(1);
}
#endif
dsp_data_endpoint = dsp_data_send_endpoint;
dsp_command_endpoint = dsp_data_send_endpoint;
return status;
}
void* second_thread(void* data)
{
mca_status_t mcapi_status;
mcapi_info_t mcapi_version;
mcapi_param_t parms;
int rc = 0;
/* do some MCAPI work */
printf("In thread 2, pid=%d\n",getpid());
mcapi_initialize(the_domain,
the_second_node,
NULL,&parms,
&mcapi_version,
&mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: thread 2 (pid %d) failed to initialize MCAPI: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return NULL;
}
printf("Thread 2 INITIALIZE DONE\n");
thread2_recv_endpt =
mcapi_endpoint_create(RECV_PORT, &mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: thread 2 (pid %d) failed to create recv endpoint: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return NULL;
}
printf("Thread 2 CREATE RECV ENDPT DONE\n");
thread2_send_endpt =
mcapi_endpoint_create(SEND_PORT, &mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: thread 2 (pid %d) failed to create send endpoint: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return NULL;
}
printf("Thread 2 CREATE SEND ENDPT DONE\n");
finalize(MCAPI_FALSE);
return NULL;
}
int do_main_thread(void)
{
mca_status_t mcapi_status;
mcapi_info_t mcapi_version;
mcapi_param_t parms;
int rc = 0;
printf("In main thread, pid=%d\n",getpid());
mcapi_initialize(the_domain,
the_main_node,
NULL,&parms,
&mcapi_version,
&mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: thread 2 (pid %d) failed to initialize MCAPI: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return rc;
}
printf("Main Thread INITIALIZE DONE\n");
main_recv_endpt =
mcapi_endpoint_create(RECV_PORT, &mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: main thread (pid %d) failed to create recv endpoint: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return rc;
}
printf("Main Thread CREATE RECV ENDPT DONE\n");
main_send_endpt =
mcapi_endpoint_create(SEND_PORT, &mcapi_status);
if (mcapi_status != MCAPI_SUCCESS) {
fprintf(stderr,"ERROR: main thread (pid %d) failed to create send endpoint: %s\n",
getpid(),mcapi_display_status(mcapi_status,status_buff,sizeof(status_buff)));
rc++; finalize(rc); return rc;
}
printf("Main Thread CREATE SEND ENDPT DONE\n");
finalize(rc);
return rc;
}
int main(void)
{
mcapi_endpoint_t recv_endpt;
mcapi_endpoint_t send_endpt;
mca_status_t status;
int rc;
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 fail;
}
/* create the endpoints */
send_endpt = mcapi_endpoint_create(1,&status);
recv_endpt = mcapi_endpoint_create(2,&status);
sender(send_endpt,recv_endpt,0,NUM_MSGS-1);
receiver(recv_endpt,0,NUM_MSGS-1);
receiver(recv_endpt,NUM_MSGS,(NUM_MSGS*2)-1);
sender(send_endpt,recv_endpt,NUM_MSGS,(NUM_MSGS*2)-1);
rc = check_results();
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
return fail;
}
if (rc == 0) { printf(" Test PASSED\n"); } else { printf(" Test FAILED\n"); }
return rc;
}
int main(int argc,char * argv[])
{
int process_num=sysconf(_SC_NPROCESSORS_CONF);
printf("%i processors() in KeyStoneII system.\n\r",process_num);
cpu_set_t mask;
int myid= atoi(argv[1]);
CPU_ZERO(&mask);
CPU_SET(myid,&mask);
if(sched_setaffinity(getpid(),sizeof(mask),&mask)==-1)
{
printf("Error: set CPU affinity failed.\n\r");
return 0;
}
printf("Set CPU affinity success!\n\r");
usleep(3000000);
if(CPU_ISSET(myid, &mask))
{
printf("RECV is running on Processor %i\n\r",myid);
}
usleep(3000000);
mcapi_status_t status;
mcapi_info_t info;
char status_msg[MCAPI_MAX_STATUS_MSG_LEN];
size_t received_size;
char recv_buf[BUFLEN]="";
mcapi_request_t request;
mcapi_endpoint_t recv_msg_point;
mcapi_initialize(THE_DOMAIN,YELLOW_NODE,0,0,&info,&status);
recv_msg_point=mcapi_endpoint_create(YELLOW_MSG,&status);
mcapi_msg_recv(recv_msg_point,recv_buf,BUFLEN,&received_size,&status);
usleep(3000000);
printf("recviced message: %s\n\r",recv_buf);
mcapi_finalize(&status);
return EXIT_SUCCESS;
}
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;
}
int main(int argc, char** argv) {
mcapi_boolean_t recv_done = MCAPI_FALSE;
mcapi_boolean_t send_done = MCAPI_FALSE;
mca_status_t status;
mcapi_request_t request;
size_t size;
int num_sends,num_recvs,order,i;
struct timeval tv;
unsigned int seed;
mcapi_endpoint_t recv_endpt;
mcapi_endpoint_t send_endpt;
int rc = 0;
mcapi_param_t parms;
mcapi_info_t version;
mcapi_set_debug_level(6);
memset(&send_requests,0,sizeof(send_requests));
memset(&recv_requests,0,sizeof(recv_requests));
/* initialize the random number generator with a seed */
if (argc == 2) {
seed = atoi(argv[1]);
} else {
gettimeofday(&tv,0);
seed = tv.tv_sec + tv.tv_usec;
}
printf("Using seed:[%u]\n",seed);
srand(seed);
/* create a node */
mcapi_initialize(DOMAIN,NODE,NULL,&parms,&version,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to initialize (0): %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
rc++;
mcapi_finalize(&status);
return rc;
}
/* create the endpoints */
send_endpt = mcapi_endpoint_create(1,&status);
recv_endpt = mcapi_endpoint_create(2,&status);
/*************************** connect the channels *********************/
do {
mcapi_pktchan_connect_i(send_endpt,recv_endpt,&request,&status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to initialize (1): %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
rc++;
mcapi_finalize(&status);
return rc;
}
/*************************** open the channels *********************/
do {
mcapi_pktchan_recv_open_i(&r1 /*recv_handle*/,recv_endpt, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to initialize (2): %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
rc++;
mcapi_finalize(&status);
return rc;
}
do {
mcapi_pktchan_send_open_i(&s1 /*send_handle*/,send_endpt, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to initialize (3): %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
rc++;
mcapi_finalize(&status);
return rc;
}
/* randomly issue sends and receives */
printf("sending and receiving num_msgs=%d\n",NUM_MSGS);
while (!(recv_done && send_done)) {
if (send_done) { order = 1; }
else if (recv_done) { order = 0; }
else { order = get_random(); }
if (order % 2) {
/* do some receives */
num_recvs = get_random();
printf("issuing %i receives...\n",num_recvs);
for (i = 0; i < num_recvs; i++) {
recv_done = receiver();
}
} else {
/* do some sends */
num_sends = get_random();
printf("issuing %i sends...\n",num_sends);
for (i = 0; i < num_sends; i++) {
send_done = sender();
}
}
}
rc =check_results();
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
rc++;
}
if (rc == 0) {
printf(" Test PASSED\n");
} else {
printf(" Test FAILED\n");
}
return rc;
}
/**
* Creates local end-points on GPP and gets remote DSP end-points *
* @return MCAPI_SUCCESS/error
*/
mcapi_status_t initialize_comms(void) {
mcapi_status_t status = MCAPI_ERR_GENERAL;
/**
* Create local end-points for communication
*/
#ifdef DEBUG_INFO
printf("[CORE A]: Initializing communication\n");
#endif
command_endpoint = mcapi_endpoint_create(PORT_COMMAND, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
data_endpoint = mcapi_endpoint_create(PORT_DATA, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
data_recv_endpoint = mcapi_endpoint_create(PORT_DATA_RECV, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_create failure\n",
__FILE__, __LINE__, status);
exit(1);
}
#endif
/**
* Get the remote end-points for communication
*/
remote_command_endpoint = mcapi_endpoint_get(DOMAIN, NODE_CORE_1,
PORT_COMMAND, MCAPI_TIMEOUT_INFINITE, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_get failure\n", __FILE__,
__LINE__, status);
exit(1);
}
#endif
remote_data_endpoint = mcapi_endpoint_get(DOMAIN, NODE_CORE_1, PORT_DATA,
MCAPI_TIMEOUT_INFINITE, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_get failure\n", __FILE__,
__LINE__, status);
exit(1);
}
#endif
remote_data_recv_endpoint = mcapi_endpoint_get(DOMAIN, NODE_CORE_1,
PORT_DATA_RECV, MCAPI_TIMEOUT_INFINITE, &status);
#ifdef DEBUG_INFO
if (MCAPI_SUCCESS != status) {
fprintf(stdout, "[%s] %d status: %d mcapi_endpoint_get failure\n", __FILE__,
__LINE__, status);
exit(1);
}
#endif
data_endpoint = data_recv_endpoint;
command_endpoint = data_recv_endpoint ;
remote_data_endpoint = remote_data_recv_endpoint;
remote_command_endpoint = remote_data_recv_endpoint;
return status;
}
int main(int argc, char** argv)
{
mcapi_boolean_t recv_done = MCAPI_FALSE;
mcapi_boolean_t send_done = MCAPI_FALSE;
mcapi_endpoint_t recv_endpt;
mcapi_endpoint_t send_endpt;
mca_status_t status;
int num_sends,num_recvs,order,i;
struct timeval tv;
unsigned int seed;
mcapi_param_t parms;
mcapi_info_t version;
mcapi_set_debug_level(4);
/* initialize the random number generator with a seed */
if (argc == 2) {
seed = atoi(argv[1]);
} else {
gettimeofday(&tv,0);
seed = tv.tv_sec + tv.tv_usec;
}
printf("Using seed:[%u]\n",seed);
srand(seed);
/* 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 fail;
}
/* create the endpoints */
send_endpt = mcapi_endpoint_create(1,&status);
recv_endpt = mcapi_endpoint_create(2,&status);
/* randomly issue sends and receives */
while (!(recv_done && send_done)) {
order = get_random();
if (order % 2) {
/* if we chose an odd number, do some receives */
num_recvs = get_random();
if (!recv_done) { printf("issuing %i receives...\n",num_recvs); }
for (i = 0; i < num_recvs; i++) {
recv_done = receiver(recv_endpt);
}
} else {
/* if we chose an even number, do some sends */
num_sends = get_random();
if (!send_done) {printf("issuing %i sends...\n",num_sends); }
for (i = 0; i < num_sends; i++) {
send_done = sender(send_endpt,recv_endpt);
}
}
}
if (! check_results()) {
fprintf(stderr,"\nFAILED - check results\n");
mcapi_finalize(&status);
return fail;
}
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
return fail;
}
printf(" Test PASSED\n");
return ok;
}
void *receiver(void* data)
{
char buffer[NUM_MSGS];
int count = 0;
size_t recv_size;
mca_status_t status;
int i;
mcapi_param_t parms;
mcapi_info_t version;
/* create a node */
mcapi_initialize(DOMAIN,NODE+1,NULL,&parms,&version,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nFAIL: Failed to initialize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
/* make recv endpoint */
recv_endpt = mcapi_endpoint_create(1,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nFAIL: Failed to create recv endpoint: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
/* do the receives */
for (count = 0; count < NUM_MSGS; count++) {
mcapi_msg_recv(recv_endpt,
buffer,
sizeof(buffer),
&recv_size,
&status);
if ((status != MCAPI_SUCCESS) && (TIMEOUT)) {
/* yield and then retry */
for (i = 0; i < TIMEOUT; i++) {
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nWARNING: Recv failed: reason:%s recv_count:%d. Will yield and re-try.\n",mcapi_display_status(status,status_buff,sizeof(status_buff)),count);
sched_yield();
mcapi_msg_recv(recv_endpt,
buffer,
sizeof(buffer),
&recv_size,
&status);
}
if (status == MCAPI_SUCCESS) {
break;
}
}
}
if (status == MCAPI_SUCCESS) {
printf("count=%d, Received: [%s]\n",count,buffer);
} else {
fprintf(stderr,"\nFAIL: Recv failed: reason:%s recv_count:%d.\n",mcapi_display_status(status,status_buff,sizeof(status_buff)),count);
WRONG;
}
}
/* finalize */
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nFAIL: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
return NULL;
}
void *sender(void* data)
{
char buffer[NUM_MSGS];
int count = 0;
mca_status_t status;
int i;
mcapi_param_t parms;
mcapi_info_t version;
mcapi_priority_t priority = 1;
mcapi_endpoint_t remote_recv_endpt;
/* 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)));
WRONG;
}
/* make send endpoint */
send_endpt = mcapi_endpoint_create(0,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to create send endpoint: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
/* get a recv endpoint */
remote_recv_endpt = mcapi_endpoint_get(DOMAIN,NODE+1,1,MCA_INFINITE,&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nERROR: Failed to get receive endpoint: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
/* do the sends */
for (count = 0; count < NUM_MSGS; count++) {
sprintf(buffer,"Sending: %d",count);
printf("Sending: [%s]\n",buffer);
mcapi_msg_send(send_endpt,
remote_recv_endpt,
buffer,
strlen(buffer),
priority,
&status);
if ((status != MCAPI_SUCCESS) && (TIMEOUT)) {
/* yield and then retry */
for (i = 0; i < TIMEOUT; i++) {
if (status == MCAPI_ERR_MEM_LIMIT) {
fprintf(stderr,"WARNING: Send failed: reason:%s send_count:%d. Will yield and re-try.\n",mcapi_display_status(status,status_buff,sizeof(status_buff)),count);
sched_yield();
mcapi_msg_send(send_endpt,
remote_recv_endpt,
buffer,
strlen(buffer),
priority,
&status);
}
if (status == MCAPI_SUCCESS) {
break;
}
}
}
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nFAIL: Send failed: reason:%s send_count:%d\n",mcapi_display_status(status,status_buff,sizeof(status_buff)),count);
WRONG;
}
}
/* finalize */
mcapi_finalize(&status);
if (status != MCAPI_SUCCESS) {
fprintf(stderr,"\nFAIL: Failed to finalize: %s\n",mcapi_display_status(status,status_buff,sizeof(status_buff)));
WRONG;
}
return NULL;
}
/*****************************************************************************
* setup_echo_endpoints
*****************************************************************************/
int setup_echo_endpoints(int task_id)
{
mcapi_status_t status;
int local_send_port = 0;
int local_recv_port = 1;
int next_node = (task_id == num_tasks - 1) ?
0 + th_get_node_offset() :
task_id + 1 + th_get_node_offset();
int next_recv_port = 1;
mcapi_info_t version;
mcapi_param_t parms;
/* TODO -- this needs to be cleaned up */
/* figure out how many cores we have, then split the tasks up evenly among the cores */
#if (WITH_AFFINITY != 0)
int i;
int num_cores = 2;
int tasks_per_core = num_tasks/num_cores;
int core = 0;
for (i = 0; i < num_tasks; i+=tasks_per_core) {
if ((i <= task_id) && ((i + tasks_per_core) >= task_id )) {
th_log("[TC_ECHO] -- setting task_id(%i) affinity to core(%i)\n",task_id,core);
th_set_affinity(core);
break;
}
core++;
}
#endif
/* initialize */
//mca_set_debug_level(1);
mcapi_initialize(CONKER_TESTCASE_DOMAIN, task_id + th_get_node_offset(), NULL,&parms,&version,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to initialize: %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* create local_send endpoint */
th_log_info("[TC_ECHO] -- creating local send endpoint node=%d, port=%d\n",
task_id + th_get_node_offset(), local_send_port);
local_endpts[task_id].endpts[WRITE_IDX] =
mcapi_endpoint_create(local_send_port, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to create local send endpoint: %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* create local_recv endpoint */
th_log_info("[TC_ECHO] -- creating local recv endpoint node=%d, port=%d\n",
task_id + th_get_node_offset(), local_recv_port);
local_endpts[task_id].endpts[READ_IDX] =
mcapi_endpoint_create(local_recv_port, &status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to create local receive endpoint: %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
/* get the endpoint to send to */
th_log_info("[TC_ECHO] -- get next recv endpt, node=%d, next_node=%d, next_recv_port=%d\n",
task_id, next_node, next_recv_port);
remote_endpts[task_id] =
mcapi_endpoint_get(CONKER_TESTCASE_DOMAIN, next_node, next_recv_port, TIMEOUT,&status);
if (status != MCAPI_SUCCESS) {
th_log_error("Task id %d failed to get next recv endpoint: %s\n",
task_id, mcapi_display_status(status,status_buff,sizeof(status_buff)));
return -1;
}
return 0;
}
int main () {
size_t size;
mcapi_endpoint_t ep1,ep2;
mcapi_pktchan_send_hndl_t s1; /* s1 = ep1->ep2 */
mcapi_pktchan_recv_hndl_t r1; /* r1 = ep1->ep2 */
int i = 0;
int rc = 1;
mca_status_t status;
mcapi_request_t request;
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) { WRONG }
/* create endpoints */
ep1 = mcapi_endpoint_create(PORT_NUM1,&status);
if (status != MCAPI_SUCCESS) { WRONG }
ep2 = mcapi_endpoint_create(PORT_NUM2,&status);
if (status != MCAPI_SUCCESS) { WRONG }
/*************************** connect the channels *********************/
do {
mcapi_pktchan_connect_i(ep1,ep2,&request,&status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) { WRONG }
/*************************** open the channels *********************/
do {
mcapi_pktchan_recv_open_i(&r1 /*recv_handle*/,ep2, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) { WRONG }
do {
mcapi_pktchan_send_open_i(&s1 /*send_handle*/,ep1, &request, &status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) { WRONG }
/* tests: recv send send recv obeys FIFO */
do {
mcapi_pktchan_recv_i(r1,(void **)((void*)&requests[i].buffer),&requests[i].request,&requests[i].status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
i++;
do {
mcapi_pktchan_send_i(s1,"one",sizeof("one"),&requests[i].request,&requests[i].status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
i++;
do {
mcapi_pktchan_send_i(s1,"two",sizeof("two"),&requests[i].request,&requests[i].status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
i++;
do {
mcapi_pktchan_recv_i(r1,(void **)((void*)&requests[i].buffer),&requests[i].request,&requests[i].status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
i++;
rc = check_results();
/* close the channels */
do {
mcapi_pktchan_recv_close_i(r1,&request,&status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) { WRONG }
do {
mcapi_pktchan_send_close_i(s1,&request,&status);
//retry if all request handles are in-use
} while (status == MCAPI_ERR_REQUEST_LIMIT);
while (!mcapi_test(&request,&size,&status)) {}
if (status != MCAPI_SUCCESS) { WRONG }
mcapi_finalize(&status);
if (rc == 0) {
printf(" Test PASSED\n");
} else {
printf(" Test FAILED\n");
}
return rc;
}
