Completed testing of CD local allocation feature
authorJustin Sobota <jsobota@ti.com>
Mon, 29 Apr 2013 21:46:31 +0000 (17:46 -0400)
committerJustin Sobota <jsobota@ti.com>
Mon, 29 Apr 2013 21:46:31 +0000 (17:46 -0400)
12 files changed:
include/rm_dtb_utilloc.h
include/rm_policyloc.h
package.xdc
rmver.h
src/rm.c
src/rm_allocator.c
src/rm_dtb_util.c
src/rm_policy.c
test/dts_files/server-policy.c
test/dts_files/server-policy.dtb
test/dts_files/server-policy.dts
test/src/rm_test.c

index 171b13cb49cc67820b7064b91c8f203bdf25ddb9..7a04c37be0e5bfe812429f463e617723fd72ee79 100644 (file)
@@ -130,8 +130,8 @@ typedef enum {
     Rm_policyPropType_UNKNOWN = 0,     
     /** Policy DTB resource assignments property type */
     Rm_policyPropType_ASSIGNMENTS,
-    /** Policy DTB resource allocation size property type */
-    Rm_policyPropType_ALLOCATION_SIZE,
+    /** Policy DTB Client Delegate resource allocation size property type */
+    Rm_policyPropType_CD_ALLOCATION_SIZE,
     /** Policy DTB allocation alignment property type */
     Rm_policyPropType_ALLOCATION_ALIGNMENT,
     /** Policy DTB valid RM instances property type */
@@ -194,8 +194,8 @@ void rmDtbUtilResFreeNsAssignmentList(Rm_NsAssignment *nsAssignmentList);
 Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char *propertyName);
 Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr, int32_t dtbDataLen);
 void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList);
-Rm_ResourceValue *rmDtbUtilPolicyExtractAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen);
-void rmDtbUtilPolicyFreeAllocationSizes(Rm_ResourceValue *allocationSizeList);
+Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen);
+void rmDtbUtilPolicyFreeCdAllocationSizes(Rm_ResourceValue *allocationSizeList);
 Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPtr, int32_t dtbDataLen);
 void rmDtbUtilPolicyFreeResourceAlignments (Rm_ResourceValue *alignmentList);
 Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr, int32_t dtbDataLen, 
index 2d7373c984e77bb93a761f893f3fc4f22df0d38c..96ccbc2300e6919a782ef667a27cb7de7cff7669 100644 (file)
@@ -155,7 +155,7 @@ uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validI
                                  int32_t resourceOffset, Rm_PolicyCheckType policyCheckType, 
                                  int32_t *result);
 uint32_t rmPolicyGetResourceAlignment(void *policyDtb, int32_t resourceOffset);
-uint32_t rmPolicyGetResourceAllocSize(void *policyDtb, int32_t resourceOffset);
+uint32_t rmPolicyGetResourceCdAllocSize(void *policyDtb, int32_t resourceOffset);
 int32_t rmPolicyGetResourceOffset(void *policyDtb, char *resourceName);
 int32_t rmPolicyValidatePolicyResourceNames(Rm_Handle rmHandle);
 int32_t rmPolicyValidatePolicy(Rm_Handle rmHandle);
index 1406bf2baf3d90d1aee54437242ed3fd349a341f..51a5e087993e70629c577564038ed191196450fd 100644 (file)
@@ -9,6 +9,6 @@
  * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
  *****************************************************************************/\r
 \r
-package ti.drv.rm[02, 00, 00, 03] {\r
+package ti.drv.rm[02, 00, 00, 04] {\r
     module Settings;\r
 }\r
diff --git a/rmver.h b/rmver.h
index 5502d9694e0a7deb22059ed09c0f6e1bd49970ee..a388b619ddb6560380cb793cf5812e30bf9cabbb 100644 (file)
--- a/rmver.h
+++ b/rmver.h
@@ -51,13 +51,13 @@ extern "C" {
  * format:
  *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
  */
-#define RM_VERSION_ID                   (0x02000003)
+#define RM_VERSION_ID                   (0x02000004)
 
 /**
  * @brief   This is the version string which describes the RM along with the
  * date and build information.
  */
-#define RM_VERSION_STR                  "RM Revision: 02.00.00.03"
+#define RM_VERSION_STR                  "RM Revision: 02.00.00.04"
 
 
 #ifdef __cplusplus
index cfa937e2e484e7d095aa58c78b8470d51bc550bd..372e4d60807e45ae62268d5ff3a45294a3e102bc 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
@@ -430,7 +430,7 @@ static int32_t cdRequestServerResources(Rm_Inst *rmInst, Rm_Transaction *transac
 
     resourceOffsetInPolicy = rmPolicyGetResourceOffset(policy, transaction->resourceInfo.name);
     if (resourceOffsetInPolicy > 0) {
-        if (allocSize = rmPolicyGetResourceAllocSize(policy, resourceOffsetInPolicy)) {
+        if (allocSize = rmPolicyGetResourceCdAllocSize(policy, resourceOffsetInPolicy)) {
             if (newTrans = rmTransactionQueueAdd(rmInst)) {
                 newTrans->type = transaction->type;
                 strncpy(newTrans->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
index b36dd37a657d495d4fb11b2466886b6ac0a9b31c..a77da21404fa766766d632bf6177b4d88ea99b01 100644 (file)
@@ -1355,7 +1355,7 @@ int rmAllocatorGetNodeLocalization(Rm_Handle rmHandle, char *resourceName,
     Rm_Inst         *rmInst = (Rm_Inst *)rmHandle;
     void *           policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
     int32_t          resOffsetInPolicy = rmPolicyGetResourceOffset(policy, resourceName);
-    uint32_t         allocSize = rmPolicyGetResourceAllocSize(policy, resOffsetInPolicy);    
+    uint32_t         allocSize = rmPolicyGetResourceCdAllocSize(policy, resOffsetInPolicy);    
     Rm_Allocator    *allocator = rmAllocatorFind(rmHandle, resourceName);
     Rm_ResourceNode  findNode;
     Rm_ResourceNode *matchingNode = NULL;
index 9afadc32c92c98280cedff631ba15f4c6b837ad4..03de3624b5d3a4c9c4725264b1a3bda19bf150aa 100644 (file)
@@ -76,7 +76,7 @@ const char dtbUtilResNsAssignmentProp[] = "ns-assignment";
  * listed in a Resource Manager Policy */
 const char dtbUtilPolicyValidInstances[]      = "valid-instances";
 const char dtbUtilPolicyAssignments[]         = "assignments";
-const char dtbUtilPolicyAllocationSize[]      = "allocation-size";
+const char dtbUtilPolicyCdAllocationSize[]    = "cd-allocation-size";
 const char dtbUtilPolicyAllocationAlignment[] = "allocation-alignment";
 
 /**********************************************************************
@@ -478,8 +478,8 @@ Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char * propertyName)
     if(strcmp(dtbUtilPolicyAssignments, propertyName) == 0) {
         propertyType = Rm_policyPropType_ASSIGNMENTS;
     }
-    else if(strcmp(dtbUtilPolicyAllocationSize, propertyName) == 0) {
-        propertyType = Rm_policyPropType_ALLOCATION_SIZE;
+    else if(strcmp(dtbUtilPolicyCdAllocationSize, propertyName) == 0) {
+        propertyType = Rm_policyPropType_CD_ALLOCATION_SIZE;
     }
     else if(strcmp(dtbUtilPolicyAllocationAlignment, propertyName) == 0) {
         propertyType = Rm_policyPropType_ALLOCATION_ALIGNMENT;
@@ -574,7 +574,7 @@ void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList)
     }
 }
 
-/* FUNCTION PURPOSE: Extracts an allocation size from a Policy DTB
+/* FUNCTION PURPOSE: Extracts a CD allocation size from a Policy DTB
  ***********************************************************************
  * DESCRIPTION: Returns a list of allocation sizes extracted from a
  *              Policy DTB.  A allocation size in the DTB is specified
@@ -586,17 +586,17 @@ void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList)
  *                  <100>;
  *                  Results in a list of two allocation sizes.
  */
-Rm_ResourceValue *rmDtbUtilPolicyExtractAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen)
 {
     return(dtbUtilCommonExtractValueList(dtbDataPtr, dtbDataLen));
 }
 
-/* FUNCTION PURPOSE: Deletes a allocation sizes list
+/* FUNCTION PURPOSE: Deletes a CD allocation sizes list
  ***********************************************************************
  * DESCRIPTION: Frees the memory associated with a list of allocation
  *              sizes that were extracted from a Policy DTB.
  */
-void rmDtbUtilPolicyFreeAllocationSizes (Rm_ResourceValue *allocationSizeList)
+void rmDtbUtilPolicyFreeCdAllocationSizes (Rm_ResourceValue *allocationSizeList)
 {
     dtbUtilCommonFreeValueList(allocationSizeList);
 }
index cdd815ff75bfcc7bc38c42f0a195742e6a02bf65..cebbaca7348040aedfb5b92572f7c15d428e633b 100644 (file)
@@ -758,12 +758,12 @@ uint32_t rmPolicyGetResourceAlignment(void *policyDtb, int32_t resourceOffset)
     return(resourceAlignment);
 }
 
-/* FUNCTION PURPOSE: Returns resource allocation size according to the Policy
+/* FUNCTION PURPOSE: Returns resource CD allocation size according to the Policy
  ***********************************************************************
  * DESCRIPTION: Parses the policy DTB to find and return a resource's 
  *              allocation size.
  */
-uint32_t rmPolicyGetResourceAllocSize(void *policyDtb, int32_t resourceOffset)
+uint32_t rmPolicyGetResourceCdAllocSize(void *policyDtb, int32_t resourceOffset)
 {
     int32_t            propertyOffset;
     const char        *propertyName;
@@ -776,10 +776,10 @@ uint32_t rmPolicyGetResourceAllocSize(void *policyDtb, int32_t resourceOffset)
     if (propertyOffset > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
         while (propertyOffset > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
             propertyData = fdt_getprop_by_offset(policyDtb, propertyOffset, &propertyName, &propertyLen);
-            if (rmDtbUtilPolicyGetPropertyType(propertyName) == Rm_policyPropType_ALLOCATION_SIZE) {
-                allocSizeList = rmDtbUtilPolicyExtractAllocationSizes(propertyData, propertyLen);
+            if (rmDtbUtilPolicyGetPropertyType(propertyName) == Rm_policyPropType_CD_ALLOCATION_SIZE) {
+                allocSizeList = rmDtbUtilPolicyExtractCdAllocationSizes(propertyData, propertyLen);
                 resourceAllocSize = allocSizeList->value;                
-                rmDtbUtilPolicyFreeAllocationSizes(allocSizeList);
+                rmDtbUtilPolicyFreeCdAllocationSizes(allocSizeList);
             }
             propertyOffset = fdt_next_property_offset(policyDtb, propertyOffset);
         }
index 15a4f6b5462588efaabd1f5a789af3bc17b9a0b9..0903cb6102630dfe5030422873284128a995198c 100644 (file)
@@ -8,7 +8,7 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x0a,
-0xc1,
+0xd4,
 0x00,
 0x00,
 0x00,
@@ -16,7 +16,7 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x0a,
-0x80,
+0x90,
 0x00,
 0x00,
 0x00,
@@ -36,11 +36,11 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x41,
+0x44,
 0x00,
 0x00,
 0x0a,
-0x48,
+0x58,
 0x00,
 0x00,
 0x00,
@@ -544,7 +544,7 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x12,
+0x11,
 0x00,
 0x00,
 0x00,
@@ -559,7 +559,6 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x69,
 0x75,
-0x78,
 0x20,
 0x3d,
 0x20,
@@ -572,6 +571,23 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x00,
+0x00,
+0x03,
+0x00,
+0x00,
+0x00,
+0x04,
+0x00,
+0x00,
+0x00,
+0x31,
+0x00,
+0x00,
+0x00,
+0x20,
+0x00,
+0x00,
+0x00,
 0x02,
 0x00,
 0x00,
@@ -2738,6 +2754,9 @@ const char rmGlobalPolicy[] = {
 0x6e,
 0x74,
 0x00,
+0x63,
+0x64,
+0x2d,
 0x61,
 0x6c,
 0x6c,
@@ -2798,23 +2817,4 @@ const char rmGlobalPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
-0x00,
 };
index b61d2005caa2b1c327850d5187e3410f82fa2f1c..8d1b7cd53e79271b5555f75623f2dd5afcc76bf9 100644 (file)
Binary files a/test/dts_files/server-policy.dtb and b/test/dts_files/server-policy.dtb differ
index 6ab43f8d640e5a61ae262f804774f0ebe8688d8e..78592d9c641dd6373d1a7601a64758c31f036c0a 100644 (file)
@@ -37,7 +37,8 @@
 
         /* Queue definitions based on csl_qm_queue.h */
         low-prio-queue {
-            assignments = <0 512>, "iux = (*)";
+            assignments = <0 512>, "iu = (*)";
+            cd-allocation-size = <32>;
         };
         aif-queue {
             /* Give 525 shared permissions to match static policy permissions given to Client and CD.
@@ -81,7 +82,7 @@
             assignments = <896  1104>, "xiu = (*)",
                           <2000 1000>, "iu=(RM_Server RM_Client_Delegate RM_Client)",
                           <3000 5192>, "iux=(RM_Server) & iu=(RM_Client_Delegate RM_Client)";
-            allocation-size = <16>;
+            cd-allocation-size = <16>;
         };
     }; /* qmss */
 
index a2880436e6e9f5564e4bc65b9826e530fe2946e3..cf7de3a5b1db77f07aca8c9704b959908b16ab51 100644 (file)
@@ -357,6 +357,7 @@ char                resourceNameAifQ[RM_NAME_MAX_CHARS]       = "aif-queue";
 char                resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster";
 char                resourceNameAifRxCh[RM_NAME_MAX_CHARS]    = "aif-rx-ch";
 char                resourceNameInfraQ[RM_NAME_MAX_CHARS]     = "infra-queue";
+char                resourceNameLowPrioQ[RM_NAME_MAX_CHARS]   = "low-prio-queue";
 
 /* Test RM NameServer name */
 char                nameServerNameFavQ[RM_NAME_MAX_CHARS]     = "My_Favorite_Queue";
@@ -1049,7 +1050,7 @@ void rmClientTsk(UArg arg0, UArg arg1)
     rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
     waitForResponse(&responseInfo);   
     POSITIVE_PASS_CHECK("---- CD Testing: Allocate From CD (Non-Blocking) ----", 
-                        coreNum, rmCdName, resourceNameGpQ,
+                        coreNum, rmCdName, responseInfo.resourceName,
                         responseInfo.resourceBase, responseInfo.resourceLength, 
                         requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
     
@@ -1057,7 +1058,7 @@ void rmClientTsk(UArg arg0, UArg arg1)
                  RM_RESOURCE_BASE_UNSPECIFIED, 5, 0, NULL, RM_TEST_FALSE, &responseInfo);     
     rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo); 
     POSITIVE_PASS_CHECK("------ CD Testing: Allocate From CD (Blocking) ------", 
-                        coreNum, rmCdName, resourceNameGpQ,
+                        coreNum, rmCdName, responseInfo.resourceName,
                         responseInfo.resourceBase, responseInfo.resourceLength, 
                         requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
     
@@ -1066,7 +1067,7 @@ void rmClientTsk(UArg arg0, UArg arg1)
     rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
     waitForResponse(&responseInfo);    
     POSITIVE_PASS_CHECK("---- CD Testing: Allocate From Client (Non-Blocking) ----", 
-                        coreNum, rmClientName, resourceNameGpQ,
+                        coreNum, rmClientName, responseInfo.resourceName,
                         responseInfo.resourceBase, responseInfo.resourceLength, 
                         requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);   
 
@@ -1074,7 +1075,160 @@ void rmClientTsk(UArg arg0, UArg arg1)
                  RM_RESOURCE_BASE_UNSPECIFIED, 50, 0, NULL, RM_TEST_FALSE, &responseInfo);     
     rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
     POSITIVE_PASS_CHECK("------ CD Testing: Allocate From Client (Blocking) ------", 
-                        coreNum, rmClientName, resourceNameGpQ,
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ, 
+                 910, 2, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("-- CD Testing: Alloc Local Res Explicitly From Client ---", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ, 
+                 965, 2, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("---- CD Testing: Alloc Local Res Explicitly From CD -----", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);   
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ, 
+                 RM_RESOURCE_BASE_UNSPECIFIED, 5, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("-- CD Testing: Alloc Local Res Unspecified From Client --", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ, 
+                 RM_RESOURCE_BASE_UNSPECIFIED, 5, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("---- CD Testing: Alloc Local Res Unspecified From CD ----", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);   
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameLowPrioQ, 
+                 RM_RESOURCE_BASE_UNSPECIFIED, 1, 7, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("-- CD Testing: Alloc Local Res From Client For Sharing --", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        RM_RESOURCE_BASE_UNSPECIFIED, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, resourceNameLowPrioQ, 
+                 responseInfo.resourceBase, responseInfo.resourceLength, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+    waitForResponse(&responseInfo); 
+    STATUS_PASS_CHECK("----- Status Check of Resource Alloc'd Locally to CD ----", 
+                      coreNum, rmCdName, responseInfo.resourceName,
+                      responseInfo.resourceBase, responseInfo.resourceLength, 
+                      responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 1); 
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameLowPrioQ, 
+                 responseInfo.resourceBase, responseInfo.resourceLength, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("---- CD Testing: Alloc Shared Local Resource From CD ----", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);   
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, resourceNameLowPrioQ, 
+                 responseInfo.resourceBase, responseInfo.resourceLength, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+    STATUS_PASS_CHECK("- Status Check of Res Alloc'd Locally to CD After Share -", 
+                      coreNum, rmClientName, responseInfo.resourceName,
+                      responseInfo.resourceBase, responseInfo.resourceLength, 
+                      responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 2);
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ, 
+                 900, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+    waitForResponse(&responseInfo); 
+    NEGATIVE_PASS_CHECK("-- Attempt Shared Alloc of Unshared Local CD Resourcee --", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameLowPrioQ, 
+                 133, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("---- CD Testing: Free Shared Local Resource From CD -----", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);   
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameLowPrioQ, 
+                 133, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("-- CD Testing: Free Shared Local Resource From Client ---", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, resourceNameLowPrioQ, 
+                 responseInfo.resourceBase, responseInfo.resourceLength, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+    STATUS_PASS_CHECK("-- Status Check After Free of Locally Shared Resource ---", 
+                      coreNum, rmClientName, responseInfo.resourceName,
+                      responseInfo.resourceBase, responseInfo.resourceLength, 
+                      responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 0);   
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 965, 2, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("-------- CD Testing: Free Local Resource From CD --------", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED); 
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 898, 10, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("-------- CD Testing: Free Local Resource From CD --------", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 972, 5, 0, NULL, RM_TEST_FALSE, &responseInfo);     
+    rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    POSITIVE_PASS_CHECK("-------- CD Testing: Free Local Resource From CD --------", 
+                        coreNum, rmCdName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);      
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 910, 2, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("---- CD Testing: Free Local Resource From CD Client -----", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 914, 50, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("---- CD Testing: Free Local Resource From CD Client -----", 
+                        coreNum, rmClientName, responseInfo.resourceName,
+                        responseInfo.resourceBase, responseInfo.resourceLength, 
+                        requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);  
+
+    setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ, 
+                 967, 5, 0, NULL, RM_TEST_TRUE, &responseInfo);     
+    rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);  
+    waitForResponse(&responseInfo); 
+    POSITIVE_PASS_CHECK("---- CD Testing: Free Local Resource From CD Client -----", 
+                        coreNum, rmClientName, responseInfo.resourceName,
                         responseInfo.resourceBase, responseInfo.resourceLength, 
                         requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);      
     /* END Testing CD local allocation feature */