/* * Copyright (c) 2017, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file cm_program.cpp //! \brief Contains Class CmProgram definitions //! #include "cm_program.h" #include "cm_device_rt.h" #include "cm_mem.h" #include "cm_hal.h" #if USE_EXTENSION_CODE #include "cm_hw_debugger.h" #endif #include #include #define READ_FIELD_FROM_BUF( dst, type ) \ dst = *((type *) &buf[bytePos]); \ bytePos += sizeof(type); #define CM_RT_JITTER_DEBUG_FLAG "-debug" #define CM_RT_JITTER_NCSTATELESS_FLAG "-ncstateless" #define CM_RT_JITTER_MAX_NUM_FLAGS 30 #define CM_RT_JITTER_NUM_RESERVED_FLAGS 3 // one for gtpin; two for hw stepping info. #define CM_RT_JITTER_MAX_NUM_USER_FLAGS (CM_RT_JITTER_MAX_NUM_FLAGS - CM_RT_JITTER_NUM_RESERVED_FLAGS) namespace CMRT_UMD { //*----------------------------------------------------------------------------- //| Purpose: Create Cm Program //| Arguments : //| device [in] Pointer to Cm Device //| commonISACode [in] Pointer to memory where common isa locates //| size [in] Size of memory //| pProgram [in] Reference to pointer to CmProgram //| options [in] jitter or non-jitter //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::Create( CmDeviceRT* device, void* cisaCode, const uint32_t cisaCodeSize, CmProgramRT*& pProgram, const char* options, const uint32_t programId ) { int32_t result = CM_SUCCESS; pProgram = new (std::nothrow) CmProgramRT( device, programId ); if( pProgram ) { pProgram->Acquire(); result = pProgram->Initialize( cisaCode, cisaCodeSize, options ); device->m_memObjectCount.programCount++; if( result != CM_SUCCESS ) { CmProgramRT::Destroy( pProgram); } } else { CM_ASSERTMESSAGE("Error: Failed to create CmProgram due to out of system memory."); result = CM_OUT_OF_HOST_MEMORY; } return result; } //*----------------------------------------------------------------------------- //| Purpose: Destroy Cm Program //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::Destroy( CmProgramRT* &program ) { long refCount = program->SafeRelease( ); if( refCount == 0 ) { program = nullptr; } return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Acquire: Increase refcount //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::Acquire( void ) { m_refCount++; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: SafeRelease: //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::SafeRelease( void ) { --m_refCount; if( m_refCount == 0 ) { m_device->m_memObjectCount.programCount--; delete this; return 0; } return m_refCount; } //*----------------------------------------------------------------------------- //| Purpose: Constructor of Cm Program //| Returns: Result of the operation. //*----------------------------------------------------------------------------- CmProgramRT::CmProgramRT( CmDeviceRT* device, uint32_t programId ): m_device( device ), m_programCodeSize( 0 ), m_programCode(nullptr), m_isaFile(nullptr), m_options( nullptr ), m_surfaceCount( 0 ), m_kernelCount( 0 ), m_kernelInfo( CM_INIT_KERNEL_PER_PROGRAM ), m_isJitterEnabled(false), m_isHwDebugEnabled(false), m_refCount(0), m_programIndex(programId), m_kernelIndex(0), m_fJITCompile(nullptr), m_fFreeBlock(nullptr), m_fJITVersion(nullptr), m_fJITCompile_v2(nullptr), m_cisaMagicNumber(0), m_cisaMajorVersion(0), m_cisaMinorVersion(0) { CmSafeMemSet(m_isaFileName,0,sizeof(char)*CM_MAX_ISA_FILE_NAME_SIZE_IN_BYTE); } //*----------------------------------------------------------------------------- //| Purpose: Destructor of Cm Program //| Returns: Result of the operation. //*----------------------------------------------------------------------------- CmProgramRT::~CmProgramRT( void ) { MosSafeDeleteArray( m_options ); MosSafeDeleteArray( m_programCode ); for( uint32_t i = 0; i < m_kernelCount; i ++ ) { uint32_t refCount = this->ReleaseKernelInfo(i); CM_ASSERT(refCount == 0); } m_kernelInfo.Delete(); CmSafeDelete(m_isaFile); } //*----------------------------------------------------------------------------- //| Purpose: Initialize Cm Program //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::Initialize( void* cisaCode, const uint32_t cisaCodeSize, const char* options ) { bool loadingGPUCopyKernel = false; int32_t result = CM_SUCCESS; int32_t hr = CM_FAILURE; m_isJitterEnabled = true; //by default jitter is ON //get first kernel starting slot index m_kernelIndex = m_device->GetKernelSlot(); int numJitFlags = 0; const char *jitFlags[CM_RT_JITTER_MAX_NUM_FLAGS]; CmSafeMemSet(jitFlags, 0, sizeof(char *) * CM_RT_JITTER_MAX_NUM_FLAGS); char* flagStepInfo = nullptr; if( options ) { size_t length = strnlen( options, CM_MAX_OPTION_SIZE_IN_BYTE ); if(length >= CM_MAX_OPTION_SIZE_IN_BYTE) { CM_ASSERTMESSAGE("Error: option size is too long."); return CM_INVALID_ARG_VALUE; } else { m_options = MOS_NewArray(char, (length + 1)); if( !m_options ) { CM_ASSERTMESSAGE("Error: Out of system memory."); return CM_OUT_OF_HOST_MEMORY; } CmSafeMemCopy( m_options, options, length); m_options[ length ] = '\0'; if(strstr(options, "nojitter")) m_isJitterEnabled = false; if(!strcmp(m_options, "PredefinedGPUKernel")) loadingGPUCopyKernel = true; if( (m_isJitterEnabled == true) && (loadingGPUCopyKernel == false)) { // option: "nonjitter" and "PredefinedGPUCopyKernel" should not be passed to jitter char *token = nullptr; char *nextToken = nullptr; char *ptr = m_options; while( nullptr != (token = strtok_s(ptr," ",&nextToken))) { if(numJitFlags >= CM_RT_JITTER_MAX_NUM_USER_FLAGS) { CM_ASSERTMESSAGE("Error: Invalid jitter user flags number."); MosSafeDeleteArray(m_options); return CM_FAILURE; } if(!strcmp(token, CM_RT_JITTER_DEBUG_FLAG)) { m_isHwDebugEnabled = true; } jitFlags[numJitFlags] = token; numJitFlags++; ptr = nextToken; } } } } uint8_t *buf = (uint8_t*)cisaCode; uint32_t bytePos = 0; READ_FIELD_FROM_BUF(m_cisaMagicNumber, uint32_t); READ_FIELD_FROM_BUF(m_cisaMajorVersion, uint8_t); READ_FIELD_FROM_BUF(m_cisaMinorVersion, uint8_t); bool useVisaApi = true; vISA::Header *header = nullptr; auto getVersionAsInt = [](int major, int minor) {return major * 100 + minor;}; if (getVersionAsInt(m_cisaMajorVersion, m_cisaMinorVersion) < getVersionAsInt(3, 2)) { useVisaApi = false; } else { m_isaFile = new vISA::ISAfile((uint8_t*)cisaCode, cisaCodeSize); if (!m_isaFile->readFile()) { CM_ASSERTMESSAGE("Error: invalid VISA."); MosSafeDeleteArray(m_options); return CM_INVALID_COMMON_ISA; } header = m_isaFile->getHeader(); } if (m_cisaMagicNumber != CISA_MAGIC_NUMBER) { CM_ASSERTMESSAGE("Error: Invalid CISA magic number."); MosSafeDeleteArray(m_options); return CM_INVALID_COMMON_ISA; } if(loadingGPUCopyKernel)//for predefined kernel(GPUCopy), forcely disable jitting { m_isJitterEnabled = false; } const char *platform = nullptr; PCM_HAL_STATE cmHalState = \ ((PCM_CONTEXT_DATA)m_device->GetAccelData())->cmHalState; CM_CHK_NULL_GOTOFINISH_CMERROR(cmHalState); cmHalState->cmHalInterface->GetGenPlatformInfo(nullptr, nullptr, &platform); if( m_isJitterEnabled ) { #if (_DEBUG || _RELEASE_INTERNAL) //reg control for svm IA/GT cache coherence MOS_USER_FEATURE_VALUE_DATA userFeatureData; MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData)); CM_HAL_STATE *hal_state = m_device->GetHalState(); MOS_UserFeature_ReadValue_ID( nullptr, __MEDIA_USER_FEATURE_VALUE_MDF_FORCE_COHERENT_STATELESSBTI_ID, &userFeatureData, hal_state->osInterface->pOsContext); if (userFeatureData.i32Data == 1) { jitFlags[numJitFlags] = CM_RT_JITTER_NCSTATELESS_FLAG; numJitFlags++; } #endif // (_DEBUG || _RELEASE_INTERNAL) //Load jitter library and add function pointers to program // Get hmodule from CmDevice_RT or CmDevice_Sim, which is casted from CmDevice result = m_device->LoadJITDll(); if(result != CM_SUCCESS) { CM_ASSERTMESSAGE("Error: Load jitter library failure."); MosSafeDeleteArray(m_options); return result; } m_device->GetJITCompileFnt(m_fJITCompile); m_device->GetJITCompileFntV2(m_fJITCompile_v2); m_device->GetFreeBlockFnt(m_fFreeBlock); m_device->GetJITVersionFnt(m_fJITVersion); uint32_t jitMajor = 0; uint32_t jitMinor = 0; m_fJITVersion(jitMajor, jitMinor); if((jitMajor < m_cisaMajorVersion) || (jitMajor == m_cisaMajorVersion && jitMinor < m_cisaMinorVersion)) return CM_JITDLL_OLDER_THAN_ISA; #if USE_EXTENSION_CODE if( m_device->CheckGTPinEnabled() && !loadingGPUCopyKernel) { hr = InitForGTPin(jitFlags, numJitFlags); if (hr != CM_SUCCESS) { goto finish; } } #endif //Pass stepping info to JITTER..." char *stepstr = nullptr; m_device->GetGenStepInfo(stepstr); if(stepstr != nullptr) { flagStepInfo = MOS_NewArray(char, CM_JIT_FLAG_SIZE); if (flagStepInfo) { jitFlags[numJitFlags] = "-stepping"; numJitFlags++; CmSafeMemSet(flagStepInfo, 0, CM_JIT_FLAG_SIZE); MOS_SecureStringPrint(flagStepInfo, CM_JIT_FLAG_SIZE, CM_JIT_FLAG_SIZE, "%s", stepstr); if (numJitFlags >= CM_RT_JITTER_MAX_NUM_FLAGS) { CM_ASSERTMESSAGE("Error: Invalid jitter user flags number."); hr = CM_FAILURE; goto finish; } jitFlags[numJitFlags] = flagStepInfo; numJitFlags++; } else { CM_ASSERTMESSAGE("Error: Out of system memory."); MosSafeDeleteArray(m_options); return CM_OUT_OF_HOST_MEMORY; } } } if (useVisaApi) { m_kernelCount = header->getNumKernels(); } else { bytePos = 4 + 1 + 1; // m_cisaMagicNumber:sizeof (uint32_t) + m_cisaMajorVersion:sizeof(uint8_t) + m_cisaMinorVersion:sizeof(uint8_t) unsigned short numKernels; READ_FIELD_FROM_BUF(numKernels, unsigned short); m_kernelCount = numKernels; } #ifdef _DEBUG if(m_isJitterEnabled) CM_NORMALMESSAGE("Jitter Compiling..."); #endif for (uint32_t i = 0; i < m_kernelCount; i++) { CM_KERNEL_INFO* kernInfo = new (std::nothrow) CM_KERNEL_INFO; if (!kernInfo) { CM_ASSERTMESSAGE("Error: Out of system memory."); MosSafeDeleteArray(flagStepInfo); MosSafeDeleteArray(m_options); hr = CM_OUT_OF_HOST_MEMORY; goto finish; } CmSafeMemSet(kernInfo, 0, sizeof(CM_KERNEL_INFO)); vISA::Kernel *kernel = nullptr; uint16_t nameLen = 0; if (useVisaApi) { kernel = header->getKernelInfo()[i]; if (getVersionAsInt(m_cisaMajorVersion, m_cisaMinorVersion) < getVersionAsInt(3, 7)) { nameLen = (uint16_t) kernel->getNameLen_Ver306(); } else { nameLen = kernel->getNameLen(); } CmSafeMemCopy(kernInfo->kernelName, kernel->getName(), nameLen); } else { READ_FIELD_FROM_BUF(nameLen, uint8_t); CmSafeMemCopy(kernInfo->kernelName, buf + bytePos, nameLen); // move bytePos to the right index bytePos += nameLen; } if(m_isJitterEnabled) { if (useVisaApi) { kernInfo->kernelIsaOffset = kernel->getOffset(); kernInfo->kernelIsaSize = kernel->getSize(); kernInfo->inputCountOffset = kernel->getInputOffset(); } else { uint32_t kernelIsaOffset; uint32_t kernelIsaSize; uint32_t inputCountOffset; READ_FIELD_FROM_BUF(kernelIsaOffset, uint32_t); //read kernel isa offset READ_FIELD_FROM_BUF(kernelIsaSize, uint32_t); //read kernel isa size READ_FIELD_FROM_BUF(inputCountOffset, uint32_t); kernInfo->kernelIsaOffset = kernelIsaOffset; kernInfo->kernelIsaSize = kernelIsaSize; kernInfo->inputCountOffset = inputCountOffset; // read relocation symbols unsigned short numVarSyms = 0, num_func_syms = 0; unsigned char numGenBinaries = 0; READ_FIELD_FROM_BUF(numVarSyms, uint16_t); // CISA layout of var_syms is symbolic_index[0], resolved_index[0], // ...resolved_index[n-1]. Skip all. bytePos += sizeof(uint16_t) * numVarSyms; bytePos += sizeof(uint16_t) * numVarSyms; READ_FIELD_FROM_BUF(num_func_syms, uint16_t); // CISA layout of func_syms is symbolic_index[0], resolved_index[0], // ...resolved_index[n-1]. Skip all. bytePos += sizeof(uint16_t) * num_func_syms; bytePos += sizeof(uint16_t) * num_func_syms; // numGenBinaries READ_FIELD_FROM_BUF(numGenBinaries, uint8_t); // CISA layout of gen_binaries is genPlatform[0], binary offset[0], // binary size[0]...binary size[n-1]. Skip all. // skip all genPlatform bytePos += sizeof(uint8_t) * numGenBinaries; // skip all binary offset bytePos += sizeof(uint32_t) * numGenBinaries; // skip all binary size bytePos += sizeof(uint32_t) * numGenBinaries; // bytePos should point to nameLen of next kernel } } else // non jitting { uint8_t numGenBinaries = 0; if (useVisaApi) { kernInfo->kernelIsaOffset = kernel->getOffset(); kernInfo->inputCountOffset = kernel->getInputOffset(); numGenBinaries = kernel->getNumGenBinaries(); } else { uint32_t kernelIsaOffset; READ_FIELD_FROM_BUF(kernelIsaOffset, uint32_t); //read kernel isa offset kernInfo->kernelIsaOffset = kernelIsaOffset; // skipping kernelIsaSize bytePos += 4; uint32_t inputCountOffset; READ_FIELD_FROM_BUF(inputCountOffset, uint32_t); kernInfo->inputCountOffset = inputCountOffset; // read relocation symbols unsigned short numVarSyms = 0, num_func_syms = 0; READ_FIELD_FROM_BUF(numVarSyms, uint16_t); // CISA layout of var_syms is symbolic_index[0], resolved_index[0], // ...resolved_index[n-1]. Skip all. bytePos += sizeof(uint16_t) * numVarSyms; bytePos += sizeof(uint16_t) * numVarSyms; READ_FIELD_FROM_BUF(num_func_syms, uint16_t); // CISA layout of func_syms is symbolic_index[0], resolved_index[0], // ...resolved_index[n-1]. Skip all. bytePos += sizeof(uint16_t) * num_func_syms; bytePos += sizeof(uint16_t) * num_func_syms; // numGenBinaries READ_FIELD_FROM_BUF(numGenBinaries, uint8_t); } uint32_t genxBinaryOffset = 0; uint32_t genxBinarySize = 0; for (int j = 0; j < numGenBinaries; j++) { vISA::GenBinary *genBinary = nullptr; uint8_t genPlatform = 0; uint32_t offset = 0; uint32_t size = 0; if (useVisaApi) { genBinary = kernel->getGenBinaryInfo()[j]; genPlatform = genBinary->getGenPlatform(); offset = genBinary->getBinaryOffset(); size = genBinary->getBinarySize(); } else { // genPlatform READ_FIELD_FROM_BUF(genPlatform, uint8_t); // binary offset READ_FIELD_FROM_BUF(offset, uint32_t); // binary size READ_FIELD_FROM_BUF(size, uint32_t); } if (cmHalState->cmHalInterface->IsCisaIDSupported((uint32_t)genPlatform)) { // assign correct offset/size based on platform genxBinaryOffset = offset; genxBinarySize = size; } else { MosSafeDeleteArray(flagStepInfo); MosSafeDeleteArray(m_options); CmSafeDelete(kernInfo); return CM_INVALID_GENX_BINARY; } } kernInfo->genxBinaryOffset = genxBinaryOffset; kernInfo->genxBinarySize = genxBinarySize; if ( kernInfo->genxBinarySize == 0 || kernInfo->genxBinaryOffset == 0 ) { CM_ASSERTMESSAGE("Error: Invalid genx binary."); MosSafeDeleteArray(flagStepInfo); MosSafeDeleteArray(m_options); CmSafeDelete(kernInfo); return CM_INVALID_GENX_BINARY; } } if(m_isJitterEnabled) { kernInfo->jitBinaryCode = 0; void* jitBinary = 0;// = (void**)malloc(m_kernelCount*sizeof(void*)); uint32_t jitBinarySize = 0;// = (uint32_t*)malloc(m_kernelCount*sizeof(uint32_t*)); char* errorMsg = (char*)malloc(CM_JIT_ERROR_MESSAGE_SIZE); if (errorMsg == nullptr) { CM_ASSERTMESSAGE("Error: Out of system memory."); CmSafeDelete(kernInfo); hr = CM_OUT_OF_HOST_MEMORY; goto finish; } CmSafeMemSet( errorMsg, 0, CM_JIT_ERROR_MESSAGE_SIZE ); FINALIZER_INFO *jitProfInfo = (FINALIZER_INFO *)malloc(CM_JIT_PROF_INFO_SIZE); if(jitProfInfo == nullptr) { CM_ASSERTMESSAGE("Error: Out of system memory."); free(errorMsg); CmSafeDelete(kernInfo); hr = CM_OUT_OF_HOST_MEMORY; goto finish; } CmSafeMemSet( jitProfInfo, 0, CM_JIT_PROF_INFO_SIZE ); void *extra_info = nullptr; CmNotifierGroup *notifiers = m_device->GetNotifiers(); if (notifiers) { notifiers->NotifyCallingJitter(&extra_info); } if (m_fJITCompile_v2) { result = m_fJITCompile_v2( kernInfo->kernelName, (uint8_t*)cisaCode, cisaCodeSize, jitBinary, jitBinarySize, platform, m_cisaMajorVersion, m_cisaMinorVersion, numJitFlags, jitFlags, errorMsg, jitProfInfo, extra_info ); } else { result = m_fJITCompile( kernInfo->kernelName, (uint8_t*)cisaCode, cisaCodeSize, jitBinary, jitBinarySize, platform, m_cisaMajorVersion, m_cisaMinorVersion, numJitFlags, jitFlags, errorMsg, jitProfInfo ); } //if error code returned or error message not nullptr if(result != CM_SUCCESS)// || errorMsg[0]) { CM_NORMALMESSAGE("%s.", errorMsg); free(errorMsg); CmSafeDelete(kernInfo); hr = CM_JIT_COMPILE_FAILURE; goto finish; } // if spill code exists and scrach space disabled, return error to user if( jitProfInfo->isSpill && m_device->IsScratchSpaceDisabled()) { CmSafeDelete(kernInfo); free(errorMsg); return CM_INVALID_KERNEL_SPILL_CODE; } free(errorMsg); kernInfo->jitBinaryCode = jitBinary; kernInfo->jitBinarySize = jitBinarySize; kernInfo->jitInfo = jitProfInfo; #if USE_EXTENSION_CODE if ( m_isHwDebugEnabled ) { NotifyKernelBinary(this->m_device, this, kernInfo->kernelName, jitBinary, jitBinarySize, jitProfInfo->genDebugInfo, jitProfInfo->genDebugInfoSize, nullptr, m_device->GetDriverStoreFlag()); } #endif } m_kernelInfo.SetElement( i, kernInfo ); this->AcquireKernelInfo(i); } #ifdef _DEBUG if(m_isJitterEnabled) CM_NORMALMESSAGE("Jitter Done."); #endif // now bytePos index to the start of common isa body; // compute the code size for common isa m_programCodeSize = cisaCodeSize; m_programCode = MOS_NewArray(uint8_t, m_programCodeSize); if( !m_programCode ) { CM_ASSERTMESSAGE("Error: Out of system memory."); hr = CM_OUT_OF_HOST_MEMORY; goto finish; } //Copy CISA content CmFastMemCopy((void *)m_programCode, cisaCode, cisaCodeSize); //Caculate hash value for each kernel for (uint32_t i = 0; i < m_kernelCount; i++) { CM_KERNEL_INFO *kernelInfo = (CM_KERNEL_INFO *)m_kernelInfo.GetElement(i); CM_CHK_NULL_GOTOFINISH_CMERROR(kernelInfo); // higher 32bit is the order of kernel in LoadProgram in the device // lower 32bit is the hash value of kernel info kernelInfo->hashValue = GetKernelInfoHash(kernelInfo) | ((uint64_t)m_device->KernelsLoaded() << 32); ++ m_device->KernelsLoaded(); } hr = CM_SUCCESS; finish: MosSafeDeleteArray(flagStepInfo); if(hr != CM_SUCCESS ) { MosSafeDeleteArray(m_options); MosSafeDeleteArray(m_programCode); } return hr; } //*----------------------------------------------------------------------------- //| Purpose: Get size and address of Common Isa //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::GetCommonISACode( void* & commonISACode, uint32_t & size ) { commonISACode = (void *)m_programCode; size = m_programCodeSize; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Get the count of kernel //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::GetKernelCount( uint32_t& kernelCount ) { kernelCount = m_kernelCount; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Get the Kernel's Infomation //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::GetKernelInfo( uint32_t index, CM_KERNEL_INFO*& kernelInfo ) { if( index < m_kernelCount ) { kernelInfo = (CM_KERNEL_INFO*)m_kernelInfo.GetElement( index ) ; return CM_SUCCESS; } else { kernelInfo = nullptr; return CM_FAILURE; } } //*----------------------------------------------------------------------------- //| Purpose: Get the name of ISA file //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::GetIsaFileName( char* & isaFileName ) { isaFileName = m_isaFileName; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Get Kernel's options //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::GetKernelOptions( char* & kernelOptions ) { kernelOptions = m_options; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Get the number of Surfaces //| Returns: Result of the operation. //*----------------------------------------------------------------------------- uint32_t CmProgramRT::GetSurfaceCount(void) { return m_surfaceCount; } //*----------------------------------------------------------------------------- //| Purpose: Set Program's surface count //| Returns: Result of the operation. //*----------------------------------------------------------------------------- int32_t CmProgramRT::SetSurfaceCount(uint32_t count) { m_surfaceCount = count; return CM_SUCCESS; } //*----------------------------------------------------------------------------- //| Purpose: Acquire Kernel Info //| Returns: Result of the operation. //*----------------------------------------------------------------------------- uint32_t CmProgramRT::AcquireKernelInfo(uint32_t index) { CM_KERNEL_INFO* kernelInfo = nullptr; if( index < m_kernelCount ) { kernelInfo = (CM_KERNEL_INFO *)m_kernelInfo.GetElement( index ) ; if (kernelInfo) { CM_ASSERT( (int32_t)kernelInfo->kernelInfoRefCount >= 0 ); CM_ASSERT( kernelInfo->kernelInfoRefCount < UINT_MAX ); ++ kernelInfo->kernelInfoRefCount; return kernelInfo->kernelInfoRefCount; } else { return 0; } } else { return 0; } } //*----------------------------------------------------------------------------- //| Purpose: Release Kernel Info //| Returns: Result of the operation. //*----------------------------------------------------------------------------- uint32_t CmProgramRT::ReleaseKernelInfo(uint32_t index) { CM_KERNEL_INFO* kernelInfo = nullptr; if( index < m_kernelCount ) { kernelInfo = (CM_KERNEL_INFO *)m_kernelInfo.GetElement( index ) ; if (kernelInfo) { CM_ASSERT( kernelInfo->kernelInfoRefCount > 0 ); -- kernelInfo->kernelInfoRefCount; if (kernelInfo->kernelInfoRefCount == 1) { ///////////////////////////////////////////////////////////// //Free global string memory space, Start for (int i = 0; i < (int) kernelInfo->globalStringCount; i ++) { if (kernelInfo->globalStrings[i]) { free((void *)kernelInfo->globalStrings[i]); } } if (kernelInfo->globalStrings) { free((void *)kernelInfo->globalStrings); kernelInfo->globalStrings = nullptr; kernelInfo->globalStringCount = 0; } //Free global string memory space, End ///////////////////////////////////////////////////////////// for (uint32_t i = 0; i < kernelInfo->surfaceCount; i++) { if (kernelInfo->surface[i].attributeCount && kernelInfo->surface[i].attributes) { free(kernelInfo->surface[i].attributes); } } if (kernelInfo->surface) { free(kernelInfo->surface); kernelInfo->surface = nullptr; kernelInfo->surfaceCount = 0; } return 1; } else if (kernelInfo->kernelInfoRefCount == 0) { if(m_isJitterEnabled) { if(kernelInfo->jitBinaryCode) m_fFreeBlock(kernelInfo->jitBinaryCode); if(kernelInfo->jitInfo) { if (kernelInfo->jitInfo->freeGRFInfo) { m_fFreeBlock(kernelInfo->jitInfo->freeGRFInfo); } free(kernelInfo->jitInfo); } } ///////////////////////////////////////////////////////////// //Free global string memory space, Start for (int i = 0; i < (int) kernelInfo->globalStringCount; i ++) { if (kernelInfo->globalStrings[i]) { free((void *)kernelInfo->globalStrings[i]); } } if (kernelInfo->globalStrings) { free((void *)kernelInfo->globalStrings); } //Free global string memory space, End ///////////////////////////////////////////////////////////// for (uint32_t i = 0; i < kernelInfo->surfaceCount; i++) { if (kernelInfo->surface[i].attributeCount && kernelInfo->surface[i].attributes) { free(kernelInfo->surface[i].attributes); } } if (kernelInfo->surface) { free(kernelInfo->surface); } CmSafeDelete( kernelInfo ); m_kernelInfo.SetElement(index, nullptr); return 0; } else { return kernelInfo->kernelInfoRefCount; } } else { return 0; } } else { return 0; } } int32_t CmProgramRT::GetKernelInfoRefCount(uint32_t index, uint32_t& refCount) { CM_KERNEL_INFO* kernelInfo = nullptr; refCount = 0; if( index < m_kernelCount ) { kernelInfo =(CM_KERNEL_INFO *) m_kernelInfo.GetElement( index ) ; if (kernelInfo) { refCount = kernelInfo->kernelInfoRefCount; return CM_SUCCESS; } else { return CM_FAILURE; } } else { return CM_FAILURE; } } int32_t CmProgramRT::GetCISAVersion(uint32_t& majorVersion, uint32_t& minorVersion) { majorVersion = m_cisaMajorVersion; minorVersion = m_cisaMinorVersion; return CM_SUCCESS; } uint32_t CmProgramRT::GetProgramIndex() { return m_programIndex; } vISA::ISAfile *CmProgramRT::getISAfile() { return m_isaFile; } template inline void hashCombine(uint32_t &res, const T &field) { std::hash hasher; res ^= hasher(field) + 0x9e3779b9 + (res << 6) + (res >> 2); } inline void hashCombineString(uint32_t &res, char *str) { uint32_t strHash = std::hash{}(std::string(str)); hashCombine(res, strHash); } uint32_t CmProgramRT::GetKernelInfoHash(CM_KERNEL_INFO *kernelInfo) { uint32_t value = 0; hashCombineString(value, kernelInfo->kernelName); hashCombine(value, kernelInfo->inputCountOffset); hashCombine(value, kernelInfo->kernelIsaOffset); hashCombine(value, kernelInfo->kernelIsaSize); uint8_t *kernelBin = nullptr; uint32_t kernelSize = 0; if (m_isJitterEnabled) { kernelBin = (uint8_t *)kernelInfo->jitBinaryCode; kernelSize = kernelInfo->jitBinarySize; } else { kernelBin = m_programCode + kernelInfo->genxBinaryOffset; kernelSize = kernelInfo->genxBinarySize; } uint32_t *kernelBinDW = (uint32_t *)kernelBin; uint32_t kernelSizeDW = kernelSize / 4; double step = (double)kernelSizeDW/64.0; for (int i = 0; i < 256; i ++) { int index = (int)(kernelSizeDW - 1 - i*step); if (index < 0) { index = 0; } hashCombine(value, kernelBinDW[index]); } hashCombine(value, kernelSize); return value; } }