diff --git a/test/rm_test.c b/test/rm_test.c
index 1a9623b44d7ee66a1f5ee9ef69b243aa5daef59c..0837905826b992fd42c3712257bd6f4082f84513 100644 (file)
--- a/test/rm_test.c
+++ b/test/rm_test.c
/*
- * Copyright (c) 2012, Texas Instruments Incorporated
+ * Copyright (c) 2012-2013, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* */
+
/*
* ======== rm_test.c ========
* RM multicore test example
*
- * This is an example program that uses MessageQ to pass a message
- * from one processor to another.
- *
- * Each processor creates its own MessageQ first and then will try to open
- * a remote processor's MessageQ.
- *
- * See message_multicore.k file for expected output.
*/
#include <c6x.h>
/* ----------------------------------- BIOS6 module Headers */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
+#include <ti/sysbios/family/c64p/Hwi.h>
/* ----------------------------------- Resource Manager Headers */
#include <ti/drv/rm/rm.h>
#include <ti/drv/rm/rm_transport.h>
#include <ti/drv/rm/rm_services.h>
+/* ----------------------------------- CSL Module Headers */
+#include <ti/csl/csl_semAux.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_xmcAux.h>
+
/* ======== Task Handles ======== */
Task_Handle startupRmTskHandle;
Task_Handle testReceiveTskHandle;
#define MSGQ_HEAP_ID 0
/* ======== RM Instance Names ======== */
-Char rmServerName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Server";
-Char rmClientDelegateName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client_Delegate";
-Char rmClientName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client";
+Char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server";
+Char rmClientDelegateName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate";
+Char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
/* ======== RM IPC MessageQ Names ======== */
-Char serverCdQueueName[30] = "RM_Server_CD_Queue";
-Char cdServerQueueName[30] = "RM_CD_Server_Queue";
-Char cdClientQueueName[30] = "RM_CD_Client_Queue";
-Char clientCdQueueName[30] = "RM_Client_CD_Queue";
-
+Char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue";
+Char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue";
+Char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue";
+Char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue";
+
+/* ======== Test Resource & NameServer Names ======== */
+Char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions";
+char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch";
+Char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue";
+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 nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
+
/* ======== RM Instance Handles ======== */
Rm_Handle rmServerHandle = NULL;
Rm_Handle rmClientDelegateHandle = NULL;
Rm_Handle rmClientHandle = NULL;
/* ======== RM Instance Service Ports ======== */
-Rm_ServicePort *rmServerServicePort = NULL;
-Rm_ServicePort *rmClientDelegateServicePort = NULL;
-Rm_ServicePort *rmClientServicePort = NULL;
+Rm_ServiceHandle *rmServerServiceHandle = NULL;
+Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
+Rm_ServiceHandle *rmClientServiceHandle = NULL;
/* ======== RM Transport Packet Definition ======== */
typedef struct {
typedef struct {
Rm_TransportHandle transportHandle;
MessageQ_Handle receiveMsgQ;
- MessageQ_QueueId remoteMsgQId;
} Transport_MapEntry;
/* Core 1 will have three mapping entries
#pragma DATA_ALIGN (testSyncObj, 16)
syncObj testSyncObj;
+/**
+ * @b Description
+ * @n
+ * The function is used to indicate that a block of memory is
+ * about to be accessed. If the memory block is cached then this
+ * indicates that the application would need to ensure that the
+ * cache is updated with the data from the actual memory.
+ *
+ * @param[in] ptr
+ * Address of memory block
+ *
+ * @param[in] size
+ * Size of memory block
+ *
+ * @retval
+ * Not Applicable
+ */
+void beginMemAccess (void *ptr, uint32_t size)
+{
+ uint32_t key;
+
+ key = Hwi_disable();
+
+ /* Cleanup the prefetch buffer also. */
+ CSL_XMC_invalidatePrefetchBuffer();
+ /* Invalidate L1D cache and wait until operation is complete.
+ * Use this approach if L2 cache is not enabled */
+ CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);
+ asm (" nop 4");
+ asm (" nop 4");
+ asm (" nop 4");
+ asm (" nop 4");
+ Hwi_restore(key);
+}
+
+/**
+ * @b Description
+ * @n
+ * The function is used to indicate that the block of memory has
+ * finished being accessed. If the memory block is cached then the
+ * application would need to ensure that the contents of the cache
+ * are updated immediately to the actual memory.
+ *
+ * @param[in] ptr
+ * Address of memory block
+ *
+ * @param[in] size
+ * Size of memory block
+ *
+ * @retval
+ * Not Applicable
+ */
+void endMemAccess (void *ptr, uint32_t size)
+{
+ uint32_t key;
+
+ key = Hwi_disable();
+
+ /* Writeback L1D cache and wait until operation is complete.
+ * Use this approach if L2 cache is not enabled */
+ CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);
+ asm (" nop 4");
+ asm (" nop 4");
+ asm (" nop 4");
+ asm (" nop 4");
+ Hwi_restore(key);
+}
+
+
void initSyncObj(void)
{
- Rm_osalBeginMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
testSyncObj.sem = 0;
- Rm_osalEndMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ endMemAccess((void *) &testSyncObj, sizeof(syncObj));
}
void takeSyncObj(void)
{
- Rm_osalBeginMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
testSyncObj.sem = 1;
- Rm_osalEndMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ endMemAccess((void *) &testSyncObj, sizeof(syncObj));
}
void waitOnSyncObj(void)
{
- do
- {
+ do {
/* Yield for other tasks */
Task_yield();
- Rm_osalBeginMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
} while (testSyncObj.sem == 1);
}
void releaseSyncObj(void)
{
- Rm_osalBeginMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
testSyncObj.sem = 0;
- Rm_osalEndMemAccess((void *) &testSyncObj, sizeof(syncObj));
+ endMemAccess((void *) &testSyncObj, sizeof(syncObj));
}
/* ======== RM Application Transport APIs ======== */
-Rm_Packet *TransportAlloc (Rm_TransportHandle transportHandle, uint32_t pktSize)
+Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
{
- Rm_Packet *pkt = NULL;
-
- /* All transports will allocate from the same heap */
-
- pkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
+ Rm_Packet *rmPkt = NULL;
+ MsgQ_RmPacket *rmMsg = NULL;
- if (pkt != NULL)
- {
- pkt->pktLenBytes = pktSize;
+ /* Allocate a messageQ message for containing the RM packet */
+ rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
+ if (rmMsg == NULL) {
+ System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
+ *pktHandle = NULL;
+ return(NULL);
}
-
- return (pkt);
+ else {
+ /* Create and attach RM packet to MessageQ message. All transports will allocate from the same heap */
+ rmPkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
+ rmPkt->pktLenBytes = pktSize;
+ endMemAccess((void *)rmPkt, rmPkt->pktLenBytes);
+ rmMsg->rmPkt = rmPkt;
+ *pktHandle = (Rm_PacketHandle)rmMsg;
+ }
+ return (rmPkt);
}
-int32_t TransportFree (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
+void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt)
{
uint32_t pktSize = pkt->pktLenBytes;
+ int32_t status;
- /* All transports will free to the same heap */
-
+ /* All transports will free rmPkts to the same heap */
HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
- return (0);
+ status = MessageQ_free(rmMsgQMsg);
+ if (status < 0) {
+ System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", MultiProc_self());
+ }
}
-int32_t TransportSend (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
+int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
{
- MsgQ_RmPacket *rmMsg = NULL;
- MessageQ_QueueId remoteQueueId;
- bool handleValid = false;
- int32_t status, i;
-
- /* Get the remoteQueueId based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the remoteQueueId associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- remoteQueueId = rmTransportMap[i].remoteMsgQId;
- /* Break out of the search loop */
- handleValid = true;
- break;
- }
- }
-
- if (handleValid)
- {
- /* Allocate a messageQ message for containing the RM packet */
- rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
- if (rmMsg == NULL)
- {
- System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
- }
-
- /* Attach the RM packet to the MessageQ message */
- Rm_osalEndMemAccess((void *) pkt, pkt->pktLenBytes);
- rmMsg->rmPkt = pkt;
- /* Send the message to the remote side */
- status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
- if (status < 0)
- {
- System_printf("Core %d: MessageQ_put had a failure/error in TransportSend\n", MultiProc_self());
- }
+ MessageQ_QueueId remoteQueueId = (MessageQ_QueueId)appTransport;
+ MsgQ_RmPacket *rmMsg = pktHandle;
+ int32_t status;
+
+ /* Write back data that was written by RM after alloc */
+ endMemAccess((void *)rmMsg->rmPkt, rmMsg->rmPkt->pktLenBytes);
+
+ /* Send the message to the remote side */
+ status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
+ if (status < 0) {
+ transportFree((MessageQ_Msg)rmMsg, rmMsg->rmPkt);
+ System_printf("Core %d: MessageQ_put had a failure/error in TransportSend: error: %d\n", MultiProc_self(),
+ status);
}
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportSend couldn't find transportHandle in transport map\n", MultiProc_self());
- status = -1;
- }
-
return (status);
}
-void *TransportReceive (Rm_TransportHandle transportHandle)
+void transportReceive (uint32_t transportMapEntry)
{
- MessageQ_Handle receiveQ;
- MessageQ_Msg rmMsg = NULL;
- Rm_Packet *rmPkt = NULL;
- bool queueValid = false;
- int32_t status, i;
-
- /* Get the receiveQ based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the receiveQ associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- receiveQ = rmTransportMap[i].receiveMsgQ;
- /* Break out of the search loop */
- queueValid = true;
- break;
- }
- }
-
- if (queueValid)
- {
- /* Get the next message from the receiveQ */
+ MessageQ_Handle receiveQ;
+ int32_t numPkts;
+ MessageQ_Msg rmMsg = NULL;
+ Rm_Packet *rmPkt = NULL;
+ int32_t status;
+ uint32_t i;
+
+ /* Check if any packets available */
+ receiveQ = rmTransportMap[transportMapEntry].receiveMsgQ;
+ numPkts = (int32_t) MessageQ_count(receiveQ);
+
+ /* Process all available packets */
+ for (i = 0; i < numPkts; i++) {
status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
- if (status < 0)
- {
+ if (status < 0) {
System_abort("This should not happen since timeout is forever\n");
}
- if (rmMsg == NULL)
- {
+ if (rmMsg == NULL) {
System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
}
/* Extract the Rm_Packet from the RM msg */
rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
- Rm_osalBeginMemAccess((void *) rmPkt, rmPkt->pktLenBytes);
+ beginMemAccess((void *) rmPkt, rmPkt->pktLenBytes);
- /* Free the messageQ message now that RM packet pointer has been extracted */
- status = MessageQ_free(rmMsg);
- if (status < 0)
- {
- System_printf("Core %d: MessageQ_free had a failure/error in TransportReceive\n", MultiProc_self());
+ /* Provide packet to RM for processing */
+ if (status = Rm_receivePacket(rmTransportMap[transportMapEntry].transportHandle, rmPkt)) {
+ System_printf("Core %d: RM encountered error processing received packet: %d\n", MultiProc_self(), status);
}
- }
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportReceive couldn't find transportHandle in transport map\n", MultiProc_self());
- }
-
- /* Pass the RM packet back to RM */
- return ((void *)rmPkt);
-}
-int32_t TransportNumPktsReceived (Rm_TransportHandle transportHandle)
-{
- MessageQ_Handle receiveQ;
- bool queueValid = false;
- int32_t numPkts, i;
-
- /* Get the receiveQ based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the receiveQ associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- receiveQ = rmTransportMap[i].receiveMsgQ;
- /* Break out of the search loop */
- queueValid = true;
- break;
- }
- }
-
- if (queueValid)
- {
- /* Get the number of messages in the receiveQ */
- numPkts = (int32_t) MessageQ_count(receiveQ);
- }
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportNumPktsReceived couldn't find transportHandle in transport map\n", MultiProc_self());
- numPkts = -1;
+ /* Free RM packet buffer and messageQ message */
+ transportFree(rmMsg, rmPkt);
}
-
- return (numPkts);
}
/*
*/
void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
{
- if (serviceResponse->serviceId == waitForBlockingOperation)
- {
+ if (serviceResponse->serviceId == waitForBlockingOperation) {
waitForBlockingOperation = 0;
strcpy(responseInfo.resourceName, serviceResponse->resourceName);
responseInfo.resourceBase = serviceResponse->resourceBase;
responseInfo.resourceLength = serviceResponse->resourceLength;
responseInfo.serviceState = serviceResponse->serviceState;
}
+ else {
+ System_printf("Core %d: validation of static request with ID %d\n", MultiProc_self(),
+ serviceResponse->serviceId);
+ System_printf(" resource: %s, state: %d, base: %d, length: %d\n", serviceResponse->resourceName,
+ serviceResponse->serviceState,
+ serviceResponse->resourceBase,
+ serviceResponse->resourceLength);
+ }
}
bool blockForResponse(Rm_ServiceRespInfo *respInfo)
waitForBlockingOperation = respInfo->serviceId;
/* Block and wait for the response if the RM needed to perform a blocking operation
* to complete the request */
- while(waitForBlockingOperation)
- {
+ while(waitForBlockingOperation) {
/* Yield to receive task to see if there are any packets for RM instance */
Task_yield();
}
if ((respInfo->serviceState != RM_SERVICE_PROCESSING) &&
- (respInfo->serviceState != RM_SERVICE_APPROVED_AND_COMPLETED))
- {
+ (respInfo->serviceState != RM_SERVICE_APPROVED) &&
+ (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) {
System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(),
respInfo->serviceState);
return(FALSE);
}
-
return(TRUE);
}
{
/* Delete the RM test task */
System_printf("Core %d: Deleting RM test task...\n", MultiProc_self());
- if (testRmTskHandle)
- {
+ if (testRmTskHandle) {
Task_delete(&testRmTskHandle);
/* Set the task handle to be NULL so that the delete only occurs once */
testRmTskHandle = NULL;
}
/* Delete the RM receive task */
System_printf("Core %d: Deleting RM receive task...\n", MultiProc_self());
- if (testReceiveTskHandle)
- {
+ if (testReceiveTskHandle) {
Task_delete(&testReceiveTskHandle);
/* Set the task handle to be NULL so that the delete only occurs once */
testReceiveTskHandle = NULL;
}
-
-
/* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
BIOS_exit(0);
*/
void testReceiveTsk(UArg arg0, UArg arg1)
{
- int32_t retVal;
-
- while(1)
- {
-
- /* Run the RM polling functions for each RM instance. */
- if (MultiProc_self() == 0)
- {
- retVal = Rm_receivePktPolling(rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle);
- if (retVal != RM_TRANSPORT_SUCCESSFUL)
- {
- System_printf("Core %d: %s to %s transport receive error %d\n", MultiProc_self(),
- rmServerName,
- rmClientDelegateName,
- retVal);
- }
+ while(1) {
+ if (MultiProc_self() == 0) {
+ transportReceive(SERVER_TO_CD_MAP_ENTRY);
}
- else if (MultiProc_self() == 1)
- {
- retVal = Rm_receivePktPolling(rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle);
- if (retVal != RM_TRANSPORT_SUCCESSFUL)
- {
- System_printf("Core %d: %s to %s transport receive error %d\n", MultiProc_self(),
- rmClientDelegateName,
- rmServerName,
- retVal);
- }
-
- retVal = Rm_receivePktPolling(rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle);
- if (retVal != RM_TRANSPORT_SUCCESSFUL)
- {
- System_printf("Core %d: %s to %s transport receive error %d\n", MultiProc_self(),
- rmClientDelegateName,
- rmClientName,
- retVal);
- }
-
- retVal = Rm_receivePktPolling(rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle);
- if (retVal != RM_TRANSPORT_SUCCESSFUL)
- {
- System_printf("Core %d: %s to %s transport receive error %d\n", MultiProc_self(),
- rmClientName,
- rmClientDelegateName,
- retVal);
- }
+ else if (MultiProc_self() == 1) {
+ transportReceive(CD_TO_SERVER_MAP_ENTRY);
+ transportReceive(CD_TO_CLIENT_MAP_ENTRY);
+ transportReceive(CLIENT_TO_CD_MAP_ENTRY);
}
-
/* Yield for main test task */
Task_yield();
}
void testRmTsk(UArg arg0, UArg arg1)
{
Rm_ServiceReqInfo requestInfo;
- Task_Params taskParams;
+ Task_Params taskParams;
+ int32_t result;
/* Delete the RM startup task */
System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
- if (startupRmTskHandle)
- {
+ if (startupRmTskHandle) {
Task_delete(&startupRmTskHandle);
/* Set the task handle to be NULL so that the delete only occurs once */
startupRmTskHandle = NULL;
/* Open service ports on all the RM instances to test service requests from the different
* RM instances */
- if (MultiProc_self() == 0)
- {
- rmServerServicePort = Rm_getServicePort(rmServerHandle);
+ if (MultiProc_self() == 0) {
+ rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
+
+ Rm_printInstanceStatus(rmServerHandle);
}
- else if (MultiProc_self() == 1)
- {
- rmClientDelegateServicePort = Rm_getServicePort(rmClientDelegateHandle);
- rmClientServicePort = Rm_getServicePort(rmClientHandle);
+ else if (MultiProc_self() == 1) {
+ /* CD and Client serviceHandles were allocated in main() for static allocations.
+ * just reuse */
+
+ Rm_printInstanceStatus(rmClientDelegateHandle);
+ Rm_printInstanceStatus(rmClientHandle);
}
memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
System_printf("Core %d: Testing NameServer features...\n", MultiProc_self());
/* Use the service ports to test the service requests */
- if (MultiProc_self() == 0)
- {
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "gp-queue";
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "My_Favorite_Queue";
+ if (MultiProc_self() == 0) {
+ /* Issue the service request create a new NameServer object via the service port */
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameGpQ;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 1;
+ requestInfo.resourceAlignment = 0;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ /* Issue the service request create a new NameServer object via the service port */
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameGpQ;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 1;
+ requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ /* Issue the service request create a new NameServer object via the service port */
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameGpQ;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 1;
+ requestInfo.resourceAlignment = 200;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ Rm_printResourceStatus(rmServerHandle);
- char aifName[RM_RESOURCE_NAME_MAX_CHARS] = "aif-rx-ch";
- char memRegionName[RM_RESOURCE_NAME_MAX_CHARS] = "memory-regions";
/* Issue the service request create a new NameServer object via the service port */
requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
- requestInfo.resourceName = resourceName;
+ requestInfo.resourceName = resourceNameGpQ;
requestInfo.resourceBase = 1002;
requestInfo.resourceLength = 1;
- requestInfo.resourceNsName = resourceNsName;
+ requestInfo.resourceNsName = nameServerNameFavQ;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- resourceNsName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ nameServerNameFavQ,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
}
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Wait for Client Delegate and Client to retrieve resource via the name and allocate it */
waitOnSyncObj();
/* Try to allocate the memory region taken by the Linux Kernel */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
- requestInfo.resourceName = memRegionName;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameMemRegion;
requestInfo.resourceBase = 12;
requestInfo.resourceLength = 1;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Allocate some resources for testing tree interaction with multiple allocations from different instances */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
- requestInfo.resourceName = aifName;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 14;
requestInfo.resourceLength = 5;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
- requestInfo.resourceName = aifName;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 19;
requestInfo.resourceLength = 31;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
}
/* Wait for Client and Client Delegate to do their allocates */
/* Free resources to show tree handling of different frees */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
- requestInfo.resourceName = aifName;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 25;
requestInfo.resourceLength = 3;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
}
- Rm_printResourceStatus(rmServerHandle);
-
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
- requestInfo.resourceName = aifName;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 34;
requestInfo.resourceLength = 3;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
-
- Rm_printResourceStatus(rmServerHandle);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
- requestInfo.resourceName = aifName;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 28;
requestInfo.resourceLength = 6;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAifRxCh;
+ requestInfo.resourceBase = 53;
+ requestInfo.resourceLength = 2;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
}
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAifRxCh;
+ requestInfo.resourceBase = 2;
+ requestInfo.resourceLength = 2;
+ requestInfo.callback.serviceCallback = testServiceCallback;
- Rm_printResourceStatus(rmServerHandle);
+ System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
- }
- else if (MultiProc_self() == 1)
- {
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "gp-queue";
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "My_Favorite_Queue";
+ Rm_printResourceStatus(rmServerHandle);
- char aifName[RM_RESOURCE_NAME_MAX_CHARS] = "aif-rx-ch";
+ /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
+ waitOnSyncObj();
+
+ Rm_printResourceStatus(rmServerHandle);
+ /* Test allocation of a resource twice from the same instance with init and use privileges. Both
+ * should be approved but the instance should only be mentioned once in the resource's owner list */
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameGpQ;
+ requestInfo.resourceBase = 6543;
+ requestInfo.resourceLength = 10;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource for init...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameGpQ;
+ requestInfo.resourceBase = 6543;
+ requestInfo.resourceLength = 10;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating same resource for use...\n", MultiProc_self(), rmServerName);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmServerName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ Rm_printResourceStatus(rmServerHandle);
+ }
+ else if (MultiProc_self() == 1) {
/* Issue the service request for the resources tied to the name via the service port */
requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME;
- requestInfo.resourceNsName = resourceNsName;
+ requestInfo.resourceNsName = nameServerNameFavQ;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
rmClientDelegateName);
- rmClientDelegateServicePort->rmService(rmClientDelegateServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
- rmClientDelegateName,
- resourceNsName,
- responseInfo.resourceBase,
- responseInfo.resourceLength);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientDelegateName,
+ nameServerNameFavQ,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
}
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Allocate the resources via the service port from the Client */
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
requestInfo.resourceName = responseInfo.resourceName;
requestInfo.resourceBase = responseInfo.resourceBase;
requestInfo.resourceLength = responseInfo.resourceLength;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->rmService(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
- rmClientName,
- resourceNsName,
- responseInfo.resourceBase,
- responseInfo.resourceLength);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ nameServerNameFavQ,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
}
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Release the syncObj so Server can print results of NameServer object add and resource allocate */
releaseSyncObj();
/* Free the named resource using the name via the service port from the Client */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
- requestInfo.resourceNsName = resourceNsName;
+ requestInfo.resourceNsName = nameServerNameFavQ;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->rmService(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
- rmClientName,
- resourceNsName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
+ rmClientName,
+ nameServerNameFavQ);
+ }
}
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Delete the name object from the NameServer */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME;
- requestInfo.resourceNsName = resourceNsName;
+ requestInfo.resourceNsName = nameServerNameFavQ;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
rmClientName,
- resourceNsName);
- rmClientServicePort->rmService(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
- rmClientName,
- resourceNsName);
+ nameServerNameFavQ);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
+ rmClientName,
+ nameServerNameFavQ);
+ }
}
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Release the syncObj so Server can print results of resource free and NameServer object delete. */
releaseSyncObj();
/* Allocate some resources for testing tree interaction with multiple allocations from different instances */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
- requestInfo.resourceName = aifName;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 0;
requestInfo.resourceLength = 6;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->rmService(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
- rmClientName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- requestInfo.type = Rm_service_RESOURCE_ALLOCATE;
- requestInfo.resourceName = aifName;
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 50;
requestInfo.resourceLength = 7;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
- rmClientDelegateServicePort->rmService(rmClientDelegateServicePort->rmHandle, &requestInfo, &responseInfo);
- if (blockForResponse(&responseInfo))
- {
- System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
- rmClientDelegateName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientDelegateName,
+ requestInfo.resourceName,
+ requestInfo.resourceBase,
+ requestInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
/* Release the syncObj so Server can print results of resource allocations */
- releaseSyncObj();
+ releaseSyncObj();
+
+ /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */
+ takeSyncObj();
+
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAccumCh;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 5;
+ requestInfo.resourceAlignment = 4;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientDelegateName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAccumCh;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 2;
+ requestInfo.resourceAlignment = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
+ requestInfo.resourceName = resourceNameAccumCh;
+ requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
+ requestInfo.resourceLength = 2;
+ requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
+ (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
+ if (blockForResponse(&responseInfo)) {
+ System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ responseInfo.resourceName,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ /* Release the syncObj so Server can print results of resource allocations */
+ releaseSyncObj();
}
System_printf("Core %d: Testing is complete\n", MultiProc_self());
*/
Void startupRmTsk(UArg arg0, UArg arg1)
{
- MessageQ_Handle serverCdMsgQ, cdServerMsgQ, cdClientMsgQ, clientCdMsgQ;
- MessageQ_QueueId serverCdQId, cdServerQId, cdClientQId, clientCdQId;
- Int status, i;
- HeapBufMP_Handle msgQHeapHandle;
- HeapBufMP_Params heapBufParams;
- Rm_TransportCfg rmTransportCfg;
+ MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
+ MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
+ Int status, i;
+ HeapBufMP_Handle msgQHeapHandle;
+ HeapBufMP_Params heapBufParams;
+ Rm_TransportCfg rmTransportCfg;
+ int32_t result = 0;
Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
- Task_Params taskParams;
+ Task_Params taskParams;
- if (MultiProc_self() == 1)
- {
+ if (MultiProc_self() == 1) {
/* Take the syncObj on core 1, preparing for RM testing */
takeSyncObj();
}
/* Initialize the transport map */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
+ for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
rmTransportMap[i].transportHandle = NULL;
}
- if (MultiProc_self() == 0)
- {
+ if (MultiProc_self() == 0) {
/* Create the heap that will be used to allocate RM messages. This
* heap is a multi-processor heap. It will be shared amongst
* all RM instances. */
heapBufParams.numBlocks = 64;
heapBufParams.blockSize = sizeof(Rm_Packet);
rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
- if (rmPktHeapHandle == NULL)
- {
+ if (rmPktHeapHandle == NULL) {
System_abort("HeapBufMP_create failed for RM packet heap\n" );
}
System_printf("Core %d: RM packet heap created\n", MultiProc_self());
heapBufParams.numBlocks = 64;
heapBufParams.blockSize = sizeof(MsgQ_RmPacket);
msgQHeapHandle = HeapBufMP_create(&heapBufParams);
- if (msgQHeapHandle == NULL)
- {
+ if (msgQHeapHandle == NULL) {
System_abort("HeapBufMP_create failed MessageQ message heap\n" );
}
System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
}
- else
- {
+ else {
/* Open the heaps created by the other processor. Loop until opened. */
- do
- {
+ do {
status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
- do
- {
+ do {
status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
/* Create the messageQ's for each RM instance connection
* Need four queues. Topology will be:
* RM Server <---> RM Client Delegate <---> RM Client
- * 1 queue on RM Server
+ * 1 queues on RM Server
* 2 queues on RM Client Delegate
- * 1 queue on RM Client */
- if (MultiProc_self() == 0)
- {
- /* Create the RM Server messageQ used by the RM Client Delegate */
- serverCdMsgQ = MessageQ_create(serverCdQueueName, NULL);
- if (serverCdMsgQ == NULL)
- {
+ * 1 queues on RM Client */
+ if (MultiProc_self() == 0) {
+ serverFromCdMsgQ = MessageQ_create(serverFromCdQueueName, NULL);
+ if (serverFromCdMsgQ == NULL) {
System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
}
System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
}
- else if (MultiProc_self() == 1)
- {
- /* Create the RM Client Delegate messageQ used by the RM Server */
- cdServerMsgQ = MessageQ_create(cdServerQueueName, NULL);
- if (cdServerMsgQ == NULL)
- {
+ else if (MultiProc_self() == 1) {
+ cdFromServerMsgQ = MessageQ_create(cdFromServerQueueName, NULL);
+ if (cdFromServerMsgQ == NULL) {
System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
}
System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
- /* Create the RM Client Delegate messageQ used by the RM Client */
- cdClientMsgQ = MessageQ_create(cdClientQueueName, NULL);
- if (cdClientMsgQ == NULL)
- {
+
+ cdFromClientMsgQ = MessageQ_create(cdFromClientQueueName, NULL);
+ if (cdFromClientMsgQ == NULL) {
System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
}
System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
- /* Create the RM Client messageQ used by the RM Client Delegate */
- clientCdMsgQ = MessageQ_create(clientCdQueueName, NULL);
- if (clientCdMsgQ == NULL)
+
+ clientFromCdMsgQ = MessageQ_create(clientFromCdQueueName, NULL);
+ if (clientFromCdMsgQ == NULL)
{
System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
}
}
/* Open the remote message queues. Also register the RM transports with each RM instance */
- if (MultiProc_self() == 0)
- {
+ if (MultiProc_self() == 0) {
/* Open the Client Delegate messageQ from the Server */
- do
- {
- status = MessageQ_open(cdServerQueueName, &serverCdQId);
+ do {
+ status = MessageQ_open(cdFromServerQueueName, &serverToCdQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
/* Register the Client Delegate with the RM Server Instance */
+ rmTransportCfg.rmHandle = rmServerHandle;
+ rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCdQId;
rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
/* Set the callouts as valid for the first transport configuration on Server instance */
rmTransportCfg.transportCalloutsValid = true;
- rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
- rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
- rmTransportCfg.transportCallouts.rmSend = TransportSend;
- rmTransportCfg.transportCallouts.rmReceive = TransportReceive;
- rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived;
-
- serverCdHandle = Rm_transportRegister(rmServerHandle, &rmTransportCfg);
+ rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
+ rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
+ serverCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
/* Store the mapping information in the transport map */
rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
- rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverCdMsgQ;
- rmTransportMap[SERVER_TO_CD_MAP_ENTRY].remoteMsgQId = serverCdQId;
+ rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ;
System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
-
}
- else if (MultiProc_self() == 1)
- {
+ else if (MultiProc_self() == 1) {
/* Open the Server messageQ from the Client Delegate */
- do
- {
- status = MessageQ_open(serverCdQueueName, &cdServerQId);
+ do {
+ status = MessageQ_open(serverFromCdQueueName, &cdToServerQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
/* Register the Server with the RM Client Delegate Instance */
+ rmTransportCfg.rmHandle = rmClientDelegateHandle;
+ rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToServerQId;
rmTransportCfg.remoteInstType = Rm_instType_SERVER;
rmTransportCfg.remoteInstName = &rmServerName[0];
/* Set the callouts as valid for the first transport configuration on Client Delegate instance */
- rmTransportCfg.transportCalloutsValid = true;
- rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
- rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
- rmTransportCfg.transportCallouts.rmSend = TransportSend;
- rmTransportCfg.transportCallouts.rmReceive = TransportReceive;
- rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived;
- cdServerHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
+ rmTransportCfg.transportCalloutsValid = true;
+ rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
+ rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
+ cdServerHandle = Rm_transportRegister(&rmTransportCfg, &result);
/* Store the mapping information in the transport map */
rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
- rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdServerMsgQ;
- rmTransportMap[CD_TO_SERVER_MAP_ENTRY].remoteMsgQId = cdServerQId;
+ rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ;
System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
/* Open the Client messageQ from the Client Delegate */
- do
- {
- status = MessageQ_open(clientCdQueueName, &cdClientQId);
+ do {
+ status = MessageQ_open(clientFromCdQueueName, &cdToClientQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
/* Register the Client with the RM Client Delegate Instance */
+ rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClientQId;
rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
rmTransportCfg.remoteInstName = &rmClientName[0];
/* Callouts already set on the Client Delegate so set them as invalid */
rmTransportCfg.transportCalloutsValid = false;
-
- cdClientHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
+ cdClientHandle = Rm_transportRegister(&rmTransportCfg, &result);
/* Store the mapping information in the transport map */
rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
- rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdClientMsgQ;
- rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].remoteMsgQId = cdClientQId;
+ rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ;
System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
/* Open the Client Delegate messageQ from the Client */
- do
- {
- status = MessageQ_open(cdClientQueueName, &clientCdQId);
+ do {
+ status = MessageQ_open(cdFromClientQueueName, &clientToCdQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
/* Register the Client Delegate with the RM Client Instance */
+ rmTransportCfg.rmHandle = rmClientHandle;
+ rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCdQId;
rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
/* Set the callouts as valid for the first transport configuration on Client instance */
rmTransportCfg.transportCalloutsValid = true;
- rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
- rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
- rmTransportCfg.transportCallouts.rmSend = TransportSend;
- rmTransportCfg.transportCallouts.rmReceive = TransportReceive;
- rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived;
-
- clientCdHandle = Rm_transportRegister(rmClientHandle, &rmTransportCfg);
+ rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
+ rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
+ clientCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
/* Store the mapping information in the transport map */
rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
- rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientCdMsgQ;
- rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].remoteMsgQId = clientCdQId;
+ rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ;
System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
}
- /* Creat the RM receive task. */
+ /* Create the RM receive task. */
System_printf("Core %d: Creating RM receive task...\n", MultiProc_self());
Task_Params_init (&taskParams);
testReceiveTskHandle = Task_create (testReceiveTsk, &taskParams, NULL);
*/
Int main(Int argc, Char* argv[])
{
- Rm_InitCfg rmInitCfg;
- Task_Params taskParams;
- FILE *globalResourceFp;
- FILE *linuxDtbFp;
- FILE *globalPolicyFp;
- Int globalResourceFileSize;
- Int linuxDtbFileSize;
- Int globalPolicyFileSize;
- void *globalResourceList = NULL;
- void *linuxDtb = NULL;
- void *globalPolicy = NULL;
- Int status;
- Int readSize;
+ Rm_InitCfg rmInitCfg;
+ Task_Params taskParams;
+ FILE *globalResourceFp;
+ FILE *linuxDtbFp;
+ FILE *globalPolicyFp;
+ FILE *staticPolicyFp;
+ Int globalResourceFileSize;
+ Int linuxDtbFileSize;
+ Int globalPolicyFileSize;
+ Int staticPolicyFileSize;
+ void *globalResourceList = NULL;
+ void *linuxDtb = NULL;
+ void *globalPolicy = NULL;
+ void *staticPolicy = NULL;
+ Int status;
+ Int readSize;
+ Rm_ServiceReqInfo requestInfo;
+ int32_t result;
System_printf ("*********************************************************\n");
System_printf ("********************** RM Testing ***********************\n");
* Core 1: 2 RM Instances - RM Client Delegate
* RM Client
*/
- if (MultiProc_self()== 0)
- {
+ if (MultiProc_self()== 0) {
initSyncObj();
- /* Open the Global Resource and Policy DTB files */
- globalResourceFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\tci6614-global-resources.dtb", "rb");
- linuxDtbFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\tci6614-linux-evm.dtb", "rb");
- globalPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\global-policy.dtb", "rb");
+ globalResourceFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\global-resources.dtb", "rb");
+ linuxDtbFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\linux-evm.dtb", "rb");
+ globalPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\server-policy.dtb", "rb");
- /* Get the size of the Global Resource List, Linux DTB, and Global Policy */
fseek(globalResourceFp, 0, SEEK_END);
globalResourceFileSize = ftell(globalResourceFp);
rewind(globalResourceFp);
globalPolicyFileSize = ftell(globalPolicyFp);
rewind(globalPolicyFp);
- /* Allocate buffers to hold the Global Resource List, Linux DTB, and Global Policy */
globalResourceList = Osal_rmMalloc(globalResourceFileSize);
linuxDtb = Osal_rmMalloc(linuxDtbFileSize);
globalPolicy = Osal_rmMalloc(globalPolicyFileSize);
- /* Read the file data into the allocated buffers */
readSize = fread(globalResourceList, 1, globalResourceFileSize, globalResourceFp);
System_printf("Read Size compared to file size: %d : %d\n", readSize, globalResourceFileSize);
readSize = fread(linuxDtb, 1, linuxDtbFileSize, linuxDtbFp);
System_printf("Read Size compared to file size: %d : %d\n", readSize, linuxDtbFileSize);
readSize = fread(globalPolicy, 1, globalPolicyFileSize, globalPolicyFp);
System_printf("Read Size compared to file size: %d : %d\n", readSize, globalPolicyFileSize);
-
- System_printf("Core %d: RM Server instance created\n", MultiProc_self());
-
- /* Create the RM Server instance */
+
+ /* Create the Server instance */
rmInitCfg.instName = &rmServerName[0];
rmInitCfg.instType = Rm_instType_SERVER;
- /* Provide the DTBs to the RM Server */
- rmInitCfg.globalResourceList = globalResourceList;
- rmInitCfg.linuxDtb = linuxDtb;
- rmInitCfg.startupPolicy = globalPolicy;
-
- /* Get the RM Server handle */
- rmServerHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Server instance created\n", MultiProc_self());
+ rmInitCfg.instCfg.serverCfg.globalResourceList = globalResourceList;
+ rmInitCfg.instCfg.serverCfg.linuxDtb = linuxDtb;
+ rmInitCfg.instCfg.serverCfg.globalPolicy = globalPolicy;
+ rmServerHandle = Rm_init(&rmInitCfg, &result);
+ System_printf("Core %d: RM Server instance created. Result = %d\n", MultiProc_self(), result);
Rm_printResourceStatus(rmServerHandle);
}
- else if (MultiProc_self()== 1)
- {
+ else if (MultiProc_self()== 1) {
+ staticPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\static-policy.dtb", "rb");
+
+ fseek(staticPolicyFp, 0, SEEK_END);
+ staticPolicyFileSize = ftell(staticPolicyFp);
+ rewind(staticPolicyFp);
+ staticPolicy = Osal_rmMalloc(staticPolicyFileSize);
+ readSize = fread(staticPolicy, 1, staticPolicyFileSize, staticPolicyFp);
+ System_printf("Read Size compared to file size: %d : %d\n", readSize, staticPolicyFileSize);
+
/* Create the RM Client Delegate instance */
rmInitCfg.instName = &rmClientDelegateName[0];
rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
- /* SET TO NULL - FEATURES NOT ADDED YET */
- rmInitCfg.globalResourceList = NULL;
- rmInitCfg.startupPolicy = NULL;
-
- /* Get the RM Client Delegate handle */
- rmClientDelegateHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Client Delegate instance created\n", MultiProc_self());
+ rmInitCfg.instCfg.cdCfg.staticPolicy = staticPolicy;
+ rmClientDelegateHandle = Rm_init(&rmInitCfg, &result);
+ System_printf("Core %d: RM Client Delegate instance created. Result = %d\n", MultiProc_self(), result);
/* Create the RM Client instance */
rmInitCfg.instName = &rmClientName[0];
- rmInitCfg.instType = Rm_instType_CLIENT;
- /* SET TO NULL - FEATURES NOT ADDED YET */
- rmInitCfg.globalResourceList = NULL;
- rmInitCfg.startupPolicy = NULL;
-
- /* Get the RM Client handle */
- rmClientHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Client instance created\n", MultiProc_self());
+ rmInitCfg.instType = Rm_instType_CLIENT;
+ rmInitCfg.instCfg.clientCfg.staticPolicy = staticPolicy;
+ rmClientHandle = Rm_init(&rmInitCfg, &result);
+ System_printf("Core %d: RM Client instance created. Result = %d\n", MultiProc_self(), result);
+
+ /* Open service handles on the CD and Client to test static allocations */
+ rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result);
+ rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
+
+ /* Static allocations */
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameQosCluster;
+ requestInfo.resourceBase = 0;
+ requestInfo.resourceLength = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
+ rmClientDelegateName,
+ resourceNameQosCluster,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameQosCluster;
+ requestInfo.resourceBase = 2;
+ requestInfo.resourceLength = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ resourceNameQosCluster,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ /* Next request should return error */
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameQosCluster;
+ requestInfo.resourceBase = 1;
+ requestInfo.resourceLength = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ resourceNameQosCluster,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ /* Allocated shared resource to both CD and Client using static policy */
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameAifQ;
+ requestInfo.resourceBase = 525;
+ requestInfo.resourceLength = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
+ rmClientDelegateName,
+ resourceNameAifQ,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
+
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
+ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
+ requestInfo.resourceName = resourceNameAifQ;
+ requestInfo.resourceBase = 525;
+ requestInfo.resourceLength = 1;
+ requestInfo.callback.serviceCallback = testServiceCallback;
+
+ System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
+ rmClientName,
+ resourceNameAifQ,
+ responseInfo.resourceBase,
+ responseInfo.resourceLength);
+ }
+ else {
+ System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
+ responseInfo.serviceState);
+ }
}
- /*
- * Ipc_start() calls Ipc_attach() to synchronize all remote processors
- * because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
- */
System_printf("Core %d: Starting IPC...\n", MultiProc_self());
status = Ipc_start();
- if (status < 0)
- {
+ if (status < 0) {
System_abort("Ipc_start failed\n");
}