e3233b50243e8321abdfec23f1ccb4563ba68b1b
[processor-sdk/big-data-ipc-examples.git] / host_bios / simple_buffer_example / host / App.c
1 /*
2  * Copyright (c) 2017 Texas Instruments Incorporated - http://www.ti.com
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *  ======== App.c ========
35  */
37 /* package header files */
38 #include <xdc/std.h>
39 #include <xdc/runtime/Diags.h>
40 #include <xdc/runtime/Error.h>
41 #include <xdc/runtime/IHeap.h>
42 #include <xdc/runtime/Log.h>
43 #include <xdc/runtime/Memory.h>
44 #include <xdc/runtime/System.h>
46 #include <ti/ipc/Ipc.h>
47 #include <ti/ipc/MessageQ.h>
48 #include <ti/ipc/MultiProc.h>
49 #include <ti/ipc/SharedRegion.h>
51 #include <ti/sysbios/heaps/HeapBuf.h>
52 #include <ti/sysbios/knl/Task.h>
53 #include <ti/ipc/HeapMemMP.h>
54 #include <ti/sysbios/hal/Cache.h>
56 /* local header files */
57 #include "../shared/AppCommon.h"
58 #include "App.h"
60 /* round up the value 'size' to the next 'align' boundary */
61 #define ROUNDUP(size, align) \
62     (UInt32)(((UInt32)(size) + ((UInt32)(align) - 1)) & ~((UInt32)(align) - 1))
64 #define NUM_MSGS 4
66 /* module structure */
67 typedef struct {
68     MessageQ_Handle     hostQue;    // created locally
69     MessageQ_QueueId    slaveQue;   // opened remotely
70     UInt16              heapId;     // MessageQ heapId
71     HeapBuf_Handle      heap;       // message heap
72     Int                 msgSize;    // aligned size of message
73     Int                 poolSize;   // size of message pool
74     Ptr                 store;      // memory store for message pool
75 } App_Module;
77 /* private data */
78 static App_Module Module;
80 /*
81  *  ======== App_create ========
82  */
84 Int App_create(UInt16 remoteProcId)
85 {
86     Int                 status = 0;
87     Int                 align;
88     Error_Block         eb;
89     IHeap_Handle        srHeap;
90     HeapBuf_Params      heapParams;
91     MessageQ_Params     msgqParams;
92     char                msgqName[32];
94     Log_print0(Diags_INFO, "App_create: -->");
96     /* setting default values */
97     Module.hostQue = NULL;
98     Module.slaveQue = MessageQ_INVALIDMESSAGEQ;
99     Module.heapId = App_MsgHeapId;
100     Module.msgSize = 0;
102     /* compute message size to fill entire cache lines */
103     align = SharedRegion_getCacheLineSize(0);
104     Module.msgSize = ROUNDUP(sizeof(App_Msg), align);
106     /* compute message pool size */
107     Module.poolSize = Module.msgSize * NUM_MSGS;
109     /* acquire message pool memory */
110     srHeap = (IHeap_Handle)SharedRegion_getHeap(0);
111     Module.store = Memory_alloc(srHeap, Module.poolSize, align, NULL);
113     /* create a heap in shared memory for message pool */
114     HeapBuf_Params_init(&heapParams);
115     heapParams.blockSize = Module.msgSize;
116     heapParams.numBlocks = NUM_MSGS;
117     heapParams.bufSize = Module.poolSize;
118     heapParams.align = align;
119     heapParams.buf = Module.store;
120     Error_init(&eb);
122     Module.heap = HeapBuf_create(&heapParams, &eb);
124     if (Module.heap == NULL) {
125         Log_error0("App_create: failed creating message pool");
126         status = -1;
127         goto leave;
128     }
130     /* bind message pool to heapId */
131     MessageQ_registerHeap((Ptr)(Module.heap), App_MsgHeapId);
133     /* create local message queue (inbound messages) */
134     MessageQ_Params_init(&msgqParams);
136     Module.hostQue = MessageQ_create(NULL, &msgqParams);
138     if (Module.hostQue == NULL) {
139         Log_error0("App_create: failed creating MessageQ");
140         status = -1;
141         goto leave;
142     }
144     /* open the remote message queue */
145     System_sprintf(msgqName, App_SlaveMsgQueName,
146             MultiProc_getName(remoteProcId));
148     do {
149         status = MessageQ_open(msgqName, &Module.slaveQue);
150         Task_sleep(1);
151     } while (status == MessageQ_E_NOTFOUND);
153     if (status < 0) {
154         Log_error0("App_create: failed opening MessageQ");
155         goto leave;
156     }
158     Log_print0(Diags_INFO, "App_create: Host is ready");
160 leave:
161     Log_print1(Diags_INFO, "App_create: <-- status=%d", (IArg)status);
162     return(status);
165 /*
166  *  ======== App_delete ========
167  */
168 Int App_delete(Void)
170     Int             status;
171     IHeap_Handle    srHeap;
173     Log_print0(Diags_INFO, "App_delete: -->");
175     /* close remote resources */
176     status = MessageQ_close(&Module.slaveQue);
178     if (status < 0) {
179         goto leave;
180     }
182     /* delete the host message queue */
183     status = MessageQ_delete(&Module.hostQue);
185     if (status < 0) {
186         goto leave;
187     }
189     /* unregister message pool heap */
190     MessageQ_unregisterHeap(App_MsgHeapId);
192     /* delete the message pool heap */
193     HeapBuf_delete(&Module.heap);
195     /* release message pool memory */
196     srHeap = (IHeap_Handle)SharedRegion_getHeap(0);
197     Memory_free(srHeap, Module.store, Module.poolSize);
199 leave:
200     Log_print1(Diags_INFO, "App_delete: <-- status=%d", (IArg)status);
201     return(status);
204 /*
205  *  ======== App_exec ========
206  */
207 Int App_exec(Void)
209     Int         status;
210     App_Msg *   msg;
211     Uint32 *bigDataPtr;
212     SharedRegion_SRPtr bigDataSharedPtr;
213     Int16 i,j;
214     UInt16  regionId1;
215     Memory_Stats stats;
216     HeapMemMP_ExtendedStats extStats;
217     SharedRegion_Entry *pSrEntry;
218     HeapMemMP_Params heapMemMp_params;
219     HeapMemMP_Handle sr1Heap;
220     Uint16 regionId;
221     HeapMemMP_Handle srHeap;
222     UInt32 errorCount=0;
224     Log_print0(Diags_INFO, "App_exec: -->");
226     /* obtain information about heap (if any) in SR_1 */
227     regionId1 = SharedRegion_getIdByName("SR_1");
228     Log_print1(Diags_INFO, "App_taskFxn: SR_1 region Id=%d",regionId1);
229     sr1Heap = SharedRegion_getHeap(regionId1);
230     if (sr1Heap != NULL)
231     {
232         Log_error0("App_taskFxn: Error: Example assumes shared region without preconfigured heap");
233         status = -1;
234         goto leave;
235     }
236     else
237     {
238         Log_print0(Diags_INFO, "App_taskFxn: SR_1, sr1Heap=NULL");
239         
240         pSrEntry = SharedRegion_getEntryPtr(regionId1);
241         Log_print1(Diags_INFO, "App_taskFxn: SR_1, len=%d", pSrEntry->len);
243         /* Create HeapMP at run-time:
244            This heap is intended to be used for big data ipc */
245         HeapMemMP_Params_init(&heapMemMp_params);
246         heapMemMp_params.name = "sr1HeapMemMp";
247         heapMemMp_params.sharedAddr = pSrEntry->base;
248         heapMemMp_params.sharedBufSize = ROUNDUP(pSrEntry->len, pSrEntry->cacheLineSize); 
249         heapMemMp_params.gate = NULL;
250         sr1Heap = HeapMemMP_create(&heapMemMp_params);
251         if (!sr1Heap) {
252             Log_error0("srHeap creation failed");
253             status = -1;
254             goto leave;
255         }
256         HeapMemMP_getStats((HeapMemMP_Handle)sr1Heap, &stats);
257         Log_print3(Diags_INFO, "App_taskFxn: SR_1 heap, totalSize=%d,totalFreeSize=%d,largestFreeSize=%d", (IArg)stats.totalSize, (IArg)stats.totalFreeSize, (IArg)stats.largestFreeSize);
258         HeapMemMP_getExtendedStats((HeapMemMP_Handle)sr1Heap, &extStats);
259         Log_print2(Diags_INFO, "App_taskFxn: SR_1 heap, buf=0x%x,size=%d", (IArg)extStats.buf, (IArg)extStats.size);
260     }
262     srHeap = sr1Heap;
263     regionId = regionId1;
265     /* fill process pipeline */
266     for (i = 1; i <= 3; i++) {
267         Log_print1(Diags_INFO, "App_exec: sending message %d", (IArg)i);
269         /* allocate message */
270         msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
272         if (msg == NULL) {
273             status = -1;
274             goto leave;
275         }
277         /* set the return address in the message header */
278         MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);
280         if ( i == 1) {
281             /* fill in message payload for Shared region init*/
282             msg->cmd = App_CMD_SHARED_REGION_INIT;
283             msg->id = i;
284             msg->regionId = regionId;
285             /* Passing the local shared memory address to the remote */
286             /* Actually this can be any allocated buffer for the used for the heap */
287             msg->u.sharedRegionInitCfg.base = (intptr_t)(pSrEntry->base);
288             msg->u.sharedRegionInitCfg.size = (UInt64)(pSrEntry->len);
289         } else {
290             /* fill in message payload */
291             msg->cmd = App_CMD_NOP;
292             msg->id = i;
293         }
295         /* send message */
296         MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
297     }
299     /* process steady state (keep pipeline full) */
300     for (i = 4; i <= 16; i++) {
302         /* Now this section of code starts receiving messages
303            See the next section for the code for sending further messages */
304         /* Receive messages: Start======================================= */
306         /* wait for return message */
307         status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
308             MessageQ_FOREVER);
310         if (status < 0) {
311             goto leave;
312         }
314         /* extract message payload */
316         if ((msg->cmd == App_CMD_BIGDATA) && (msg->u.bigDataBuffer.sharedPtr) ) {
318             /* Translate to local address */
319             bigDataPtr = (Uint32 *)SharedRegion_getPtr(msg->u.bigDataBuffer.sharedPtr);
321             /* If shared region is configured for cache enabled do cache operation */
322             if (SharedRegion_isCacheEnabled(msg->regionId)) {
323                 Cache_inv(bigDataPtr,
324                     msg->u.bigDataBuffer.size, Cache_Type_ALL, TRUE);
325             }
326 #ifdef DEBUG
327             /* print data from big data buffer */
328             Log_print1(Diags_INFO, " Received back buffer %d", msg->id);
329             Log_print0(Diags_INFO, " First 8 bytes: ");
330             for ( j = 0; j < 8 && j < msg->u.bigDataBuffer.size/sizeof(uint32_t); j+=4)
331                 Log_print4(Diags_INFO, "0x%x, 0x%x, 0x%x, 0x%x",
332                     bigDataPtr[j], bigDataPtr[j+1], bigDataPtr[j+2], bigDataPtr[j+3]);
333             Log_print0(Diags_INFO, " Last 8 bytes: ");
334             for ( j = (msg->u.bigDataBuffer.size/sizeof(uint32_t))-8 ;
335                  j < msg->u.bigDataBuffer.size/sizeof(uint32_t); j+=4)
336                 Log_print4(Diags_INFO, "0x%x, 0x%x, 0x%x, 0x%x",
337                     bigDataPtr[j], bigDataPtr[j+1], bigDataPtr[j+2], bigDataPtr[j+3]);
338 #endif
339             /* Check values to see expected results */
340             for( j=0; j < msg->u.bigDataBuffer.size/sizeof(uint32_t); j++) {
341                 if ( bigDataPtr[j] != (msg->id+10+j) ) {
342                     errorCount++;
343                 }
344             }
346             /* Free big data buffer */
347             HeapMemMP_free(srHeap, bigDataPtr, msg->u.bigDataBuffer.size);
348         }
350         /* free the message */
351         MessageQ_free((MessageQ_Msg)msg);
353         Log_print1(Diags_INFO, "App_exec: message received, sending message %d",
354                 (IArg)i);
355         /* Receive messages: End ======================================= */
357         /* Send messages: Start  ======================================= */
359         /* allocate message */
360         msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
362         if (msg == NULL) {
363             status = -1;
364             goto leave;
365         }
367         /* set the return address in the message header */
368         MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);
370         /* fill in message payload */
371         if (i < 14) {
373             /* Send Big data messages */
375             msg->cmd = App_CMD_BIGDATA;
376             msg->id = i;
378             /* Allocate buffer from HeapMemMP */
379             bigDataPtr = (Uint32 *)(HeapMemMP_alloc(srHeap, BIGDATA_SIZE, BIGDATA_ALIGN));
381             if ( ! bigDataPtr ) {
382                 status = -1;
383                 goto leave;
384             }
386             /* Fill Big data buffer */
387             for(j=0; j< BIGDATA_SIZE/sizeof(uint32_t); j++) {
388                bigDataPtr[j] = j+i;
389             }
391             /* Cache write back data buffer */
392             if (SharedRegion_isCacheEnabled(regionId)) {
393                 Cache_wb(bigDataPtr, BIGDATA_SIZE, Cache_Type_ALL, TRUE);
394             }
396             /* Translate Address to Shared address */
397             bigDataSharedPtr = SharedRegion_getSRPtr(bigDataPtr, regionId);
399             msg->u.bigDataBuffer.sharedPtr = bigDataSharedPtr;
400             msg->u.bigDataBuffer.size = BIGDATA_SIZE;
401             msg->regionId = regionId;
402         } else {
403             if (i == 16) {
404                 /* Last message will tell the slave to shutdown */
405                 msg->cmd = App_CMD_SHUTDOWN;
406                 msg->id = i;
407             } else {
408                 /* Send dummy NOP messages before shutdown */
409                 msg->cmd = App_CMD_NOP;
410                 msg->id = i;
411             }
412         }
414         /* send message */
415         MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
417         /* Send messages: End  ======================================= */
419     }
421     /* drain process pipeline */
422     for (i = 1; i <= 3; i++) {
423         Log_print0(Diags_INFO, "App_exec: message received");
425         /* wait for return message */
426         status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
427             MessageQ_FOREVER);
429         if (status < 0) {
430             goto leave;
431         }
433         /* extract message payload */
435         /* free the message */
436         MessageQ_free((MessageQ_Msg)msg);
437     }
439 leave:
440     /* Print error count if non-zero */
441     if (errorCount) {
442         Log_print1(Diags_INFO, "App_exec: Error Count %d", errorCount);
443         status = -1;
444     }
445     else
446         Log_print0(Diags_INFO, "App_exec: Data check clean");
448     Log_print1(Diags_INFO, "App_exec: <-- status=%d", (IArg)status);
449     return(status);