/** ============================================================================
* @func helloDSP_Main
*
* @desc Entry point for the application
*
* @modif None
* ============================================================================
*/
NORMAL_API Void helloDSP_Main(IN Char8* dspExecutable, IN Char8* strNumIterations, IN Char8* strProcessorId)
{
DSP_STATUS status = DSP_SOK;
Uint32 numIterations = 0;
Uint8 processorId = 0;
SYSTEM_0Print ("========== Sample Application : helloDSP ==========\n");
if ((dspExecutable != NULL) && (strNumIterations != NULL))
{
numIterations = SYSTEM_Atoi(strNumIterations);
if (numIterations > 0xFFFF)
{
status = DSP_EINVALIDARG;
SYSTEM_1Print("ERROR! Invalid arguments specified for helloDSP application.\n Max iterations = %d\n", 0xFFFF);
}
else
{
processorId = SYSTEM_Atoi(strProcessorId);
if (processorId >= MAX_DSPS)
{
SYSTEM_1Print("== Error: Invalid processor id %d specified ==\n", processorId);
status = DSP_EFAIL;
}
/* Specify the dsp executable file name for message creation phase. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_Create(dspExecutable, strNumIterations, processorId);
/* Execute the message execute phase. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_Execute(numIterations, processorId);
}
/* Perform cleanup operation. */
helloDSP_Delete(processorId);
}
}
}
else
{
status = DSP_EINVALIDARG;
SYSTEM_0Print("ERROR! Invalid arguments specified for helloDSP application\n");
}
SYSTEM_0Print ("====================================================\n");
}
/** ============================================================================
* @func helloDSP_Delete
*
* @desc This function releases resources allocated earlier by call to
* helloDSP_Create ().
* During cleanup, the allocated resources are being freed
* unconditionally. Actual applications may require stricter check
* against return values for robustness.
*
* @modif None
* ============================================================================
*/
NORMAL_API Void helloDSP_Delete(Uint8 processorId)
{
DSP_STATUS status = DSP_SOK;
DSP_STATUS tmpStatus = DSP_SOK;
SYSTEM_0Print("Entered helloDSP_Delete ()\n");
/* Release the remote message queue */
status = MSGQ_release(SampleDspMsgq);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_release () failed. Status = [0x%x]\n", status);
}
/* Close the remote transport */
tmpStatus = MSGQ_transportClose(processorId);
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("MSGQ_transportClose () failed. Status = [0x%x]\n", status);
}
/* Stop execution on DSP. */
tmpStatus = PROC_stop(processorId);
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("PROC_stop () failed. Status = [0x%x]\n", status);
}
/* Reset the error handler before deleting the MSGQ that receives */
/* the error messages. */
tmpStatus = MSGQ_setErrorHandler(MSGQ_INVALIDMSGQ, MSGQ_INVALIDMSGQ);
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("MSGQ_setErrorHandler () failed. Status = [0x%x]\n", status);
}
/* Close the GPP's message queue */
tmpStatus = MSGQ_close(SampleGppMsgq);
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("MSGQ_close () failed. Status = [0x%x]\n", status);
}
/* Close the pool */
tmpStatus = POOL_close(POOL_makePoolId(processorId, SAMPLE_POOL_ID));
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("POOL_close () failed. Status = [0x%x]\n", status);
}
/* Detach from the processor */
tmpStatus = PROC_detach(processorId);
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("PROC_detach () failed. Status = [0x%x]\n", status);
}
/* Destroy the PROC object. */
tmpStatus = PROC_destroy();
if (DSP_SUCCEEDED(status) && DSP_FAILED(tmpStatus))
{
status = tmpStatus;
SYSTEM_1Print("PROC_destroy () failed. Status = [0x%x]\n", status);
}
SYSTEM_0Print("Leaving helloDSP_Delete ()\n");
}
/** ============================================================================
* @func helloDSP_Execute
*
* @desc This function implements the execute phase for this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API DSP_STATUS helloDSP_Execute(IN Uint32 numIterations, Uint8 processorId)
{
DSP_STATUS status = DSP_SOK;
Uint16 sequenceNumber = 0;
Uint16 msgId = 0;
Uint32 i;
ControlMsg *msg;
SYSTEM_0Print("Entered helloDSP_Execute ()\n");
#if defined (PROFILE)
SYSTEM_GetStartTime();
#endif
for (i = 1 ; ((numIterations == 0) || (i <= (numIterations + 1))) && (DSP_SUCCEEDED (status)); i++)
{
/* Receive the message. */
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
#if defined (VERIFY_DATA)
/* Verify correctness of data received. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_VerifyData(msg, sequenceNumber);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
}
}
#endif
if (msg->command == 0x01)
SYSTEM_1Print("Message received: %s\n", (Uint32) msg->arg1);
else if (msg->command == 0x02)
SYSTEM_1Print("Message received: %s\n", (Uint32) msg->arg1);
/* If the message received is the final one, free it. */
if ((numIterations != 0) && (i == (numIterations + 1)))
{
MSGQ_free((MsgqMsg) msg);
}
else
{
/* Send the same message received in earlier MSGQ_get () call. */
if (DSP_SUCCEEDED(status))
{
msgId = MSGQ_getMsgId(msg);
MSGQ_setMsgId(msg, msgId);
status = MSGQ_put(SampleDspMsgq, (MsgqMsg) msg);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
SYSTEM_1Print("MSGQ_put () failed. Status = [0x%x]\n", status);
}
}
sequenceNumber++;
/* Make sure that the sequenceNumber stays within the permitted
* range for applications. */
if (sequenceNumber == MSGQ_INTERNALIDSSTART)
{
sequenceNumber = 0;
}
#if !defined (PROFILE)
if (DSP_SUCCEEDED(status) && ((i % 100) == 0))
{
SYSTEM_1Print("Transferred %ld messages\n", i);
}
#endif
}
}
#if defined (PROFILE)
if (DSP_SUCCEEDED(status))
{
SYSTEM_GetEndTime();
SYSTEM_GetProfileInfo(numIterations);
}
#endif
SYSTEM_0Print("Leaving helloDSP_Execute ()\n");
return status;
}
/** ============================================================================
* @func helloDSP_Create
*
* @desc This function allocates and initializes resources used by
* this application.
*
* @modif helloDSP_InpBufs , helloDSP_OutBufs
* ============================================================================
*/
NORMAL_API DSP_STATUS helloDSP_Create(IN Char8* dspExecutable, IN Char8* strNumIterations, IN Uint8 processorId)
{
DSP_STATUS status = DSP_SOK;
Uint32 numArgs = NUM_ARGS;
MSGQ_LocateAttrs syncLocateAttrs;
Char8* args[NUM_ARGS];
SYSTEM_0Print("Entered helloDSP_Create ()\n");
/* Create and initialize the proc object. */
status = PROC_setup(NULL);
/* Attach the Dsp with which the transfers have to be done. */
if (DSP_SUCCEEDED(status))
{
status = PROC_attach(processorId, NULL);
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_attach () failed. Status = [0x%x]\n", status);
}
}
/* Open the pool. */
if (DSP_SUCCEEDED(status))
{
status = POOL_open(POOL_makePoolId(processorId, SAMPLE_POOL_ID), &SamplePoolAttrs);
if (DSP_FAILED(status))
{
SYSTEM_1Print("POOL_open () failed. Status = [0x%x]\n", status);
}
}
else
{
SYSTEM_1Print("PROC_setup () failed. Status = [0x%x]\n", status);
}
/* Open the GPP's message queue */
if (DSP_SUCCEEDED(status))
{
status = MSGQ_open(SampleGppMsgqName, &SampleGppMsgq, NULL);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_open () failed. Status = [0x%x]\n", status);
}
}
/* Set the message queue that will receive any async. errors */
if (DSP_SUCCEEDED(status))
{
status = MSGQ_setErrorHandler(SampleGppMsgq, POOL_makePoolId(processorId, SAMPLE_POOL_ID));
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_setErrorHandler () failed. Status = [0x%x]\n", status);
}
}
/* Load the executable on the DSP. */
if (DSP_SUCCEEDED(status))
{
args [0] = strNumIterations;
{
status = PROC_load(processorId, dspExecutable, numArgs, args);
}
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_load () failed. Status = [0x%x]\n", status);
}
}
/* Start execution on DSP. */
if (DSP_SUCCEEDED(status))
{
status = PROC_start(processorId);
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_start () failed. Status = [0x%x]\n", status);
}
}
/* Open the remote transport. */
if (DSP_SUCCEEDED(status))
{
mqtAttrs.poolId = POOL_makePoolId(processorId, SAMPLE_POOL_ID);
status = MSGQ_transportOpen(processorId, &mqtAttrs);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_transportOpen () failed. Status = [0x%x]\n", status);
}
}
/* Locate the DSP's message queue */
/* At this point the DSP must open a message queue named "DSPMSGQ" */
if (DSP_SUCCEEDED(status))
{
syncLocateAttrs.timeout = WAIT_FOREVER;
status = DSP_ENOTFOUND;
SYSTEM_2Sprint(dspMsgqName, "%s%d", (Uint32) SampleDspMsgqName, processorId);
while ((status == DSP_ENOTFOUND) || (status == DSP_ENOTREADY))
{
status = MSGQ_locate(dspMsgqName, &SampleDspMsgq, &syncLocateAttrs);
if ((status == DSP_ENOTFOUND) || (status == DSP_ENOTREADY))
{
SYSTEM_Sleep(100000);
}
else if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_locate () failed. Status = [0x%x]\n", status);
}
}
}
SYSTEM_0Print("Leaving helloDSP_Create ()\n");
return status;
}
/** ============================================================================
* @func helloDSP_Execute
*
* @desc This function implements the execute phase for this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API DSP_STATUS helloDSP_Execute(IN Uint32 numIterations, Uint8 processorId)
{
DSP_STATUS status = DSP_SOK;
Uint16 sequenceNumber = 0;
Uint16 msgId = 0;
Uint8 i,j,k, count;
ControlMsg *msg;
Uint16 A[SIZE][SIZE], B[SIZE][SIZE];
Uint8 step_select;
step_select = SIZE % 2;
SYSTEM_0Print("Entered helloDSP_Execute ()\n");
//Create Matrix
for (j = 0; j < SIZE; j++)
{
for (k = 0; k < SIZE; k++)
{
A[j][k] = 1;
B[j][k] = 2;
}
}
#if defined (PROFILE)
SYSTEM_GetStartTime();
#endif
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
#if defined (VERIFY_DATA)
/* Verify correctness of data received. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_VerifyData(msg, sequenceNumber);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
}
}
#endif
SYSTEM_1Print("Message received: %s\n", (Uint32) msg->arg1);
for (i = 1 ; ((numIterations == 0) || (i < (numIterations + 1))) && (DSP_SUCCEEDED (status)); i++)
{
count = 0;
while(count < 2)
{
/* If the message received is the final one, free it. */
if ((numIterations != 0) && (i == (numIterations + 1)))
{
MSGQ_free((MsgqMsg) msg);
}
else
{
if(count == 0)
{ msg->row = SIZE/2;
msg->col = SIZE;
for (j = 0; j < SIZE/2; j++)
{
for (k = 0; k < SIZE; k++)
{
msg->mat[j+SIZE/2 + step_select][k] = A[j+ SIZE/2 + step_select][k];
}
}
}
if(count == 1)
{ msg->row = SIZE;
msg->col = SIZE;
for (j = 0; j < SIZE; j++)
{
for (k = 0; k < SIZE; k++)
{
msg->mat[j][k] = B[j][k];
}
}
}
/* Send the same message received in earlier MSGQ_get () call. */
if (DSP_SUCCEEDED(status))
{
msgId = MSGQ_getMsgId(msg);
MSGQ_setMsgId(msg, msgId);
status = MSGQ_put(SampleDspMsgq, (MsgqMsg) msg);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
SYSTEM_1Print("MSGQ_put () failed. Status = [0x%x]\n", status);
}
}
sequenceNumber++;
/* Make sure that the sequenceNumber stays within the permitted
* range for applications. */
if (sequenceNumber == MSGQ_INTERNALIDSSTART)
{
sequenceNumber = 0;
}
#if !defined (PROFILE)
if (DSP_SUCCEEDED(status) && ((i % 100) == 0))
{
SYSTEM_1Print("Transferred %ld messages\n", i);
}
#endif
/* Receive the message. */
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
#if defined (VERIFY_DATA)
/* Verify correctness of data received. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_VerifyData(msg, sequenceNumber);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
}
}
#endif
if (msg->command == 0x02)
{
SYSTEM_1Print("Message received: %s\n", (Uint32) msg->arg1);
if(count == 1)
{
for (j = 0; j < SIZE/2; j++)
{
for (k = 0; k < SIZE; k++)
{
printf("%d ", msg->mat[j+SIZE/2+step_select][k]);
}
printf("\n");
}
}
//printf("SIZE %d\n", SIZE);
}
}
printf("%d\n", count);
count++;
}//while ends
}
#if defined (PROFILE)
if (DSP_SUCCEEDED(status))
{
SYSTEM_GetEndTime();
SYSTEM_GetProfileInfo(numIterations);
}
#endif
SYSTEM_0Print("Leaving helloDSP_Execute ()\n");
return status;
}
/** ============================================================================
* @func helloDSP_Main
*
* @desc Entry point for the application
*
* @modif None
* ============================================================================
*/
NORMAL_API Void helloDSP_Main(IN Char8* dspExecutable, IN Char8* strNumIterations, IN Char8* strProcessorId)
{
DSP_STATUS status = DSP_SOK;
//Uint32 numIterations = 0;
Uint8 processorId = 0;
// Define the mxsize to define the matrices
Uint32 mxSize = SYSTEM_Atoi(strNumIterations);
Uint32 matrixA[mxSize * mxSize];
Uint32 matrixB[mxSize * mxSize];
Uint32 matrixC[mxSize * mxSize];
//Uint8 numMessages = ((2 * mxSize * mxSize - 1) / ARG_SIZE) + 2;
// WARNING strNumIterations is the matrixSize
SYSTEM_0Print ("========== Starting the GPP Code ==========\n");
if ((dspExecutable != NULL) && (strNumIterations != NULL))
{
// WARNING This is also the matrix size
mxSize = SYSTEM_Atoi(strNumIterations);
// TODO possibly alter the maximum matrix size afterwards
if (mxSize > 128)
{
status = DSP_EINVALIDARG;
SYSTEM_1Print("ERROR! Invalid arguments specified for helloDSP application.\n Max matrixsize = %d\n", 128);
}
else
{
processorId = SYSTEM_Atoi(strProcessorId);
if (processorId >= MAX_DSPS)
{
SYSTEM_1Print("== Error: Invalid processor id %d specified ==\n", processorId);
status = DSP_EFAIL;
}
/* Specify the dsp executable file name for message creation phase. */
if (DSP_SUCCEEDED(status))
{
// WARNING strNumIterations is still the matrixSize
status = helloDSP_Create(dspExecutable, strNumIterations, processorId);
/* Execute the message execute phase. */
if (DSP_SUCCEEDED(status))
{
status = helloDSP_Execute(mxSize, processorId, (Uint32*) matrixA, (Uint32*) matrixB, (Uint32*) matrixC);
}
/* Perform cleanup operation. */
helloDSP_Delete(processorId);
}
}
}
else
{
status = DSP_EINVALIDARG;
SYSTEM_0Print("ERROR! Invalid arguments specified for helloDSP application\n");
}
SYSTEM_0Print ("====================================================\n");
}
// WARNING mxSize is the matrixSize here
NORMAL_API DSP_STATUS helloDSP_Execute(IN Uint32 mxSize, Uint8 processorId, Uint32* matrixA, Uint32* matrixB, Uint32* matrixC)
{
DSP_STATUS status = DSP_SOK;
Uint16 sequenceNumber = 0;
Uint16 msgId = 0;
Uint32 i, j;
ControlMsg *msg;
Uint8 flag = 0;
Uint32 matrixD[mxSize * mxSize];
Uint32 numElements, numMessages, elementCount, messageCount;
Uint32 sizeElements, numProdMessages, matrixCount, prodElements;
Char8 ascii_string[STRING_SIZE + 1];
Char8 null_string[STRING_SIZE + 1] = {'\0','\0','\0','\0','\0','\0'};
myStrcpy(ascii_string, null_string);
SYSTEM_0Print("Entered helloDSP_Execute ()\n");
// Wait for the first DSP is awake message
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
// TODO possibly verify the data?
SYSTEM_1Print("Received message: %s\n", (Uint32) msg->arg1);
SYSTEM_0Print("Generated matrices:\n");
// Generate the matrices after the DSPLink is established
matrixGen(mxSize, matrixA, matrixB);
// Have to translate the Int32 matrix elements to string elements
// or the communication protocol
prodElements = (mxSize * mxSize);
numElements = (mxSize * mxSize * 2);
sizeElements = numElements * STRING_SIZE;
numMessages = ((sizeElements - 1) / ARG_MSG) + 1;
numProdMessages = (((sizeElements / 2) - 1) / ARG_MSG) + 1;
//SYSTEM_2Print("NumElements: %d, NumMessages: %d\n", numElements, numMessages);
// WARNING Sending 5 Char8 each for loop
// Start sending the matrices to the DSP which is not waiting
for (messageCount = 0, elementCount = 0; messageCount < numMessages; messageCount++)
{
// First send a message, then receive
//for ( ; (((elementCount - (messageCount * ARG_MSG)) * STRING_SIZE) < ARG_MSG ) && elementCount < numElements; elementCount++)
#if defined (PROFILE)
SYSTEM_GetStartTimeDspEnc();
#endif
for (; (elementCount - (messageCount * ARG_MSG)) < ARG_MSG && elementCount < numElements; elementCount++)
{
//SYSTEM_0Print("Putting element in a message\n");
//itoa
if(elementCount < prodElements)
{
SYSTEM_itoa(matrixA[elementCount], ascii_string, 10);
//SYSTEM_1Print("Looping through string: %s in MatrixA\n", (Uint32) ascii_string);
}
else
{
SYSTEM_itoa(matrixB[elementCount - prodElements], ascii_string, 10);
//SYSTEM_1Print("Looping through string: %s in MatrixB\n", (Uint32) ascii_string);
}
//SYSTEM_0Print("After SYSTEM_itoa\n");
// loop through characters of the string
for (i = 0; i < STRING_SIZE; i++)
{
msg->arg1[((elementCount * STRING_SIZE) - (messageCount * ARG_MSG)) + i] = ascii_string[i];
//SYSTEM_sprintf(msg->arg1[(elementCount - (messageCount * ARG_MSG)) + i] = ascii_string[i];
}
// clean the string
myStrcpy(ascii_string, null_string);
}
#if defined (PROFILE)
SYSTEM_GetEndTimeDspEnc();
#endif
//SYSTEM_0Print("Filled a single message\n");
// After filling a single message, should send it to the DSP and wait for a reply
// unless it is the last one
if (DSP_SUCCEEDED(status))
{
//SYSTEM_0Print("DSP succeeded after filling\n");
#if defined (PROFILE)
SYSTEM_GetStartTimeDspMes();
#endif
msgId = MSGQ_getMsgId(msg);
MSGQ_setMsgId(msg, msgId);
// TODO set the command flag of the msg to distinguish
status = MSGQ_put(SampleDspMsgq, (MsgqMsg) msg);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
SYSTEM_1Print("MSGQ_put () failed. Status = [0x%x]\n", status);
}
#if defined (PROFILE)
else {
SYSTEM_GetEndTimeDspMes();
SYSTEM_GetStartTimeDspCalc();
}
#endif
}
//SYSTEM_0Print("Message send\n");
sequenceNumber++;
// Make sure that the sequenceNumber stays within the permitted
// range for applications.
if (sequenceNumber == MSGQ_INTERNALIDSSTART)
{
//SYSTEM_0Print("Something with sequences\n");
sequenceNumber = 0;
}
// If it is the last message, don't wait for an acknowledge
if (messageCount + 1 < numMessages)
{
// Wait for a response of the DSP before sending a reply
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
//SYSTEM_1Print("Received: %s\n", (Uint32) msg->arg1);
}
}
//SYSTEM_0Print("Sending completed..\n");
// TODO start receiving the product matrix
// WARNING wait and acknowledge except for last loop
for (messageCount = 0, elementCount = 0, matrixCount = 0; messageCount < numProdMessages; messageCount++)
{
status = MSGQ_get(SampleGppMsgq, WAIT_FOREVER, (MsgqMsg *) &msg);
if (messageCount == 0) {
#if defined (PROFILE)
SYSTEM_GetEndTimeDspCalc();
#endif
SYSTEM_0Print("\nProduct matrix on DSP:\n");
}
//SYSTEM_1Print("Message received: %s\n", (Uint32) msg->arg1);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_get () failed. Status = [0x%x]\n", status);
}
// Put the received message in the matrixC
for (; matrixCount < prodElements && (elementCount - (messageCount * ARG_MSG)) < ARG_MSG && elementCount < (prodElements * STRING_SIZE); matrixCount++, elementCount += STRING_SIZE)
{
// atoi
for (i = 0; i < STRING_SIZE; i++)
{
ascii_string[i] = msg->arg1[elementCount + i];
}
ascii_string[5] = '\0';
/*
if (matrixCount >= 72)
{
SYSTEM_1Print("Ascii string received: %s\n", ascii_string);
}
*/
// Put it in the matrixC
matrixC[matrixCount] = atoi(ascii_string);
// print the string
if (matrixCount % mxSize == 0)
{
SYSTEM_0Print("\n");
}
SYSTEM_1Print("%d ", matrixC[matrixCount]);
// Clean the string
myStrcpy(ascii_string, null_string);
}
// If this is not the last message, send an acknowledge
if (messageCount + 1 < numProdMessages)
{
// Send the same message received in earlier MSGQ_get () call.
if (DSP_SUCCEEDED(status))
{
msgId = MSGQ_getMsgId(msg);
MSGQ_setMsgId(msg, msgId);
status = MSGQ_put(SampleDspMsgq, (MsgqMsg) msg);
if (DSP_FAILED(status))
{
MSGQ_free((MsgqMsg) msg);
SYSTEM_1Print("MSGQ_put () failed. Status = [0x%x]\n", status);
}
}
sequenceNumber++;
// Make sure that the sequenceNumber stays within the permitted
// range for applications.
if (sequenceNumber == MSGQ_INTERNALIDSSTART)
{
sequenceNumber = 0;
}
}
}
SYSTEM_0Print("\n");
MSGQ_free((MsgqMsg) msg);
//SYSTEM_0Print("After freeing the message..\n");
SYSTEM_0Print("\nProduct matrix on GPP:\n");
#if defined (PROFILE)
SYSTEM_GetStartTimeGpp();
#endif
matMult(matrixA, matrixB, matrixD, mxSize);
#if defined (PROFILE)
SYSTEM_GetEndTimeGpp();
#endif
// compare the matrices
for(i=0; i<mxSize; i++)
{
for(j=0; j<mxSize; j++)
{
if(matrixC[i * mxSize + j] != matrixD[i * mxSize + j])
{
SYSTEM_2Print("Matrices are not equal row: %d, column: %d\n", i, j);
flag = 1;
break;
}
}
}
if (flag == 0)
{
SYSTEM_0Print("\nMatrix products are equal\n");
}
SYSTEM_0Print("Leaving helloDSP_Execute ()\n");
#if defined (PROFILE)
if (DSP_SUCCEEDED(status))
{
SYSTEM_GetProfileInfoGpp();
SYSTEM_GetProfileInfoDsp(numMessages); //is numProdMessages interesting?
}
#endif
return status;
}