/* * ======== Algorithm_delete ======== */ Void Algorithm_delete(Algorithm_Handle alg) { Algorithm_Obj *pObject = (Algorithm_Obj *)alg; IRES_Status status; Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)", (IArg)alg); if (pObject != NULL) { if (pObject->iresFxns) { /* Call RMAN fuction to free resources */ status = RMAN_freeResources(pObject->alg, pObject->iresFxns, pObject->groupId); if (status != IRES_OK) { Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing " "of alg resources through RMAN FAILED (0x%x)", (IArg)status); } } if (pObject->idma3Fxns) { Log_print0(Diags_USER4, "[+4] Algorithm_delete> releasing " "DMA resources"); DMAN3_releaseDmaChannels(&(pObject->alg), &(pObject->idma3Fxns),1); } if (pObject->alg) { ALG_delete(pObject->groupId, pObject->alg, pObject->useCachedMem); } Memory_free(pObject, sizeof (*pObject), NULL); } Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit"); }
/* * ======== Algorithm_delete ======== */ Void Algorithm_delete(Algorithm_Handle alg) { Algorithm_Obj *pObject = (Algorithm_Obj *)alg; IRES_Status status; Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)", (IArg)alg); if (pObject != NULL) { if (pObject->iresFxns) { /* Call RMAN fuction to free resources */ status = RMAN_freeResources(pObject->alg, pObject->iresFxns, pObject->groupId); if (status != IRES_OK) { Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing " "of alg resources through RMAN FAILED (0x%x)", (IArg)status); } } if (pObject->alg) { DSKT2_freeAlg(pObject->groupId, pObject->alg); } Memory_free(pObject, sizeof (*pObject), NULL); } Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit"); }
Int32 SWOSD_close(SWOSD_Obj *pObj) { Int32 scratchId = g_scratchIndex; IRES_Status status; IRES_Fxns * resFxns = &SWOSD_TI_IRES; if(pObj->algHndl == NULL) return SWOSD_EFAIL; /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)pObj->algHndl, resFxns, scratchId); /* Deactivate algorithm */ DSKT2_deactivateAlg(scratchId, (IALG_Handle)pObj->algHndl); /* * Free resources assigned to this algorihtm */ status = RMAN_freeResources((IALG_Handle)pObj->algHndl, resFxns, scratchId); if (IRES_OK != status) { return SWOSD_EFAIL; } DSKT2_freeAlg(scratchId, (IALG_Handle)pObj->algHndl); return SWOSD_SOK; }
/* * ======== rmanTask ======== */ Void rmanTask(UArg arg0, UArg arg1) { Int taskId = (Int)arg0; Int index = (Int)arg1; /* index into attrsTable */ IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG; IRES_Fxns * resFxns = &DUMALG_TI_IRES; IDUMALG_Handle dumHandle = NULL; IDUMALG_Params params; Int scratchId = attrsTable[index].scratchId; Int yieldFlag = attrsTable[index].yieldFlag; Int priority = attrsTable[index].priority; Arg resourceId = (Arg)(&(attrsTable[index].id)); Int i; IRES_Status status; Log_print0(Diags_ENTRY, "[+E] rmanTask> Enter "); params.size = sizeof(IDUMALG_Params); Log_print4(Diags_USER4, "[+4] rmanTask> " "Task #%d: ScratchId %d, Priority %d Yield %d", (IArg)taskId, (IArg)scratchId, (IArg)priority, (IArg)yieldFlag); params.yieldFlag = yieldFlag; params.taskId = taskId; for (i = 0; i < NUM_RESOURCES; i++) { params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i); Log_print1(Diags_USER4, "[+4] rmanTask> " "Requesting resource %d (2 => ANY)", (IArg)((Int)params.hdvicp[i])); } /* * Create an instance of the algorithm using "algFxns" */ SemThread_pend(mutex, SemThread_FOREVER, NULL); dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId, (IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms); if (dumHandle == NULL) { Log_print0(Diags_USER7, "[+7] rmanTask> Alg creation failed"); System_abort("DSKT2_createAlg() failed, aborting...\n"); } SemThread_post(mutex, NULL); /* Assign resources to the algorithm */ status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId); if (status != IRES_OK) { Log_print1(Diags_USER7, "[+7] rmanTask> Assign resource failed [%d]", (IArg)status); System_abort("RMAN_assignResources() failed, aborting...\n"); } /* Activate the Algorithm */ DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle); /* Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Use IALG interfaces to do something */ dumHandle->fxns->useHDVICP(dumHandle, taskId); /* Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Deactivate algorithm */ DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle); /* Free resources assigned to this algorihtm */ status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId); if (status != IRES_OK) { Log_print1(Diags_USER7, "[+7] rmanTask> Free resource failed [%d]", (IArg)status); System_abort("RMAN_freeResources() failed, aborting...\n"); } /* * Free instance of the algorithm created */ SemThread_pend(mutex, SemThread_FOREVER, NULL); DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle); SemThread_post(mutex, NULL); SemThread_post(done, NULL); Log_print0(Diags_EXIT, "[+X] rmanTask> Exit "); }
/* ARGSUSED - this line tells the compiler to not generate compiler warnings * for unused arguments */ Int smain(Int argc, Char * argv[]) { IRES_Status status; Int size = 0; Int scratchId = 2; IALG_Fxns * algFxns = (IALG_Fxns *)&TEMPLATE_TI_CODECIRES; IRES_Fxns * resFxns = &TEMPLATE_TI_IRES; IALG_Handle dumHandle = NULL; ITEMPLATE_Status algStatus; /* * Create an instance of the algorithm using "algFxns" */ dumHandle = DSKT2_createAlg(scratchId, (IALG_Fxns *)algFxns, NULL, (IALG_Params *)NULL); if (dumHandle == NULL) { printf("Alg creation failed \n"); return -1; } /* * Supply initialization information for the RESMAN while registering */ size = sizeof(IRESMAN_Params); configParams.allocFxn = RMAN_PARAMS.allocFxn; configParams.freeFxn = RMAN_PARAMS.freeFxn; configParams.size = size; /* * Register the NULL protocol/resource manager with the generic resource * manager */ status = RMAN_register(&IRESMAN_NULLRES, (IRESMAN_Params *)&configParams); if (IRES_EEXISTS == status) { printf("Protocol Already Registered\n"); } /* Create an instance of an algorithm that implements IALG and IRES_Fxns */ if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle, resFxns,scratchId)) { printf("Assign Resource Failed \n"); return (-1); } /* Activate the Algorithm */ DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle); /* Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, -1); /* Use IALG interfaces to do something */ ((ITEMPLATE_Handle)dumHandle)->fxns->process((ITEMPLATE_Handle)dumHandle, (ITEMPLATE_InArgs *)NULL, (ITEMPLATE_OutArgs *)NULL); ((ITEMPLATE_Handle)dumHandle)->fxns->control((ITEMPLATE_Handle)dumHandle, (ITEMPLATE_Cmd )0, (ITEMPLATE_DynamicParams *)NULL, &algStatus); /* Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, -1); /* Deactivate algorithm */ DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle); /* Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, -1)) { printf("Free Resource Failed\n"); return (-1); } /* Free instance of the algorithm created */ DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle); /* Unregister the protocol */ if (IRES_OK != RMAN_unregister(&IRESMAN_NULLRES)) { printf("Unregister Protocol Failed\n"); return (-1); } RMAN_exit(); return (0); }
Int rmanTask(Arg scratchId, Arg resourceId, Arg priority, Arg taskId, Arg yieldFlag) { Int i; IALG_Fxns * algFxns = &DUMALG_TI_IALG; IRES_Fxns * resFxns = &DUMALG_TI_IRES; IDUMALG_Handle dumHandle = NULL; IDUMALG_Params params; GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Enter \n"); params.size = sizeof(IDUMALG_Params); GT_4trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> " "Task #%d: ScratchId %d, Priority %d Yield %d\n",taskId, scratchId, priority, yieldFlag); params.yieldFlag = yieldFlag; params.taskId = taskId; for (i = 0; i < NUM_RESOURCES; i++) { params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i); GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> " "Requesting resource %d (2 => ANY)\n",(Int)params.hdvicp[i]); } /* * Create an instance of the algorithm using "algFxns" */ SEM_pend(mutex, SYS_FOREVER); dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId, (IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms); if (dumHandle == NULL) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Alg creation failed\n"); return -1; } SEM_post(mutex); /* Assign resources to the algorithm */ if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId)) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Assign resource failed\n"); return -1; } /* * Activate the Algorithm */ DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle); /* * Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* * Use IALG interfaces to do something */ dumHandle->fxns->useHDVICP(dumHandle, taskId); /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* * Deactivate algorithm */ DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle); /* * Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId)) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Free resource failed\n"); return -1; } /* * Free instance of the algorithm created */ SEM_pend(mutex, SYS_FOREVER); DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle); SEM_post(mutex); SEM_post(done); GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Exit \n"); return 0; }
/* * ======== smain ======== */ Int smain(Int argc, Char * argv[]) { ISHMALG_Handle alg; ISHMALG_Fxns fxns = SHMALG_TI_ISHMALG; ISHMALG_Params params = ISHMALG_PARAMS; IRES_Fxns iresFxns = SHMALG_TI_IRES; IRES_Status status; Int scratchId; Bool passed = FALSE; Bool retVal = TRUE; Int fillVal = 1; if (argc > 1) { fillVal = atoi(argv[1]); } params.fillVal = fillVal; System_printf("shmbuf_test2> Started. buffer fill value: %d\n", fillVal); /* Initialize and register resource manager */ System_printf("Calling RMAN_init()...\n"); status = RMAN_init(); if (status != IRES_OK) { /* Test failed */ System_printf("RMAN_init() failed: %s [%d]\n", getError(status), status); goto done; } SHMBUF_PARAMS.bufsize = SHMBUFSIZE; SHMBUF_PARAMS.isScratch = TRUE; /* Make the buffer sharable */ System_printf("Calling RMAN_register()...\n"); status = RMAN_register(&SHMBUF_MGRFXNS, (IRESMAN_Params *)&SHMBUF_PARAMS); if (status != IRES_OK) { /* Test failed */ System_printf("RMAN_register() failed %s [%d]\n", getError(status), status); goto done; } scratchId = 1; System_printf("Calling DSKT2_createAlg()...\n"); alg = (ISHMALG_Handle)DSKT2_createAlg(scratchId, (IALG_Fxns *)&fxns, NULL, (IALG_Params *)¶ms); if (alg == NULL) { System_printf("DSKT2_createAlg() failed\n"); goto done; } /* Assign resources to the algorithm */ System_printf("Calling RMAN_assignResources()...\n"); status = RMAN_assignResources((IALG_Handle)alg, &iresFxns, scratchId); if (status != IRES_OK) { System_printf("RMAN_assignResources() failed %s [%d]\n", getError(status), status); goto done; } System_printf("Calling DSKT2_activateAlg()...\n"); DSKT2_activateAlg(scratchId, (IALG_Handle)alg); /* Activate All Resources */ System_printf("Calling RMAN_activateAllResources()...\n"); status = RMAN_activateAllResources((IALG_Handle)alg, &iresFxns, scratchId); if (status != IRES_OK) { System_printf("RMAN_activateAllResourceRMAN_unregister(&SHMBUF_MGRFXNS);s() failed %s [%d]\n", getError(status), status); goto done; } /* Use the buffer */ alg->fxns->useBufs(alg); /* Hold onto the resource for awhile */ System_printf("Sleeping...\n"); sleep(10); /* Check contents of the buffer */ if (!(retVal = alg->fxns->checkBufs(alg))) { System_printf("Buffer overwritten by another alg.\n"); } /* Deactivate All Resources */ System_printf("Calling RMAN_deactivateAllResources()...\n"); status = RMAN_deactivateAllResources((IALG_Handle)alg, &iresFxns, scratchId); if (status != IRES_OK) { System_printf("RMAN_deactivateAllResources() failed %s [%d]\n", getError(status), status); goto done; } /* Deactivate algorithm */ System_printf("Calling DSKT2_deactivateAlg()...\n"); DSKT2_deactivateAlg(scratchId, (IALG_Handle)alg); /* Free resources assigned to this algorihtm */ System_printf("Calling RMAN_freeResources()...\n"); status = RMAN_freeResources((IALG_Handle)(alg), &iresFxns, scratchId); if (status != IRES_OK) { System_printf("RMAN_freeResources() failed %s [%d]\n", getError(status), status); goto done; } /* Free instance of the algorithm created */ System_printf("Calling DSKT2_freeAlg()...\n"); DSKT2_freeAlg(scratchId, (IALG_Handle)alg); System_printf("Calling RMAN_unregister()...\n"); status = RMAN_unregister(&SHMBUF_MGRFXNS); if (status != IRES_OK) { System_printf("RMAN_unregister() failed %s [%d]\n", getError(status), status); goto done; } System_printf("Calling RMAN_exit()...\n"); status = RMAN_exit(); if (status != IRES_OK) { System_printf("RMAN_exit() failed %s [%d]\n", getError(status), status); goto done; } else { if (retVal) { passed = TRUE; } } done: RMAN_exit(); if (passed) { System_printf("TEST PASSED\n"); } else { System_printf("TEST FAILED\n"); } return (0); }
/* ARGSUSED - this line tells the compiler to not generate compiler warnings * for unused arguments */ Int smain(Int argc, Char * argv[]) { Int scratchId1 = 0; Int scratchId2 = 0; IALG_Status algStatus; IALG_Fxns * algFxns = &DUMRES_TI_IALG; IRES_Fxns * resFxns = &DUMRES_TI_IRES; DUMRES_TI_Handle algHandle1 = NULL; DUMRES_TI_Handle algHandle2 = NULL; EDMA3_RM_Handle rmHandle = NULL; EDMA3_RM_ResDesc resObj; MEM_Stat stat; Bool retVal; Int i = 0; /* * Create 2 instances of the algorithm using "algFxns" */ algHandle1 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId1, (IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL); if (algHandle1 == NULL) { printf("Alg creation failed for algHandle1\n"); return -1; } algHandle2 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId2, (IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL); if (algHandle2 == NULL) { printf("Alg creation failed for algHandle2\n"); return -1; } /* Assign resources to the algorithm */ if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle1, resFxns, scratchId1)) { GT_0trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask, GT_7CLASS, "Assign Resource Failed \n"); goto AppEnd1; } /* * Activate the Algorithm */ DSKT2_activateAlg(scratchId1, (IALG_Handle)algHandle1); /* * Activate All Resources */ RMAN_activateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1); /* * Use IALG interfaces to do something */ DSKT2_controlAlg((IALG_Handle)algHandle1, (IALG_Cmd)NULL, &algStatus); /* Assign resources to the second algorithm */ if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle2, resFxns, scratchId2)) { printf("Assign Resource Failed \n"); return -1; } /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1); /* * Deactivate algorithm */ DSKT2_deactivateAlg(scratchId1, (IALG_Handle)algHandle1); /* * Activate the Algorithm */ DSKT2_activateAlg(scratchId2, (IALG_Handle)algHandle2); /* * Activate All Resources */ RMAN_activateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2); /* * Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle1), resFxns, scratchId1)) { printf("Free Resource Failed \n"); return -1; } /* * Acquire the EDMA3 handle first */ rmHandle = EDMA3_getResourceManager(NULL, -1); if (NULL == rmHandle) { printf("Error obtaining SYSTEM resource Manager Handle \n"); return (-1); } resObj.resId = 151; resObj.type = EDMA3_RM_RES_PARAM_SET; if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) { printf("Could not allocate this resource, as it is already owned by " "the algorithm\n"); } resObj.resId = 256; if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) { printf("Error, could not allocate resource %d\n" "ERROR for 6467, OK for 6446\n", resObj.resId); } if (EDMA3_RM_SOK != EDMA3_releaseResourceManager(NULL, -1)) { printf("Error releasing system resource manager handle\n"); } /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2); /* * Deactivate algorithm */ DSKT2_deactivateAlg(scratchId2, (IALG_Handle)algHandle2); /* * Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle2), resFxns, scratchId2)) { printf("Free Resource Failed \n"); return -1; } AppEnd1: /* * Free instance of the algorithm created */ DSKT2_freeAlg(scratchId1, (IALG_Handle)algHandle1); /* * Free instance of the algorithm created */ DSKT2_freeAlg(scratchId2, (IALG_Handle)algHandle2); /* * Unregister the protocol */ if (IRES_OK != RMAN_unregister(&IRESMAN_EDMA3CHAN)) { printf("Unregister Protocol Failed \n"); return -1; } for (i = 0; i < MAXMEMSEGMENTS; i++) { retVal = MEM_stat(i, &stat); if (!retVal) { GT_assert(ti_sdo_fc_rman_examples_scratchEdma3_GTMask, memStat[i].size == 0); } else { if (memStat[i].used != stat.used) { GT_3trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask, GT_7CLASS, "MEM seg [%d]: orig used = 0x%x, " "curr used = 0x%x", i, memStat[i].used, stat.used); return (-1); } } } RMAN_exit(); return (0); }
/* ARGSUSED */ Int rmanTask(Int argc, Char * argv[]) { Int i; IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG; IRES_Fxns * resFxns = &DUMALG_TI_IRES; IDUMALG_Handle dumHandle = NULL; IDUMALG_Params params; Int taskId = 1; Int scratchId = -1; GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Enter\n"); params.size = sizeof(IDUMALG_Params); params.yieldFlag = FALSE; params.taskId = taskId; /* Configure the params to indicate the HDVICP requirements of each alg */ for (i = 0; i < NUM_RESOURCES; i++) { params.hdvicp[i] = *((IRES_HDVICP_RequestType *)&attrsTable[0].id[i]); GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> " "Requesting resource %d (2 => ANY)\n",(Int)params.hdvicp[i]); } ALG_init(); /* Create an instance of the algorithm using "algFxns" */ dumHandle = (IDUMALG_Handle)ALG_create((IALG_Fxns *)algFxns, (IALG_Handle)NULL, (IALG_Params *)¶ms); if (dumHandle == NULL) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Alg creation failed\n"); printf("App failed\n"); return (myIdle(argc, argv)); } /* Assign resources to the algorithm */ if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId)) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Assign resource failed\n"); return (myIdle(argc, argv)); } /* Activate the Algorithm */ ALG_activate((IALG_Handle)dumHandle); /* Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Use IALG interfaces to do something */ dumHandle->fxns->useHDVICP(dumHandle, taskId); /* Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Deactivate the algorithm */ ALG_deactivate((IALG_Handle)dumHandle); /* Free resources assigned to this algorithm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId)) { GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> " "Free resource failed\n"); return (myIdle(argc, argv)); } /* Free instance of the algorithm created */ ALG_delete((IALG_Handle)dumHandle); GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Exit\n"); return (myIdle(argc, argv)); }
/* ARGSUSED - this line tells the compiler to not generate compiler warnings * for unused arguments */ Int smain(UArg arg0, UArg arg1) { IRES_Status status; Int size = 0; Int scratchId = 2; IALG_Status algStatus; IALG_Fxns * algFxns = &DUMRES_TI_IALG; IRES_Fxns * resFxns = &DUMRES_TI_IRES; DUMRES_TI_Handle dumHandle = NULL; status = RMAN_init(); if (IRES_OK != status) { System_abort("RMAN initialization Failed \n"); } /* * Create an instance of the algorithm using "algFxns" */ dumHandle = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId, (IALG_Fxns *)algFxns, NULL, (IALG_Params *)NULL); if (dumHandle == NULL) { System_abort("Alg creation failed \n"); } /* Create an instance of an algorithm that implements IALG and IRES_Fxns */ status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId); if (status != IRES_OK) { System_printf("Assign Resource Failed [%d]\n", status); System_abort("Aborting...\n"); } /* Activate the Algorithm */ DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle); /* Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Use IALG interfaces to do something */ DSKT2_controlAlg((IALG_Handle)dumHandle, (IALG_Cmd)NULL, &algStatus); /* Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId); /* Deactivate algorithm */ DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle); /* Free resources assigned to this algorihtm */ status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId); if (status != IRES_OK) { System_printf("Free Resource Failed [%d]\n", status); System_abort("Aborting...\n"); } /* Free instance of the algorithm created */ DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle); RMAN_exit(); return (1); }
/* ARGSUSED - this line tells the compiler to not generate compiler warnings * for unused arguments */ Int smain(Int argc, Char * argv[]) { IRES_Status status; Int scratchId = 2; IALG_Fxns * algFxns = (IALG_Fxns *)&DUMRES_TI_IDUMRES; IRES_Fxns * resFxns = &DUMRES_TI_IRES; IDUMRES_Handle dumHandle = NULL; IDUMRES_Params params; Int sleepTime = 0; if (argc > 1) { sleepTime = atoi(argv[1]); } if (argc > 2) { scratchId = atoi(argv[2]); } ALG_init(); /* Create an instance of the algorithm using "algFxns" */ //params.taskId = taskId; params.taskId = 6; dumHandle = (IDUMRES_Handle)ALG_create( (IALG_Fxns *)algFxns, (IALG_Handle)NULL, (IALG_Params *)¶ms); if (dumHandle == NULL) { printf("Alg creation failed \n"); return (-1); } /* Create an instance of an algorithm that implements IALG and IRES_Fxns */ status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns,scratchId); if (IRES_OK != status) { printf("Assign Resource Failed \n"); result = FALSE; } else { ALG_activate((IALG_Handle)dumHandle); /* Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, -1); SLEEP(sleepTime); /* Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, -1); ALG_deactivate((IALG_Handle)dumHandle); /* Free resources assigned to this algorihtm */ status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId); if (IRES_OK != status) { printf("Free Resource Failed \n"); result = FALSE; } } ALG_delete((IALG_Handle)dumHandle); status = RMAN_exit(); if (status != IRES_OK) { result = FALSE; } if (result) { printf("TEST PASSED\n"); } else { printf("TEST FAILED.\n"); } }
/* ARGSUSED - this line tells the compiler to not generate compiler warnings * for unused arguments */ Int smain(Int argc, String argv[]) { Int scratchId1 = 0; Int scratchId2 = 1; /* IALG_Status algStatus;*/ IALG_Fxns * algFxns = &DUMRES_TI_IALG; IRES_Fxns * resFxns = &DUMRES_TI_IRES; DUMRES_TI_Handle dumHandle1 = NULL; DUMRES_TI_Handle dumHandle2 = NULL; EDMA3_Handle rmHandle = NULL; EDMA3_ResDesc resObj; Bool status = TRUE; IDUMRES_Params params; if (argc > 1) { scratchId1 = atoi(argv[1]); } if (argc > 2) { scratchId2 = atoi(argv[2]); } ALG_init(); /* * Create an instance of the algorithm using "algFxns" */ params.algNum = 1; dumHandle1 = (DUMRES_TI_Handle)ALG_create((IALG_Fxns *)algFxns, (IALG_Handle)NULL, (IALG_Params *)¶ms); if (dumHandle1 == NULL) { printf("Alg1 creation failed \n"); return -1; } params.algNum = 2; dumHandle2 = (DUMRES_TI_Handle)ALG_create((IALG_Fxns *)algFxns, (IALG_Handle)NULL, (IALG_Params *)¶ms); if (dumHandle2 == NULL) { printf("Alg2 creation failed \n"); return -1; } /* Create an instance of an algorithm that implements IALG and IRES_Fxns */ if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle1, resFxns,scratchId1)) { printf("Assign Resource Failed \n"); status = FALSE; goto AppEnd1; } /* * Activate the Algorithm */ ALG_activate((IALG_Handle)dumHandle1); /* * Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle1, resFxns, scratchId1); /* * Use IALG interfaces to do something */ //TODO: DSKT2_controlAlg((IALG_Handle)dumHandle, (IALG_Cmd)NULL, &algStatus); /* Assign resources to the second algorithm */ if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle2, resFxns, scratchId2)) { printf("Assign Resource Failed \n"); return -1; } /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle1, resFxns, scratchId1); /* * Deactivate algorithm */ ALG_deactivate((IALG_Handle)dumHandle1); /* * Activate the Algorithm */ ALG_activate((IALG_Handle)dumHandle2); /* * Activate All Resources */ RMAN_activateAllResources((IALG_Handle)dumHandle2, resFxns, scratchId2); /* * Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle1), resFxns, scratchId1)) { printf("Free Resource Failed \n"); return -1; } /* * Acquire the EDMA3 handle first */ rmHandle = EDMA3_getResourceManager((IALG_Handle)NULL, (Int)-1); if (NULL == rmHandle) { printf("Error obtaining SYSTEM resource Manager Handle \n"); return (-1); } resObj.resId = 65; resObj.type = EDMA3_RES_PARAM_SET; if (EDMA3_SOK != EDMA3_allocResource(rmHandle, &resObj)) { printf("Note, could not allocate this resource.\n"); } resObj.resId = 126; if (EDMA3_SOK != EDMA3_allocResource(rmHandle, &resObj)) { printf("Note, could not allocate resource %d\n", resObj.resId); } if (EDMA3_SOK != EDMA3_releaseResourceManager(NULL, -1)) { printf("Note, releasing system resource manager handle\n"); } /* * Deactivate All Resources */ RMAN_deactivateAllResources((IALG_Handle)dumHandle2, resFxns, scratchId2); /* * Deactivate algorithm */ ALG_deactivate((IALG_Handle)dumHandle2); /* * Free resources assigned to this algorihtm */ if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle2), resFxns, scratchId2)) { printf("Free Resource Failed \n"); return -1; } AppEnd1: /* * Free instance of the algorithm created */ ALG_delete((IALG_Handle)dumHandle1); /* * Free instance of the algorithm created */ ALG_delete((IALG_Handle)dumHandle2); RMAN_exit(); if (status) printf("Application exiting normally\n"); return (0); }
/* * ======== RMAN_assignResources ======== * Assign resources to the algorithm indicated by alg. The resource * requirements can be determined by using the IRES_Fxns implementation */ IRES_Status RMAN_assignResources(IALG_Handle alg, IRES_Fxns * resFxns, Int scratchGroupId) { Int numResources; Int k; Int n = 0; size_t resDescSize; IRESMAN_Fxns * resman = NULL; IRES_Status status = IRES_OK; IRES_Status freeStatus = IRES_OK; IRES_Status algStatus = IRES_OK; IRES_YieldFxn yieldFxn = NULL; IRES_YieldArgs * yieldArgs = NULL; IRES_ResourceDescriptor * resDesc = NULL; IArg key; if (initStatus != IRES_OK) { Log_print0(Diags_USER7, "[+7] RMAN_assignResources> " "RMAN_init call hasn't happened successfully. Please " "initialize RMAN before calling any other RMAN API"); Log_print0(Diags_EXIT, "[+X] RMAN_assignResources> " "Exit (status=IRES_ENOINIT)"); return (IRES_ENOINIT); } Assert_isTrue(resFxns != NULL, (Assert_Id)NULL); Assert_isTrue(RMAN_PARAMS.allocFxn != NULL, (Assert_Id)NULL); Assert_isTrue(RMAN_PARAMS.freeFxn != NULL, (Assert_Id)NULL); Log_print3(Diags_ENTRY, "[+E] RMAN_assignResources> " "Enter (alg=0x%x, resFxns=0x%x, scratchGroupId=%d)", (IArg)alg, (IArg)resFxns, (IArg)scratchGroupId); /* * Get resource requirements of the algorithm */ numResources = (resFxns->numResourceDescriptors)(alg); resDescSize = numResources * sizeof(IRES_ResourceDescriptor); /* Allocate memory to hold algorithm's resource descriptors */ if ((resDesc = myAlloc(resDescSize, 0)) == NULL) { Log_print1(Diags_USER7, "[+7] RMAN_assignResources> " "Could not allocate memory size 0x%x in space " "IALG_EXTERNAL of type IALG_PERSIST", (IArg)resDescSize); Log_print0(Diags_EXIT, "[+X] RMAN_assignResources> " "Exit (status=IRES_ENOMEM)"); return (IRES_ENOMEM); } algStatus = resFxns->getResourceDescriptors(alg, resDesc); if (algStatus != IRES_OK) { Log_print3(Diags_USER7, "[+7] RMAN_assignResources> Error obtaining " "Resource Descriptors [status: %d] from alg 0x%x, " "IRES interface 0x%x", (IArg)algStatus, (IArg)alg, (IArg)resDesc); status = IRES_EALG; } if (status == IRES_OK) { /* For each requested resource */ for (n = 0 ; n < numResources; n++) { /* If someone populated the resource descriptor improperly, bail */ if ((resDesc[n].resourceName == NULL) || (resDesc[n].revision == NULL)) { Log_print0(Diags_USER7, "[+7] RMAN_assignResources> " "Resource protocol and/or version were NULL. " "Most likely an issue with the algorithm's " "getResourceRequestDescriptor implementation."); status = IRES_EALG; break; } resman = getResman(resDesc[n].resourceName, resDesc[n].revision); if (resman != NULL) { /* * Call getHandle on the IRESMAN implementation using * the protocolArgs extracted. */ Log_print1(Diags_USER2, "[+2] RMAN_assignResources> Call " "getHandle on the IRESMAN implementation 0x%x", (IArg)resman); /* Acquire lock */ key = IGateProvider_enter(gate); resDesc[n].handle = resman->getHandle(alg, &resDesc[n], scratchGroupId, &status); /* Release lock */ IGateProvider_leave(gate, key); if (IRES_OK != status) { break; } } else { Log_print2(Diags_USER7, "[+7] RMAN_assignResources> " "Resource protocol %s and version 0x%x didn't match " "any registered protocol.", (IArg)(resDesc[n].resourceName), (IArg)(resDesc[n].revision)); status = IRES_ENOTFOUND; break; } } } /* n = number of resources allocated */ /* * Return those handles to IALG using the appropriate IRES call */ if (IRES_OK == status) { if ((RMAN_PARAMS.yieldFxn != NULL) && (ti_sdo_fc_rman_RMAN_setYieldArgs != NULL)) { yieldFxn = RMAN_PARAMS.yieldFxn; yieldArgs = ti_sdo_fc_rman_RMAN_setYieldArgs(scratchGroupId, RMAN_PARAMS.yieldSamePriority); } /* Acquire lock */ key = IGateProvider_enter(gate); algStatus = resFxns->initResources(alg, resDesc, yieldFxn, yieldArgs); /* Release lock */ IGateProvider_leave(gate, key); if (algStatus != IRES_OK) { Log_print1(Diags_USER7, "[+7] RMAN_assignResources> " "resFxns->initResources() failed [%d]", (IArg)algStatus); status = IRES_EALG; } } if (status != IRES_OK) { /* * Error somewhere in initialization of resource handles * Free all allocated handles. */ for (k = 0; k < n; k++) { resman = getResman(resDesc[k].resourceName, resDesc[k].revision); if (NULL == resman) { /* Resource table is messed up - bail out */ Log_print2(Diags_USER7, "[+7] RMAN_assignResources> Could " "not find IRESMAN matching resource %s version 0x%x", (IArg)(resDesc[k].resourceName), (IArg)(resDesc[k].revision)); status = IRES_EFAIL; break; } /* Acquire lock */ key = IGateProvider_enter(gate); freeStatus = resman->freeHandle(alg, resDesc[k].handle, &resDesc[k], scratchGroupId); /* Release lock */ IGateProvider_leave(gate, key); if (freeStatus != IRES_OK) { /* * If we can't free the resource handle, something is really * messed up. Don't try to free anything else. */ status = IRES_EFAIL; Log_print2(Diags_USER7, "[+7] RMAN_assignResources> Free " "handle failed [%d] on IRESMAN implementation 0x%x", (IArg)status, (IArg)resman); break; } } } else { /* Status is OKAY, add entry to table */ /* if (FALSE == addVTableEntry((IALG_Fxns *)alg->fxns, resFxns)) { */ if (FALSE == addVTableEntry((IALG_Handle)alg, resFxns)) { /* TODO: Add trace */ status = IRES_EFAIL; RMAN_freeResources(alg, resFxns, scratchGroupId); } } if (resDesc) { myFree(resDesc, resDescSize); } Log_print1(Diags_EXIT, "[+X] RMAN_assignResources> Exit (status=%d)", (IArg)status); return (status); }