Return warning when opening CD instance due to instabilities. Fixed policy verificat...
[keystone-rtos/rm-lld.git] / test / src / rm_mem_test.c
1 /*
2  *   rm_test.c
3  *
4  *   Multicore Resource Manager test that uses IPC to an application
5  *   requesting RM services from a RM Server, Client Delegate, and Client.
6  *
7  *  ============================================================================
8  *
9  * Copyright (c) 2012-2013, Texas Instruments Incorporated
10  * All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  *
16  * *  Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  *
19  * *  Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the distribution.
22  *
23  * *  Neither the name of Texas Instruments Incorporated nor the names of
24  *    its contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
29  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
31  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
34  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
35  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
36  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
37  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38  *
39  */
40  
41 /* Standard Includes */
42 #include <string.h>
44 /* XDC Includes */
45 #include <xdc/std.h>
46 #include <xdc/runtime/System.h>
48 /* IPC Includes */
49 #include <ti/ipc/Ipc.h>
50 #include <ti/ipc/GateMP.h>
52 /* BIOS Includes */
53 #include <ti/sysbios/BIOS.h>
54 #include <ti/sysbios/knl/Task.h>
56 /* CSL Includes */
57 #include <ti/csl/csl_chip.h>
58 #include <ti/csl/csl_cacheAux.h>
59 #include <ti/csl/csl_xmcAux.h>
61 /* RM Includes */
62 #include <ti/drv/rm/rm.h>
63 #include <ti/drv/rm/rm_transport.h>
64 #include <ti/drv/rm/rm_services.h>
65 #include <ti/drv/rm/rm_osal.h>
67 /**********************************************************************
68  ************************** RM Test Symbols ***************************
69  **********************************************************************/
71 #define SYSINIT                      0
72 #define NUM_CORES                    2
74 /* Test FALSE */
75 #define RM_TEST_FALSE                0
76 /* Test TRUE */
77 #define RM_TEST_TRUE                 1
79 /* GateMP names used to synchronize instance tasks */
80 #define RM_SERVER_GATE_NAME            "serverGate"
81 #define RM_CLIENT_GATE_NAME            "clientGate"
83 /* Size of RM service response queue */
84 #define MAX_QUEUED_SERVICE_RESPONSES 10
86 /**********************************************************************
87  ********************** Extern Variables ******************************
88  **********************************************************************/
90 /* GRL for testing multicore Server-Client interaction leaks */
91 extern const char rmGlobalResourceList[];
92 /* Global policy for testing multicore Server-Client interaction leaks */
93 extern const char rmDspPlusArmPolicy[];
95 /* GRL for testing Server-CD-Client interaction leaks */
96 extern const char rmGRL[];
97 /* Global policy for testing Server-CD-Client interaction leaks */
98 extern const char rmGlobalPolicy[];
99 /* Static policy for testing Server-CD-Client interaction leaks */
100 extern const char rmStaticPolicy[];
101 /* Example Linux DTB */
102 extern const char rmLinuxDtb[];
104 /* Alloc and free OSAL variables */
105 extern uint32_t rmMallocCounter;
106 extern uint32_t rmFreeCounter;
108 extern void *Osal_rmMalloc (uint32_t num_bytes);
109 extern void  Osal_rmFree (void *ptr, uint32_t size);
110 extern void  Osal_rmBeginMemAccess(void *ptr, uint32_t size);
111 extern void  Osal_rmEndMemAccess(void *ptr, uint32_t size);
113 extern int setupRmTransConfig(uint32_t numTestCores, uint32_t systemInitCore, Task_FuncPtr testTask);
114 extern int deleteRmTrans(void);
116 /**********************************************************************
117  ********************** Global Variables ******************************
118  **********************************************************************/
120 /* DSP core number according to DNUM */
121 uint16_t            coreNum;
122 /* Number of errors that occurred during the test */
123 uint16_t            testErrors;
125 /* Task to configure application transport code for RM */
126 Task_Handle         rmStartupTskHandle;
127 /* RM server test task */
128 Task_Handle         rmServerTskHandle;
129 /* RM client delegate and client test task */
130 Task_Handle         rmClientTskHandle;
132 /* GateMP handles used to synchronize instance tasks */
133 GateMP_Handle       serverGateHandle = NULL;
134 GateMP_Handle       clientGateHandle = NULL;
135 /* GateMP keys */
136 IArg                serverKey;
137 IArg                clientKey;
139 /* RM instance variables */
140 Rm_Handle           rmHandle = NULL;
141 char                rmInstName[RM_NAME_MAX_CHARS];
143 /* Malloc/Free tracking variables */
144 uint32_t            sMalloc, mMalloc;
145 uint32_t            sFree, mFree;
147 /* RM response info queue used to store service responses received via the callback function */
148 Rm_ServiceRespInfo  responseInfoQueue[MAX_QUEUED_SERVICE_RESPONSES];
150 /* rmGRL resource names (must match resource node names in rmGRL, rmGlobalPolicy, and rmStaticPolicy */
151 char                resNameGpQ[RM_NAME_MAX_CHARS]   = "gp-queue";
152 char                resNameQos[RM_NAME_MAX_CHARS]   = "qos-cluster";
154 /* rmGlobalResourceList names (must match resource node names in rmGlobalResourceList and rmDspPlusArmPolicy */
155 char                resNameMcGpQ[RM_NAME_MAX_CHARS] = "GENERAL_PURPOSE_QUEUE-qm1";
157 /* Test RM NameServer name */
158 char                nsNameFavQ[RM_NAME_MAX_CHARS]   = "My_Favorite_Queue";
160 /* RM initialization sync point */
161 #pragma DATA_SECTION (isRmInitialized, ".rm");
162 #pragma DATA_ALIGN (isRmInitialized, 128)
163 volatile int8_t   isRmInitialized[128];
165 /**********************************************************************
166  ***************************** Test Macros ****************************
167  **********************************************************************/
169 /* Error checking macro */
170 #define ERROR_CHECK(checkVal, resultVal, rmInstName, printMsg)                   \
171     if (resultVal != checkVal) {                                                 \
172         char errorMsgToPrint[] = printMsg;                                       \
173         System_printf("Error Core %d : %s : ", coreNum, rmInstName);             \
174         System_printf("%s with error code : %d\n", errorMsgToPrint, resultVal);  \
175         testErrors++;                                                            \
176         System_abort("Test Failure\n");                                          \
177     }
179 #define MEM_TEST_START_STORE() sMalloc = rmMallocCounter; sFree = rmFreeCounter; 
180 #define MEM_TEST_MID_STORE()   mMalloc = rmMallocCounter; mFree = rmFreeCounter; 
181 #define MEM_TEST_END_PRINT(title, sApiOrFunc, mApiOrFunc, eApiOrFunc)                               \
182     do {                                                                                            \
183         char    titleMsg[] = title;                                                                 \
184         char    sApiOrFuncMsg[] = sApiOrFunc;                                                       \
185         char    mApiOrFuncMsg[] = mApiOrFunc;                                                       \
186         char    eApiOrFuncMsg[] = eApiOrFunc;                                                       \
187         int32_t mallocFreeBalance = (rmMallocCounter - sMalloc) - (rmFreeCounter - sFree);          \
188                                                                                                     \
189         System_printf ("Core %d : ---------------------------------------------------------\n",     \
190                        coreNum);                                                                    \
191         System_printf ("Core %d : %s\n", coreNum, titleMsg);                                        \
192         System_printf ("Core %d : - API/Functionality     : malloc count   |   free count -\n",     \
193                        coreNum);                                                                    \
194         System_printf ("Core %d : - %s :  %6d        |  %6d      -\n", coreNum, sApiOrFuncMsg,      \
195                        sMalloc, sFree);                                                             \
196         System_printf ("Core %d : - %s :  %6d        |  %6d      -\n", coreNum, mApiOrFuncMsg,      \
197                        mMalloc, mFree);                                                             \
198         System_printf ("Core %d : - %s :  %6d        |  %6d      -\n", coreNum,                     \
199                        eApiOrFuncMsg, rmMallocCounter, rmFreeCounter);                              \
200         if (mallocFreeBalance > 0) {                                                                \
201             System_printf ("Core %d : - FAILED - %6d unfreed mallocs                       -\n",    \
202                            coreNum, mallocFreeBalance);                                             \
203             testErrors++;                                                                           \
204         }                                                                                           \
205         else if (mallocFreeBalance < 0) {                                                           \
206             System_printf ("Core %d : - FAILED - %6d more frees than mallocs               -\n",    \
207                            coreNum, -mallocFreeBalance);                                            \
208             testErrors++;                                                                           \
209         }                                                                                           \
210         else {                                                                                      \
211             System_printf ("Core %d : - PASSED                                                -\n", \
212                            coreNum);                                                                \
213         }                                                                                           \
214         System_printf ("Core %d : ---------------------------------------------------------\n",     \
215                        coreNum);                                                                    \
216         System_printf ("\n");                                                                       \
217     } while(0)
220 /**********************************************************************
221  *************************** Test Functions ***************************
222  **********************************************************************/
224 void serviceCallback(Rm_ServiceRespInfo *serviceResponse)
226     uint32_t qIndex = 0;
227     
228     /* Populate next free entry in the responseInfoQueue */
229     while (responseInfoQueue[qIndex].serviceId != 0) {
230         qIndex++;
231         if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
232             qIndex = 0;
233         }
234     }
236     /* Save the response in the response queue for the test task to pick up */
237     memcpy((void *)&responseInfoQueue[qIndex], (void *)serviceResponse, sizeof(responseInfoQueue[qIndex]));
240 void waitForResponse(Rm_ServiceRespInfo *respInfo)
242     uint32_t qIndex = 0;
244     if ((respInfo->serviceState == RM_SERVICE_PROCESSING) ||
245         (respInfo->serviceState == RM_SERVICE_PENDING_SERVER_RESPONSE)) {
246         /* Scan responseInfoQueue for the response received via the callback function */
247         while((responseInfoQueue[qIndex].serviceId != respInfo->serviceId) ||
248               (responseInfoQueue[qIndex].rmHandle != respInfo->rmHandle)) {
249             qIndex++;
250             if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
251                 qIndex = 0;
252             }
253             
254             /* Higher priority receive task will retrieve response */
255         }  
257         memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(*respInfo));
258         memset((void *)&responseInfoQueue[qIndex], 0, sizeof(responseInfoQueue[qIndex]));
259     }
262 void setRmRequest(Rm_ServiceReqInfo *reqInfo, Rm_ServiceType type, const char *resName, int32_t resBase,
263                   uint32_t resLen, int32_t resAlign, const char *nsName, int setCallback, Rm_ServiceRespInfo *respInfo)
264 {                                                                                
265     memset((void *)reqInfo, 0, sizeof(*reqInfo));                                        
266     reqInfo->type = type;                                                                           
267     reqInfo->resourceName = resName;                                                                
268     reqInfo->resourceBase = resBase;                                                                
269     reqInfo->resourceLength = resLen;                                                               
270     reqInfo->resourceAlignment = resAlign;                                                          
271     reqInfo->resourceNsName = nsName;
272     if (setCallback) {
273         reqInfo->callback.serviceCallback = serviceCallback;  
274     }
275     memset((void *)respInfo, 0, sizeof(*respInfo));                                     
278 void rmCleanupTsk(UArg arg0, UArg arg1)
280     int32_t rmResult;
281     int32_t finalMallocFree;    
282     
283     /* Delete the RM test tasks */
284     System_printf("Core %d: Deleting RM startup task...\n", coreNum);
285     if (rmStartupTskHandle) {
286        Task_delete(&rmStartupTskHandle);
287        /* Set the task handle to be NULL so that the delete only occurs once */
288        rmStartupTskHandle = NULL;
289     }  
290     
291     if (coreNum == SYSINIT) {
292         if (rmServerTskHandle) {
293             System_printf("Core %d: Deleting RM server task...\n", coreNum);
294             Task_delete(&rmServerTskHandle);
295             /* Set the task handle to be NULL so that the delete only occurs once */
296             rmServerTskHandle = NULL;
297         }
298     }
299     else {
300         if (rmClientTskHandle) {
301             System_printf("Core %d: Deleting RM client task...\n", coreNum);        
302             Task_delete(&rmClientTskHandle);
303             /* Set the task handle to be NULL so that the delete only occurs once */
304             rmClientTskHandle = NULL;
305         }
306     }
308     /* Cleanup RM instances and check final malloc/free numbers */
309     rmResult = deleteRmTrans();
310     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Transport cleanup failed");    
311     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
312     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
314     System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
315     System_printf ("Core %d : ------------------ Example Completion -------------------\n", coreNum);
316     System_printf ("Core %d : - API/Functionality     : malloc count   |   free count -\n", coreNum);
317     System_printf ("Core %d : - Example Completion    :  %6d        |  %6d      -\n", coreNum,
318                    rmMallocCounter, rmFreeCounter);
319     finalMallocFree = rmMallocCounter - rmFreeCounter;
320     if (finalMallocFree > 0) {
321         System_printf ("Core %d : - FAILED - %6d unfreed mallocs                       -\n",
322                        coreNum, finalMallocFree);
323         testErrors++;
324     }
325     else if (finalMallocFree < 0) {
326         System_printf ("Core %d : - FAILED - %6d more frees than mallocs               -\n",
327                        coreNum, -finalMallocFree);
328         testErrors++;
329     }
330     else {
331         System_printf ("Core %d : - PASSED                                                -\n",
332                        coreNum);
333     }    
334     if (testErrors) {
335         System_printf ("Core %d : -                                                       -\n", coreNum); 
336         System_printf ("Core %d : - Test Errors: %-32d         -\n", coreNum, testErrors);
337     }    
338     System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
339     System_printf ("\n");  
341     BIOS_exit(0);
344 void rmServerTsk(UArg arg0, UArg arg1)
346     Rm_ServiceHandle   *serviceHandle;
347     Task_Params         taskParams;
348     int32_t             rmResult;
350     /* Open Client service handle */
351     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
352     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
355     MEM_TEST_START_STORE();
356     /* Leave the server gate to let client task request resource */
357     GateMP_leave(serverGateHandle, serverKey);
358     /* Block until Client finishes allocating the resource */
359     clientKey = GateMP_enter(clientGateHandle);
360     MEM_TEST_MID_STORE();  
361     GateMP_leave(clientGateHandle, clientKey);
362     /* Block until Client finishes freeing the resource */
363     serverKey = GateMP_enter(serverGateHandle);
364     MEM_TEST_END_PRINT("------- Remote Alloc/Free From Client (Blocking) --------",
365                        "Pre Client Alloc     ", "Post Client Alloc Req", "Post Client Free     ");   
368     MEM_TEST_START_STORE();
369     /* Leave the server gate to let client task request resources */
370     GateMP_leave(serverGateHandle, serverKey);
371     /* Block until Client finishes allocating the resources */
372     clientKey = GateMP_enter(clientGateHandle); 
373     MEM_TEST_MID_STORE();
374     GateMP_leave(clientGateHandle, clientKey);
375     /* Block until Client finishes freeing the resources */
376     serverKey = GateMP_enter(serverGateHandle);           
377     MEM_TEST_END_PRINT("--- Remote Multiple Alloc/Free From Client (Blocking) ---",
378                        "Pre Client Alloc     ", "Post Client Alloc Req", "Post Client Free     ");    
381     MEM_TEST_START_STORE();
382     /* Leave the server gate to let client task map a resource in the NameServer */
383     GateMP_leave(serverGateHandle, serverKey);
384     /* Block until Client finishes mapping resource */
385     clientKey = GateMP_enter(clientGateHandle);
386     MEM_TEST_MID_STORE();
387     GateMP_leave(clientGateHandle, clientKey);
388     /* Block until Client finishes unmapping resource */
389     serverKey = GateMP_enter(serverGateHandle);           
390     MEM_TEST_END_PRINT("-- Remote NameServer Map/Unmap From Client (Blocking) ---",
391                        "Pre Client NS Map    ", "Post Client NS Map   ", "Post Client NS Unmap ");    
394     MEM_TEST_START_STORE();
395     /* Leave the server gate to let client task request resources */
396     GateMP_leave(serverGateHandle, serverKey);
397     /* Block until Client finishes allocating the resources */
398     clientKey = GateMP_enter(clientGateHandle); 
399     MEM_TEST_MID_STORE();
400     GateMP_leave(clientGateHandle, clientKey);
401     /* Block until Client finishes freeing the resources */
402     serverKey = GateMP_enter(serverGateHandle);           
403     MEM_TEST_END_PRINT("- Remote Multiple Alloc/Free From Client (Non-Blocking) -",
404                        "Pre Client Alloc     ", "Post Client Alloc Req", "Post Client Free     "); 
407     Rm_serviceCloseHandle(serviceHandle);
408     
409     /* Create the RM cleanup task. */
410     System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
411     Task_Params_init (&taskParams);
412     Task_create (rmCleanupTsk, &taskParams, NULL);
415 void rmClientTsk(UArg arg0, UArg arg1)
417     Rm_ServiceHandle   *serviceHandle;
418     Rm_ServiceReqInfo   request;
419     Rm_ServiceRespInfo  response;    
420     int32_t             rmResult;    
421     Task_Params         taskParams;
423     /* Open Client service handle */
424     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
425     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
428     /* Block until server is ready to receive request */
429     serverKey = GateMP_enter(serverGateHandle);
430     MEM_TEST_START_STORE();      
431     /* Allocate a resource to add a node to a resource tree */
432     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
433                  896, 1, 0, NULL, RM_TEST_FALSE, &response);
434     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
435     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
436     /* Let server save memory usage for alloc */
437     GateMP_leave(clientGateHandle, clientKey);    
438     MEM_TEST_MID_STORE();
439     /* Block until Server saves malloc/free info */
440     clientKey = GateMP_enter(clientGateHandle);     
441     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
442                  896, 1, 0, NULL, RM_TEST_FALSE, &response);
443     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
444     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
445     MEM_TEST_END_PRINT("-------------- Client Alloc/Free (Blocking) -------------",
446                        "Pre Alloc            ", "Post Alloc Request   ", "Post Free            ");
447     /* Let server print memory usage */
448     GateMP_leave(serverGateHandle, serverKey);
451     /* Block until server is ready to receive request */
452     serverKey = GateMP_enter(serverGateHandle);
453     MEM_TEST_START_STORE();       
454     /* Perform multiple allocs to force the tree to combine nodes */
455     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
456                  900, 50, 0, NULL, RM_TEST_FALSE, &response);
457     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
458     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
459     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
460                  2000, 50, 0, NULL, RM_TEST_FALSE, &response);
461     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
462     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
463     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
464                  1000, 1000, 0, NULL, RM_TEST_FALSE, &response);
465     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
466     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
467     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
468                  950, 50, 0, NULL, RM_TEST_FALSE, &response);
469     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
470     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed"); 
471     /* Let server save memory usage for alloc */
472     GateMP_leave(clientGateHandle, clientKey);
473     MEM_TEST_MID_STORE();    
474     /* Block until Server saves malloc/free info */
475     clientKey = GateMP_enter(clientGateHandle);      
476     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
477                  1000, 500, 0, NULL, RM_TEST_FALSE, &response);
478     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
479     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");     
480     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
481                  1500, 550, 0, NULL, RM_TEST_FALSE, &response);
482     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
483     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");   
484     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
485                  900, 100, 0, NULL, RM_TEST_FALSE, &response);
486     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
487     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");  
488     MEM_TEST_END_PRINT("--------- Client Multiple Alloc/Free (Blocking) ---------",
489                        "Pre Alloc            ", "Post Alloc Requests  ", "Post Free            ");
490     /* Let server print memory usage */
491     GateMP_leave(serverGateHandle, serverKey);
492     
494     /* Block until server is ready to receive request */
495     serverKey = GateMP_enter(serverGateHandle);
496     MEM_TEST_START_STORE();       
497     /* Map a resource in the NameServer */
498     setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameMcGpQ, 
499                  5000, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
500     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
501     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer map failed");
502     /* Let server save memory usage for alloc */
503     GateMP_leave(clientGateHandle, clientKey);
504     MEM_TEST_MID_STORE();    
505     /* Block until Server saves malloc/free info */
506     clientKey = GateMP_enter(clientGateHandle);      
507     setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL, 
508                  0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
509     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
510     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer unmap failed");
511     MEM_TEST_END_PRINT("-------- Client NameServer Map/Unmap (Blocking) ---------",
512                        "Pre NS Map           ", "Name Mapped to NS    ", "Name Unmapped from NS");       
513     /* Let server print memory usage */
514     GateMP_leave(serverGateHandle, serverKey);
517     /* Block until server is ready to receive request */
518     serverKey = GateMP_enter(serverGateHandle);
519     MEM_TEST_START_STORE();       
520     /* Perform multiple allocs without RM blocking to force the tree to combine nodes */
521     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
522                  900, 50, 0, NULL, RM_TEST_TRUE, &response);
523     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
524     waitForResponse(&response);
525     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
526     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
527                  2000, 50, 0, NULL, RM_TEST_TRUE, &response);
528     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
529     waitForResponse(&response);
530     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
531     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
532                  1000, 1000, 0, NULL, RM_TEST_TRUE, &response);
533     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
534     waitForResponse(&response);
535     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
536     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ, 
537                  950, 50, 0, NULL, RM_TEST_TRUE, &response);
538     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
539     waitForResponse(&response);
540     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed"); 
541     /* Let server save memory usage for alloc */
542     GateMP_leave(clientGateHandle, clientKey);
543     MEM_TEST_MID_STORE();    
544     /* Block until Server saves malloc/free info */
545     clientKey = GateMP_enter(clientGateHandle);      
546     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
547                  1000, 500, 0, NULL, RM_TEST_TRUE, &response);
548     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
549     waitForResponse(&response);
550     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");     
551     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
552                  1500, 550, 0, NULL, RM_TEST_TRUE, &response);
553     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
554     waitForResponse(&response);
555     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");   
556     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ, 
557                  900, 100, 0, NULL, RM_TEST_TRUE, &response);
558     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
559     waitForResponse(&response);
560     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");  
561     MEM_TEST_END_PRINT("------- Client Multiple Alloc/Free (Non-Blocking) -------",
562                        "Pre Alloc            ", "Post Alloc Requests  ", "Post Free            ");
563     /* Let server print memory usage */
564     GateMP_leave(serverGateHandle, serverKey);
567     Rm_serviceCloseHandle(serviceHandle);
568     
569     /* Create the RM cleanup task. */
570     System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
571     Task_Params_init (&taskParams);
572     Task_create (rmCleanupTsk, &taskParams, NULL);
575 void rmStartupTsk(UArg arg0, UArg arg1)
577     Int           status;
578     GateMP_Params gateParams;    
579     Task_Params   taskParams;
581     if (coreNum == SYSINIT) {
582         GateMP_Params_init(&gateParams);
583         gateParams.name = RM_SERVER_GATE_NAME;
584         /* Disable local protection since only concerned with sync'ing cores */
585         gateParams.localProtect = GateMP_LocalProtect_NONE;
586         serverGateHandle = GateMP_create(&gateParams);
588         serverKey = GateMP_enter(serverGateHandle);  
590         do {
591             status = GateMP_open(RM_CLIENT_GATE_NAME, &clientGateHandle);
592             /* 
593              *  Sleep for 1 clock tick to avoid inundating remote processor
594              *  with interrupts if open failed
595              */
596             if (status < 0) { 
597                 Task_sleep(1);
598             }
599         } while (status < 0);        
600     }
601     else {
602         GateMP_Params_init(&gateParams);
603         gateParams.name = RM_CLIENT_GATE_NAME;
604         /* Disable local protection since only concerned with sync'ing cores */
605         gateParams.localProtect = GateMP_LocalProtect_NONE;
606         clientGateHandle = GateMP_create(&gateParams);
608         clientKey = GateMP_enter(clientGateHandle);  
609         
610         do {
611             status = GateMP_open(RM_SERVER_GATE_NAME, &serverGateHandle);
612             /* 
613              *  Sleep for 1 clock tick to avoid inundating remote processor
614              *  with interrupts if open failed
615              */
616             if (status < 0) { 
617                 Task_sleep(1);
618             }
619         } while (status < 0);
620     }
621     
622     /* Create the RM test tasks. */
623     if (coreNum == SYSINIT) {
624         System_printf("Core %d: Creating RM server task...\n", coreNum);
625         Task_Params_init (&taskParams);
626         taskParams.priority = 1;
627         rmServerTskHandle = Task_create (rmServerTsk, &taskParams, NULL);
628     }
629     else if (coreNum) {
630         System_printf("Core %d: Creating RM client task...\n", coreNum);
631         Task_Params_init (&taskParams);
632         taskParams.priority = 1;
633         rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
634     }
637 Rm_Packet *rmLocalPktAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
639     Rm_Packet *rmPkt = NULL;
641     rmPkt = Osal_rmMalloc(sizeof(*rmPkt));
642     rmPkt->pktLenBytes = pktSize;
643     *pktHandle = (Rm_PacketHandle)rmPkt;
644     return (rmPkt);
647 int32_t rmLocalPktSendRcv (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
649     Rm_TransportHandle  transportHandle = (Rm_TransportHandle)appTransport;
650     Rm_Packet          *rmPkt = (Rm_Packet *) pktHandle;  
651     int32_t             status;    
653     /* Provide packet to remote instance for processing */
654     if (status = Rm_receivePacket(transportHandle, rmPkt)) {
655         System_printf("Error Core %d : Receiving RM packet : %d\n", coreNum, status);
656         testErrors++;
657     }
659     /* Free the packet */
660     Osal_rmFree(rmPkt, sizeof(*rmPkt));
662     return (status);
665 void testServer(void)
667     Rm_InitCfg          rmInitCfg;
668     Rm_ServiceHandle   *serviceHandle;
669     Rm_ServiceReqInfo   request;
670     Rm_ServiceRespInfo  response;
671     int32_t             rmResult;
674     MEM_TEST_START_STORE(); 
675     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
676     System_sprintf (rmInstName, "RM_Server");
677     rmInitCfg.instName = rmInstName;
678     rmInitCfg.instType = Rm_instType_SERVER;
679     rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGRL;
680     rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
681     rmHandle = Rm_init(&rmInitCfg, &rmResult);
682     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");    
683     MEM_TEST_MID_STORE();
684     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
685     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
686     MEM_TEST_END_PRINT("------------------ Server Inst Init/Del -----------------",
687                        "Pre Rm_Init (Server) ", "Post Rm_Init (Server)", "Post Rm_Delete       ");    
690     rmHandle = Rm_init(&rmInitCfg, &rmResult);
691     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
692     MEM_TEST_START_STORE();
693     /* Open service handle */
694     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
695     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
696     MEM_TEST_MID_STORE();
697     rmResult = Rm_serviceCloseHandle(serviceHandle);
698     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
699     MEM_TEST_END_PRINT("--------------- Open/Close Service Handle ---------------",
700                        "Pre Service Hnd Open ", "Service Hnd Opened   ", "Service Hnd Closed   ");    
701     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
702     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");        
705     MEM_TEST_START_STORE(); 
706     rmHandle = Rm_init(&rmInitCfg, &rmResult);
707     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
708     /* Open service handle */
709     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
710     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
711     /* Allocate a resource to add a node to a resource tree */
712     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
713                  896, 1, 0, NULL, RM_TEST_TRUE, &response);
714     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
715     MEM_TEST_MID_STORE();
716     /* Delete instance making sure allocation cleaned up properly from resource tree */
717     rmResult = Rm_serviceCloseHandle(serviceHandle);
718     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");        
719     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
720     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
721     MEM_TEST_END_PRINT("-------------- Server Inst Init/Del w/ Alloc ------------",
722                        "Pre Rm_Init (Server) ", "Post Alloc Req       ", "Post Rm_Delete       ");
723     
725     /* Service request memory tests */
726     rmHandle = Rm_init(&rmInitCfg, &rmResult);
727     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
728     /* Open service handle */
729     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
730     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
733     MEM_TEST_START_STORE();        
734     /* Allocate a resource to add a node to a resource tree */
735     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
736                  896, 1, 0, NULL, RM_TEST_TRUE, &response);
737     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
738     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
739     MEM_TEST_MID_STORE();
740     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
741                  896, 1, 0, NULL, RM_TEST_TRUE, &response);
742     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
743     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");        
744     MEM_TEST_END_PRINT("-------------------- Server Alloc/Free ------------------",
745                        "Pre Alloc            ", "Post Alloc Request   ", "Post Free            ");    
748     MEM_TEST_START_STORE();        
749     /* Perform multiple allocs to force the tree to combine nodes */
750     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
751                  900, 50, 0, NULL, RM_TEST_TRUE, &response);
752     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
753     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
754     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
755                  2000, 50, 0, NULL, RM_TEST_TRUE, &response);
756     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
757     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
758     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
759                  1000, 1000, 0, NULL, RM_TEST_TRUE, &response);
760     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
761     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
762     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
763                  950, 50, 0, NULL, RM_TEST_TRUE, &response);
764     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
765     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");   
766     MEM_TEST_MID_STORE();
767     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
768                  1000, 500, 0, NULL, RM_TEST_TRUE, &response);
769     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
770     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");     
771     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
772                  1500, 550, 0, NULL, RM_TEST_TRUE, &response);
773     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
774     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");   
775     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
776                  900, 100, 0, NULL, RM_TEST_TRUE, &response);
777     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
778     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");           
779     MEM_TEST_END_PRINT("--------------- Server Multiple Alloc/Free --------------",
780                        "Pre Alloc            ", "Post Alloc Requests  ", "Post Free            ");    
783     MEM_TEST_START_STORE();        
784     /* Map a resource in the NameServer */
785     setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ, 
786                  5000, 1, 0, nsNameFavQ, RM_TEST_TRUE, &response);
787     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
788     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer map failed");
789     MEM_TEST_MID_STORE();
790     setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL, 
791                  0, 0, 0, nsNameFavQ, RM_TEST_TRUE, &response);
792     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
793     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer unmap failed");
794     MEM_TEST_END_PRINT("-------------- Server NameServer Map/Unmap --------------",
795                        "Pre NS Map           ", "Name Mapped to NS    ", "Name Unmapped from NS");
796     
798     /* Close server instance after tests complete */
799     rmResult = Rm_serviceCloseHandle(serviceHandle);
800     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");    
801     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
802     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed"); 
805 void testCd(void)
807     Rm_InitCfg          rmInitCfg;
808     Rm_ServiceHandle   *serviceHandle;
809     Rm_ServiceReqInfo   request;
810     Rm_ServiceRespInfo  response;
811     int32_t             rmResult;
813     MEM_TEST_START_STORE();      
814     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
815     System_sprintf (rmInstName, "RM_Client_Delegate");
816     rmInitCfg.instName = rmInstName;
817     rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
818     rmInitCfg.instCfg.cdCfg.cdPolicy = (void *)rmGlobalPolicy;    
819     rmHandle = Rm_init(&rmInitCfg, &rmResult);
820     ERROR_CHECK(RM_WARNING_CD_INSTANCE_NOT_STABLE, rmResult, rmInstName, "Initialization failed");
821     MEM_TEST_MID_STORE();
822     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
823     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
824     MEM_TEST_END_PRINT("--- Client Delegate Inst Init/Del (No Static Policy) ----",
825                        "Pre Rm_Init (CD)     ", "Post Rm_Init (CD)    ", "Post Rm_Delete       ");
828     MEM_TEST_START_STORE();
829     rmInitCfg.instCfg.cdCfg.cdPolicy = (void *)rmStaticPolicy;
830     rmHandle = Rm_init(&rmInitCfg, &rmResult);
831     ERROR_CHECK(RM_WARNING_CD_INSTANCE_NOT_STABLE, rmResult, rmInstName, "Initialization failed");
832     MEM_TEST_MID_STORE();
833     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
834     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
835     MEM_TEST_END_PRINT("---- Client Delegate Inst Init/Del (Static Policy) ------",
836                        "Pre Rm_Init (CD)     ", "Post Rm_Init (CD)    ", "Post Rm_Delete       ");    
839     MEM_TEST_START_STORE();
840     rmHandle = Rm_init(&rmInitCfg, &rmResult);
841     ERROR_CHECK(RM_WARNING_CD_INSTANCE_NOT_STABLE, rmResult, rmInstName, "Initialization failed");
842     /* Open service handle */
843     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
844     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
845     /* Static allocation */
846     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameQos, 
847                  0, 1, 0, NULL, RM_TEST_TRUE, &response);
848     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
849     MEM_TEST_MID_STORE();
850     /* Delete instance with deletion of pending transactions */
851     rmResult = Rm_serviceCloseHandle(serviceHandle);
852     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");    
853     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
854     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
855     MEM_TEST_END_PRINT("--- CD Inst Init/Del (Static Policy w/ Static Alloc) ----",
856                        "Pre Rm_Init (CD)     ", "Post Static Alloc Req", "Post Rm_Delete       "); 
859 void testClient(void)
861     Rm_InitCfg          rmInitCfg;
862     Rm_ServiceHandle   *serviceHandle;
863     Rm_ServiceReqInfo   request;
864     Rm_ServiceRespInfo  response;
865     int32_t             rmResult;
867     MEM_TEST_START_STORE();      
868     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
869     System_sprintf (rmInstName, "RM_Client");
870     rmInitCfg.instName = rmInstName;
871     rmInitCfg.instType = Rm_instType_CLIENT;
872     rmHandle = Rm_init(&rmInitCfg, &rmResult);
873     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
874     MEM_TEST_MID_STORE();
875     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
876     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
877     MEM_TEST_END_PRINT("-------- Client Inst Init/Del (No Static Policy) --------",
878                        "Pre Rm_Init (Client) ", "Post Rm_Init (Client)", "Post Rm_Delete       ");
881     MEM_TEST_START_STORE();
882     rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
883     rmHandle = Rm_init(&rmInitCfg, &rmResult);
884     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
885     MEM_TEST_MID_STORE();
886     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
887     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
888     MEM_TEST_END_PRINT("--------- Client Inst Init/Del (Static Policy) ----------",
889                        "Pre Rm_Init (Client) ", "Post Rm_Init (Client)", "Post Rm_Delete       ");    
892     MEM_TEST_START_STORE();
893     rmHandle = Rm_init(&rmInitCfg, &rmResult);
894     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
895     /* Open service handle */
896     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
897     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
898     /* Static allocation */
899     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameQos, 
900                  0, 1, 0, NULL, RM_TEST_TRUE, &response);
901     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
902     MEM_TEST_MID_STORE();
903     /* Delete instance with deletion of pending transactions */
904     rmResult = Rm_serviceCloseHandle(serviceHandle);
905     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");    
906     rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
907     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
908     MEM_TEST_END_PRINT("- Client Inst Init/Del (Static Policy w/ Static Alloc) --",
909                        "Pre Rm_Init (Client) ", "Post Static Alloc Req", "Post Rm_Delete       ");   
912 /* Test features for memory leaks using a Server, CD, and Client all running on a single DSP core. 
913  * The transport implemented between the instances is just direct function calls */
914 void testServerCdClient(void)
916     Rm_InitCfg          rmInitCfg;
917     char                serverName[RM_NAME_MAX_CHARS];
918     char                cdName[RM_NAME_MAX_CHARS];
919     char                clientName[RM_NAME_MAX_CHARS];
920     Rm_Handle           serverHandle, cdHandle, clientHandle;
921     Rm_TransportCfg     transCfg;
922     Rm_TransportReCfg   transReCfg;
923     Rm_TransportHandle  serverToCd, cdToServer, cdToClient, clientToCd;
924     Rm_ServiceHandle   *serviceHandle;
925     Rm_ServiceReqInfo   request;
926     Rm_ServiceRespInfo  response;
927     int32_t             rmResult;
930     MEM_TEST_START_STORE();
931     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
932     System_sprintf (serverName, "RM_Server");
933     rmInitCfg.instName = serverName;
934     rmInitCfg.instType = Rm_instType_SERVER;
935     rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGRL;
936     rmInitCfg.instCfg.serverCfg.linuxDtb = (void *)rmLinuxDtb;
937     rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;    
938     serverHandle = Rm_init(&rmInitCfg, &rmResult);
939     ERROR_CHECK(RM_OK, rmResult, serverName, "Initialization failed");  
940     MEM_TEST_MID_STORE();
941     rmResult = Rm_delete(serverHandle, RM_TEST_TRUE);
942     ERROR_CHECK(RM_OK, rmResult, serverName, "Delete failed");
943     MEM_TEST_END_PRINT("----------- Server Inst Init/Del w/ Linux Dtb -----------",
944                        "Pre Rm_Init (Server) ", "Post Rm_Init (Server)", "Post Rm_Delete       ");
946     /* Init Server */
947     serverHandle = Rm_init(&rmInitCfg, &rmResult);
948     ERROR_CHECK(RM_OK, rmResult, serverName, "Initialization failed");
949     /* Init CD */
950     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
951     System_sprintf (cdName, "RM_Client_Delegate");
952     rmInitCfg.instName = cdName;
953     rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
954     rmInitCfg.instCfg.cdCfg.cdPolicy = (void *)rmGlobalPolicy;
955     cdHandle = Rm_init(&rmInitCfg, &rmResult);
956     ERROR_CHECK(RM_WARNING_CD_INSTANCE_NOT_STABLE, rmResult, cdName, "Initialization failed"); 
957     /* Init Client */
958     memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
959     System_sprintf (clientName, "RM_Client");
960     rmInitCfg.instName = clientName;
961     rmInitCfg.instType = Rm_instType_CLIENT;      
962     clientHandle = Rm_init(&rmInitCfg, &rmResult);
963     ERROR_CHECK(RM_OK, rmResult, clientName, "Initialization failed");
965     /* Connect Server transports */
966     memset((void *)&transCfg, 0, sizeof(transCfg));
967     transCfg.rmHandle = serverHandle;
968     transCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
969     transCfg.appTransportHandle = NULL;
970     transCfg.transportCallouts.rmAllocPkt = rmLocalPktAlloc;
971     transCfg.transportCallouts.rmSendPkt = rmLocalPktSendRcv;
972     serverToCd = Rm_transportRegister(&transCfg, &rmResult);
973     ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport registration failed");
974     /* Connect Client transports */
975     transCfg.rmHandle = clientHandle;
976     transCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
977     clientToCd = Rm_transportRegister(&transCfg, &rmResult);
978     ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport registration failed");     
979     /* Connect CD transports */
980     transCfg.rmHandle = cdHandle;
981     transCfg.remoteInstType = Rm_instType_SERVER;
982     transCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCd;
983     cdToServer = Rm_transportRegister(&transCfg, &rmResult);
984     ERROR_CHECK(RM_OK, rmResult, cdName, "Server transport registration failed");
985     transCfg.rmHandle = cdHandle;
986     transCfg.remoteInstType = Rm_instType_CLIENT;
987     transCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCd;
988     cdToClient = Rm_transportRegister(&transCfg, &rmResult);
989     ERROR_CHECK(RM_OK, rmResult, cdName, "Client transport registration failed");
990     /* Reconfigure the Server and Client transports to CD with the CD transport handles for proper routing
991      * in the rmLocalPktSendRcv function */
992     memset((void*)&transReCfg, 0, sizeof(transReCfg));
993     transReCfg.appTransportHandle =(Rm_AppTransportHandle) cdToServer;
994     rmResult = Rm_transportReconfig(serverToCd, &transReCfg);
995     ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport registration failed");
996     transReCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClient;
997     rmResult = Rm_transportReconfig(clientToCd, &transReCfg);
998     ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport registration failed");    
1000     /* Open service handle on Client to send requests to Server via Client Delegate */
1001     serviceHandle = Rm_serviceOpenHandle(clientHandle, &rmResult);
1002     ERROR_CHECK(RM_OK, rmResult, clientName, "Service handle open failed");
1004   
1005     /* Allocate a resource */
1006     MEM_TEST_START_STORE();        
1007     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1008                  896, 1, 0, NULL, RM_TEST_FALSE, &response);
1009     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1010     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");   
1011     MEM_TEST_MID_STORE();    
1012     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
1013                  896, 1, 0, NULL, RM_TEST_FALSE, &response);
1014     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1015     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
1016     MEM_TEST_END_PRINT("--------------- Client Alloc/Free (via CD) --------------",
1017                        "Pre Alloc            ", "Post Alloc Request   ", "Post Free            ");
1019       
1020     /* Perform multiple allocs to force the tree to combine nodes */
1021     MEM_TEST_START_STORE(); 
1022     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1023                  900, 50, 0, NULL, RM_TEST_FALSE, &response);
1024     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1025     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
1026     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1027                  2000, 50, 0, NULL, RM_TEST_FALSE, &response);
1028     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1029     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
1030     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1031                  1000, 1000, 0, NULL, RM_TEST_FALSE, &response);
1032     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1033     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
1034     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1035                  950, 50, 0, NULL, RM_TEST_FALSE, &response);
1036     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1037     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed"); 
1038     MEM_TEST_MID_STORE();         
1039     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
1040                  1000, 500, 0, NULL, RM_TEST_FALSE, &response);
1041     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1042     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");     
1043     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
1044                  1500, 550, 0, NULL, RM_TEST_FALSE, &response);
1045     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1046     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");   
1047     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
1048                  900, 100, 0, NULL, RM_TEST_FALSE, &response);
1049     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1050     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");  
1051     MEM_TEST_END_PRINT("---------- Client Multiple Alloc/Free (via CD) ----------",
1052                        "Pre Alloc            ", "Post Alloc Requests  ", "Post Free            ");
1053     
1054      
1055     /* Map a resource in the NameServer */
1056     MEM_TEST_START_STORE();  
1057     setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ, 
1058                  5000, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1059     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1060     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer map failed");
1061     MEM_TEST_MID_STORE();        
1062     setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL, 
1063                  0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1064     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1065     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer unmap failed");
1066     MEM_TEST_END_PRINT("---------- Client NameServer Map/Unmap (via CD) ---------",
1067                        "Pre NS Map           ", "Name Mapped to NS    ", "Name Unmapped from NS");
1070     /* Check status of resource directly and through NameServer name */
1071     MEM_TEST_START_STORE(); 
1072     setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ, 
1073                  900, 50, 0, NULL, RM_TEST_FALSE, &response);
1074     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1075     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
1076     setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ, 
1077                  900, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1078     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1079     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer map failed");
1080     setRmRequest(&request, Rm_service_RESOURCE_STATUS, resNameGpQ, 
1081                  900, 50, 0, NULL, RM_TEST_FALSE, &response);
1082     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1083     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Status check failed");
1084     setRmRequest(&request, Rm_service_RESOURCE_STATUS, resNameGpQ, 
1085                  0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1086     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1087     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Status check (via NS name) failed");
1088     MEM_TEST_MID_STORE();         
1089     setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL, 
1090                  0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1091     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1092     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer unmap failed");  
1093     setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ, 
1094                  900, 50, 0, NULL, RM_TEST_FALSE, &response);
1095     serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1096     ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");  
1097     MEM_TEST_END_PRINT("--------- Client Check Resource Status (via CD) ---------",
1098                        "Pre Alloc            ", "Post Status Requests ", "Post Free            ");
1101     /* Cleanup */
1102     rmResult = Rm_serviceCloseHandle(serviceHandle);
1103     ERROR_CHECK(RM_OK, rmResult, clientName, "Service handle close failed");       
1104     rmResult = Rm_transportUnregister(serverToCd);
1105     ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport unregister failed");
1106     rmResult = Rm_transportUnregister(cdToServer);
1107     ERROR_CHECK(RM_OK, rmResult, cdName, "Server transport unregister failed");
1108     rmResult = Rm_transportUnregister(cdToClient);
1109     ERROR_CHECK(RM_OK, rmResult, cdName, "Client transport unregister failed");
1110     rmResult = Rm_transportUnregister(clientToCd);
1111     ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport unregister failed");
1112     rmResult = Rm_delete(serverHandle, RM_TEST_TRUE);
1113     ERROR_CHECK(RM_OK, rmResult, serverName, "Delete failed");
1114     rmResult = Rm_delete(cdHandle, RM_TEST_TRUE);
1115     ERROR_CHECK(RM_OK, rmResult, cdName, "Delete failed");
1116     rmResult = Rm_delete(clientHandle, RM_TEST_TRUE);
1117     ERROR_CHECK(RM_OK, rmResult, clientName, "Delete failed");    
1120 void main(Int argc, Char* argv[])
1122     Rm_InitCfg rmInitCfg;
1123     int32_t    rmResult;
1124     int        status;
1126     System_printf ("*********************************************************\n");
1127     System_printf ("******************** RM Memory Test *********************\n");
1128     System_printf ("*********************************************************\n");
1130     System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1132     /* Reset the variable to indicate to other cores RM init is not yet done */
1133     isRmInitialized[0] = 0;
1135     coreNum = CSL_chipReadReg(CSL_CHIP_DNUM);
1136     testErrors = 0;
1138     System_printf("Core %d: Starting IPC...\n", coreNum);
1139     status = Ipc_start();
1140     if (status < 0) {
1141         testErrors++;
1142         System_abort("Ipc_start failed\n");
1143     }
1145     if (coreNum == SYSINIT) {
1146         /* Test individual instance init/deletes */
1147         testServer();
1148         testCd();
1149         testClient();
1150         
1151         /* Test Server-CD-Client interaction for memory leaks all from a single core */
1152         testServerCdClient();
1153         
1154         /* Create Server for multicore interaction memory tests */
1155         memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
1156         System_sprintf (rmInstName, "RM_Server");
1157         rmInitCfg.instName = rmInstName;
1158         rmInitCfg.instType = Rm_instType_SERVER;
1159         rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGlobalResourceList;
1160         rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmDspPlusArmPolicy;
1161         rmHandle = Rm_init(&rmInitCfg, &rmResult);
1162         ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
1163      
1164         /* Signal to remote cores that Server instance has passed all initialization
1165          * memory tests and is ready */
1166         isRmInitialized[0] = 1;
1167         Osal_rmEndMemAccess((void *)isRmInitialized,sizeof(isRmInitialized));
1168     }
1169     else {
1170         /* Create Client for multicore interaction memory tests */
1171         memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
1172         System_sprintf (rmInstName, "RM_Client%d", coreNum);
1173         rmInitCfg.instName = rmInstName;
1174         rmInitCfg.instType = Rm_instType_CLIENT;
1175         rmHandle = Rm_init(&rmInitCfg, &rmResult);
1176         ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
1178         do{
1179             Osal_rmBeginMemAccess((void *)isRmInitialized, sizeof(isRmInitialized));
1180         } while (isRmInitialized[0] == 0);             
1181     }
1183     if (setupRmTransConfig(NUM_CORES, SYSINIT, rmStartupTsk) < 0)
1184     {
1185         System_printf ("Error core %d : Transport setup for RM error\n", coreNum);
1186         testErrors++;
1187         return;
1188     }
1190     System_printf("Core %d: Starting BIOS...\n", coreNum);
1191     BIOS_start();
1193     return;