summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 35a99bd)
raw | patch | inline | side by side (parent: 35a99bd)
| author | Justin Sobota <jsobota@ti.com> | |
| Fri, 1 Mar 2013 22:08:27 +0000 (17:08 -0500) | ||
| committer | Justin Sobota <jsobota@ti.com> | |
| Fri, 1 Mar 2013 22:08:27 +0000 (17:08 -0500) |
| test/rm_test.c | patch | blob | history |
diff --git a/test/rm_test.c b/test/rm_test.c
index 8b63958932d8ec83e2cd4e8067c1d1ecb2fc80f0..a07aaceff285ade0f888a740bd5d04f230c4abaf 100644 (file)
--- a/test/rm_test.c
+++ b/test/rm_test.c
-/*
+/*
+ * rm_test.c
+ *
+ * Multicore Resource Manager test that uses IPC to an application
+ * requesting RM services from a RM Server, Client Delegate, and Client.
+ *
+ * ============================================================================
+ *
* Copyright (c) 2012-2013, Texas Instruments Incorporated
* All rights reserved.
*
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* 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
*
*/
-
-#include <c6x.h>
-#include <xdc/std.h>
-#include <stdio.h>
+
+/* Standard Includes */
#include <string.h>
#include <stdbool.h>
-/* -----------------------------------XDC.RUNTIME module Headers */
+/* XDC Includes */
+#include <xdc/std.h>
#include <xdc/runtime/System.h>
-#include <xdc/runtime/IHeap.h>
-/* ----------------------------------- IPC module Headers */
+/* IPC Includes */
#include <ti/ipc/Ipc.h>
#include <ti/ipc/MessageQ.h>
#include <ti/ipc/HeapBufMP.h>
#include <ti/ipc/MultiProc.h>
+#include <ti/ipc/GateMP.h>
-/* ----------------------------------- BIOS6 module Headers */
+/* BIOS Includes */
#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_osal.h>
-#include <ti/drv/rm/rm_transport.h>
-#include <ti/drv/rm/rm_services.h>
-
-/* ----------------------------------- CSL Module Headers */
+/* CSL Includes */
#include <ti/csl/csl_semAux.h>
#include <ti/csl/csl_cacheAux.h>
#include <ti/csl/csl_xmcAux.h>
-/* ======== Task Handles ======== */
-Task_Handle rmStartupTskHandle;
-Task_Handle rmReceiveTskHandle;
-Task_Handle rmServerTskHandle;
-Task_Handle rmClientTskHandle;
+/* RM Includes */
+#include <ti/drv/rm/rm.h>
+#include <ti/drv/rm/rm_transport.h>
+#include <ti/drv/rm/rm_services.h>
-/* ======== Application Heaps ======== */
-#define RM_PKT_HEAP_NAME "rmHeapBuf"
-HeapBufMP_Handle rmPktHeapHandle = NULL;
+/**********************************************************************
+ ************************** RM Test Symbols ***************************
+ **********************************************************************/
+
+/* IPC MessageQ heap name */
+#define MSGQ_HEAP_NAME "msgQHeapBuf"
+/* IPC MessageQ heap ID */
+#define MSGQ_HEAP_ID 0
+
+/* RM packet heap name */
+#define RM_PKT_HEAP_NAME "rmHeapBuf"
+/* Name of GateMP used to synchronize the RM test tasks */
+#define RM_TASK_GATE_NAME "rmGateMP"
+
+/* Application's core 0 registered RM transport indices */
+#define SERVER_TO_CD_MAP_ENTRY 0
+/* Application's core 1 registered RM transport indices */
+#define CD_TO_SERVER_MAP_ENTRY 0
+#define CD_TO_CLIENT_MAP_ENTRY 1
+#define CLIENT_TO_CD_MAP_ENTRY 2
+/* Maximum number of registered RM transports */
+#define MAX_MAPPING_ENTRIES 3
+
+/* Size of RM service response queue */
+#define MAX_QUEUED_SERVICE_RESPONSES 10
+
+/**********************************************************************
+ ********************** RM Test Data Structures ***********************
+ **********************************************************************/
+
+/* IPC MessageQ RM packet encapsulation structure */
+typedef struct {
+ /* IPC MessageQ header (must be first element in structure) */
+ MessageQ_MsgHeader msgQHeader;
+ /* Pointer to RM packet */
+ Rm_Packet *rmPkt;
+} MsgQ_RmPacket;
-#define MSGQ_HEAP_NAME "msgQHeapBuf"
-#define MSGQ_HEAP_ID 0
+/* RM registered transport mapping structure */
+typedef struct {
+ /* Registered RM transport handle */
+ Rm_TransportHandle transportHandle;
+ /* MessageQ receive queue tied to the transport handle */
+ MessageQ_Handle receiveMsgQ;
+} Transport_MapEntry;
-/* ======== RM Instance Names ======== */
-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";
+/**********************************************************************
+ ********************** Extern Variables ******************************
+ **********************************************************************/
-/* ======== RM DTB Files ======== */
+/* RM test Global Resource List (GRL) */
extern const char rmGrl[];
+/* Example Linux DTB file provided to RM Server for automatic Linux Kernel resource extraction */
+extern const char rmLinuxDtb[];
+/* RM test Global Policy provided to RM Server */
extern const char rmGlobalPolicy[];
+/* RM test Static Policy provided to RM Client Delegate and Client */
extern const char rmStaticPolicy[];
-extern const char rmLinuxDtb[];
-/* ======== RM IPC MessageQ Names ======== */
-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 resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
-
-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_ServiceHandle *rmServerServiceHandle = NULL;
-Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
-Rm_ServiceHandle *rmClientServiceHandle = NULL;
-
-/* ======== RM Transport Packet Definition ======== */
-typedef struct {
- MessageQ_MsgHeader msgQHeader;
- /* Pointer to packet provided by RM */
- Rm_Packet *rmPkt;
-} MsgQ_RmPacket;
+/**********************************************************************
+ ********************** Global Variables ******************************
+ **********************************************************************/
-/* ======== RM Transport Mapping Tables for Application ======== */
-/* Core 0 Map Entry Indices */
-#define SERVER_TO_CD_MAP_ENTRY 0
-/* Core 1 Map Entry Indicies */
-#define CD_TO_SERVER_MAP_ENTRY 0
-#define CD_TO_CLIENT_MAP_ENTRY 1
-#define CLIENT_TO_CD_MAP_ENTRY 2
+Task_Handle rmStartupTskHandle;
+Task_Handle rmReceiveTskHandle;
+Task_Handle rmServerTskHandle;
+Task_Handle rmClientTskHandle;
-/* Max map entries across all cores */
-#define MAX_MAPPING_ENTRIES 3
+GateMP_Handle gateHandle = NULL;
+IArg gateKey;
-typedef struct {
- Rm_TransportHandle transportHandle;
- MessageQ_Handle receiveMsgQ;
-} Transport_MapEntry;
+HeapBufMP_Handle rmPktHeapHandle = NULL;
-/* Core 1 will have three mapping entries
- * Two map entries for the Client Delegate
- * One map entry for the Client */
-Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
+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";
-uint32_t waitForBlockingOperation = 0;
-Rm_ServiceRespInfo responseInfo;
+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 Application Sync APIs ======== */
+Rm_Handle rmServerHandle = NULL;
+Rm_Handle rmClientDelegateHandle = NULL;
+Rm_Handle rmClientHandle = NULL;
-typedef struct {
- uint32_t sem;
- uint32_t pad[31];
-} syncObj;
+Rm_ServiceHandle *rmServerServiceHandle = NULL;
+Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
+Rm_ServiceHandle *rmClientServiceHandle = NULL;
-#pragma DATA_SECTION (testSyncObj, ".syncObj");
-#pragma DATA_ALIGN (testSyncObj, 16)
-syncObj testSyncObj;
+Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
+Rm_ServiceRespInfo responseInfoQueue[MAX_QUEUED_SERVICE_RESPONSES];
+
+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 resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
+
+char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
+
+/**********************************************************************
+ ************************** Cache Functions ***************************
+ **********************************************************************/
/**
* @b Description
Hwi_restore(key);
}
-
-void initSyncObj(void)
-{
- beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
- testSyncObj.sem = 0;
- endMemAccess((void *) &testSyncObj, sizeof(syncObj));
-}
-
-void takeSyncObj(void)
-{
- beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
- testSyncObj.sem = 1;
- endMemAccess((void *) &testSyncObj, sizeof(syncObj));
-}
-
-void waitOnSyncObj(void)
-{
- do {
- /* Yield for other tasks */
- Task_yield();
- beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
- } while (testSyncObj.sem == 1);
-}
-
-void releaseSyncObj(void)
-{
- beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
- testSyncObj.sem = 0;
- endMemAccess((void *) &testSyncObj, sizeof(syncObj));
-}
-
-/* ======== RM Application Transport APIs ======== */
-
+/**********************************************************************
+ *********** RM Application Transport APIs (utilizing IPC) ************
+ **********************************************************************/
Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
{
Rm_Packet *rmPkt = NULL;
}
}
-/*
- * ======== testServiceCallback ========
- * Application's callback function given to RM on service requests
- */
-void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
+/**********************************************************************
+ ******** RM Service Callback Function (for blocking services) ********
+ **********************************************************************/
+void serviceCallback(Rm_ServiceRespInfo *serviceResponse)
{
- 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);
+ uint32_t qIndex = 0;
+
+ /* Populate next free entry in the responseInfoQueue */
+ while (responseInfoQueue[qIndex].serviceId) {
+ qIndex++;
+ if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
+ qIndex = 0;
+ }
}
+
+ /* Save the response in the response queue for the test task to pick up */
+ memcpy((void *)&responseInfoQueue[qIndex], (void *)serviceResponse, sizeof(Rm_ServiceRespInfo));
}
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) {
- /* 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) &&
- (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) {
- System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(),
- respInfo->serviceState);
- return(FALSE);
+ uint32_t qIndex = 0;
+
+ if (respInfo->serviceState == RM_SERVICE_PROCESSING) {
+ /* Scan responseInfoQueue for the response received via the callback function */
+ while(responseInfoQueue[qIndex].serviceId != respInfo->serviceId) {
+ qIndex++;
+ if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
+ qIndex = 0;
+ }
+
+ /* Higher priority receive task will retrieve response */
+ }
+
+ memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(Rm_ServiceRespInfo));
+ memset((void *)&responseInfoQueue[qIndex], 0, sizeof(Rm_ServiceRespInfo));
+
+ if ((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);
}
-/*
- * ======== testRmTsk ========
- * RM cleanup task
- */
void rmCleanupTsk(UArg arg0, UArg arg1)
{
int32_t result;
BIOS_exit(0);
}
-/*
- * ======== testRmTsk ========
- * RM test task
- */
void rmReceiveTsk(UArg arg0, UArg arg1)
{
while(1) {
transportReceive(CD_TO_CLIENT_MAP_ENTRY);
transportReceive(CLIENT_TO_CD_MAP_ENTRY);
}
- /* Yield for main test task */
- Task_yield();
+ /* Sleep for 1ms so that the main test tasks can run */
+ Task_sleep(1);
}
}
-/*
- * ======== testRmServerTsk ========
- * RM Server test task
- */
void rmServerTsk(UArg arg0, UArg arg1)
{
- Rm_ServiceReqInfo requestInfo;
- Task_Params taskParams;
- int32_t result;
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
+ Task_Params taskParams;
+ int32_t result;
/* Delete the RM startup task */
System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
}
/* Issue the service request create a new NameServer object via the service port */
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service 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;
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
}
// Rm_printResourceStatus(rmServerHandle);
System_printf("Core %d: %s creating NameServer object...\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 created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- nameServerNameFavQ,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service 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();
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
// Rm_printResourceStatus(rmServerHandle);
/* Wait for Client to free resource via the NameServer and delete the NameServer object. */
- waitOnSyncObj();
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
// Rm_printResourceStatus(rmServerHandle);
System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\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 (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
}
/* Allocate some resources for testing tree interaction with multiple allocations from different instances */
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,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
}
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
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,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
/* Wait for Client and Client Delegate to do their allocates */
- waitOnSyncObj();
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
// 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 freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
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 freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_FREE;
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 freed resource: %s base: %d length: %d\n", MultiProc_self(),
- rmServerName,
- requestInfo.resourceName,
- requestInfo.resourceBase,
- requestInfo.resourceLength);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service 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;
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
// Rm_printResourceStatus(rmServerHandle);
/* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
- waitOnSyncObj();
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
// Rm_printResourceStatus(rmServerHandle);
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service 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;
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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
// Rm_printResourceStatus(rmServerHandle);
System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\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);
- }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ 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);
- }
+ System_printf("Core %d: Service failed with error: %d\n", MultiProc_self(), responseInfo.serviceState);
+ }
Rm_printResourceStatus(rmServerHandle);
Task_create (rmCleanupTsk, &taskParams, NULL);
}
-/*
- * ======== testRmClientTsk ========
- * RM Client test task
- */
void rmClientTsk(UArg arg0, UArg arg1)
{
- Rm_ServiceReqInfo requestInfo;
- Task_Params taskParams;
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
+ Task_Params taskParams;
/* Delete the RM startup task */
System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
/* 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 = nameServerNameFavQ;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
rmClientDelegateName);
requestInfo.resourceBase = responseInfo.resourceBase;
requestInfo.resourceLength = responseInfo.resourceLength;
requestInfo.resourceNsName = NULL;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
responseInfo.serviceState);
}
- /* Release the syncObj so Server can print results of NameServer object add and resource allocate */
- releaseSyncObj();
-
- /* Take the syncObj to free the name resource via the name, rather than the base+length */
- takeSyncObj();
+ GateMP_leave(gateHandle, gateKey);
+ gateKey = GateMP_enter(gateHandle);
/* 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 = nameServerNameFavQ;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME;
requestInfo.resourceNsName = nameServerNameFavQ;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
rmClientName,
responseInfo.serviceState);
}
- /* Release the syncObj so Server can print results of resource free and NameServer object delete. */
- releaseSyncObj();
-
- /* Take the syncObj to allocate resources for testing resource tree interactions. */
- takeSyncObj();
+ GateMP_leave(gateHandle, gateKey);
+ gateKey = GateMP_enter(gateHandle);
/* Allocate some resources for testing tree interaction with multiple allocations from different instances */
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 0;
requestInfo.resourceLength = 6;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameAifRxCh;
requestInfo.resourceBase = 50;
requestInfo.resourceLength = 7;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
responseInfo.serviceState);
}
- /* Release the syncObj so Server can print results of resource allocations */
- releaseSyncObj();
-
- /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */
- takeSyncObj();
+ GateMP_leave(gateHandle, gateKey);
+ gateKey = GateMP_enter(gateHandle);
memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
requestInfo.resourceLength = 5;
requestInfo.resourceAlignment = 4;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
requestInfo.resourceLength = 2;
requestInfo.resourceAlignment = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
requestInfo.resourceLength = 2;
requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameInfraQ;
requestInfo.resourceBase = 800;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
responseInfo.serviceState);
}
- /* Release the syncObj so Server can print results of resource allocations */
- releaseSyncObj();
+ GateMP_leave(gateHandle, gateKey);
System_printf("Core %d: Testing is complete\n", MultiProc_self());
Task_create (rmCleanupTsk, &taskParams, NULL);
}
-
-/*
- * ======== startupRmTsk ========
- * Configures application transports and registers them with RM
- */
-Void rmStartupTsk(UArg arg0, UArg arg1)
+void rmStartupTsk(UArg arg0, UArg arg1)
{
MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
Int status, i;
+ GateMP_Params gateParams;
HeapBufMP_Handle msgQHeapHandle;
HeapBufMP_Params heapBufParams;
Rm_TransportCfg rmTransportCfg;
Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
Task_Params taskParams;
- 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++) {
rmTransportMap[i].transportHandle = NULL;
}
if (MultiProc_self() == 0) {
+ GateMP_Params_init(&gateParams);
+ gateParams.name = RM_TASK_GATE_NAME;
+ gateHandle = GateMP_create(&gateParams);
+
/* 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. */
System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
}
else {
+ do {
+ status = GateMP_open(RM_TASK_GATE_NAME, &gateHandle);
+ /*
+ * Sleep for 1 clock tick to avoid inundating remote processor
+ * with interrupts if open failed
+ */
+ if (status < 0) {
+ Task_sleep(1);
+ }
+ } while (status < 0);
+ /* Take the gate right away to prepare for RM testing */
+ gateKey = GateMP_enter(gateHandle);
+
/* Open the heaps created by the other processor. Loop until opened. */
do {
status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
}
/* Register the MessageQ heap with MessageQ */
- MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
+ MessageQ_registerHeap(msgQHeapHandle, MSGQ_HEAP_ID);
/* Create the messageQ's for each RM instance connection
* Need four queues. Topology will be:
System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
}
- /* Create the RM receive task. */
+ /* Create the RM receive task. Assign higher priority than the test tasks so that
+ * when they spin waiting for messages from other RM instances the receive task is
+ * executed. */
System_printf("Core %d: Creating RM receive task...\n", MultiProc_self());
Task_Params_init (&taskParams);
+ taskParams.priority = 2;
rmReceiveTskHandle = Task_create (rmReceiveTsk, &taskParams, NULL);
if (MultiProc_self() == 0) {
System_printf("Core %d: Creating RM server task...\n", MultiProc_self());
Task_Params_init (&taskParams);
+ taskParams.priority = 1;
rmServerTskHandle = Task_create (rmServerTsk, &taskParams, NULL);
}
else if (MultiProc_self()) {
System_printf("Core %d: Creating RM client task...\n", MultiProc_self());
Task_Params_init (&taskParams);
+ taskParams.priority = 1;
rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
}
}
-/*
- * ======== main ========
- * Synchronizes all processors (in Ipc_start) and calls BIOS_start
- */
-Int main(Int argc, Char* argv[])
+int main(Int argc, Char* argv[])
{
Rm_InitCfg rmInitCfg;
Task_Params taskParams;
Int status;
- Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
int32_t result;
System_printf ("*********************************************************\n");
System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
/* Initialize the RM instances - RM must be initialized before anything else in the system
- * Core 0: 1 RM Instance - RM Server
+ * Core 0: 1 RM Instance - RM Server
* Core 1: 2 RM Instances - RM Client Delegate
* RM Client
*/
if (MultiProc_self()== 0) {
- initSyncObj();
-
/* Create the Server instance */
rmInitCfg.instName = &rmServerName[0];
rmInitCfg.instType = Rm_instType_SERVER;
requestInfo.resourceName = resourceNameQosCluster;
requestInfo.resourceBase = 0;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameQosCluster;
requestInfo.resourceBase = 2;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameQosCluster;
requestInfo.resourceBase = 1;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameAifQ;
requestInfo.resourceBase = 525;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
requestInfo.resourceName = resourceNameAifQ;
requestInfo.resourceBase = 525;
requestInfo.resourceLength = 1;
- requestInfo.callback.serviceCallback = testServiceCallback;
+ requestInfo.callback.serviceCallback = serviceCallback;
System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);