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>
  43
  44 /* XDC Includes */
  45 #include <xdc/std.h>
  46 #include <xdc/runtime/System.h>
  47
  48 /* IPC Includes */
  49 #include <ti/ipc/Ipc.h>
  50 #include <ti/ipc/GateMP.h>
  51
  52 /* BIOS Includes */
  53 #include <ti/sysbios/BIOS.h>
  54 #include <ti/sysbios/knl/Task.h>
  55
  56 /* CSL Includes */
  57 #include <ti/csl/csl_chip.h>
  58 #include <ti/csl/csl_cacheAux.h>
  59 #include <ti/csl/csl_xmcAux.h>
  60
  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>
  66
  67 /**********************************************************************
  68  ************************** RM Test Symbols ***************************
  69  **********************************************************************/
  70
  71 #define SYSINIT                      0
  72 #define NUM_CORES                    2
  73
  74 /* Test FALSE */
  75 #define RM_TEST_FALSE                0
  76 /* Test TRUE */
  77 #define RM_TEST_TRUE                 1
  78
  79 /* GateMP names used to synchronize instance tasks */
  80 #define RM_SERVER_GATE_NAME            "serverGate"
  81 #define RM_CLIENT_GATE_NAME            "clientGate"
  82
  83 /* Size of RM service response queue */
  84 #define MAX_QUEUED_SERVICE_RESPONSES 10
  85
  86 /**********************************************************************
  87  ********************** Extern Variables ******************************
  88  **********************************************************************/
  89
  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[];
  94
  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[];
 103
 104 /* Alloc and free OSAL variables */
 105 extern uint32_t rmMallocCounter;
 106 extern uint32_t rmFreeCounter;
 107
 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);
 112
 113 extern int setupRmTransConfig(uint32_t numTestCores, uint32_t systemInitCore, Task_FuncPtr testTask);
 114 extern int deleteRmTrans(void);
 115
 116 /**********************************************************************
 117  ********************** Global Variables ******************************
 118  **********************************************************************/
 119
 120 /* DSP core number according to DNUM */
 121 uint16_t            coreNum;
 122 /* Number of errors that occurred during the test */
 123 uint16_t            testErrors;
 124
 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;
 131
 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;
 138
 139 /* RM instance variables */
 140 Rm_Handle           rmHandle = NULL;
 141 char                rmInstName[RM_NAME_MAX_CHARS];
 142
 143 /* Malloc/Free tracking variables */
 144 uint32_t            sMalloc, mMalloc;
 145 uint32_t            sFree, mFree;
 146
 147 /* RM response info queue used to store service responses received via the callback function */
 148 Rm_ServiceRespInfo  responseInfoQueue[MAX_QUEUED_SERVICE_RESPONSES];
 149
 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";
 153
 154 /* rmGlobalResourceList names (must match resource node names in rmGlobalResourceList and rmDspPlusArmPolicy */
 155 char                resNameMcGpQ[RM_NAME_MAX_CHARS] = "GENERAL_PURPOSE_QUEUE-qm1";
 156
 157 /* Test RM NameServer name */
 158 char                nsNameFavQ[RM_NAME_MAX_CHARS]   = "My_Favorite_Queue";
 159
 160 /* RM initialization sync point */
 161 #pragma DATA_SECTION (isRmInitialized, ".rm");
 162 #pragma DATA_ALIGN (isRmInitialized, 128)
 163 volatile int8_t   isRmInitialized[128];
 164
 165 /**********************************************************************
 166  ***************************** Test Macros ****************************
 167  **********************************************************************/
 168
 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     }
 178
 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)
 218
 219
 220 /**********************************************************************
 221  *************************** Test Functions ***************************
 222  **********************************************************************/
 223
 224 void serviceCallback(Rm_ServiceRespInfo *serviceResponse)
 225 {
 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     }
 235
 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 }
 239
 240 void waitForResponse(Rm_ServiceRespInfo *respInfo)
 241 {
 242     uint32_t qIndex = 0;
 243
 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         }
 256
 257         memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(*respInfo));
 258         memset((void *)&responseInfoQueue[qIndex], 0, sizeof(responseInfoQueue[qIndex]));
 259     }
 260 }
 261
 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));
 276 }
 277
 278 void rmCleanupTsk(UArg arg0, UArg arg1)
 279 {
 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     }
 307
 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");
 313
 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");
 340
 341     BIOS_exit(0);
 342 }
 343
 344 void rmServerTsk(UArg arg0, UArg arg1)
 345 {
 346     Rm_ServiceHandle   *serviceHandle;
 347     Task_Params         taskParams;
 348     int32_t             rmResult;
 349
 350     /* Open Client service handle */
 351     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
 352     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
 353
 354
 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     ");
 366
 367
 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     ");
 379
 380
 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 ");
 392
 393
 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     ");
 405
 406
 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);
 413 }
 414
 415 void rmClientTsk(UArg arg0, UArg arg1)
 416 {
 417     Rm_ServiceHandle   *serviceHandle;
 418     Rm_ServiceReqInfo   request;
 419     Rm_ServiceRespInfo  response;
 420     int32_t             rmResult;
 421     Task_Params         taskParams;
 422
 423     /* Open Client service handle */
 424     serviceHandle = Rm_serviceOpenHandle(rmHandle, &rmResult);
 425     ERROR_CHECK(RM_OK, rmResult, rmInstName, "Service handle open failed");
 426
 427
 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);
 449
 450
 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
 493
 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);
 515
 516
 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);
 565
 566
 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);
 573 }
 574
 575 void rmStartupTsk(UArg arg0, UArg arg1)
 576 {
 577     Int           status;
 578     GateMP_Params gateParams;
 579     Task_Params   taskParams;
 580
 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);
 587
 588         serverKey = GateMP_enter(serverGateHandle);
 589
 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);
 607
 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     }
 635 }
 636
 637 Rm_Packet *rmLocalPktAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
 638 {
 639     Rm_Packet *rmPkt = NULL;
 640
 641     rmPkt = Osal_rmMalloc(sizeof(*rmPkt));
 642     rmPkt->pktLenBytes = pktSize;
 643     *pktHandle = (Rm_PacketHandle)rmPkt;
 644     return (rmPkt);
 645 }
 646
 647 int32_t rmLocalPktSendRcv (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
 648 {
 649     Rm_TransportHandle  transportHandle = (Rm_TransportHandle)appTransport;
 650     Rm_Packet          *rmPkt = (Rm_Packet *) pktHandle;
 651     int32_t             status;
 652
 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     }
 658
 659     /* Free the packet */
 660     Osal_rmFree(rmPkt, sizeof(*rmPkt));
 661
 662     return (status);
 663 }
 664
 665 void testServer(void)
 666 {
 667     Rm_InitCfg          rmInitCfg;
 668     Rm_ServiceHandle   *serviceHandle;
 669     Rm_ServiceReqInfo   request;
 670     Rm_ServiceRespInfo  response;
 671     int32_t             rmResult;
 672
 673
 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       ");
 688
 689
 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");
 703
 704
 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
 724
 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");
 731
 732
 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            ");
 746
 747
 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            ");
 781
 782
 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
 797
 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");
 803 }
 804
 805 void testCd(void)
 806 {
 807     Rm_InitCfg          rmInitCfg;
 808     Rm_ServiceHandle   *serviceHandle;
 809     Rm_ServiceReqInfo   request;
 810     Rm_ServiceRespInfo  response;
 811     int32_t             rmResult;
 812
 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       ");
 826
 827
 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       ");
 837
 838
 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       ");
 857 }
 858
 859 void testClient(void)
 860 {
 861     Rm_InitCfg          rmInitCfg;
 862     Rm_ServiceHandle   *serviceHandle;
 863     Rm_ServiceReqInfo   request;
 864     Rm_ServiceRespInfo  response;
 865     int32_t             rmResult;
 866
 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       ");
 879
 880
 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       ");
 890
 891
 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       ");
 910 }
 911
 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)
 915 {
 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;
 928
 929
 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       ");
 945
 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");
 964
 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");
 999
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");
1003
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            ");
1018
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");
1068
1069
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            ");
1099
1100
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");
1118 }
1119
1120 void main(Int argc, Char* argv[])
1121 {
1122     Rm_InitCfg rmInitCfg;
1123     int32_t    rmResult;
1124     int        status;
1125
1126     System_printf ("*********************************************************\n");
1127     System_printf ("******************** RM Memory Test *********************\n");
1128     System_printf ("*********************************************************\n");
1129
1130     System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1131
1132     /* Reset the variable to indicate to other cores RM init is not yet done */
1133     isRmInitialized[0] = 0;
1134
1135     coreNum = CSL_chipReadReg(CSL_CHIP_DNUM);
1136     testErrors = 0;
1137
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     }
1144
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");
1177
1178         do{
1179             Osal_rmBeginMemAccess((void *)isRmInitialized, sizeof(isRmInitialized));
1180         } while (isRmInitialized[0] == 0);
1181     }
1182
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     }
1189
1190     System_printf("Core %d: Starting BIOS...\n", coreNum);
1191     BIOS_start();
1192
1193     return;
1194 }
1195