Пример #1
0
Int RcmClient_execCmd(RcmClient_Object *obj, RcmClient_Message *msg)
{
    RcmClient_Packet *packet;
    MessageQ_Msg msgqMsg;
    Int rval;
    Int status = RcmClient_S_SUCCESS;


    Log_print2(Diags_ENTRY | Diags_INFO,
        "--> "FXNN": (obj=0x%x, msg=0x%x)", (IArg)obj, (IArg)msg);

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(msg);
    packet->desc |= RcmClient_Desc_CMD << RcmClient_Desc_TYPE_SHIFT;

    /* set the return address to the error message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->errorMsgQue, msgqMsg);

    /* send the message to the server */
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (rval < 0) {
        Log_error0(FXNN": unable to send message to server");
        status = RcmClient_E_IPCERROR;
    }

    Log_print1(Diags_EXIT | Diags_INFO, "<-- "FXNN": %d", (IArg)status);
    return(status);
}
Пример #2
0
Int RcmClient_execDpc(RcmClient_Object *obj,
    RcmClient_Message *cmdMsg, RcmClient_Message **returnMsg)
{
    RcmClient_Packet *packet;
    RcmClient_Message *rtnMsg;
    MessageQ_Msg msgqMsg;
    UInt16 msgId;
    Int rval;
    Int status = RcmClient_S_SUCCESS;


    Log_print3(Diags_ENTRY,
        "--> %s: 0x%x, 0x%x", (IArg)FXNN, (IArg)obj, (IArg)returnMsg);

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(cmdMsg);
    packet->desc |= RcmClient_Desc_DPC << RcmClient_Desc_TYPE_SHIFT;
    msgId = packet->msgId;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (rval < 0) {
        /* Log_error() */
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_EXECFAILED;
        goto leave;
    }

    /* get the return message from the server */
    rval = RcmClient_getReturnMsg_P(obj, msgId, &rtnMsg);

    if (rval < 0) {
        *returnMsg = NULL;
        status = rval;
        goto leave;
    }
    *returnMsg = rtnMsg;


leave:
    Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
    return(status);
}
Пример #3
0
Int RcmClient_execAsync(RcmClient_Object *obj, RcmClient_Message *cmdMsg,
    RcmClient_CallbackFxn callback, Ptr appData)
{
    RcmClient_Packet *packet;
    MessageQ_Msg msgqMsg;
    Int rval;
    Int status = RcmClient_S_SUCCESS;


    Log_print3(Diags_ENTRY,
        "--> %s: 0x%x, 0x%x", (IArg)FXNN, (IArg)obj, (IArg)cmdMsg);

    /* cannot use this function if callback notification is false */
    if (!obj->cbNotify) {
        Log_error0(FXNN": asynchronous notification not enabled");
        status = RcmClient_E_EXECASYNCNOTENABLED;
        goto leave;
    }

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(cmdMsg);
    packet->desc |= RcmClient_Desc_RCM_MSG << RcmClient_Desc_TYPE_SHIFT;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (rval < 0) {
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_EXECFAILED;
        goto leave;
    }

    /* TODO finish this function */

leave:
    Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
    return(status);
}
Пример #4
0
Int RcmClient_execNoWait(RcmClient_Object *obj, RcmClient_Message *cmdMsg,
    UInt16 *msgId)
{
    RcmClient_Packet *packet;
    MessageQ_Msg msgqMsg;
    Int rval;
    Int status = RcmClient_S_SUCCESS;


    Log_print4(Diags_ENTRY,
        "--> %s: 0x%x, 0x%x, 0x%x",
        (IArg)FXNN, (IArg)obj, (IArg)cmdMsg, (IArg)msgId);

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(cmdMsg);
    packet->desc |= RcmClient_Desc_RCM_MSG << RcmClient_Desc_TYPE_SHIFT;
    *msgId = packet->msgId;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    Log_print1(Diags_ANALYSIS, "%s: >>> MessageQ_put", (IArg)FXNN);
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);
    Log_print1(Diags_ANALYSIS, "%s: <<< MessageQ_put", (IArg)FXNN);

    if (rval < 0) {
        *msgId = RcmClient_INVALIDMSGID;
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_EXECFAILED;
        goto leave;
    }

leave:
    Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
    return(status);
}
Пример #5
0
/******************************************************************************
 * TASK FUNCTION
 *****************************************************************************/
void task_fxn(UArg arg0, UArg arg1){
	Int 				status;
	Int 				coreCount;
	Int 				nextCore;
	MessageQ_Msg 		msg;
	MessageQ_QueueId 	msgQueueIds[MAX_NUM_CORES];

	/* Register this heap with the Message Q */
	MessageQ_registerHeap((IHeap_Handle)SharedRegion_getHeap(0), HEAP_ID);

/*
 * In order to send messages to other cores, we must know that core's Queue
 * ID.  So, we'll create an array on each core that associates the Queue ID
 * with the core number, and then we'll open each queue.  Again, we spin
 * here until the queue is open, sleeping for one tick after every attempt.
 */
	for (coreCount = 0; coreCount < MAX_NUM_CORES; coreCount++){
		System_sprintf(remoteQueueName, "%s", MultiProc_getName(coreCount));
		do {
			status = MessageQ_open(remoteQueueName, &msgQueueIds[coreCount]);
			if (status < 0){
				Task_sleep(1);
			}
		}while (status < 0);
	}


	/*
	 * At this point, our application is ready to begin sending messages using
	 * Message Queue.  The core with the number TOKEN_START_CORE has the
	 * responsibility of sending the first message.  So, we'll handle that in
	 * this block.
	 */
	if (selfId == TOKEN_START_CORE){

		/*
		 * Allocate the initial message.  If the message is not properly
		 * allocated, we must abort
		 */

		/*
		 * TODO: IPC #1 - Allocate Memory for Token Message
		 * Add core below that ALLOCATES the memory for the token message.
		 * We've already declared the variable msg to hold the pointer to
		 * this message.  The code to check if the pointer is NULL is
		 * already included.
		 */
		msg = MessageQ_alloc(HEAP_ID, sizeof(myMsg));

		if (msg == NULL){
			System_abort("MessageQ_alloc failed\n");
		}

		/*
		 * Now randomly select the next processor to send the.  This function
		 * simply selects a random core number and ensures it's not the same as
		 * the current core number.
		 */
		nextCore = findNextCore(selfId);

		/*
		 * Set the Initial Token Count in the message, and specify that the
		 * message type is MSG_TOKEN
		 */
		((myMsg*)msg)->tokenCount = 1;
		((myMsg*)msg)->messageType = MSG_TOKEN;

		/*
		 * We can also set a reply queue so that the core can acknowledge this
		 * message without having to know which core it came from.
		 */
		MessageQ_setReplyQueue(messageQ, msg);

		/*
		 * Now we actually send the message to the next core that we've chosen.
		 */

		/* TODO: IPC #2 - Pass the token to the destination core
		 * Add the code to send the message to the destination core.  This is
		 * done by putting the message in the destination core's queue.  Don't
		 * forget that the ID of the destination core's queue is stored at
		 * element "nextCore" in the array msgQueueIds, and is NOT the same
		 * as the core number.
		 */
		status = MessageQ_put(msgQueueIds[nextCore], msg);

	}

	while (TRUE){
		msgType messageType;
		MessageQ_Msg ack;
		MessageQ_QueueId ackQueueId;
		Int currentTokenCount;

		/* TODO: IPC #3 - Get a Message from the local queue.
		 * Take the message from the local queue and store it in the variable
		 * message.  The function call return value should be stored in the
		 * variable status.  Hint: The parameters passed to this function
		 * specify a time out size.  We want to configure this call to
		 * never time out, and block eternally until a message is received.
		 */
		status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER);

		if (status < 0){
			System_abort("This should not occur since the timeout is forever\n");
		}

		/*
		 * Read the Message Type from the received message, along with the current
		 * token count.
		 */
		messageType = ((myMsg*)msg)->messageType;
		currentTokenCount = ((myMsg*)msg)->tokenCount;

		/*
		 * Now, check what type of message it is and take action.  Here are the
		 * actions to be taken.
		 *
		 * MSG_TOKEN
		 * 	- Acknowledge that token is received to sending core.
		 * 	- If token count is less than MAX_MESSAGES
		 * 		- Increment the token count.
		 * 		- Forward the token on to the next random core
		 *	- If token count is equal to MAX Messages
		 *		- Free the Token message.
		 *		- Send a Done Message to all other cores.
		 *		- Break out of the infinite loop.
		 *
		 * MSG_ACK
		 * 	- Free the Ack message
		 * MSG_DONE
		 *  - Free the Done Message
		 *  - Break Out of infinite loop
		 */
		switch (messageType){
		case MSG_TOKEN:
			System_printf("Token Received - Count = %d\n", currentTokenCount);

			/*
			 * TODO: IPC #4 - Get the Reply Queue for the token
			 * Store the ID of the reply queue in the variable ackQueueId.
			 * This function allows us to not have to figure out which core
			 * sent this message.  This is the analogous function to the
			 * MessageQ_setReplyQueue() function that was set before the
			 * message was sent.  This data is stored in the MessageQ_MsgHeader
			 * element that's included with the message
			 */
			ackQueueId = MessageQ_getReplyQueue(msg);

			/*
			 * TODO: IPC #5 - Allocate the acknowledge message
			 * Allocate the acknowledge message and store the pointer to it
			 * in the variable ack.
			 */
			ack = MessageQ_alloc(HEAP_ID, sizeof(myMsg));

			// Set the Message Type of the new Message to MSG_ACK
			if (ack==NULL){
				System_abort("MessageQ Alloc Failed\n");
			}

			// Set the Message Type of the new Message to MSG_ACK
			((myMsg*)ack)->messageType = MSG_ACK;

			/*
			 * TODO: IPC #6 - Send the Acknowledge message
			 * Don't forget that we've already stored the reply queue ID in
			 * ackQueueId above.
			 */
			status = MessageQ_put(ackQueueId, ack);

			/*
			 * Now handle the actions required by the status of the message. First
			 * we must check to see if we're at the Token Passing limit.  So we'll
			 * compare the current Token count with MAX_MESSAGES.
			 */

			/*
			 * If the current token count is the max, then we must free the current
			 * message and then allocate new DONE messages to be sent to the other
			 * cores.
			 */
			if (currentTokenCount == NUM_MESSAGES){
				/*
				 * TODO: IPC #7 - Free the memory used by the token message
				 * Don't forget that the pointer to this memory is in the
				 * variable msg.
				 */
				MessageQ_free(msg);

				/*
				 * Now allocate and send ALL cores a DONE message.  We don't need to
				 * worry about special handling of the current core.  It will just
				 * send itself a DONE message and handle it just as the other cores
				 * do
				 */
				/*
				 * TODO: IPC #8 - Note that this core will send itself a message.
				 * There's nothing to be added here.  just note that this
				 * routine is blindly sending done messages to all of the cores
				 * and not taking into account it's own core number.  So, this
				 * core will send one of these messages to itself.
				 */
				for (coreCount =0; coreCount < MAX_NUM_CORES; coreCount++){
					msg = MessageQ_alloc(HEAP_ID, sizeof(myMsg));
					if (msg == NULL){
						System_abort("MessageQ Alloc Failed\n");
					}

					// Set the Message Type to MSG_DONE
					((myMsg*)msg)->messageType = MSG_DONE;

					// Now send it to the selected core
					status = MessageQ_put(msgQueueIds[coreCount], msg);
				}
				break;
			}

			/*
			 * If we're not at the last message, then we must increment the
			 * tokenCount and pass the message on to a random core.  Don't
			 * forget to set the reply queue so we can get an acknowledge.
			 */
			nextCore = findNextCore(selfId);
			((myMsg*)msg)->tokenCount = currentTokenCount + 1;

			/*
			 * TODO: IPC #9- Set the reply queue for the token message.
			 * We need to be sure to set the reply queue each time.
			 * Otherwise, the wrong core will receive the acknowledge.
			 */
			MessageQ_setReplyQueue(messageQ, msg);

			// Put the message on the proper queue
			status = MessageQ_put(msgQueueIds[nextCore], msg);

			break;
		case MSG_ACK:
			System_printf("Ack Received\n");
			/*
			 * All we need to do in this case is free the Ack message
			 */
			MessageQ_free(msg);
			break;
		case MSG_DONE:
			System_printf("Done Received\n");
			/*
			 * If we receive the Done message we just need to free the message, and
			 * then exit SYS/BIOS because the application is complete.
			 */
			MessageQ_free(msg);
			BIOS_exit(0);
			break;
		default:
			System_printf("Invalid Message Type Received\n");
			return;
		}


	}
}
Пример #6
0
Int MessageQApp_execute(UInt32 numLoops, UInt16 procId)
{
    Int32                    status = 0;
    MessageQ_Msg             msg = NULL;
    MessageQ_Params          msgParams;
    UInt32                   i;
    MessageQ_QueueId         queueId = MessageQ_INVALIDMESSAGEQ;
    MessageQ_Handle          msgqHandle;
    char                     remoteQueueName[64];
    UInt32                   msgId;

    printf("Entered MessageQApp_execute\n");

    /* Create the local Message Queue for receiving. */
    MessageQ_Params_init(&msgParams);
    msgqHandle = MessageQ_create(MPU_MESSAGEQNAME, &msgParams);
    if (msgqHandle == NULL) {
        printf("Error in MessageQ_create\n");
        goto exit;
    }
    else {
        printf("Local MessageQId: 0x%x\n", MessageQ_getQueueId(msgqHandle));
    }

    sprintf(remoteQueueName, "%s_%s", SLAVE_MESSAGEQNAME,
             MultiProc_getName(procId));

    /* Poll until remote side has it's messageQ created before we send: */
    do {
        status = MessageQ_open(remoteQueueName, &queueId);
        sleep (1);
    } while (status == MessageQ_E_NOTFOUND);

    if (status < 0) {
        printf("Error in MessageQ_open [%d]\n", status);
        goto cleanup;
    }
    else {
        printf("Remote queueId  [0x%x]\n", queueId);
    }

    msg = MessageQ_alloc(HEAPID, sizeof(SyncMsg));
    if (msg == NULL) {
        printf("Error in MessageQ_alloc\n");
        MessageQ_close(&queueId);
        goto cleanup;
    }

    /* handshake with remote to set the number of loops */
    MessageQ_setReplyQueue(msgqHandle, msg);
    ((SyncMsg *)msg)->numLoops = numLoops;
    ((SyncMsg *)msg)->print = FALSE;
    MessageQ_put(queueId, msg);
    MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);

    printf("Exchanging %d messages with remote processor %s...\n",
           numLoops, MultiProc_getName(procId));

    for (i = 1 ; i <= numLoops; i++) {
        ((SyncMsg *)msg)->numLoops = i;

        /* Have the remote proc reply to this message queue */
        MessageQ_setReplyQueue(msgqHandle, msg);

        status = MessageQ_put(queueId, msg);
        if (status < 0) {
            printf("Error in MessageQ_put [%d]\n", status);
            MessageQ_free(msg);
            break;
        }

        status = MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);

        if (status < 0) {
            printf("Error in MessageQ_get [%d]\n", status);
            break;
        }
        else {
            /* validate the returned message */
            msgId = ((SyncMsg *)msg)->numLoops;
            if ((msg != NULL) && (msgId != i)) {
                printf("Data integrity failure!\n"
                        "    Expected %d\n"
                        "    Received %d\n",
                        i, msgId);
                break;
            }
        }

        if (numLoops <= 200) {
            printf("MessageQ_get #%d Msg = 0x%x\n", i, (UInt)msg);
        }
        else if ((i % 1000) == 0) {
            printf("MessageQ_get #%d Msg = 0x%x\n", i, (UInt)msg);
        }
    }

    printf("Exchanged %d messages with remote processor %s\n",
        (i-1), MultiProc_getName(procId));

    if (status >= 0) {
       printf("Sample application successfully completed!\n");
       MessageQ_free(msg);
    }

    MessageQ_close(&queueId);

cleanup:
    /* Clean-up */
    status = MessageQ_delete(&msgqHandle);
    if (status < 0) {
        printf("Error in MessageQ_delete [%d]\n", status);
    }

exit:
    printf("Leaving MessageQApp_execute\n\n");

    return (status);
}
Пример #7
0
/*
 *  ======== NameServerMessageQ_get ========
 */
Int NameServerMessageQ_get(NameServerMessageQ_Object *obj,
                           String instanceName,
                           String name,
                           Ptr value,
                           UInt32 *valueLen,
                           ISync_Handle syncHandle,
                           Error_Block *eb)
{
    Int len;
    Int status;
    IArg key;
    MessageQ_QueueId queueId;
    NameServerMsg    *msg;
    Semaphore_Handle semRemoteWait = NameServerMessageQ_module->semRemoteWait;
    GateMutex_Handle gateMutex = NameServerMessageQ_module->gateMutex;

    /* enter gate - prevent multiple threads from entering */
    key = GateMutex_enter(gateMutex);

    /* alloc a message from specified heap */
    msg = (NameServerMsg *)MessageQ_alloc(NameServerMessageQ_heapId,
                                          sizeof(NameServerMsg));
    
    /* make sure message is not NULL */
    if (msg == NULL) {
        Error_raise(eb, NameServerMessageQ_E_outOfMemory,
                    NameServerMessageQ_heapId, 0);
        return (NameServer_E_OSFAILURE);
    }
    
    /* make sure this is a request message */
    msg->request = NameServerMessageQ_REQUEST;
    msg->requestStatus = 0;

    /* get the length of instanceName */
    len = strlen(instanceName);

    /* assert length is smaller than max (must have room for null character) */
    Assert_isTrue(len < MAXNAMEINCHAR, NameServerMessageQ_A_nameIsTooLong);

    /* copy the name of instance into putMsg */
    strncpy((Char *)msg->instanceName, instanceName, len);

    /* get the length of name */
    len = strlen(name);

    /* assert length is smaller than max (must have room for null character) */
    Assert_isTrue(len < MAXNAMEINCHAR, NameServerMessageQ_A_nameIsTooLong);

    /* copy the name of nameserver entry into putMsg */
    strncpy((Char *)msg->name, name, len);

    /* determine the queueId based upon the processor */
    queueId = MessageQ_openQueueId(MESSAGEQ_INDEX, obj->remoteProcId);

    /* set the reply procId */
    MessageQ_setReplyQueue(
        (MessageQ_Handle)NameServerMessageQ_module->msgHandle,
        (MessageQ_Msg)msg);
    
    /* send message to remote processor. */
    status = MessageQ_put(queueId, (MessageQ_Msg)msg);

    /* make sure message sent successfully */
    if (status < 0) {
        /* free the message */
        MessageQ_free((MessageQ_Msg)msg);

        return (NameServer_E_FAIL);
    }

    /* pend here until we get a response back from remote processor */
    status = Semaphore_pend(semRemoteWait, NameServerMessageQ_timeout);

    if (status == FALSE) {
        /* return timeout failure */
        return (NameServer_E_OSFAILURE);
    }

    /* get the message */
    msg = NameServerMessageQ_module->msg;

    if (msg->requestStatus) {
        /* name is found */

        /* set length to amount of data that was copied */
        *valueLen = sizeof(Bits32);
    
        /* set the contents of value */
        memcpy(value, &(msg->value), sizeof(Bits32));

        /* set the status to success */
        status = NameServer_S_SUCCESS;
    }
    else {
        /* name is not found */

        /* set status to not found */
        status = NameServer_E_NOTFOUND;
    }

    /* free the message */
    MessageQ_free((MessageQ_Msg)msg);

    /* leave the gate */
    GateMutex_leave(gateMutex, key);
    
    /* return success status */
    return (status);
}
Пример #8
0
/*
 *  ======== clientTask ========
 */
Void clientTask(UArg arg0, UArg arg1)
{
    MessageQ_Handle  messageQ;
    MessageQ_QueueId serverQueue;
    MessageQ_Msg     msg;
    UInt16           msgId = arg0;
    Int              status;
    Int              i;

    /*
     *  Create client's MessageQ.
     *
     *  Use 'NULL' for name since no since this queueId is passed by
     *  referene and no one opens it by name. 
     *  Use 'NULL' for params to get default parameters.
     */
    messageQ = MessageQ_create(NULL, NULL);
    if (messageQ == NULL) {
        System_abort("Failed to create MessageQ\n");
    }

    /* Open the server's MessageQ */
    do {
        status = MessageQ_open(SERVERNAME, &serverQueue);
        if (status < 0) {
            Task_sleep(1);  /* give server a chance to create queue */ 
        }
    }
    while (status < 0);
    
    msg = MessageQ_alloc(HEAPID, sizeof(MessageQ_MsgHeader));
    if (msg == NULL) {
        System_abort("MessageQ_alloc failed\n" );
    }
    
    /* Have the remote processor reply to this message queue */
    MessageQ_setReplyQueue(messageQ, msg);

    /* Loop requesting information from the server task */
    System_printf("Client #%d is starting to send requests\n", arg0);
    for (i = 0; i < NUMMSGS; i++) {        

        /* Server will increment and send back */
        MessageQ_setMsgId(msg, msgId);
        msgId += NUMCLIENTS;       

        /* Send the message off */
        status = MessageQ_put(serverQueue, msg);
        if (status < 0) {            
            MessageQ_free(msg);
            System_abort("MessageQ_put failed\n");
        }

        /* Wait for the reply... */
        status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER);
        if (status < 0) {
            System_abort("MessageQ_get had an error\n");
        }

        /* Validate the returned message. */
        if (MessageQ_getMsgId(msg) != msgId) {
            System_abort("Unexpected value\n");
        }

        System_printf("Client #%d received response #%d\n", arg0, i + 1);

        /* To make some variation in the execution order */
        Task_sleep(500 * (arg0 + 1));
    }
    
    System_printf("Client #%d is done sending requests\n", arg0);
    
    numCompleted++;
    if (numCompleted == 3) {
        /* All client tasks are done sending requests */
        BIOS_exit(0);
    }



}
Пример #9
0
Файл: App.c Проект: yesj/J5_A8
/*
 *  ======== App_exec ========
 */
Int App_exec(Void)
{
    Int         status;
    Int         i;
    App_Msg *   msg;

    printf("--> App_exec:\n");

    /* fill process pipeline */
    for (i = 1; i <= 3; i++) {
        printf("App_exec: sending message %d\n", i);

        /* allocate message */
        msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);

        if (msg == NULL) {
            status = -1;
            goto leave;
        }

        /* set the return address in the message header */
        MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);

        /* fill in message payload */
        msg->cmd = App_CMD_NOP;

        /* send message */
        MessageQ_put(Module.videoQue, (MessageQ_Msg)msg);
    }

    /* process steady state (keep pipeline full) */
    for (i = 4; i <= 15; i++) {

        /* wait for return message */
        status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
            MessageQ_FOREVER);

        if (status < 0) {
            goto leave;
        }

        /* extract message payload */

        /* free the message */
        MessageQ_free((MessageQ_Msg)msg);

        printf("App_exec: message received, sending message %d\n", i);

        /* allocate message */
        msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);

        if (msg == NULL) {
            status = -1;
            goto leave;
        }

        /* set the return address in the message header */
        MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);

        /* fill in message payload */
        msg->cmd = App_CMD_NOP;

        /* send message */
        MessageQ_put(Module.videoQue, (MessageQ_Msg)msg);
    }

    /* drain process pipeline */
    for (i = 1; i <= 3; i++) {
        printf("App_exec: message received\n");

        /* wait for return message */
        status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
            MessageQ_FOREVER);

        if (status < 0) {
            goto leave;
        }

        /* extract message payload */

        /* free the message */
        MessageQ_free((MessageQ_Msg)msg);
    }

leave:
    printf("<-- App_exec: %d\n", status);
    return(status);
}
Пример #10
0
Int MessageQApp_execute(UInt32 numLoops, UInt32 payloadSize, UInt16 procId)
{
    Int32                    status     = 0;
    MessageQ_Msg             msg        = NULL;
    MessageQ_Params          msgParams;
    UInt32                   i;
    MessageQ_QueueId         queueId = MessageQ_INVALIDMESSAGEQ;
    MessageQ_Handle          msgqHandle;
    char                     remoteQueueName[64];
    struct timespec          start, end;
    long                     elapsed;
    UInt32                   msgId;

    printf("Entered MessageQApp_execute\n");

    /* Create the local Message Queue for receiving. */
    MessageQ_Params_init(&msgParams);
    msgqHandle = MessageQ_create(MPU_MESSAGEQNAME, &msgParams);
    if (msgqHandle == NULL) {
        printf("Error in MessageQ_create\n");
        goto exit;
    }
    else {
        printf("Local MessageQId: 0x%x\n", MessageQ_getQueueId(msgqHandle));
    }

    sprintf(remoteQueueName, "%s_%s", SLAVE_MESSAGEQNAME,
             MultiProc_getName(procId));

    /* Poll until remote side has its messageQ created before we send: */
    do {
        status = MessageQ_open(remoteQueueName, &queueId);
        sleep (1);
    } while (status == MessageQ_E_NOTFOUND);

    if (status < 0) {
        printf("Error in MessageQ_open [%d]\n", status);
        goto cleanup;
    }
    else {
        printf("Remote queueId  [0x%x]\n", queueId);
    }

    msg = MessageQ_alloc(HEAPID, sizeof(SyncMsg) + payloadSize);
    if (msg == NULL) {
        printf("Error in MessageQ_alloc\n");
        MessageQ_close(&queueId);
        goto cleanup;
    }

    /* handshake with remote to set the number of loops */
    MessageQ_setReplyQueue(msgqHandle, msg);
    ((SyncMsg *)msg)->numLoops = numLoops;
    ((SyncMsg *)msg)->print = FALSE;
    MessageQ_put(queueId, msg);
    MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);

    printf("Exchanging %d messages with remote processor %s...\n",
           numLoops, MultiProc_getName(procId));

    clock_gettime(CLOCK_REALTIME, &start);

    for (i = 1 ; i <= numLoops; i++) {
        ((SyncMsg *)msg)->numLoops = i;

        /* Have the remote proc reply to this message queue */
        MessageQ_setReplyQueue(msgqHandle, msg);

        status = MessageQ_put(queueId, msg);
        if (status < 0) {
            printf("Error in MessageQ_put [%d]\n", status);
            break;
        }

        status = MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);

        if (status < 0) {
            printf("Error in MessageQ_get [%d]\n", status);
            break;
        }
        else {
            /* Validate the returned message */
            msgId = ((SyncMsg *)msg)->numLoops;
            if ((msg != NULL) && (msgId != i)) {
                printf("Data integrity failure!\n"
                        "    Expected %d\n"
                        "    Received %d\n",
                        i, msgId);
                break;
            }
        }
    }

    clock_gettime(CLOCK_REALTIME, &end);
    elapsed = diff(start, end);

    if (numLoops > 0) {
        printf("%s: Avg round trip time: %ld usecs\n",
               MultiProc_getName(procId), elapsed / numLoops);
    }

    MessageQ_free(msg);
    MessageQ_close(&queueId);

cleanup:
    status = MessageQ_delete(&msgqHandle);
    if (status < 0) {
        printf ("Error in MessageQ_delete [%d]\n", status);
    }

exit:
    printf("Leaving MessageQApp_execute\n\n");

    return (status);
}
Пример #11
0
/**
 * Send all prepared IPC messages to all cores and return the calculation result (ssd/jac/hess)
 */
void send_to_cores(const processing_type_e ProcessingType, const uint32_T number_of_cores, real32_T *SSD, real32_T JD[3], real32_T JD2[9])
{
    process_message_t * p_msg = 0;
    uint16_t msgId = 0;
    int32_T ret_val=0;
#ifdef _TRACE_MC_
    Types_FreqHz freq;
    float processing_time=0;
    Int32 ts1, ts2;
#endif

    int32_t j;
    int32_t i;

#ifdef _TRACE_MC_
    logout("[MAIN  ] Execute Process (ProcessingType=%u)\n", ProcessingType);		//trace
    Timestamp_getFreq(&freq);
#endif

#ifdef _DO_ERROR_CHECKS_
    if(NULL == h_receive_queue)
    {
        logout("No master msg receive queue available.\n", max_core);
    }

    if ((number_of_cores <= 0) || (number_of_cores > max_core)) {
        logout("Invalid number_of_cores: It should be between 1 to %u\n", max_core);
        ret_val = -1;
        goto mcip_process_error;
    }
#endif

    //CACHING NOTE:
    //The picture data was cache write backed after images have been received. More
    //data is not to be cache write backed as we pass all other data (also arrays
    //element by element) to the cores using the message queue. Results are passed
    //back also using the message interface as we don't receive bulk data results.

#ifdef _TRACE_MC_
    ts1 = (Int32) Timestamp_get32();
#endif

    /* Send messages to processing cores, start at the highest core */
    for (i = CORE_AMOUNT-1; i >= (int)(CORE_AMOUNT-number_of_cores); i-- ) {
        p_msg = p_queue_msg[i];
        MessageQ_setMsgId(p_msg, ++msgId);
        MessageQ_setReplyQueue(h_receive_queue, (MessageQ_Msg)p_msg);

#ifdef _TRACE_MC_
        logout("[MAIN  ] Start process on core %u (ProcessingType=%u)\n", p_msg->core_id, ProcessingType, p_msg->info.NewImageDataArrived);		//trace
#endif

        /* send the message to the remote processor */
        if (MessageQ_put(queue_id[p_msg->core_id], (MessageQ_Msg)p_msg) < 0) {
            logout("MessageQ_put had a failure error\n");
            ret_val = -1;
            goto mcip_process_error;
        }
    }

    //All cores have invalidated their cache to read new image data. Next time cache invalidation is no more necessary (until new image data arrives).
    g_NewImageDataArrived = 0;
#ifdef _TRACE_MC_
    logout("[MAIN  ] Reset g_NetImageDataArrived signal to %d.\n", g_NewImageDataArrived);
#endif

    //Clear result buffers (will be summed up, have to start at 0)
    if(pt_ssd == ProcessingType || pt_ssdJacHess == ProcessingType)
    {
        (*SSD)=0;
        if(pt_ssdJacHess == ProcessingType)
        {
            memset(JD, 0, sizeof(real32_T) * 3);
            memset(JD2, 0, sizeof(real32_T) * 9);
        }
    }

    //ToDo: Once it looked like all other cores finished calculating before core 0 started. Why ?
    //One could think of having no mcip_core_task at the main core and call the calculation directly instead ... Use _TRACE_MC_ (only) to see this
    //ToDo: When adding a big sleep command to the processing functions one should see if there's something wrong

    /* Receive the result */
    for (i = (CORE_AMOUNT-number_of_cores); i < CORE_AMOUNT; i++) {

        if (MessageQ_get(h_receive_queue, (MessageQ_Msg *)&p_msg, MessageQ_FOREVER) < 0) {
            logout("This should not happen since timeout is forever\n");
            ret_val = -1;
        }/* else if (p_msg->info.flag != 0) {
           logout("Process image error received from core %d\n", p_msg->core_id);
   		ret_val = -1;
       }*/
#ifdef _TRACE_MC_
        if(pt_ssd == ProcessingType || pt_ssdJacHess == ProcessingType)
        {
            logout("[MAIN  ] process answer received from core %u (SSD=%f, ProcessingType=%u)\n", p_msg->core_id, (double)p_msg->info.out_SSD, ProcessingType);		//trace
            if(pt_ssdJacHess == ProcessingType)
            {
                logout("[MAIN  ] JD = [%f %f %f], JD2 = [%f ... %f ... %f]\n", (double)p_msg->info.out_JD[0], (double)p_msg->info.out_JD[1], (double)p_msg->info.out_JD[2],
                       (double)p_msg->info.out_JD2[0], (double)p_msg->info.out_JD2[4], (double)p_msg->info.out_JD2[8]);
            }
        }
        else
        {
            logout("[MAIN  ] process answer received from core %u (ProcessingType=%u)\n", p_msg->core_id, ProcessingType);		//trace
        }
#endif

        //Sum up the results
        if(pt_ssd == ProcessingType || pt_ssdJacHess == ProcessingType)
        {
            (*SSD) += p_msg->info.out_SSD;
            if(pt_ssdJacHess == ProcessingType)
            {
                for(j=0; j<3; j++)
                {
                    JD[j] += p_msg->info.out_JD[j];
                }
                for(j=0; j<9; j++)
                {
                    JD2[j] += p_msg->info.out_JD2[j];
                }
            }
        }
    }

    if (ret_val == -1) {
        goto mcip_process_error;
    }

#ifdef _TRACE_MC_
    ts2 = (Int32) Timestamp_get32();
    ts2 = ts2 - ts1;
    processing_time = ((float)ts2 / (float)freq.lo);
    if(pt_ssd == ProcessingType || pt_ssdJacHess == ProcessingType)
    {
        logout("[MAIN  ] SSD calculated in: %f s. Result = %f\n", processing_time, (double)(*SSD));		//trace
        if(pt_ssdJacHess == ProcessingType)
        {
            logout("[MAIN  ] JD = [%f %f %f], JD2 = [%f ... %f ... %f]\n", (double)JD[0], (double)JD[1], (double)JD[2], (double)JD2[0], (double)JD2[4], (double)JD2[8]);
        }
    }
    else
    {
        logout("[MAIN  ] Image shrinked in: %f s.\n", processing_time);		//trace
    }
#endif

    return;

mcip_process_error:
    logout("mcip_process_error !!! \n");
    shutdown_message_q();
}
Пример #12
0
Int RcmClient_exec(RcmClient_Object *obj,
        RcmClient_Message *cmdMsg, RcmClient_Message **returnMsg)
{
    RcmClient_Packet *packet;
    RcmClient_Message *rtnMsg;
    MessageQ_Msg msgqMsg;
    UInt16 msgId;
    UInt16 serverStatus;
    Int rval;
    Int status = RcmClient_S_SUCCESS;


    Log_print2(Diags_ENTRY,
        "--> "FXNN": (cmdMsg=0x%x, rtnMsg=0x%x)", (IArg)obj, (IArg)returnMsg);

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(cmdMsg);
    packet->desc |= RcmClient_Desc_RCM_MSG << RcmClient_Desc_TYPE_SHIFT;
    msgId = packet->msgId;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    status = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (status < 0) {
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_EXECFAILED;
        goto leave;
    }

    /* get the return message from the server */
    rval = RcmClient_getReturnMsg_P(obj, msgId, &rtnMsg);

    if (rval < 0) {
        *returnMsg = NULL;
        status = rval;
        goto leave;
    }
    *returnMsg = rtnMsg;

    /* check the server's status stored in the packet header */
    packet = RcmClient_getPacketAddr_P(rtnMsg);
    serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
            RcmClient_Desc_TYPE_SHIFT;

    switch (serverStatus) {
        case RcmServer_Status_SUCCESS:
            break;

        case RcmServer_Status_INVALID_FXN:
            Log_error1(FXNN": invalid function index: 0x%x",
                (IArg)rtnMsg->fxnIdx);
            status = RcmClient_E_INVALIDFXNIDX;
            goto leave;

        case RcmServer_Status_MSG_FXN_ERR:
            Log_error1(FXNN": message function error %d", (IArg)rtnMsg->result);
            status = RcmClient_E_MSGFXNERROR;
            goto leave;

        default:
            Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
            status = RcmClient_E_SERVERERROR;
            goto leave;
    }

leave:
    Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
    return(status);
}
Пример #13
0
Int RcmClient_acquireJobId(RcmClient_Object *obj, UInt16 *jobIdPtr)
{
    RcmClient_Message *msg;
    RcmClient_Packet *packet;
    MessageQ_Msg msgqMsg;
    UInt16 msgId;
    Int rval;
    UInt16 serverStatus;
    Int status = RcmClient_S_SUCCESS;


    Log_print2(Diags_ENTRY,
        "--> "FXNN": (obj=0x%x, jobIdPtr=0x%x)", (IArg)obj, (IArg)jobIdPtr);

    /* allocate a message */
    status = RcmClient_alloc(obj, sizeof(UInt16), &msg);

    if (status < 0) {
        goto leave;
    }

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(msg);
    packet->desc |= RcmClient_Desc_JOB_ACQ << RcmClient_Desc_TYPE_SHIFT;
    msgId = packet->msgId;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (rval < 0) {
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_FAIL;
        goto leave;
    }

    /* get the return message from the server */
    status = RcmClient_getReturnMsg_P(obj, msgId, &msg);

    if (status < 0) {
        goto leave;
    }

    /* check message status for error */
    packet = RcmClient_getPacketAddr_P(msg);
    serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
            RcmClient_Desc_TYPE_SHIFT;

    switch (serverStatus) {
        case RcmServer_Status_SUCCESS:
            break;

        default:
            Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
            status = RcmClient_E_SERVERERROR;
            goto leave;
    }

    /* extract return value */
    *jobIdPtr = (UInt16)(msg->data[0]);


leave:
    if (msg != NULL) {
        RcmClient_free(obj, msg);
    }
    Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
    return(status);
}
Пример #14
0
Int RcmClient_getSymbolIndex(RcmClient_Object *obj, String name, UInt32 *index)
{
    SizeT len;
    RcmClient_Packet *packet;
    UInt16 msgId;
    MessageQ_Msg msgqMsg;
    Int rval;
    UInt16 serverStatus;
    RcmClient_Message *rcmMsg = NULL;
    Int status = RcmClient_S_SUCCESS;


    Log_print3(Diags_ENTRY,
        "--> "FXNN": (obj=0x%x, name=0x%x, index=0x%x",
        (IArg)obj, (IArg)name, (IArg)index);

    /* allocate a message */
    len = _strlen(name) + 1;
    rval = RcmClient_alloc(obj, len, &rcmMsg);

    if (rval < 0) {
        status = rval;
        goto leave;
    }

    /* copy the function name into the message payload */
    rcmMsg->dataSize = len;  //TODO this is not proper!
    _strcpy((Char *)rcmMsg->data, name);

    /* classify this message */
    packet = RcmClient_getPacketAddr_P(rcmMsg);
    packet->desc |= RcmClient_Desc_SYM_IDX << RcmClient_Desc_TYPE_SHIFT;
    msgId = packet->msgId;

    /* set the return address to this instance's message queue */
    msgqMsg = (MessageQ_Msg)packet;
    MessageQ_setReplyQueue(obj->msgQue, msgqMsg);

    /* send the message to the server */
    rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);

    if (rval < 0) {
        Log_error0(FXNN": unable to the send message to the server");
        status = RcmClient_E_EXECFAILED;
        goto leave;
    }

    /* get the return message from the server */
    rval = RcmClient_getReturnMsg_P(obj, msgId, &rcmMsg);

    if (rval < 0) {
        status = rval;
        goto leave;
    }

    /* check message status for error */
    packet = RcmClient_getPacketAddr_P(rcmMsg);
    serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
            RcmClient_Desc_TYPE_SHIFT;

    switch (serverStatus) {
        case RcmServer_Status_SUCCESS:
            break;

        case RcmServer_Status_SYMBOL_NOT_FOUND:
            Log_error1(FXNN": symbol not found, name=0x%x", (IArg)name);
            status = RcmClient_E_SYMBOLNOTFOUND;
            goto leave;

        default:
            Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
            status = RcmClient_E_SERVERERROR;
            goto leave;
    }

    /* extract return value */
    *index = rcmMsg->data[0];


leave:
    if (rcmMsg != NULL) {
        RcmClient_free(obj, rcmMsg);
    }
    Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
    return(status);
}
Пример #15
0
Int32 System_ipcMsgQSendMsg(UInt32 linkId, UInt32 cmd, Void *pPrm, UInt32 prmSize, Bool waitAck, UInt32 timeout)
{
    Int32 status=OSA_SOK;
    SystemIpcMsgQ_Msg *pMsgCommon;
    UInt32 procId;
    Void *pMsgPrm;

    UTILS_assert(prmSize<=SYSTEM_IPC_MSGQ_MSG_SIZE_MAX);

    procId = SYSTEM_GET_PROC_ID(linkId);

    #ifdef TI_8107_BUILD
    if(procId==SYSTEM_PROC_DSP)
    {
        printf(" %u: MSGQ: WARNING: Trying to send command [0x%04x] to link [%d] on processor [%s], BUT [%s] is NOT present on this platform !!!\n",
                        OSA_getCurTimeInMsec(),
                        cmd,
                        SYSTEM_GET_LINK_ID(linkId),
                        MultiProc_getName(procId),
                        MultiProc_getName(procId)
                        );

        /* return SUCCESS so that calling API can continue */
        return status;
    }
    #endif

    UTILS_assert(  procId < SYSTEM_PROC_MAX);
    /*wuzc modify for malloc fail*/
    OSA_mutexLock(&gSystem_ipcObj.msgQLock);
    pMsgCommon = (SystemIpcMsgQ_Msg *)MessageQ_alloc(
                    SYSTEM_IPC_MSGQ_HEAP,
                    sizeof(*pMsgCommon)+prmSize
                    );

    UTILS_assert(pMsgCommon!=NULL);

    if(prmSize && pPrm)
    {
        pMsgPrm = SYSTEM_IPC_MSGQ_MSG_PAYLOAD_PTR(pMsgCommon);
        memcpy(pMsgPrm, pPrm, prmSize);
    }

    pMsgCommon->linkId = linkId;
    pMsgCommon->cmd = cmd;
    pMsgCommon->prmSize = prmSize;
    pMsgCommon->waitAck = waitAck;
    pMsgCommon->status = OSA_SOK;

    MessageQ_setReplyQueue(gSystem_ipcObj.selfAckMsgQ, (MessageQ_Msg)pMsgCommon);
    MessageQ_setMsgId(pMsgCommon, linkId);

    //OSA_mutexLock(&gSystem_ipcObj.msgQLock);

    status = MessageQ_put(gSystem_ipcObj.remoteProcMsgQ[procId], (MessageQ_Msg)pMsgCommon);
    if(status!=MessageQ_S_SUCCESS)
    {
        printf(" %u: MSGQ: MsgQ put for [%s] failed !!!\n",
                        OSA_getCurTimeInMsec(),
                        MultiProc_getName(procId)
                        );
        MessageQ_free((MessageQ_Msg)pMsgCommon);
        OSA_mutexUnlock(&gSystem_ipcObj.msgQLock);
        return status;
    }

    if(waitAck)
    {
        SystemIpcMsgQ_Msg *pAckMsg;

        status = MessageQ_get(gSystem_ipcObj.selfAckMsgQ, (MessageQ_Msg*)&pAckMsg, timeout);
        if(status!=MessageQ_S_SUCCESS)
        {
            printf(" %u: MSGQ: MsgQ Ack get from [%s] failed !!!\n",
                        OSA_getCurTimeInMsec(),
                        MultiProc_getName(procId)
                        );
            MessageQ_free((MessageQ_Msg)pMsgCommon);
            OSA_mutexUnlock(&gSystem_ipcObj.msgQLock);
            return status;
        }

        if(prmSize && pPrm)
        {
            pMsgPrm = SYSTEM_IPC_MSGQ_MSG_PAYLOAD_PTR(pAckMsg);
            memcpy(pPrm, pMsgPrm, prmSize);
        }

        status = pAckMsg->status;

        MessageQ_free((MessageQ_Msg)pAckMsg);
    }

    OSA_mutexUnlock(&gSystem_ipcObj.msgQLock);

    return status;
}
Пример #16
0
static Void * pingThreadFxn(void *arg)
{
    Int                      threadNum = *(int *)arg;
    Int32                    status     = 0;
    MessageQ_Msg             msg        = NULL;
    MessageQ_Params          msgParams;
    UInt16                   i;
    MessageQ_Handle          handle;
    MessageQ_QueueId         queueId = MessageQ_INVALIDMESSAGEQ;

    char             remoteQueueName[64];
    char             hostQueueName[64];

    printf ("Entered pingThreadFxn: %d\n", threadNum);

    sprintf(remoteQueueName, "%s_%d%d", SLAVE_MESSAGEQNAME, threadNum, (threadNum % (MultiProc_getNumProcessors() - 1)) + 1);
    sprintf(hostQueueName,   "%s_%d", HOST_MESSAGEQNAME,  threadNum );

    /* Create the local Message Queue for receiving. */
    MessageQ_Params_init (&msgParams);
    handle = MessageQ_create (hostQueueName, &msgParams);
    if (handle == NULL) {
        printf ("Error in MessageQ_create\n");
        goto exit;
    }
    else {
        printf ("thread: %d, Local Message: %s, QId: 0x%x\n",
            threadNum, hostQueueName, MessageQ_getQueueId(handle));
    }

    /* Poll until remote side has it's messageQ created before we send: */
    do {
        status = MessageQ_open (remoteQueueName, &queueId);
        sleep (1);
    } while (status == MessageQ_E_NOTFOUND);
    if (status < 0) {
        printf ("Error in MessageQ_open [0x%x]\n", status);
        goto cleanup;
    }
    else {
        printf ("thread: %d, Remote queue: %s, QId: 0x%x\n",
                 threadNum, remoteQueueName, queueId);
    }

    printf ("\nthread: %d: Exchanging messages with remote processor...\n",
            threadNum);
    for (i = 0 ; i < numLoops ; i++) {
        /* Allocate message. */
        msg = MessageQ_alloc (HEAPID, MSGSIZE);
        if (msg == NULL) {
            printf ("Error in MessageQ_alloc\n");
            break;
        }

        MessageQ_setMsgId (msg, i);

        /* Have the remote proc reply to this message queue */
        MessageQ_setReplyQueue (handle, msg);

        status = MessageQ_put (queueId, msg);
        if (status < 0) {
            printf ("Error in MessageQ_put [0x%x]\n", status);
            break;
        }

        status = MessageQ_get(handle, &msg, MessageQ_FOREVER);
        if (status < 0) {
            printf ("Error in MessageQ_get [0x%x]\n", status);
            break;
        }
        else {
            /* Validate the returned message. */
            if ((msg != NULL) && (MessageQ_getMsgId (msg) != i)) {
                printf ("Data integrity failure!\n"
                        "    Expected %d\n"
                        "    Received %d\n",
                        i, MessageQ_getMsgId (msg));
                break;
            }

            status = MessageQ_free (msg);
        }

        printf ("thread: %d: Exchanged %d msgs\n", threadNum, (i+1));
    }

    printf ("thread: %d: pingThreadFxn successfully completed!\n", threadNum);

    MessageQ_close (&queueId);

cleanup:
    /* Clean-up */
    status = MessageQ_delete (&handle);
    if (status < 0) {
        printf ("Error in MessageQ_delete [0x%x]\n", status);
    }

exit:

    return ((void *)status);
}