/* * ======== BUF_create ======== */ BUF_Handle BUF_create(Uns numbuff, MEM_sizep size, Uns align, BUF_Attrs *attrs) { HeapBuf_Params params; BUF_Handle buf = NULL; Error_Block eb; if (attrs == NULL) { attrs = &BUF_ATTRS; } Error_init(&eb); HeapBuf_Params_init(¶ms); params.buf = MEM_alloc(attrs->segid, size * numbuff, align); params.numBlocks = numbuff; params.blockSize = size; params.align = align; params.bufSize = size * numbuff; if (params.buf != NULL) { buf = (BUF_Handle)HeapBuf_create(¶ms, &eb); } return (buf); }
Int SystemCfg_createResources(SystemCfg_Object *obj) { Error_Block eb; Int status = 0; HeapBuf_Params heapBufP; IHeap_Handle heapH; Log_print1(Diags_ENTRY | Diags_INFO, "--> "FXNN": (obj=0x%x)",(IArg)obj); Error_init(&eb); /* allocate heap backing store from SR_0 heap */ heapH = (IHeap_Handle)SharedRegion_getHeap(0); obj->rcmHeapBufSize = 5 * 128; obj->rcmHeapBufBase = Memory_alloc(heapH, obj->rcmHeapBufSize, 128, &eb); if (Error_check(&eb)) { Log_error1(FXNN": out of memory: size=%u", obj->rcmHeapBufSize); status = -1; goto leave; } /* create heap for messages */ HeapBuf_Params_init(&heapBufP); heapBufP.blockSize = 128; // header = 52 B, payload = 76 B heapBufP.numBlocks = 5; // 5 messages, total heap storage = 640 B heapBufP.align = 128; // align on cache line boundary heapBufP.buf = obj->rcmHeapBufBase; // heap storage base address heapBufP.bufSize = obj->rcmHeapBufSize; // heap storage size obj->rcmHeapH = HeapBuf_create(&heapBufP, &eb); if (Error_check(&eb)) { Log_error0(FXNN": HeapBuf_create() failed"); status = -1; goto leave; } /* register this heap with MessageQ */ Log_print2(Diags_INFO, FXNN": MessageQ_registerHeap: (rcmHeapH: 0x%x, heapId: %d)", (IArg)(obj->rcmHeapH), (IArg)SystemCfg_RcmMsgHeapId_CompDev); MessageQ_registerHeap((Ptr)(obj->rcmHeapH), SystemCfg_RcmMsgHeapId_CompDev); leave: Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status); return(status); }
/* * ======== main ======== */ Int main() { /* Call board init functions */ Board_initGeneral(); /* Construct BIOS objects */ Task_Params taskParams; HeapBuf_Params heapBufParams; HeapMem_Params heapMemParams; /* Construct writer/reader Task threads */ Task_Params_init(&taskParams); taskParams.stackSize = TASKSTACKSIZE; taskParams.stack = &task0Stack; Task_construct(&task0Struct, (Task_FuncPtr)task0Fxn, &taskParams, NULL); taskParams.stack = &task1Stack; Task_construct(&task1Struct, (Task_FuncPtr)task1Fxn, &taskParams, NULL); /* Construct two heaps to be used by two separate tasks for alloc and free. */ HeapBuf_Params_init(&heapBufParams); heapBufParams.blockSize = HEAPBUFSIZE / 2; heapBufParams.numBlocks = 2; heapBufParams.align = 8; heapBufParams.buf = heapBufBuffer; heapBufParams.bufSize = HEAPBUFSIZE; HeapBuf_construct(&heapBufStruct, &heapBufParams, NULL); task0Heap = HeapBuf_handle(&heapBufStruct); HeapMem_Params_init(&heapMemParams); heapMemParams.size = HEAPMEMSIZE; heapMemParams.minBlockAlign = 8; heapMemParams.buf = heapMemBuffer; HeapMem_construct(&heapMemStruct, &heapMemParams); task1Heap = HeapMem_handle(&heapMemStruct); System_printf("Memory example started.\n"); BIOS_start(); /* Does not return */ return(0); }
/* * ======== tsk0_func ======== * Allocates a message and ping-pongs the message around the processors. * A local message queue is created and a remote message queue is opened. * Messages are sent to the remote message queue and retrieved from the * local MessageQ. */ Void tsk0_func(UArg arg0, UArg arg1) { MessageQ_Msg msg; MessageQ_Handle messageQ; MessageQ_QueueId remoteQueueId; Int status; UInt16 msgId = 0; Ptr buf; HeapBuf_Handle heapHandle; HeapBuf_Params hbparams; SizeT blockSize; UInt numBlocks; /* Compute the blockSize & numBlocks for the HeapBuf */ numBlocks = 2; blockSize = sizeof(MessageQ_MsgHeader); /* Alloc a buffer from the default heap */ buf = Memory_alloc(0, numBlocks * blockSize, 0, NULL); /* * Create the heap that is used for allocating MessageQ messages. */ HeapBuf_Params_init(&hbparams); hbparams.align = 0; hbparams.numBlocks = numBlocks; hbparams.blockSize = blockSize; hbparams.bufSize = numBlocks * blockSize; hbparams.buf = buf; heapHandle = HeapBuf_create(&hbparams, NULL); if (heapHandle == NULL) { System_abort("HeapBuf_create failed\n" ); } /* Register default system heap with MessageQ */ MessageQ_registerHeap((IHeap_Handle)(heapHandle), HEAPID); /* Create the local message queue */ messageQ = MessageQ_create(localQueueName, NULL); if (messageQ == NULL) { System_abort("MessageQ_create failed\n" ); } /* Open the remote message queue. Spin until it is ready. */ do { status = MessageQ_open(remoteQueueName, &remoteQueueId); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); if (MultiProc_self() == 0) { /* Allocate a message to be ping-ponged around the processors */ msg = MessageQ_alloc(HEAPID, sizeof(MessageQ_MsgHeader)); if (msg == NULL) { System_abort("MessageQ_alloc failed\n" ); } /* * Send the message to the remote processor and wait for a message * from the previous processor. */ System_printf("Start the main loop\n"); while (msgId < NUMLOOPS) { /* Increment...the remote side will check this */ msgId++; MessageQ_setMsgId(msg, msgId); System_printf("Sending a message #%d to %s\n", msgId, remoteQueueName); /* send the message to the remote processor */ status = MessageQ_put(remoteQueueId, msg); if (status < 0) { System_abort("MessageQ_put had a failure/error\n"); } /* Get a message */ status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER); if (status < 0) { System_abort("This should not happen since timeout is forever\n"); } } } else { /* * Wait for a message from the previous processor and * send it to the remote processor */ System_printf("Start the main loop\n"); while (TRUE) { /* Get a message */ status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER); if (status < 0) { System_abort("This should not happen since timeout is forever\n"); } System_printf("Sending a message #%d to %s\n", MessageQ_getMsgId(msg), remoteQueueName); /* Get the message id */ msgId = MessageQ_getMsgId(msg); /* send the message to the remote processor */ status = MessageQ_put(remoteQueueId, msg); if (status < 0) { System_abort("MessageQ_put had a failure/error\n"); } /* test done */ if (msgId >= NUMLOOPS) { break; } } } System_printf("The test is complete\n"); BIOS_exit(0); }