This thread has been locked.
If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.
Hi,
i´ve developed my app in 4 core. I´m using ddr3 (32M/core) to store my data.
when I using the simulator all program in running 100% each core send message to another core and all data ok.
Now when I try to use the evm my app does not initialize and still stopped.
When I try to use program that not use DDR3 all program is working.
In the EVM I´m using no boot mode. I believe that I have some mistake. Can anyone help me?
Regards, Nivaldo
hi,
I was looking for and found one way to see the problem.
I have the print screen and you can see. But can you help me?what i need to do and solve this bug?
sorry
now the source code
/************************************************************************************************************************
Programa para core 1
**********************************************************************************************************************/
#include <stdio.h>
#include <xdc/std.h>
#include <string.h>
#include <math.h>
/* -----------------------------------XDC.RUNTIME module Headers */
#include <xdc/runtime/System.h>
#include <xdc/runtime/IHeap.h>
/* ----------------------------------- IPC module Headers */
#include <ti/ipc/Ipc.h>
#include <ti/ipc/MessageQ.h>
#include <ti/ipc/HeapBufMP.h>
#include <ti/ipc/MultiProc.h>
/* ----------------------------------- BIOS6 module Headers */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
/* ----------------------------------- To get globals from .cfg Header */
#include <xdc/cfg/global.h>
//****************************************************************************************************************
// Cache
#include <csl/csl_types.h>
#include <csl/csl.h>
#include <csl/csl_cache.h>
#include <ti/sysbios/hal/Cache.h>
//****************************************************************************************************************
#define tamanho_linha 2046
#define tamanho_coluna 128
#define HEAP_NAME "myHeapBuf"
#define HEAPID 0
//****************************************************************************************************************
typedef struct DataMsg_vetor_core_0
{
MessageQ_MsgHeader header;
double *vetor_data_0;
} DataMsg_vetor_core_0;
//****************************************************************************************************************
typedef struct DataMsg_vetor_core_1
{
MessageQ_MsgHeader header;
double *vetor_data_1;
} DataMsg_vetor_core_1;
//****************************************************************************************************************
Char localQueueName[10];
Char nextQueueName[10];
UInt16 nextProcId;
//****************************************************************************************************************
// Vari�veis
//****************************************************************************************************************
int passo = 10;
int decimacao = 10;
int cont,linha,coluna,tamanho_linha_coluna, cont_teste;
double maximo;
double valor_16,media_16;
//****************************************************************************************************************
Void tsk0_func(UArg arg0, UArg arg1)
{
MessageQ_Msg msg;
MessageQ_Handle messageQ;
MessageQ_QueueId remoteQueueId;
Int status;
// UInt16 msgId = 0;
HeapBufMP_Handle heapHandle;
HeapBufMP_Params heapBufParams;
DataMsg_vetor_core_1 *dataMsg_vetor_core_1;
DataMsg_vetor_core_0 *dataMsg_vetor_core_0;
//****************************************************************************************************************
// Cria heap para alocar a mensagem
//****************************************************************************************************************
if (MultiProc_self() == 0)
{
/*
* Create the heap that will be used to allocate messages.
*/
HeapBufMP_Params_init(&heapBufParams);
heapBufParams.regionId = 0;
heapBufParams.name = HEAP_NAME;
heapBufParams.align = 128;//1024;
heapBufParams.numBlocks = 1024;
heapBufParams.blockSize = 1024;//sizeof(DataMsg_vetor_core_1);//(DataMsg_1_int);;
// heapBufParams.blockSize = sizeof(DataMsg_vetor_core_1);
heapHandle = HeapBufMP_create(&heapBufParams);
if (heapHandle == NULL)
{
System_abort("HeapBufMP_create failed\n" );
}
}
else
{
/* Open the heap created by the other processor. Loop until opened. */
do {
status = HeapBufMP_open(HEAP_NAME, &heapHandle);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
if (status < 0)
{
Task_sleep(1);
}
} while (status < 0);
}
/* Register this heap with MessageQ */
MessageQ_registerHeap((IHeap_Handle)heapHandle, HEAPID);
//*********************************************************************************************************
// Conectando ao core 0
//*********************************************************************************************************
messageQ = MessageQ_create("CORE0", NULL);
if (messageQ == NULL)
{
System_abort("MessageQ_create failed\n" );
}
//*********************************************************************************************************
status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER);
if (status < 0)
{
System_abort("This should not happen since timeout is forever\n");
}
//*********************************************************************************************************
// Rotina core 1 - recebendo dados do core 0
//*********************************************************************************************************
tamanho_linha_coluna = tamanho_linha*tamanho_coluna;
System_printf("Recebendo dados do core 0 \n\n");
dataMsg_vetor_core_0 = (DataMsg_vetor_core_0*)MessageQ_alloc(HEAPID,sizeof(DataMsg_vetor_core_0));
MessageQ_get(messageQ, (MessageQ_Msg*)&dataMsg_vetor_core_0, MessageQ_FOREVER);
Cache_inv(dataMsg_vetor_core_0->vetor_data_0,tamanho_linha_coluna*sizeof(double),Cache_Type_ALL, heapBufParams.align);
printf("\n endere�o data_0 %x\n",dataMsg_vetor_core_0->vetor_data_0);
System_printf("\nRotina core 1 \n\n");
//*********************************************************************************************************
// Calcula valor m�ximo antes do envelope
//*********************************************************************************************************
maximo = 1.0e-100;
for(linha = 0; linha < tamanho_linha_coluna; linha++)
{
if (dataMsg_vetor_core_0->vetor_data_0[linha] > maximo)
maximo = dataMsg_vetor_core_0->vetor_data_0[linha];
}
printf("\n\n O valor m�ximo antes do envelope � = %e\n\n",maximo);
//*********************************************************************************************************
MessageQ_free(msg);
MessageQ_delete(&messageQ);
//*********************************************************************************************************
// Chamando core 2
//*********************************************************************************************************
System_printf("chamando o core 2 \n\n");
//*********************************************************************************************************
// Enviando para o core 2
//*********************************************************************************************************
do {
status = MessageQ_open("CORE1", &remoteQueueId);
if (status < 0)
{
Task_sleep(1);
}
} while (status < 0);
//*********************************************************************************************************
msg = MessageQ_alloc(HEAPID, sizeof(MessageQ_MsgHeader));
if (msg == NULL)
{
System_abort("MessageQ_alloc failed\n" );
}
//*********************************************************************************************************
System_printf("Enviando dados para core 2 \n\n");
status = MessageQ_put(remoteQueueId, msg);
if (status < 0)
{
System_abort("MessageQ_put had a failure/error\n");
}
//***********************************************************************************************************
dataMsg_vetor_core_1 = (DataMsg_vetor_core_1*)MessageQ_alloc(HEAPID,sizeof(DataMsg_vetor_core_1));
//***********************************************************************************************************
// alocando dado na regi�o shared
//***********************************************************************************************************
dataMsg_vetor_core_1->vetor_data_1 = (double*) HeapBufMP_alloc(heapHandle, sizeof(double), heapBufParams.align);
if (dataMsg_vetor_core_1->vetor_data_1 == NULL)
System_abort("erro HeapBufMP_alloc core 1");
printf("\n heapBufParams.align data 1--> %d\n",heapBufParams.align);
//***********************************************************************************************************
dataMsg_vetor_core_1->vetor_data_1 = (double *) malloc((tamanho_linha_coluna)*sizeof(double));
//***********************************************************************************************************
// Criando Buffer de Zeros
//***********************************************************************************************************
printf("\nbuffer de zeros do core 1 \n");
for(linha = 0; linha < tamanho_linha_coluna; linha++)
dataMsg_vetor_core_1->vetor_data_1[linha] = 0.0;
//***********************************************************************************************************
for(linha = 0; linha < tamanho_linha_coluna; linha++)
dataMsg_vetor_core_1->vetor_data_1[linha] = dataMsg_vetor_core_0->vetor_data_0[linha];
System_printf("\n*************************************************************************");
System_printf("\n*********** Verfica se dados est�o certos *********************");
System_printf("\n*************************************************************************\n");
cont_teste = 0;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 1;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2045;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046*127;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046*128-1;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
System_printf("\n*************************************************************************");
//*************************************************************************************************************************************
System_printf("\n*************************************************************************");
System_printf("\n*********** filtro ruido por media 16 *********************");
System_printf("\n*************************************************************************\n");
long vezes,nl,nc;
for (nl = 0; nl < tamanho_linha; nl++)
{
for (vezes = 0; vezes < 8; vezes++)
{
media_16 = 0;
for (nc = 1; nc <= 16; nc++)
{
valor_16 = dataMsg_vetor_core_0->vetor_data_0[vezes*16*2046 + (nc - 1)*2046 + nl];
media_16 = media_16 + valor_16;
}
media_16 = (media_16/16);
for (nc = 1; nc <= 16; nc++)
dataMsg_vetor_core_1->vetor_data_1[vezes*16*2046 + (nc - 1)*2046 + nl] = dataMsg_vetor_core_0->vetor_data_0[vezes*16*2046 + (nc - 1)*2046 + nl] - media_16;
}
}
System_printf("\n*************************************************************************");
System_printf("\n*********** Verfica dados ru�do *********************");
System_printf("\n*************************************************************************\n");
cont_teste = 0;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 1;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2045;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046*127;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
cont_teste = 2046*128-1;
printf("\nvetor_data_1[%d] = %e - end %x",cont_teste, dataMsg_vetor_core_1->vetor_data_1[cont_teste],&dataMsg_vetor_core_1->vetor_data_1[cont_teste]);
System_printf("\n*************************************************************************");
//**************************************************************************************************************************************
// printf("\n total de pontos %d\n",cont_novo);
// for(linha = 0; linha < 102; linha++)
// printf("dataMsg_vetor_core_1->vetor_data_1[%d] = %e - endereco %x\n",linha,dataMsg_vetor_core_1->vetor_data_1[linha],&dataMsg_vetor_core_1->vetor_data_1[linha]);
//*********************************************************************************************************
//***********************************************************************************************************
Cache_wbInv(dataMsg_vetor_core_1->vetor_data_1,(tamanho_linha_coluna)*sizeof(double),Cache_Type_ALL, heapBufParams.align);
// Cache_wbInv(dataMsg_vetor_core_1->vetor_data_1,sizeof(double),Cache_Type_ALL, heapBufParams.align);
// printf("\ncore 1 passou wbinv\n");
status = MessageQ_put(remoteQueueId,(MessageQ_Msg)dataMsg_vetor_core_1);
if (status < 0)
{
System_abort("Falhou a transmiss�o da dados para core 2 \n");
}
// printf("\npassou put\n");
//*********************************************************************************************************
MessageQ_close(&remoteQueueId);
//*********************************************************************************************************
// envia_pc_txt(valor_recebido);
System_printf("fim core 1\n");
while(1);// nao posso finalizar.
// BIOS_exit(0);
}
/*
* ======== main ========
* Synchronizes all processors (in Ipc_start) and calls BIOS_start
*/
Int main(Int argc, Char* argv[])
{
Int status;
printf("Iniciando core 1\n\n");
status = Ipc_start();
if (status < 0)
{
System_abort("Ipc_start failed\n");
}
BIOS_start();
return (0);
}