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 */
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)
225 {
226 uint32_t qIndex = 0;
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]));
238 }
240 void waitForResponse(Rm_ServiceRespInfo *respInfo)
241 {
242 uint32_t qIndex = 0;
244 if (respInfo->serviceState == RM_SERVICE_PROCESSING) {
245 /* Scan responseInfoQueue for the response received via the callback function */
246 while((responseInfoQueue[qIndex].serviceId != respInfo->serviceId) ||
247 (responseInfoQueue[qIndex].rmHandle != respInfo->rmHandle)) {
248 qIndex++;
249 if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
250 qIndex = 0;
251 }
253 /* Higher priority receive task will retrieve response */
254 }
256 memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(*respInfo));
257 memset((void *)&responseInfoQueue[qIndex], 0, sizeof(responseInfoQueue[qIndex]));
258 }
259 }
261 void setRmRequest(Rm_ServiceReqInfo *reqInfo, Rm_ServiceType type, const char *resName, int32_t resBase,
262 uint32_t resLen, int32_t resAlign, const char *nsName, int setCallback, Rm_ServiceRespInfo *respInfo)
263 {
264 memset((void *)reqInfo, 0, sizeof(*reqInfo));
265 reqInfo->type = type;
266 reqInfo->resourceName = resName;
267 reqInfo->resourceBase = resBase;
268 reqInfo->resourceLength = resLen;
269 reqInfo->resourceAlignment = resAlign;
270 reqInfo->resourceNsName = nsName;
271 if (setCallback) {
272 reqInfo->callback.serviceCallback = serviceCallback;
273 }
274 memset((void *)respInfo, 0, sizeof(*respInfo));
275 }
277 void rmCleanupTsk(UArg arg0, UArg arg1)
278 {
279 int32_t rmResult;
280 int32_t finalMallocFree;
282 /* Delete the RM test tasks */
283 System_printf("Core %d: Deleting RM startup task...\n", coreNum);
284 if (rmStartupTskHandle) {
285 Task_delete(&rmStartupTskHandle);
286 /* Set the task handle to be NULL so that the delete only occurs once */
287 rmStartupTskHandle = NULL;
288 }
290 if (coreNum == SYSINIT) {
291 if (rmServerTskHandle) {
292 System_printf("Core %d: Deleting RM server task...\n", coreNum);
293 Task_delete(&rmServerTskHandle);
294 /* Set the task handle to be NULL so that the delete only occurs once */
295 rmServerTskHandle = NULL;
296 }
297 }
298 else {
299 if (rmClientTskHandle) {
300 System_printf("Core %d: Deleting RM client task...\n", coreNum);
301 Task_delete(&rmClientTskHandle);
302 /* Set the task handle to be NULL so that the delete only occurs once */
303 rmClientTskHandle = NULL;
304 }
305 }
307 /* Cleanup RM instances and check final malloc/free numbers */
308 rmResult = deleteRmTrans();
309 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Transport cleanup failed");
310 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
311 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
313 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
314 System_printf ("Core %d : ------------------ Example Completion -------------------\n", coreNum);
315 System_printf ("Core %d : - API/Functionality : malloc count | free count -\n", coreNum);
316 System_printf ("Core %d : - Example Completion : %6d | %6d -\n", coreNum,
317 rmMallocCounter, rmFreeCounter);
318 finalMallocFree = rmMallocCounter - rmFreeCounter;
319 if (finalMallocFree > 0) {
320 System_printf ("Core %d : - FAILED - %6d unfreed mallocs -\n",
321 coreNum, finalMallocFree);
322 testErrors++;
323 }
324 else if (finalMallocFree < 0) {
325 System_printf ("Core %d : - FAILED - %6d more frees than mallocs -\n",
326 coreNum, -finalMallocFree);
327 testErrors++;
328 }
329 else {
330 System_printf ("Core %d : - PASSED -\n",
331 coreNum);
332 }
333 if (testErrors) {
334 System_printf ("Core %d : - -\n", coreNum);
335 System_printf ("Core %d : - Test Errors: %-32d -\n", coreNum, testErrors);
336 }
337 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
338 System_printf ("\n");
340 BIOS_exit(0);
341 }
343 void rmServerTsk(UArg arg0, UArg arg1)
344 {
345 Rm_ServiceHandle *serviceHandle;
346 Task_Params taskParams;
347 int32_t rmResult;
349 /* Open Client service handle */
350 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
351 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
354 MEM_TEST_START_STORE();
355 /* Leave the server gate to let client task request resource */
356 GateMP_leave(serverGateHandle, serverKey);
357 /* Block until Client finishes allocating the resource */
358 clientKey = GateMP_enter(clientGateHandle);
359 MEM_TEST_MID_STORE();
360 GateMP_leave(clientGateHandle, clientKey);
361 /* Block until Client finishes freeing the resource */
362 serverKey = GateMP_enter(serverGateHandle);
363 MEM_TEST_END_PRINT("------------- Remote Alloc/Free From Client -------------",
364 "Pre Client Alloc ", "Post Client Alloc Req", "Post Client Free ");
367 MEM_TEST_START_STORE();
368 /* Leave the server gate to let client task request resources */
369 GateMP_leave(serverGateHandle, serverKey);
370 /* Block until Client finishes allocating the resources */
371 clientKey = GateMP_enter(clientGateHandle);
372 MEM_TEST_MID_STORE();
373 GateMP_leave(clientGateHandle, clientKey);
374 /* Block until Client finishes freeing the resources */
375 serverKey = GateMP_enter(serverGateHandle);
376 MEM_TEST_END_PRINT("-------- Remote Multiple Alloc/Free From Client ---------",
377 "Pre Client Alloc ", "Post Client Alloc Req", "Post Client Free ");
380 MEM_TEST_START_STORE();
381 /* Leave the server gate to let client task map a resource in the NameServer */
382 GateMP_leave(serverGateHandle, serverKey);
383 /* Block until Client finishes mapping resource */
384 clientKey = GateMP_enter(clientGateHandle);
385 MEM_TEST_MID_STORE();
386 GateMP_leave(clientGateHandle, clientKey);
387 /* Block until Client finishes unmapping resource */
388 serverKey = GateMP_enter(serverGateHandle);
389 MEM_TEST_END_PRINT("-------- Remote NameServer Map/Unmap From Client --------",
390 "Pre Client NS Map ", "Post Client NS Map ", "Post Client NS Unmap ");
393 Rm_serviceCloseHandle(serviceHandle);
395 /* Create the RM cleanup task. */
396 System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
397 Task_Params_init (&taskParams);
398 Task_create (rmCleanupTsk, &taskParams, NULL);
399 }
401 void rmClientTsk(UArg arg0, UArg arg1)
402 {
403 Rm_ServiceHandle *serviceHandle;
404 Rm_ServiceReqInfo request;
405 Rm_ServiceRespInfo response;
406 int32_t rmResult;
407 Task_Params taskParams;
409 /* Open Client service handle */
410 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
411 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
414 /* Block until server is ready to receive request */
415 serverKey = GateMP_enter(serverGateHandle);
416 MEM_TEST_START_STORE();
417 /* Allocate a resource to add a node to a resource tree */
418 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ,
419 896, 1, 0, NULL, RM_TEST_FALSE, &response);
420 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
421 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
422 /* Let server save memory usage for alloc */
423 GateMP_leave(clientGateHandle, clientKey);
424 MEM_TEST_MID_STORE();
425 /* Block until Server saves malloc/free info */
426 clientKey = GateMP_enter(clientGateHandle);
427 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ,
428 896, 1, 0, NULL, RM_TEST_FALSE, &response);
429 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
430 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
431 MEM_TEST_END_PRINT("------------ Client Alloc/Free (Non-Blocking) -----------",
432 "Pre Alloc ", "Post Alloc Request ", "Post Free ");
433 /* Let server print memory usage */
434 GateMP_leave(serverGateHandle, serverKey);
437 /* Block until server is ready to receive request */
438 serverKey = GateMP_enter(serverGateHandle);
439 MEM_TEST_START_STORE();
440 /* Perform multiple allocs to force the tree to combine nodes */
441 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ,
442 900, 50, 0, NULL, RM_TEST_FALSE, &response);
443 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
444 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
445 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ,
446 2000, 50, 0, NULL, RM_TEST_FALSE, &response);
447 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
448 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
449 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ,
450 1000, 1000, 0, NULL, RM_TEST_FALSE, &response);
451 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
452 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
453 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameMcGpQ,
454 950, 50, 0, NULL, RM_TEST_FALSE, &response);
455 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
456 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
457 /* Let server save memory usage for alloc */
458 GateMP_leave(clientGateHandle, clientKey);
459 MEM_TEST_MID_STORE();
460 /* Block until Server saves malloc/free info */
461 clientKey = GateMP_enter(clientGateHandle);
462 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ,
463 1000, 500, 0, NULL, RM_TEST_FALSE, &response);
464 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
465 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
466 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ,
467 1500, 550, 0, NULL, RM_TEST_FALSE, &response);
468 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
469 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
470 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameMcGpQ,
471 900, 100, 0, NULL, RM_TEST_FALSE, &response);
472 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
473 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
474 MEM_TEST_END_PRINT("--------------- Client Multiple Alloc/Free --------------",
475 "Pre Alloc ", "Post Alloc Requests ", "Post Free ");
476 /* Let server print memory usage */
477 GateMP_leave(serverGateHandle, serverKey);
480 /* Block until server is ready to receive request */
481 serverKey = GateMP_enter(serverGateHandle);
482 MEM_TEST_START_STORE();
483 /* Map a resource in the NameServer */
484 setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameMcGpQ,
485 5000, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
486 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
487 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer map failed");
488 /* Let server save memory usage for alloc */
489 GateMP_leave(clientGateHandle, clientKey);
490 MEM_TEST_MID_STORE();
491 /* Block until Server saves malloc/free info */
492 clientKey = GateMP_enter(clientGateHandle);
493 setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL,
494 0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
495 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
496 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer unmap failed");
497 MEM_TEST_END_PRINT("-------------- Client NameServer Map/Unmap --------------",
498 "Pre NS Map ", "Name Mapped to NS ", "Name Unmapped from NS");
499 /* Let server print memory usage */
500 GateMP_leave(serverGateHandle, serverKey);
503 Rm_serviceCloseHandle(serviceHandle);
505 /* Create the RM cleanup task. */
506 System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
507 Task_Params_init (&taskParams);
508 Task_create (rmCleanupTsk, &taskParams, NULL);
509 }
511 void rmStartupTsk(UArg arg0, UArg arg1)
512 {
513 Int status;
514 GateMP_Params gateParams;
515 Task_Params taskParams;
517 if (coreNum == SYSINIT) {
518 GateMP_Params_init(&gateParams);
519 gateParams.name = RM_SERVER_GATE_NAME;
520 /* Disable local protection since only concerned with sync'ing cores */
521 gateParams.localProtect = GateMP_LocalProtect_NONE;
522 serverGateHandle = GateMP_create(&gateParams);
524 serverKey = GateMP_enter(serverGateHandle);
526 do {
527 status = GateMP_open(RM_CLIENT_GATE_NAME, &clientGateHandle);
528 /*
529 * Sleep for 1 clock tick to avoid inundating remote processor
530 * with interrupts if open failed
531 */
532 if (status < 0) {
533 Task_sleep(1);
534 }
535 } while (status < 0);
536 }
537 else {
538 GateMP_Params_init(&gateParams);
539 gateParams.name = RM_CLIENT_GATE_NAME;
540 /* Disable local protection since only concerned with sync'ing cores */
541 gateParams.localProtect = GateMP_LocalProtect_NONE;
542 clientGateHandle = GateMP_create(&gateParams);
544 clientKey = GateMP_enter(clientGateHandle);
546 do {
547 status = GateMP_open(RM_SERVER_GATE_NAME, &serverGateHandle);
548 /*
549 * Sleep for 1 clock tick to avoid inundating remote processor
550 * with interrupts if open failed
551 */
552 if (status < 0) {
553 Task_sleep(1);
554 }
555 } while (status < 0);
556 }
558 /* Create the RM test tasks. */
559 if (coreNum == SYSINIT) {
560 System_printf("Core %d: Creating RM server task...\n", coreNum);
561 Task_Params_init (&taskParams);
562 taskParams.priority = 1;
563 rmServerTskHandle = Task_create (rmServerTsk, &taskParams, NULL);
564 }
565 else if (coreNum) {
566 System_printf("Core %d: Creating RM client task...\n", coreNum);
567 Task_Params_init (&taskParams);
568 taskParams.priority = 1;
569 rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
570 }
571 }
573 Rm_Packet *rmLocalPktAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
574 {
575 Rm_Packet *rmPkt = NULL;
577 rmPkt = Osal_rmMalloc(sizeof(*rmPkt));
578 rmPkt->pktLenBytes = pktSize;
579 *pktHandle = (Rm_PacketHandle)rmPkt;
580 return (rmPkt);
581 }
583 int32_t rmLocalPktSendRcv (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
584 {
585 Rm_TransportHandle transportHandle = (Rm_TransportHandle)appTransport;
586 Rm_Packet *rmPkt = (Rm_Packet *) pktHandle;
587 int32_t status;
589 /* Provide packet to remote instance for processing */
590 if (status = Rm_receivePacket(transportHandle, rmPkt)) {
591 System_printf("Error Core %d : Receiving RM packet : %d\n", coreNum, status);
592 testErrors++;
593 }
595 /* Free the packet */
596 Osal_rmFree(rmPkt, sizeof(*rmPkt));
598 return (status);
599 }
601 void testServer(void)
602 {
603 Rm_InitCfg rmInitCfg;
604 Rm_ServiceHandle *serviceHandle;
605 Rm_ServiceReqInfo request;
606 Rm_ServiceRespInfo response;
607 int32_t rmResult;
610 MEM_TEST_START_STORE();
611 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
612 System_sprintf (rmInstName, "RM_Server");
613 rmInitCfg.instName = rmInstName;
614 rmInitCfg.instType = Rm_instType_SERVER;
615 rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGRL;
616 rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
617 rmHandle = Rm_init(&rmInitCfg, &rmResult);
618 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
619 MEM_TEST_MID_STORE();
620 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
621 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
622 MEM_TEST_END_PRINT("------------------ Server Inst Init/Del -----------------",
623 "Pre Rm_Init (Server) ", "Post Rm_Init (Server)", "Post Rm_Delete ");
626 rmHandle = Rm_init(&rmInitCfg, &rmResult);
627 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
628 MEM_TEST_START_STORE();
629 /* Open service handle */
630 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
631 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
632 MEM_TEST_MID_STORE();
633 rmResult = Rm_serviceCloseHandle(serviceHandle);
634 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
635 MEM_TEST_END_PRINT("--------------- Open/Close Service Handle ---------------",
636 "Pre Service Hnd Open ", "Service Hnd Opened ", "Service Hnd Closed ");
637 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
638 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
641 MEM_TEST_START_STORE();
642 rmHandle = Rm_init(&rmInitCfg, &rmResult);
643 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
644 /* Open service handle */
645 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
646 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
647 /* Allocate a resource to add a node to a resource tree */
648 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
649 896, 1, 0, NULL, RM_TEST_TRUE, &response);
650 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
651 MEM_TEST_MID_STORE();
652 /* Delete instance making sure allocation cleaned up properly from resource tree */
653 rmResult = Rm_serviceCloseHandle(serviceHandle);
654 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
655 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
656 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
657 MEM_TEST_END_PRINT("-------------- Server Inst Init/Del w/ Alloc ------------",
658 "Pre Rm_Init (Server) ", "Post Alloc Req ", "Post Rm_Delete ");
661 /* Service request memory tests */
662 rmHandle = Rm_init(&rmInitCfg, &rmResult);
663 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
664 /* Open service handle */
665 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
666 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
669 MEM_TEST_START_STORE();
670 /* Allocate a resource to add a node to a resource tree */
671 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
672 896, 1, 0, NULL, RM_TEST_TRUE, &response);
673 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
674 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
675 MEM_TEST_MID_STORE();
676 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
677 896, 1, 0, NULL, RM_TEST_TRUE, &response);
678 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
679 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
680 MEM_TEST_END_PRINT("-------------------- Server Alloc/Free ------------------",
681 "Pre Alloc ", "Post Alloc Request ", "Post Free ");
684 MEM_TEST_START_STORE();
685 /* Perform multiple allocs to force the tree to combine nodes */
686 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
687 900, 50, 0, NULL, RM_TEST_TRUE, &response);
688 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
689 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
690 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
691 2000, 50, 0, NULL, RM_TEST_TRUE, &response);
692 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
693 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
694 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
695 1000, 1000, 0, NULL, RM_TEST_TRUE, &response);
696 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
697 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
698 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
699 950, 50, 0, NULL, RM_TEST_TRUE, &response);
700 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
701 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Allocate failed");
702 MEM_TEST_MID_STORE();
703 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
704 1000, 500, 0, NULL, RM_TEST_TRUE, &response);
705 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
706 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
707 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
708 1500, 550, 0, NULL, RM_TEST_TRUE, &response);
709 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
710 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
711 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
712 900, 100, 0, NULL, RM_TEST_TRUE, &response);
713 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
714 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "Free failed");
715 MEM_TEST_END_PRINT("--------------- Server Multiple Alloc/Free --------------",
716 "Pre Alloc ", "Post Alloc Requests ", "Post Free ");
719 MEM_TEST_START_STORE();
720 /* Map a resource in the NameServer */
721 setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ,
722 5000, 1, 0, nsNameFavQ, RM_TEST_TRUE, &response);
723 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
724 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer map failed");
725 MEM_TEST_MID_STORE();
726 setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL,
727 0, 0, 0, nsNameFavQ, RM_TEST_TRUE, &response);
728 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
729 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, rmInstName, "NameServer unmap failed");
730 MEM_TEST_END_PRINT("-------------- Server NameServer Map/Unmap --------------",
731 "Pre NS Map ", "Name Mapped to NS ", "Name Unmapped from NS");
734 /* Close server instance after tests complete */
735 rmResult = Rm_serviceCloseHandle(serviceHandle);
736 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
737 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
738 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
739 }
741 void testCd(void)
742 {
743 Rm_InitCfg rmInitCfg;
744 Rm_ServiceHandle *serviceHandle;
745 Rm_ServiceReqInfo request;
746 Rm_ServiceRespInfo response;
747 int32_t rmResult;
749 MEM_TEST_START_STORE();
750 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
751 System_sprintf (rmInstName, "RM_Client_Delegate");
752 rmInitCfg.instName = rmInstName;
753 rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
754 rmHandle = Rm_init(&rmInitCfg, &rmResult);
755 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
756 MEM_TEST_MID_STORE();
757 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
758 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
759 MEM_TEST_END_PRINT("--- Client Delegate Inst Init/Del (No Static Policy) ----",
760 "Pre Rm_Init (CD) ", "Post Rm_Init (CD) ", "Post Rm_Delete ");
763 MEM_TEST_START_STORE();
764 rmInitCfg.instCfg.cdCfg.cdPolicy = (void *)rmStaticPolicy;
765 rmHandle = Rm_init(&rmInitCfg, &rmResult);
766 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
767 MEM_TEST_MID_STORE();
768 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
769 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
770 MEM_TEST_END_PRINT("---- Client Delegate Inst Init/Del (Static Policy) ------",
771 "Pre Rm_Init (CD) ", "Post Rm_Init (CD) ", "Post Rm_Delete ");
774 MEM_TEST_START_STORE();
775 rmHandle = Rm_init(&rmInitCfg, &rmResult);
776 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
777 /* Open service handle */
778 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
779 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
780 /* Static allocation */
781 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameQos,
782 0, 1, 0, NULL, RM_TEST_TRUE, &response);
783 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
784 MEM_TEST_MID_STORE();
785 /* Delete instance with deletion of pending transactions */
786 rmResult = Rm_serviceCloseHandle(serviceHandle);
787 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
788 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
789 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
790 MEM_TEST_END_PRINT("--- CD Inst Init/Del (Static Policy w/ Static Alloc) ----",
791 "Pre Rm_Init (CD) ", "Post Static Alloc Req", "Post Rm_Delete ");
792 }
794 void testClient(void)
795 {
796 Rm_InitCfg rmInitCfg;
797 Rm_ServiceHandle *serviceHandle;
798 Rm_ServiceReqInfo request;
799 Rm_ServiceRespInfo response;
800 int32_t rmResult;
802 MEM_TEST_START_STORE();
803 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
804 System_sprintf (rmInstName, "RM_Client");
805 rmInitCfg.instName = rmInstName;
806 rmInitCfg.instType = Rm_instType_CLIENT;
807 rmHandle = Rm_init(&rmInitCfg, &rmResult);
808 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
809 MEM_TEST_MID_STORE();
810 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
811 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
812 MEM_TEST_END_PRINT("-------- Client Inst Init/Del (No Static Policy) --------",
813 "Pre Rm_Init (Client) ", "Post Rm_Init (Client)", "Post Rm_Delete ");
816 MEM_TEST_START_STORE();
817 rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
818 rmHandle = Rm_init(&rmInitCfg, &rmResult);
819 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
820 MEM_TEST_MID_STORE();
821 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
822 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
823 MEM_TEST_END_PRINT("--------- Client Inst Init/Del (Static Policy) ----------",
824 "Pre Rm_Init (Client) ", "Post Rm_Init (Client)", "Post Rm_Delete ");
827 MEM_TEST_START_STORE();
828 rmHandle = Rm_init(&rmInitCfg, &rmResult);
829 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
830 /* Open service handle */
831 serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
832 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
833 /* Static allocation */
834 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameQos,
835 0, 1, 0, NULL, RM_TEST_TRUE, &response);
836 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
837 MEM_TEST_MID_STORE();
838 /* Delete instance with deletion of pending transactions */
839 rmResult = Rm_serviceCloseHandle(serviceHandle);
840 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle close failed");
841 rmResult = Rm_delete(rmHandle, RM_TEST_TRUE);
842 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Delete failed");
843 MEM_TEST_END_PRINT("- Client Inst Init/Del (Static Policy w/ Static Alloc) --",
844 "Pre Rm_Init (Client) ", "Post Static Alloc Req", "Post Rm_Delete ");
845 }
847 /* Test features for memory leaks using a Server, CD, and Client all running on a single DSP core.
848 * The transport implemented between the instances is just direct function calls */
849 void testServerCdClient(void)
850 {
851 Rm_InitCfg rmInitCfg;
852 char serverName[RM_NAME_MAX_CHARS];
853 char cdName[RM_NAME_MAX_CHARS];
854 char clientName[RM_NAME_MAX_CHARS];
855 Rm_Handle serverHandle, cdHandle, clientHandle;
856 Rm_TransportCfg transCfg;
857 Rm_TransportHandle serverToCd, cdToServer, cdToClient, clientToCd;
858 Rm_ServiceHandle *serviceHandle;
859 Rm_ServiceReqInfo request;
860 Rm_ServiceRespInfo response;
861 int32_t rmResult;
864 MEM_TEST_START_STORE();
865 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
866 System_sprintf (serverName, "RM_Server");
867 rmInitCfg.instName = serverName;
868 rmInitCfg.instType = Rm_instType_SERVER;
869 rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGRL;
870 rmInitCfg.instCfg.serverCfg.linuxDtb = (void *)rmLinuxDtb;
871 rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
872 serverHandle = Rm_init(&rmInitCfg, &rmResult);
873 ERROR_CHECK(RM_OK, rmResult, serverName, "Initialization failed");
874 MEM_TEST_MID_STORE();
875 rmResult = Rm_delete(serverHandle, RM_TEST_TRUE);
876 ERROR_CHECK(RM_OK, rmResult, serverName, "Delete failed");
877 MEM_TEST_END_PRINT("----------- Server Inst Init/Del w/ Linux Dtb -----------",
878 "Pre Rm_Init (Server) ", "Post Rm_Init (Server)", "Post Rm_Delete ");
880 /* Init Server */
881 serverHandle = Rm_init(&rmInitCfg, &rmResult);
882 ERROR_CHECK(RM_OK, rmResult, serverName, "Initialization failed");
883 /* Init CD */
884 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
885 System_sprintf (cdName, "RM_Client_Delegate");
886 rmInitCfg.instName = cdName;
887 rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
888 cdHandle = Rm_init(&rmInitCfg, &rmResult);
889 ERROR_CHECK(RM_OK, rmResult, cdName, "Initialization failed");
890 /* Init Client */
891 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
892 System_sprintf (clientName, "RM_Client");
893 rmInitCfg.instName = clientName;
894 rmInitCfg.instType = Rm_instType_CLIENT;
895 clientHandle = Rm_init(&rmInitCfg, &rmResult);
896 ERROR_CHECK(RM_OK, rmResult, clientName, "Initialization failed");
898 /* Connect Server transports */
899 memset((void *)&transCfg, 0, sizeof(transCfg));
900 transCfg.rmHandle = serverHandle;
901 transCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
902 transCfg.remoteInstName = cdName;
903 transCfg.appTransportHandle = NULL;
904 transCfg.transportCallouts.rmAllocPkt = rmLocalPktAlloc;
905 transCfg.transportCallouts.rmSendPkt = rmLocalPktSendRcv;
906 serverToCd = Rm_transportRegister(&transCfg, &rmResult);
907 ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport registration failed");
908 /* Connect Client transports */
909 transCfg.rmHandle = clientHandle;
910 transCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
911 transCfg.remoteInstName = cdName;
912 clientToCd = Rm_transportRegister(&transCfg, &rmResult);
913 ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport registration failed");
914 /* Connect CD transports */
915 transCfg.rmHandle = cdHandle;
916 transCfg.remoteInstType = Rm_instType_SERVER;
917 transCfg.remoteInstName = serverName;
918 transCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCd;
919 cdToServer = Rm_transportRegister(&transCfg, &rmResult);
920 ERROR_CHECK(RM_OK, rmResult, cdName, "Server transport registration failed");
921 transCfg.rmHandle = cdHandle;
922 transCfg.remoteInstType = Rm_instType_CLIENT;
923 transCfg.remoteInstName = clientName;
924 transCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCd;
925 cdToClient = Rm_transportRegister(&transCfg, &rmResult);
926 ERROR_CHECK(RM_OK, rmResult, cdName, "Client transport registration failed");
927 /* Reconfigure the Server and Client transports to CD with the CD transport handles for proper routing
928 * in the rmLocalPktSendRcv function */
929 transCfg.rmHandle = serverHandle;
930 transCfg.remoteInstName = cdName;
931 transCfg.appTransportHandle =(Rm_AppTransportHandle) cdToServer;
932 Rm_transportRegister(&transCfg, &rmResult);
933 ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport registration failed");
934 transCfg.rmHandle = clientHandle;
935 transCfg.remoteInstName = cdName;
936 transCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClient;
937 Rm_transportRegister(&transCfg, &rmResult);
938 ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport registration failed");
940 /* Open service handle on Client to send requests to Server via Client Delegate */
941 serviceHandle = Rm_serviceOpenHandle(clientHandle, &rmResult);
942 ERROR_CHECK(RM_OK, rmResult, clientName, "Service handle open failed");
945 /* Allocate a resource */
946 MEM_TEST_START_STORE();
947 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
948 896, 1, 0, NULL, RM_TEST_FALSE, &response);
949 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
950 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
951 MEM_TEST_MID_STORE();
952 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
953 896, 1, 0, NULL, RM_TEST_FALSE, &response);
954 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
955 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
956 MEM_TEST_END_PRINT("--------------- Client Alloc/Free (via CD) --------------",
957 "Pre Alloc ", "Post Alloc Request ", "Post Free ");
960 /* Perform multiple allocs to force the tree to combine nodes */
961 MEM_TEST_START_STORE();
962 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
963 900, 50, 0, NULL, RM_TEST_FALSE, &response);
964 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
965 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
966 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
967 2000, 50, 0, NULL, RM_TEST_FALSE, &response);
968 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
969 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
970 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
971 1000, 1000, 0, NULL, RM_TEST_FALSE, &response);
972 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
973 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
974 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
975 950, 50, 0, NULL, RM_TEST_FALSE, &response);
976 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
977 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
978 MEM_TEST_MID_STORE();
979 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
980 1000, 500, 0, NULL, RM_TEST_FALSE, &response);
981 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
982 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
983 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
984 1500, 550, 0, NULL, RM_TEST_FALSE, &response);
985 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
986 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
987 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
988 900, 100, 0, NULL, RM_TEST_FALSE, &response);
989 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
990 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
991 MEM_TEST_END_PRINT("---------- Client Multiple Alloc/Free (via CD) ----------",
992 "Pre Alloc ", "Post Alloc Requests ", "Post Free ");
995 /* Map a resource in the NameServer */
996 MEM_TEST_START_STORE();
997 setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ,
998 5000, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
999 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1000 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer map failed");
1001 MEM_TEST_MID_STORE();
1002 setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL,
1003 0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1004 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1005 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer unmap failed");
1006 MEM_TEST_END_PRINT("---------- Client NameServer Map/Unmap (via CD) ---------",
1007 "Pre NS Map ", "Name Mapped to NS ", "Name Unmapped from NS");
1010 /* Check status of resource directly and through NameServer name */
1011 MEM_TEST_START_STORE();
1012 setRmRequest(&request, Rm_service_RESOURCE_ALLOCATE_INIT, resNameGpQ,
1013 900, 50, 0, NULL, RM_TEST_FALSE, &response);
1014 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1015 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Allocate failed");
1016 setRmRequest(&request, Rm_service_RESOURCE_MAP_TO_NAME, resNameGpQ,
1017 900, 1, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1018 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1019 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer map failed");
1020 setRmRequest(&request, Rm_service_RESOURCE_STATUS, resNameGpQ,
1021 900, 50, 0, NULL, RM_TEST_FALSE, &response);
1022 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1023 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Status check failed");
1024 setRmRequest(&request, Rm_service_RESOURCE_STATUS, resNameGpQ,
1025 0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1026 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1027 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Status check (via NS name) failed");
1028 MEM_TEST_MID_STORE();
1029 setRmRequest(&request, Rm_service_RESOURCE_UNMAP_NAME, NULL,
1030 0, 0, 0, nsNameFavQ, RM_TEST_FALSE, &response);
1031 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1032 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "NameServer unmap failed");
1033 setRmRequest(&request, Rm_service_RESOURCE_FREE, resNameGpQ,
1034 900, 50, 0, NULL, RM_TEST_FALSE, &response);
1035 serviceHandle->Rm_serviceHandler(serviceHandle->rmHandle, &request, &response);
1036 ERROR_CHECK(RM_SERVICE_APPROVED, response.serviceState, clientName, "Free failed");
1037 MEM_TEST_END_PRINT("--------- Client Check Resource Status (via CD) ---------",
1038 "Pre Alloc ", "Post Status Requests ", "Post Free ");
1041 /* Cleanup */
1042 rmResult = Rm_serviceCloseHandle(serviceHandle);
1043 ERROR_CHECK(RM_OK, rmResult, clientName, "Service handle close failed");
1044 rmResult = Rm_transportUnregister(serverToCd);
1045 ERROR_CHECK(RM_OK, rmResult, serverName, "Client Delegate transport unregister failed");
1046 rmResult = Rm_transportUnregister(cdToServer);
1047 ERROR_CHECK(RM_OK, rmResult, cdName, "Server transport unregister failed");
1048 rmResult = Rm_transportUnregister(cdToClient);
1049 ERROR_CHECK(RM_OK, rmResult, cdName, "Client transport unregister failed");
1050 rmResult = Rm_transportUnregister(clientToCd);
1051 ERROR_CHECK(RM_OK, rmResult, clientName, "Client Delegate transport unregister failed");
1052 rmResult = Rm_delete(serverHandle, RM_TEST_TRUE);
1053 ERROR_CHECK(RM_OK, rmResult, serverName, "Delete failed");
1054 rmResult = Rm_delete(cdHandle, RM_TEST_TRUE);
1055 ERROR_CHECK(RM_OK, rmResult, cdName, "Delete failed");
1056 rmResult = Rm_delete(clientHandle, RM_TEST_TRUE);
1057 ERROR_CHECK(RM_OK, rmResult, clientName, "Delete failed");
1058 }
1060 void main(Int argc, Char* argv[])
1061 {
1062 Rm_InitCfg rmInitCfg;
1063 int32_t rmResult;
1064 int status;
1066 System_printf ("*********************************************************\n");
1067 System_printf ("******************** RM Memory Test *********************\n");
1068 System_printf ("*********************************************************\n");
1070 System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1072 /* Reset the variable to indicate to other cores RM init is not yet done */
1073 isRmInitialized[0] = 0;
1075 coreNum = CSL_chipReadReg(CSL_CHIP_DNUM);
1076 testErrors = 0;
1078 System_printf("Core %d: Starting IPC...\n", coreNum);
1079 status = Ipc_start();
1080 if (status < 0) {
1081 testErrors++;
1082 System_abort("Ipc_start failed\n");
1083 }
1085 if (coreNum == SYSINIT) {
1086 /* Test individual instance init/deletes */
1087 testServer();
1088 testCd();
1089 testClient();
1091 /* Test Server-CD-Client interaction for memory leaks all from a single core */
1092 testServerCdClient();
1094 /* Create Server for multicore interaction memory tests */
1095 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
1096 System_sprintf (rmInstName, "RM_Server");
1097 rmInitCfg.instName = rmInstName;
1098 rmInitCfg.instType = Rm_instType_SERVER;
1099 rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGlobalResourceList;
1100 rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmDspPlusArmPolicy;
1101 rmHandle = Rm_init(&rmInitCfg, &rmResult);
1102 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
1104 /* Signal to remote cores that Server instance has passed all initialization
1105 * memory tests and is ready */
1106 isRmInitialized[0] = 1;
1107 Osal_rmEndMemAccess((void *)isRmInitialized,sizeof(isRmInitialized));
1108 }
1109 else {
1110 /* Create Client for multicore interaction memory tests */
1111 memset((void *)&rmInitCfg, 0, sizeof(rmInitCfg));
1112 System_sprintf (rmInstName, "RM_Client%d", coreNum);
1113 rmInitCfg.instName = rmInstName;
1114 rmInitCfg.instType = Rm_instType_CLIENT;
1115 rmHandle = Rm_init(&rmInitCfg, &rmResult);
1116 ERROR_CHECK(RM_OK, rmResult, rmInstName, "Initialization failed");
1118 do{
1119 Osal_rmBeginMemAccess((void *)isRmInitialized, sizeof(isRmInitialized));
1120 } while (isRmInitialized[0] == 0);
1121 }
1123 if (setupRmTransConfig(NUM_CORES, SYSINIT, rmStartupTsk) < 0)
1124 {
1125 System_printf ("Error core %d : Transport setup for RM error\n", coreNum);
1126 testErrors++;
1127 return;
1128 }
1130 System_printf("Core %d: Starting BIOS...\n", coreNum);
1131 BIOS_start();
1133 return;
1134 }