INT CmDevice_RT::SetCapsInternal(CM_DEVICE_CAP_NAME capName, size_t capValueSize, void *pCapValue) { CM_RETURN_CODE hr = CM_SUCCESS; DXVA_CM_SET_CAPS setCaps; UINT maxValue; size_t size = sizeof(maxValue); CmSafeMemSet(&setCaps, 0, sizeof(setCaps)); switch (capName) { case CAP_HW_THREAD_COUNT: if (capValueSize != sizeof(UINT)) { CM_ASSERT(0); return CM_INVALID_HARDWARE_THREAD_NUMBER; } if (*(UINT *) pCapValue <= 0) { CM_ASSERT(0); return CM_INVALID_HARDWARE_THREAD_NUMBER; } GetCaps(CAP_HW_THREAD_COUNT, size, &maxValue); if (*(UINT *) pCapValue > maxValue) { CM_ASSERT(0); return CM_INVALID_HARDWARE_THREAD_NUMBER; } setCaps.Type = DXVA_CM_MAX_HW_THREADS; setCaps.MaxValue = *(UINT *) pCapValue; break; case CAP_L3_CONFIG: if (capValueSize != sizeof(L3_CONFIG_REGISTER_VALUES)){ CM_ASSERT(0); return CM_INVALIDE_L3_CONFIGURATION; } else { L3_CONFIG_REGISTER_VALUES *l3_c = (L3_CONFIG_REGISTER_VALUES *)pCapValue; setCaps.L3_SQCREG1 = l3_c->SQCREG1_VALUE; setCaps.L3_CNTLREG2 = l3_c->CNTLREG2_VALUE; setCaps.L3_CNTLREG3 = l3_c->CNTLREG3_VALUE; setCaps.L3_CNTLREG = l3_c->CNTLREG_VALUE; setCaps.Type = DXVA_CM_MAX_HW_L3_CONFIG; } break; default: return CM_FAILURE; } PCM_CONTEXT pCmData = (PCM_CONTEXT) this->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState-> pfnSetCaps(pCmData->pCmHalState, (PCM_HAL_MAX_SET_CAPS_PARAM) & setCaps)); finish: return hr; }
CM_RT_API INT CmDevice_RT::GetSurface2DInfo(UINT width, UINT height, CM_SURFACE_FORMAT format, UINT & pitch, UINT & physicalSize) { CM_RETURN_CODE hr = CM_SUCCESS; CM_HAL_SURFACE2D_UP_PARAM inParam; PCM_CONTEXT pCmData; PCM_HAL_STATE pCmHalState; CMCHK_HR(m_pSurfaceMgr->Surface2DSanityCheck(width, height, format)); CmSafeMemSet(&inParam, 0, sizeof(CM_HAL_SURFACE2D_UP_PARAM)); inParam.iWidth = width; inParam.iHeight = height; inParam.format = m_pSurfaceMgr->CmFmtToGenHwFmt(format); pCmData = (PCM_CONTEXT) GetAccelData(); pCmHalState = pCmData->pCmHalState; CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetSurface2DPitchAndSize (pCmHalState, &inParam)); pitch = inParam.iPitch; physicalSize = inParam.iPhysicalSize; finish: return hr; }
INT CmDevice_RT::CreateAuxDevice(CmDriverContext * pDriverContext) { INT hr = CM_SUCCESS; PCM_HAL_STATE pCmHalState; PCM_CONTEXT pCmCtx; PGENOS_CONTEXT pOsContext; pOsContext = (PGENOS_CONTEXT) GENOS_AllocAndZeroMemory(sizeof(GENOS_CONTEXT)); CMCHK_NULL(pOsContext); if (pDriverContext) { pOsContext->wDeviceID = pDriverContext->deviceid; pOsContext->wRevision = pDriverContext->device_rev; pOsContext->bufmgr = pDriverContext->bufmgr; } m_pUmdContext = pOsContext; CHK_GENOSSTATUS_RETURN_CMERROR(HalCm_Create (pOsContext, &m_DevCreateOption, &pCmHalState)); CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnCmAllocate(pCmHalState)); pCmCtx = (PCM_CONTEXT) GENOS_AllocAndZeroMemory(sizeof(CM_CONTEXT)); CMCHK_NULL(pCmCtx); pCmCtx->GenHwDrvCtx = *pOsContext; pCmCtx->pCmHalState = pCmHalState; m_pAccelData = (PVOID) pCmCtx; CMCHK_HR_MESSAGE(GetMaxValueFromCaps(m_HalMaxValues, m_HalMaxValuesEx), "Failed to get Max values."); CMCHK_HR_MESSAGE(GetGenPlatform(m_Platform), "Failed to get GPU type."); m_DDIVersion = VA_CM_VERSION; finish: return hr; }
INT CmEvent::Query(void) { CM_RETURN_CODE hr = CM_SUCCESS; if ((m_Status != CM_STATUS_FLUSHED) && (m_Status != CM_STATUS_STARTED)) { return CM_FAILURE; } CM_ASSERT(m_TaskDriverId > -1); CM_HAL_QUERY_TASK_PARAM param; param.iTaskId = m_TaskDriverId; PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState-> pfnQueryTask(pCmData->pCmHalState, ¶m)); if (param.status == CM_TASK_FINISHED) { CmQueue *pQueue = NULL; m_Time = param.iTaskDuration; m_Status = CM_STATUS_FINISHED; m_GlobalCMSubmitTime = param.iTaskGlobalCMSubmitTime; m_CMSubmitTimeStamp = param.iTaskCMSubmitTimeStamp; m_HWStartTimeStamp = param.iTaskHWStartTimeStamp; m_HWEndTimeStamp = param.iTaskHWEndTimeStamp; m_CompleteTime = param.iTaskCompleteTime; m_pDevice->GetQueue(pQueue); if (!pQueue) { CM_ASSERT(0); return CM_FAILURE; } if (m_OsData) { drm_intel_bo_unreference((drm_intel_bo *) m_OsData); } m_GlobalCMSubmitTime = param.iTaskGlobalCMSubmitTime; m_CMSubmitTimeStamp = param.iTaskCMSubmitTimeStamp; m_HWStartTimeStamp = param.iTaskHWStartTimeStamp; m_HWEndTimeStamp = param.iTaskHWEndTimeStamp; m_CompleteTime = param.iTaskCompleteTime; } else if (param.status == CM_TASK_IN_PROGRESS) { m_Status = CM_STATUS_STARTED; } finish: return hr; }
INT CmSurfaceManager::FreeSurface2D(UINT handle) { CM_RETURN_CODE hr = CM_SUCCESS; PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData-> pCmHalState->pfnFreeSurface2D(pCmData-> pCmHalState, handle)); finish: return hr; }
INT CmSurfaceManager::UpdateBuffer(CmBuffer_RT * pSurface1D, UINT size) { CM_RETURN_CODE hr = CM_SUCCESS; UINT handle = 0; pSurface1D->GetHandle(handle); pSurface1D->SetSize(size); PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData-> pCmHalState->pfnUpdateBuffer(pCmData-> pCmHalState, (DWORD) handle, size)); finish: return hr; }
INT CmSurfaceManager::AllocateSurface2D(UINT width, UINT height, CM_SURFACE_FORMAT format, UINT & handle, UINT & pitch) { CM_RETURN_CODE hr = CM_SUCCESS; GENOS_STATUS genos_status = GENOS_STATUS_SUCCESS; PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData(); CM_HAL_SURFACE2D_PARAM inParam; CmSafeMemSet(&inParam, 0, sizeof(CM_HAL_SURFACE2D_PARAM)); inParam.iWidth = width; inParam.iHeight = height; inParam.format = CmFmtToGenHwFmt(format); inParam.pData = NULL; inParam.isAllocatedbyCmrtUmd = TRUE; genos_status = pCmData->pCmHalState->pfnAllocateSurface2D(pCmData->pCmHalState, &inParam); while (genos_status == GENOS_STATUS_NO_SPACE) { if (!TouchSurfaceInPoolForDestroy()) { CM_ASSERT(0); return CM_SURFACE_ALLOCATION_FAILURE; } genos_status = pCmData->pCmHalState->pfnAllocateSurface2D(pCmData-> pCmHalState, &inParam); } GENOSSTATUS2CM_AND_CHECK(genos_status, hr); handle = inParam.dwHandle; CHK_GENOSSTATUS_RETURN_CMERROR(pCmData-> pCmHalState->pfnGetSurface2DTileYPitch (pCmData->pCmHalState, &inParam)); pitch = inParam.iPitch; finish: return hr; }
INT CmSurfaceManager::UpdateSurface2D(CmSurface2D * pSurface2D, UINT width, UINT height, CM_SURFACE_FORMAT format) { CM_RETURN_CODE hr = CM_SUCCESS; UINT handle = 0; pSurface2D->GetHandle(handle); pSurface2D->SetSurfaceProperties(width, height, format); PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData-> pCmHalState->pfnUpdateSurface2D(pCmData-> pCmHalState, (DWORD) handle, width, height)); finish: return hr; }
INT CmDevice_RT::GetCapsInternal(PVOID pCaps, PUINT puSize) { PDXVA_CM_QUERY_CAPS pQueryCaps; PCM_CONTEXT pCmData; PCM_HAL_STATE pCmHalState; CM_RETURN_CODE hr = CM_SUCCESS; if ((!puSize) || (!pCaps) || (*puSize < sizeof(DXVA_CM_QUERY_CAPS))) { CM_ASSERTMESSAGE("Invalid Arguments."); hr = CM_FAILURE; goto finish; } pQueryCaps = (PDXVA_CM_QUERY_CAPS) pCaps; *puSize = sizeof(DXVA_CM_QUERY_CAPS); if (pQueryCaps->Type == DXVA_CM_QUERY_VERSION) { pQueryCaps->iVersion = DXVA_CM_VERSION; hr = CM_SUCCESS; goto finish; } pCmData = (PCM_CONTEXT) GetAccelData(); CMCHK_NULL(pCmData); pCmHalState = pCmData->pCmHalState; CMCHK_NULL(pCmHalState); switch (pQueryCaps->Type) { case DXVA_CM_QUERY_REG_HANDLE: pQueryCaps->hRegistration = (HANDLE *) & pCmHalState->SurfaceRegTable; break; case DXVA_CM_MAX_VALUES: CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetMaxValues (pCmHalState, &pQueryCaps->MaxValues)); break; case DXVA_CM_MAX_VALUES_EX: CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetMaxValuesEx (pCmHalState, &pQueryCaps->MaxValuesEx)); break; case DXVA_CM_QUERY_GPU: pQueryCaps->genCore = pCmHalState->pHwInterface->Platform.eRenderCoreFamily; break; case DXVA_CM_QUERY_GT: if (GFX_IS_PRODUCT (pCmHalState->pHwInterface->Platform, IGFX_CHERRYVIEW)) { pQueryCaps->genGT = PLATFORM_INTEL_GTCHV; } else if (pCmHalState->pHwInterface->Platform.GtType == GTTYPE_GT1) { pQueryCaps->genGT = PLATFORM_INTEL_GT1; } else if (pCmHalState->pHwInterface->Platform.GtType == GTTYPE_GT2) { pQueryCaps->genGT = PLATFORM_INTEL_GT2; } else if (pCmHalState->pHwInterface->Platform.GtType == GTTYPE_GT3) { pQueryCaps->genGT = PLATFORM_INTEL_GT3; } break; case DXVA_CM_QUERY_STEP: pQueryCaps->genStepId = pCmHalState->Platform.usRevId; break; case DXVA_CM_QUERY_GPU_FREQ: CHK_GENOSSTATUS_RETURN_CMERROR (pCmHalState->pfnGetGPUCurrentFrequency (pCmHalState, &pQueryCaps->GPUCurrentFreq)); break; case DXVA_CM_QUERY_SURFACE2D_FORMAT_COUNT: pQueryCaps->Surface2DCount = CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL; break; case DXVA_CM_QUERY_SURFACE2D_FORMATS: if (pQueryCaps->pSurface2DFormats) { CM_SURFACE_FORMAT formats[CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL] = { CM_SURFACE_FORMAT_X8R8G8B8, CM_SURFACE_FORMAT_A8R8G8B8, CM_SURFACE_FORMAT_R32F, CM_SURFACE_FORMAT_V8U8, CM_SURFACE_FORMAT_P8, CM_SURFACE_FORMAT_YUY2, CM_SURFACE_FORMAT_A8, CM_SURFACE_FORMAT_NV12, CM_SURFACE_FORMAT_UYVY, CM_SURFACE_FORMAT_R8_UINT, CM_SURFACE_FORMAT_R16_UINT, CM_SURFACE_FORMAT_411P, CM_SURFACE_FORMAT_422H, CM_SURFACE_FORMAT_444P, CM_SURFACE_FORMAT_IMC3, CM_SURFACE_FORMAT_422V, CM_SURFACE_FORMAT_YV12,}; CmSafeMemCopy(pQueryCaps->pSurface2DFormats, formats, CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL * sizeof(CM_SURFACE_FORMAT)); break; } else { hr = CM_FAILURE; goto finish; } default: hr = CM_FAILURE; goto finish; } finish: return hr; }
INT CmQueue::FlushEnqueueWithHintsTask(CmTaskInternal * pTask) { CM_RETURN_CODE hr = CM_SUCCESS; CM_HAL_EXEC_HINTS_TASK_PARAM param; PCM_CONTEXT pCmData = NULL; CmKernelData *pKernelData = NULL; UINT kernelDataSize = 0; UINT count = 0; CmEvent *pEvent = NULL; PCM_HAL_KERNEL_PARAM pTempData = NULL; CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_HINTS_TASK_PARAM)); pTask->GetKernelCount(count); param.iNumKernels = count; param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count]; param.piKernelSizes = new(std::nothrow) UINT[count]; param.piKernelCurbeOffset = new(std::nothrow) UINT[count]; CMCHK_NULL(param.pKernels); CMCHK_NULL(param.piKernelSizes); CMCHK_NULL(param.piKernelCurbeOffset); pTask->GetHints(param.iHints); pTask->GetNumTasksGenerated(param.iNumTasksGenerated); pTask->GetLastTask(param.isLastTask); for (UINT i = 0; i < count; i++) { pTask->GetKernelData(i, pKernelData); CMCHK_NULL(pKernelData); pTask->GetKernelDataSize(i, kernelDataSize); if (kernelDataSize == 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTempData = pKernelData->GetHalCmKernelData(); param.pKernels[i] = pTempData; param.piKernelSizes[i] = kernelDataSize; param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i); } pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData(); CMCHK_NULL(pCmData); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState-> pfnSetPowerOption(pCmData->pCmHalState, pTask->GetPowerOption ())); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->pfnExecuteHintsTask (pCmData->pCmHalState, ¶m)); if (param.iTaskIdOut < 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTask->GetTaskEvent(pEvent); CMCHK_NULL(pEvent); CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut)); CMCHK_HR(pEvent->SetTaskOsData(param.OsData)); CMCHK_HR(pTask->ReleaseKernel()); finish: CmSafeDeleteArray(param.pKernels); CmSafeDeleteArray(param.piKernelSizes); CmSafeDeleteArray(param.piKernelCurbeOffset); return hr; }
INT CmQueue::FlushGroupTask(CmTaskInternal * pTask) { CM_RETURN_CODE hr = CM_SUCCESS; CM_HAL_EXEC_TASK_GROUP_PARAM param; CmKernelData *pKernelData = NULL; UINT kernelDataSize = 0; UINT count = 0; PCM_CONTEXT pCmData = NULL; CmEvent *pEvent = NULL; PCM_HAL_KERNEL_PARAM pTempData = NULL; CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_TASK_GROUP_PARAM)); pTask->GetKernelCount(count); param.iNumKernels = count; param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count]; param.piKernelSizes = new(std::nothrow) UINT[count]; param.piKernelCurbeOffset = new(std::nothrow) UINT[count]; param.iPreemptionMode = pTask->GetPreemptionMode(); CMCHK_NULL(param.pKernels); CMCHK_NULL(param.piKernelSizes); CMCHK_NULL(param.piKernelCurbeOffset); for (UINT i = 0; i < count; i++) { pTask->GetKernelData(i, pKernelData); CMCHK_NULL(pKernelData); pTask->GetKernelDataSize(i, kernelDataSize); if (kernelDataSize == 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTempData = pKernelData->GetHalCmKernelData(); param.pKernels[i] = pTempData; param.piKernelSizes[i] = kernelDataSize; param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i); param.bGlobalSurfaceUsed |= pTempData->bGlobalSurfaceUsed; param.bKernelDebugEnabled |= pTempData->bKernelDebugEnabled; } pTask->GetSLMSize(param.iSLMSize); if (param.iSLMSize > MAX_SLM_SIZE_PER_GROUP_IN_1K) { CM_ASSERT(0); hr = CM_EXCEED_MAX_SLM_SIZE; goto finish; } if (pTask->IsThreadGroupSpaceCreated()) { pTask->GetThreadGroupSpaceSize(param.threadSpaceWidth, param.threadSpaceHeight, param.groupSpaceWidth, param.groupSpaceHeight); } param.uiSyncBitmap = pTask->GetSyncBitmap(); pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->pfnExecuteGroupTask (pCmData->pCmHalState, ¶m)); if (param.iTaskIdOut < 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTask->GetTaskEvent(pEvent); CMCHK_NULL(pEvent); CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut)); CMCHK_HR(pEvent->SetTaskOsData(param.OsData)); CMCHK_HR(pTask->ReleaseKernel()); finish: CmSafeDeleteArray(param.pKernels); CmSafeDeleteArray(param.piKernelSizes); CmSafeDeleteArray(param.piKernelCurbeOffset); return hr; }
INT CmQueue::FlushGeneralTask(CmTaskInternal * pTask) { CM_RETURN_CODE hr = CM_SUCCESS; CM_HAL_EXEC_TASK_PARAM param; CmKernelData *pKernelData = NULL; UINT kernelDataSize = 0; PCM_CONTEXT pCmData = NULL; CmEvent *pEvent = NULL; UINT totalThreadCount = 0; UINT count = 0; PCM_HAL_KERNEL_PARAM pTempData = NULL; CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_TASK_PARAM)); pTask->GetKernelCount(count); param.iNumKernels = count; param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count]; param.piKernelSizes = new(std::nothrow) UINT[count]; param.piKernelCurbeOffset = new(std::nothrow) UINT[count]; CMCHK_NULL_RETURN(param.pKernels, CM_OUT_OF_HOST_MEMORY); CMCHK_NULL_RETURN(param.piKernelSizes, CM_OUT_OF_HOST_MEMORY); CMCHK_NULL_RETURN(param.piKernelCurbeOffset, CM_OUT_OF_HOST_MEMORY); for (UINT i = 0; i < count; i++) { pTask->GetKernelData(i, pKernelData); CMCHK_NULL(pKernelData); pTask->GetKernelDataSize(i, kernelDataSize); if (kernelDataSize == 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTempData = pKernelData->GetHalCmKernelData(); param.pKernels[i] = pTempData; param.piKernelSizes[i] = kernelDataSize; param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i); param.bGlobalSurfaceUsed |= pTempData->bGlobalSurfaceUsed; param.bKernelDebugEnabled |= pTempData->bKernelDebugEnabled; } pTask->GetTotalThreadCount(totalThreadCount); param.threadSpaceWidth = (totalThreadCount > CM_MAX_THREADSPACE_WIDTH) ? CM_MAX_THREADSPACE_WIDTH : totalThreadCount; if (totalThreadCount % CM_MAX_THREADSPACE_WIDTH) { param.threadSpaceHeight = totalThreadCount / CM_MAX_THREADSPACE_WIDTH + 1; } else { param.threadSpaceHeight = totalThreadCount / CM_MAX_THREADSPACE_WIDTH; } param.DependencyPattern = CM_DEPENDENCY_NONE; if (pTask->IsThreadSpaceCreated()) { if (pTask->IsThreadCoordinatesExisted()) { param.ppThreadCoordinates = new(std::nothrow) PCM_HAL_SCOREBOARD_XY[count]; param.ppDependencyMasks = new(std::nothrow) PCM_HAL_MASK_AND_RESET[count]; CMCHK_NULL_RETURN(param.ppThreadCoordinates, CM_OUT_OF_HOST_MEMORY); CMCHK_NULL_RETURN(param.ppDependencyMasks, CM_OUT_OF_HOST_MEMORY); for (UINT i = 0; i < count; i++) { void *pKernelCoordinates = NULL; void *pDependencyMasks = NULL; pTask->GetKernelCoordinates(i, pKernelCoordinates); pTask->GetKernelDependencyMasks(i, pDependencyMasks); param.ppThreadCoordinates[i] = (PCM_HAL_SCOREBOARD_XY) pKernelCoordinates; param.ppDependencyMasks[i] = (PCM_HAL_MASK_AND_RESET) pDependencyMasks; } } else { param.ppThreadCoordinates = NULL; } pTask->GetDependencyPattern(param.DependencyPattern); pTask->GetThreadSpaceSize(param.threadSpaceWidth, param.threadSpaceHeight); pTask->GetWalkingPattern(param.WalkingPattern); if (pTask->CheckWalkingParametersSet()) { param.walkingParamsValid = 1; CMCHK_HR(pTask->GetWalkingParameters (param.walkingParams)); } else { param.walkingParamsValid = 0; } if (pTask->CheckDependencyVectorsSet()) { param.dependencyVectorsValid = 1; CMCHK_HR(pTask->GetDependencyVectors (param.dependencyVectors)); } else { param.dependencyVectorsValid = 0; } } pTask->GetColorCountMinusOne(param.ColorCountMinusOne); param.uiSyncBitmap = pTask->GetSyncBitmap(); pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData(); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState-> pfnSetPowerOption(pCmData->pCmHalState, pTask->GetPowerOption ())); CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState-> pfnExecuteTask(pCmData->pCmHalState, ¶m)); if (param.iTaskIdOut < 0) { CM_ASSERT(0); hr = CM_FAILURE; goto finish; } pTask->GetTaskEvent(pEvent); CMCHK_NULL(pEvent); CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut)); CMCHK_HR(pEvent->SetTaskOsData(param.OsData)); CMCHK_HR(pTask->ReleaseKernel()); finish: CmSafeDeleteArray(param.pKernels); CmSafeDeleteArray(param.piKernelSizes); CmSafeDeleteArray(param.ppThreadCoordinates); CmSafeDeleteArray(param.ppDependencyMasks); CmSafeDeleteArray(param.piKernelCurbeOffset); return hr; }