blob: bcb8e0d00d9c8d8ec7ac6133085db1baf4c0476f [file] [log] [blame]
/*
* 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.
*/
#include "cm_device.h"
#include <cstdarg>
#include "cm_debug.h"
#include "cm_mem.h"
#if USE_EXTENSION_CODE
#include "cm_gtpin_external_interface.h"
#endif
#include "cm_printf_host.h"
#include "cm_surface_manager.h"
#include "cm_queue.h"
#include "cm_perf_statistics.h"
#include "cm_timer.h"
class CmBuffer;
class CmBufferUP;
class CmBufferSVM;
#if MDF_PROFILER_ENABLED
CmPerfStatistics gCmPerfStatistics; // global instance to record API's perf
#endif
CM_RT_API int32_t CmDevice_RT::CreateBuffer(uint32_t size, CmBuffer* &buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateBuffer(size, buffer);
}
CM_RT_API int32_t CmDevice_RT::CreateBufferUP(uint32_t size, void* sysMem, CmBufferUP* &buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateBufferUP( size, sysMem, buffer);
}
CM_RT_API int32_t CmDevice_RT::DestroySurface(CmBuffer* &buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroyBuffer(buffer);
}
CM_RT_API int32_t CmDevice_RT::DestroyBufferUP(CmBufferUP* &buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroyBufferUP(buffer);
}
//!
//! Create a CmSurface2D
//! Input :
//! Surface width, height and format;
//! Reference to the pointer to the CmSurface2D .
//! Output:
//! CM_SUCCESS if the CmSurface2D is successfully created;
//! CM_OUT_OF_HOST_MEMORY if out of system memory;
//! CM_SURFACE_ALLOCATION_FAILURE if surface creation fails;
//! CM_FAILURE otherwise;
//!NOTES: general API
CM_RT_API int32_t CmDevice_RT::CreateSurface2D(uint32_t width, uint32_t height, CM_SURFACE_FORMAT format, CmSurface2D* & surface )
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateSurface2D( width, height, format, surface);;
}
CM_RT_API int32_t CmDevice_RT::CreateSurface2DUP( uint32_t width, uint32_t height, CM_SURFACE_FORMAT format, void* sysMem, CmSurface2DUP* &surface )
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateSurface2DUP( width, height, format, sysMem, surface);
}
CM_RT_API int32_t CmDevice_RT::DestroySurface2DUP( CmSurface2DUP* &surface)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroySurface2DUP(surface);
}
CM_RT_API int32_t CmDevice_RT::DestroySurface( CmSurface2D* &surface2d)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroySurface(surface2d);
}
CM_RT_API int32_t CmDevice_RT::GetSurface2DInfo( uint32_t width, uint32_t height, CM_SURFACE_FORMAT format, uint32_t & pitch, uint32_t & physicalSize)
{
INSERT_PROFILER_RECORD();
CM_GETSURFACE2DINFO_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_GETSURFACE2DINFO_PARAM ) );
inParam.width = width;
inParam.height = height;
inParam.format = format;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_GETSURFACE2DINFO,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
pitch = inParam.pitch;
physicalSize = inParam.physicalSize;
return CM_SUCCESS;
}
//!
//! Load the code of one or more kernels in common ISA.
//! Jit-ting of the common ISA code can happen either in LoadProgram or CreateKernel.
//! Jit options set in LoadProgram are for all kernels within the code.
//! Jit options set in CreateKernel are for the specific kernel, overwriting the jit options set in program level. LoadProgram can be called multiple times for the same code.
//! Jit options is a null terminated string. string length ( excluding the null terminater )shoudl be
//! less than 512 (CM_MAX_OPTION_SIZE_IN_BYTE ). Otherwise the option is ignored.
//! Each time a now CmProgram object is generated.
//!
//! Input:
//! 1) Pointer pointing to the common ISA code
//! 2) code size in byte
//! 3) Reference to the pointer to the CmProgram.
//! 4) Jit options. This argument is optional.
//! Output:
//! CM_SUCCESS if the CmProgram is successfully created;
//! CM_INVALID_KERNELS if any kernel is invalid;
//! CM_OUT_OF_HOST_MEMORY if out of system memory;
//! CM_FAILURE otherwise;
//!
CM_RT_API int32_t CmDevice_RT::LoadProgram( void* commonISACode, const uint32_t size, CmProgram*& program, const char* options )
{
INSERT_PROFILER_RECORD();
if( (commonISACode == nullptr) || (size == 0) )
{
CmAssert( 0 );
return CM_INVALID_COMMON_ISA;
}
return CreateProgram(commonISACode, size, program, options);
}
int32_t CmDevice_RT::CreateProgram(void* commonISACode,
const uint32_t size,
CmProgram*& program,
const char* options)
{
CM_LOADPROGRAM_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_LOADPROGRAM_PARAM ) );
inParam.cisaCode = commonISACode;
inParam.cisaCodeSize = size;
inParam.options = (char *)options;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_LOADPROGRAM,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
program = (CmProgram *)inParam.cmProgramHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyProgram(CmProgram* & program )
{
INSERT_PROFILER_RECORD();
if( program == nullptr )
{
return CM_FAILURE;
}
CM_DESTROYPROGRAM_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYPROGRAM_PARAM ) );
inParam.cmProgramHandle = program;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYPROGRAM,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
program = nullptr;
return CM_SUCCESS;
}
//!
//! Create a CmKernel_RT. Each kernel can run in multiple threads.
//! If CreateKernel is called multiple times using the same CmProgram,
//! the same kernel name, and the same options, only in the first time a new CmKernel_RT is generated,
//! all following calls only return the existing CmKernel_RT.
//! Otherwise, each time a new CmKernel_RT is generated.
//! Input :
//! 1) CM Program from which the kernel is created
//! 2) CM kernel function (genx_main) name
//! 3) Reference to the pointer to the CmKernel_RT .
//! 4) Jit options for this kernel, overwriting the jit options in
//! CmProgram level for this specific kernel. This argument is optional.
//! Output:
//! CM_SUCCESS if the CmKernel_RT is successfully created;
//! CM_OUT_OF_HOST_MEMORY if out of system memory;
//! CM_FAILURE otherwise;
//!
CM_RT_API int32_t CmDevice_RT::CreateKernel( CmProgram* program, const char* kernelName, CmKernel* & kernel, const char* options )
{
INSERT_PROFILER_RECORD();
if(program == nullptr)
{
CmAssert( 0 );
return CM_INVALID_ARG_VALUE;
}
CM_CREATEKERNEL_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATEKERNEL_PARAM ) );
inParam.cmProgramHandle = program;
inParam.kernelName = (char*)kernelName;
inParam.options = (char *)options;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATEKERNEL,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
kernel = (CmKernel *)inParam.cmKernelHandle; // Got Object from CMRT@UMD directly.
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyKernel( CmKernel*& kernel)
{
INSERT_PROFILER_RECORD();
CM_DESTROYKERNEL_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYKERNEL_PARAM ) );
inParam.cmKernelHandle = kernel;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYKERNEL,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
kernel = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateTask(CmTask *& task)
{
INSERT_PROFILER_RECORD();
CM_CREATETASK_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATETASK_PARAM ) );
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATETASK,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
task = (CmTask *)inParam.cmTaskHandle;
#if USE_EXTENSION_CODE
GTPIN_MAKER_FUNCTION(CmrtCodeMarkerForGTPin_CreateTask(this, task));
#endif
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyTask( CmTask*& task)
{
INSERT_PROFILER_RECORD();
#if USE_EXTENSION_CODE
GTPIN_MAKER_FUNCTION(CmrtCodeMarkerForGTPin_DestroyTask(this, task));
#endif
CM_DESTROYTASK_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYTASK_PARAM ) );
inParam.cmTaskHandle = task;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYTASK,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
task = nullptr;
return CM_SUCCESS;
}
//!
//! Create a task queue, CmQueue_RT. It is an in-order queue of tasks. Each task can
//! have multiple kernels running concurrently, each kernel can run in multiple threads.
//! For now only one CmQueue_RT is supported. Trying to create a second CmQueue_RT will fail.
//! Input :
//! Reference to the pointer to the CmQueue_RT .
//! Output:
//! CM_SUCCESS if the CmQueue_RT is successfully created;
//! CM_OUT_OF_HOST_MEMORY if out of system memory;
//! CM_FAILURE otherwise;
//!
CM_RT_API int32_t CmDevice_RT::CreateQueue( CmQueue* & queue )
{
INSERT_PROFILER_RECORD();
// For legacy CreateQueue API, we will only return the same queue
m_criticalSectionQueue.Acquire();
for (auto iter = m_queue.begin(); iter != m_queue.end(); iter++)
{
CM_QUEUE_TYPE queueType = (*iter)->GetQueueOption().QueueType;
if (queueType == CM_QUEUE_TYPE_RENDER)
{
queue = (*iter);
m_criticalSectionQueue.Release();
return CM_SUCCESS;
}
}
m_criticalSectionQueue.Release();
int32_t result = CreateQueueEx( queue, CM_DEFAULT_QUEUE_CREATE_OPTION);
#if USE_EXTENSION_CODE
GTPIN_MAKER_FUNCTION(CmrtCodeMarkerForGTPin_CreateQueue(this, queue));
#endif
return result;
}
CM_RT_API int32_t CmDevice_RT::CreateQueueEx(CmQueue *&queue, CM_QUEUE_CREATE_OPTION queueCreateOption)
{
INSERT_PROFILER_RECORD();
m_criticalSectionQueue.Acquire();
CmQueue_RT *queueRT = nullptr;
int32_t result = CmQueue_RT::Create(this, queueRT, queueCreateOption);
if (result != CM_SUCCESS)
{
CmAssert(0);
CmDebugMessage(("Failed to create queue!"));
m_criticalSectionQueue.Release();
return result;
}
m_queue.push_back(queueRT);
m_criticalSectionQueue.Release();
if (queueRT != nullptr)
{
queue = static_cast< CmQueue* >(queueRT);
}
return result;
}
CM_RT_API int32_t CmDevice_RT::CreateThreadSpace( uint32_t width, uint32_t height, CmThreadSpace* &threadSpace)
{
INSERT_PROFILER_RECORD();
CM_CREATETHREADSPACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATETHREADSPACE_PARAM ) );
inParam.tsWidth = width;
inParam.tsHeight = height;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATETHREADSPACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
threadSpace = (CmThreadSpace *)inParam.cmTsHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyThreadSpace( CmThreadSpace* &threadSpace)
{
INSERT_PROFILER_RECORD();
CM_DESTROYTHREADSPACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYTHREADSPACE_PARAM ) );
inParam.cmTsHandle = threadSpace;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYTHREADSPACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
threadSpace = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateVmeSurfaceG7_5( CmSurface2D* currentSurface,
CmSurface2D **forwardSurfaceArray,
CmSurface2D **backwardSurfaceArray,
const uint32_t surfaceCountForward,
const uint32_t surfaceCountBackward,
SurfaceIndex* & vmeSurfaceIndex )
{
INSERT_PROFILER_RECORD();
return CreateVmeSurface( currentSurface, forwardSurfaceArray, backwardSurfaceArray, surfaceCountForward, surfaceCountBackward, vmeSurfaceIndex, CM_FN_CMDEVICE_CREATEVMESURFACEG7_5 );
}
CM_RT_API int32_t CmDevice_RT::DestroyVmeSurfaceG7_5( SurfaceIndex* & vmeSurfaceIndex )
{
INSERT_PROFILER_RECORD();
return DestroyVmeSurface( vmeSurfaceIndex );
}
CM_RT_API int32_t CmDevice_RT::SetVmeSurfaceStateParam(SurfaceIndex* vmeIndex, CM_VME_SURFACE_STATE_PARAM *surfStateParam)
{
INSERT_PROFILER_RECORD();
if(vmeIndex == nullptr || surfStateParam == nullptr)
{
CmAssert( 0 );
return CM_INVALID_ARG_VALUE;
}
CM_CONFIGVMESURFACEDIMENSION_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CONFIGVMESURFACEDIMENSION_PARAM ) );
inParam.cmVmeSurfHandle = (void *)vmeIndex;
inParam.surfDimPara = surfStateParam;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CONFIGVMESURFACEDIMENSION,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
return inParam.returnValue;
}
CM_RT_API int32_t CmDevice_RT::CreateSampler( const CM_SAMPLER_STATE& samplerState, CmSampler* &sampler )
{
INSERT_PROFILER_RECORD();
CM_CREATESAMPLER_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER_PARAM ) );
inParam.samplerState = samplerState;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLER,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler = (CmSampler *)inParam.cmSamplerHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSamplerEx( const CM_SAMPLER_STATE_EX& samplerState, CmSampler* &sampler )
{
INSERT_PROFILER_RECORD();
CM_CREATESAMPLER_PARAM_EX inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER_PARAM_EX ) );
inParam.samplerState = samplerState;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLER_EX,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler = (CmSampler *)inParam.cmSamplerHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroySampler( CmSampler* &sampler )
{
INSERT_PROFILER_RECORD();
CM_DESTROYSAMPLER_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYSAMPLER_PARAM ) );
inParam.cmSamplerHandle = sampler;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYSAMPLER,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateThreadGroupSpace( uint32_t threadSpaceWidth, uint32_t threadSpaceHeight, uint32_t groupSpaceWidth, uint32_t groupSpaceHeight, CmThreadGroupSpace* &threadGroupSpace)
{
INSERT_PROFILER_RECORD();
CM_CREATETGROUPSPACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATETGROUPSPACE_PARAM ) );
inParam.thrdSpaceWidth = threadSpaceWidth;
inParam.thrdSpaceHeight = threadSpaceHeight;
inParam.thrdSpaceDepth = 1;
inParam.grpSpaceWidth = groupSpaceWidth;
inParam.grpSpaceHeight = groupSpaceHeight;
inParam.grpSpaceDepth = 1;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATETHREADGROUPSPACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
threadGroupSpace = (CmThreadGroupSpace *)inParam.cmGrpSpaceHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateThreadGroupSpaceEx(uint32_t threadSpaceWidth, uint32_t threadSpaceHeight, uint32_t threadSpaceDepth, uint32_t groupSpaceWidth, uint32_t groupSpaceHeight, uint32_t groupSpaceDepth, CmThreadGroupSpace* &threadGroupSpace)
{
INSERT_PROFILER_RECORD();
CM_CREATETGROUPSPACE_PARAM inParam;
CmSafeMemSet(&inParam, 0, sizeof(CM_CREATETGROUPSPACE_PARAM));
inParam.thrdSpaceWidth = threadSpaceWidth;
inParam.thrdSpaceHeight = threadSpaceHeight;
inParam.thrdSpaceDepth = threadSpaceDepth;
inParam.grpSpaceWidth = groupSpaceWidth;
inParam.grpSpaceHeight = groupSpaceHeight;
inParam.grpSpaceDepth = groupSpaceDepth;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATETHREADGROUPSPACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
threadGroupSpace = (CmThreadGroupSpace *)inParam.cmGrpSpaceHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyThreadGroupSpace(CmThreadGroupSpace* &threadGroupSpace)
{
INSERT_PROFILER_RECORD();
CM_DESTROYTGROPUSPACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYTGROPUSPACE_PARAM ) );
inParam.cmGrpSpaceHandle = threadGroupSpace;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYTHREADGROUPSPACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
threadGroupSpace = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::GetCaps(CM_DEVICE_CAP_NAME capName, size_t& capValueSize, void* capValue )
{
INSERT_PROFILER_RECORD();
CM_GETCAPS_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_GETCAPS_PARAM ) );
inParam.capName = capName;
inParam.capValueSize = (uint32_t)capValueSize;
inParam.capValue = capValue;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_GETCAPS,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSurface3D(uint32_t width, uint32_t height, uint32_t depth, CM_SURFACE_FORMAT format, CmSurface3D* & surface )
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateSurface3D( width, height, depth, format, surface);
}
CM_RT_API int32_t CmDevice_RT::CreateSampler8x8(const CM_SAMPLER_8X8_DESCR &samplerDescriptor, CmSampler8x8* &sampler)
{
INSERT_PROFILER_RECORD();
if((samplerDescriptor.stateType == CM_SAMPLER8X8_AVS && samplerDescriptor.avs == nullptr) ||
(samplerDescriptor.stateType == CM_SAMPLER8X8_CONV && samplerDescriptor.conv == nullptr) ||
(samplerDescriptor.stateType == CM_SAMPLER8X8_CONV1DH && samplerDescriptor.conv == nullptr) ||
(samplerDescriptor.stateType == CM_SAMPLER8X8_CONV1DV && samplerDescriptor.conv == nullptr) ||
(samplerDescriptor.stateType == CM_SAMPLER8X8_MISC && samplerDescriptor.misc == nullptr) ||
(samplerDescriptor.stateType == CM_SAMPLER8X8_NONE && samplerDescriptor.conv != nullptr) ||
sampler != nullptr)
{
CmAssert( 0 );
return CM_INVALID_ARG_VALUE;
}
CM_CREATESAMPLER8x8_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER8x8_PARAM ) );
inParam.sampler8x8Desc = samplerDescriptor;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLER8X8,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler = (CmSampler8x8 *)inParam.cmSampler8x8Handle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroySampler8x8( CmSampler8x8 *& sampler8x8 )
{
INSERT_PROFILER_RECORD();
CM_DESTROYSAMPLER8x8_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYSAMPLER8x8_PARAM ) );
inParam.cmSampler8x8Handle = sampler8x8;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYSAMPLER8X8,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler8x8 = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSampler8x8Surface(CmSurface2D* surface2d, SurfaceIndex* &sampler8x8SurfaceIndex, CM_SAMPLER8x8_SURFACE surfaceType, CM_SURFACE_ADDRESS_CONTROL_MODE addressControl)
{
INSERT_PROFILER_RECORD();
CmSurface2D* currentRT = static_cast< CmSurface2D* >( surface2d );
if( ! currentRT ) {
CmAssert( 0 );
return CM_FAILURE;
}
CM_CREATESAMPLER8x8SURF_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER8x8SURF_PARAM ) );
inParam.cmSurf2DHandle = currentRT;
inParam.cmSampler8x8Type = surfaceType;
inParam.sampler8x8Mode = addressControl;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLER8X8SURFACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler8x8SurfaceIndex = inParam.cmSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSampler8x8SurfaceEx(CmSurface2D* surface2d, SurfaceIndex* &sampler8x8SurfaceIndex, CM_SAMPLER8x8_SURFACE surfaceType, CM_SURFACE_ADDRESS_CONTROL_MODE addressControl, CM_FLAG* flag)
{
INSERT_PROFILER_RECORD();
CmSurface2D* currentRT = static_cast< CmSurface2D* >(surface2d);
if (!currentRT) {
CmAssert(0);
return CM_FAILURE;
}
CM_CREATESAMPLER8x8SURFEX_PARAM inParam;
CmSafeMemSet(&inParam, 0, sizeof(inParam));
inParam.cmSurf2DHandle = currentRT;
inParam.cmSampler8x8Type = surfaceType;
inParam.sampler8x8Mode = addressControl;
inParam.flag = flag;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLER8X8SURFACE_EX,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler8x8SurfaceIndex = inParam.cmSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSamplerSurface2DEx(CmSurface2D* surface2d, SurfaceIndex* & samplerSurface2dIndex, CM_FLAG* flag)
{
INSERT_PROFILER_RECORD();
CmSurface2D* surface2dRT = static_cast< CmSurface2D* >(surface2d);
if (!surface2dRT) {
CmAssert(0);
return CM_INVALID_ARG_VALUE;
}
CM_CREATESAMPLER2DEX_PARAM inParam;
CmSafeMemSet(&inParam, 0, sizeof(inParam));
inParam.cmSurface2DHandle = surface2dRT;
inParam.flag = flag;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLERSURFACE2D_EX,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
samplerSurface2dIndex = (SurfaceIndex*)inParam.samplerSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroySampler8x8Surface(SurfaceIndex* &sampler8x8SurfaceIndex)
{
INSERT_PROFILER_RECORD();
CM_DESTROYSAMPLER8x8SURF_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYSAMPLER8x8SURF_PARAM ) );
inParam.cmSurfIndexHandle = sampler8x8SurfaceIndex;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYSAMPLER8X8SURFACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
sampler8x8SurfaceIndex = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::SetL3Config(const L3ConfigRegisterValues *registerValues)
{
INSERT_PROFILER_RECORD();
m_l3Config = *registerValues;
SetCapsInternal(CAP_L3_CONFIG, sizeof(L3ConfigRegisterValues), &m_l3Config);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::SetSuggestedL3Config( L3_SUGGEST_CONFIG configIndex)
{
INSERT_PROFILER_RECORD();
//Call into UMD
CM_DEVICE_SETSUGGESTEDL3_PARAM setL3IndexParam;
CmSafeMemSet(&setL3IndexParam, 0 , sizeof(CM_DEVICE_SETSUGGESTEDL3_PARAM));
setL3IndexParam.l3SuggestConfig = configIndex;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_SETSUGGESTEDL3CONFIG,
&setL3IndexParam,
sizeof(setL3IndexParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(setL3IndexParam.returnValue);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::SetCaps(CM_DEVICE_CAP_NAME capName, size_t capValueSize, void* capValue )
{
INSERT_PROFILER_RECORD();
switch(capName)
{
case CAP_HW_THREAD_COUNT:
return SetCapsInternal(capName, capValueSize, capValue);
default:
return CM_INVALID_CAP_NAME;
}
}
int32_t CmDevice_RT::SetCapsInternal(CM_DEVICE_CAP_NAME capName, size_t capValueSize, void* capValue)
{
//Call into UMD
CM_DEVICE_SETCAP_PARAM setCapParam;
CmSafeMemSet(&setCapParam, 0 , sizeof(setCapParam));
setCapParam.capName = capName;
setCapParam.capValueSize = capValueSize;
setCapParam.capValue = capValue;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_SETCAPS,
&setCapParam, sizeof(setCapParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(setCapParam.returnValue);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSamplerSurface2D(CmSurface2D* surface2d, SurfaceIndex* & samplerSurface2dIndex)
{
INSERT_PROFILER_RECORD();
CmSurface2D* surface2dRT = static_cast< CmSurface2D* >( surface2d );
if( ! surface2dRT ) {
CmAssert( 0 );
return CM_FAILURE;
}
CM_CREATESAMPLER2D_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER2D_PARAM ) );
inParam.cmSurface2DHandle = surface2dRT;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLERSURFACE2D,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
samplerSurface2dIndex = (SurfaceIndex* )inParam.samplerSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSamplerSurface2DUP(CmSurface2DUP* surface2dUP, SurfaceIndex* & samplerSurface2dUPIndex)
{
INSERT_PROFILER_RECORD();
CM_CREATESAMPLER2DUP_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER2DUP_PARAM ) );
inParam.cmSurface2DHandle = surface2dUP;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLERSURFACE2DUP,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
samplerSurface2dUPIndex = (SurfaceIndex* )inParam.samplerSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateSamplerSurface3D(CmSurface3D* surface3d, SurfaceIndex* & samplerSurface3dIndex)
{
INSERT_PROFILER_RECORD();
CM_CREATESAMPLER3D_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATESAMPLER3D_PARAM ) );
inParam.cmSurface3DHandle = surface3d;
int32_t result
= OSALExtensionExecute(CM_FN_CMDEVICE_CREATESAMPLERSURFACE3D,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
samplerSurface3dIndex = (SurfaceIndex* )inParam.samplerSurfIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroySamplerSurface(SurfaceIndex* & samplerSurfaceIndex)
{
INSERT_PROFILER_RECORD();
CM_DESTROYSAMPLERSURF_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYSAMPLERSURF_PARAM ) );
inParam.samplerSurfIndexHandle = samplerSurfaceIndex;
int32_t result = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYSAMPLERSURFACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT:: DestroySurface( CmSurface3D* &surface3d)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroySurface3D(surface3d);
}
int32_t CmDevice_RT::CheckDdiVersionSupported(const uint32_t ddiVersion)
{
if( ( ddiVersion >= CM_DDI_7_2 ))
{
return CM_SUCCESS;
}
else
{
return CM_UMD_DRIVER_NOT_SUPPORTED;
}
}
CM_RT_API int32_t CmDevice_RT::InitPrintBuffer(size_t size)
{
INSERT_PROFILER_RECORD();
CM_DEVICE_INIT_PRINT_BUFFER_PARAM initPrintBufferParam;
CmSafeMemSet(&initPrintBufferParam, 0, sizeof(CM_DEVICE_INIT_PRINT_BUFFER_PARAM));
initPrintBufferParam.printBufferSize = (uint32_t)size;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_INIT_PRINT_BUFFER,
&initPrintBufferParam,
sizeof(initPrintBufferParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(initPrintBufferParam.returnValue);
m_printBuffer = (unsigned char *)initPrintBufferParam.printBufferMem;
m_printEnabled = true;
m_printBufferSize = size;
return CM_SUCCESS;
}
//*-----------------------------------------------------------------------------
//| Purpose: Flush the print buffer and dump it on the file
//| Returns: result of operation.
//*-----------------------------------------------------------------------------
CM_RT_API int32_t CmDevice_RT::FlushPrintBufferIntoFile(const char *filename)
{
INSERT_PROFILER_RECORD();
return FlushPrintBufferInternal(filename);
}
//*-----------------------------------------------------------------------------
//| Purpose: Flush the print buffer and dump it on stdout
//| Returns: result of operation.
//*-----------------------------------------------------------------------------
CM_RT_API int32_t CmDevice_RT::FlushPrintBuffer()
{
INSERT_PROFILER_RECORD();
return FlushPrintBufferInternal(nullptr);
}
//*-----------------------------------------------------------------------------
//| Purpose: Internal function to flush print buffer on stdout or file.
//| Returns: result of operation.
//*-----------------------------------------------------------------------------
int32_t CmDevice_RT::FlushPrintBufferInternal(const char *filename)
{
FILE * streamout = nullptr;
if (filename == nullptr)
{
streamout = stdout;
}
else
{
CM_FOPEN(streamout, filename, "wb");
if (streamout == nullptr)
{
//Open file Failed
CmAssert(0);
return CM_FAILURE;
}
}
if( m_printBuffer == nullptr ||
m_printBufferSize == 0 ||
m_printEnabled == false )
{
CmAssert(0);
if (filename)
{
fclose(streamout);
}
return CM_FAILURE;
}
//Dump memory on the screen.
DumpAllThreadOutput(streamout, m_printBuffer, m_printBufferSize);
//Flush and close stream
fflush(streamout);
if (filename)
fclose(streamout);
//clean memory
CmSafeMemSet(m_printBuffer, 0, m_printBufferSize);
*(unsigned int*)m_printBuffer = sizeof(CM_PRINT_HEADER);
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateVebox( CmVebox* & vebox )
{
INSERT_PROFILER_RECORD();
CM_CREATEVEBOX_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATEVEBOX_PARAM ) );
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATEVEBOX,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
vebox = (CmVebox *)inParam.cmVeboxHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::DestroyVebox( CmVebox* & vebox )
{
INSERT_PROFILER_RECORD();
CM_DESTROYVEBOX_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( inParam ) );
inParam.cmVeboxHandle = vebox;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYVEBOX,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
vebox = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateBufferSVM(uint32_t size, void* &sysMem, uint32_t accessFlag, CmBufferSVM* & buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->CreateBufferSVM(size, sysMem, accessFlag, buffer);
}
CM_RT_API int32_t CmDevice_RT::DestroyBufferSVM( CmBufferSVM* &buffer)
{
INSERT_PROFILER_RECORD();
return m_surfaceManager->DestroyBufferSVM(buffer);
}
CM_RT_API int32_t CmDevice_RT::CreateSurface2DAlias(CmSurface2D* originalSurface, SurfaceIndex* &aliasIndex)
{
INSERT_PROFILER_RECORD();
CM_DEVICE_CREATE_SURF2D_ALIAS_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof(inParam) );
inParam.cmSurface2DHandle = originalSurface;
inParam.surfaceIndexHandle = aliasIndex;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATESURFACE2D_ALIAS,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
aliasIndex = (SurfaceIndex*)inParam.surfaceIndexHandle;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateBufferAlias(CmBuffer *originalBuffer, SurfaceIndex* &aliasIndex)
{
INSERT_PROFILER_RECORD();
CM_DEVICE_CREATE_BUFFER_ALIAS_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof(inParam) );
inParam.cmBufferHandle = originalBuffer;
inParam.surfaceIndexHandle = aliasIndex;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CREATEBUFFER_ALIAS,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
aliasIndex = (SurfaceIndex*)inParam.surfaceIndexHandle;
return CM_SUCCESS;
}
//*-----------------------------------------------------------------------------
//| Purpose: Duplicate the kernel member values
//| Arguments :
//| destKernel [in/out] pointer to output kernel, must be nullptr
//| srcKernel [in] pointer to input kernel
//|
//| Returns: Result of the operation.
//*-----------------------------------------------------------------------------
CM_RT_API int32_t CmDevice_RT::CloneKernel( CmKernel * &destKernel, CmKernel *srcKernel )
{
INSERT_PROFILER_RECORD();
CM_CLONE_KERNEL_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CLONE_KERNEL_PARAM ) );
inParam.cmKernelHandleSrc = srcKernel;
inParam.cmKernelHandleDest = destKernel;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_CLONEKERNEL,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
destKernel = (CmKernel *)inParam.cmKernelHandleDest;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::CreateHevcVmeSurfaceG10(CmSurface2D* currentSurface, CmSurface2D** forwardSurfaceArray, CmSurface2D** backwardSurfaceArray, const uint32_t surfaceCountForward, const uint32_t surfaceCountBackward, SurfaceIndex* & vmeSurfaceIndex)
{
INSERT_PROFILER_RECORD();
return CreateVmeSurface( currentSurface, forwardSurfaceArray, backwardSurfaceArray, surfaceCountForward, surfaceCountBackward, vmeSurfaceIndex, CM_FN_CMDEVICE_CREATEHEVCVMESURFACEG10 );
}
CM_RT_API int32_t CmDevice_RT::DestroyHevcVmeSurfaceG10(SurfaceIndex* & vmeSurfaceIndex)
{
INSERT_PROFILER_RECORD();
return DestroyVmeSurface( vmeSurfaceIndex );
}
int32_t CmDevice_RT::CreateVmeSurface( CmSurface2D* currentSurface, CmSurface2D** forwardSurfaceArray, CmSurface2D** backwardSurfaceArray, const uint32_t surfaceCountForward, const uint32_t surfaceCountBackward, SurfaceIndex* & vmeSurfaceIndex, CM_FUNCTION_ID functionName)
{
if ( currentSurface == nullptr )
{
CmAssert( 0 );
return CM_NULL_POINTER;
}
CM_CREATEVMESURFACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_CREATEVMESURFACE_PARAM ) );
inParam.cmCurSurfHandle = currentSurface;
inParam.cmForwardSurfArray = forwardSurfaceArray;
inParam.cmBackwardSurfArray = backwardSurfaceArray;
inParam.forwardSurfCount = surfaceCountForward;
inParam.backwardSurfCount = surfaceCountBackward;
int32_t result = OSALExtensionExecute(functionName,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(result);
CHK_FAILURE_RETURN(inParam.returnValue);
vmeSurfaceIndex = ( SurfaceIndex* )inParam.cmVmeSurfIndexHandle;
return CM_SUCCESS;
}
int32_t CmDevice_RT::DestroyVmeSurface( SurfaceIndex* & vmeSurfaceIndex )
{
//Call into driver
CM_DESTROYVMESURFACE_PARAM inParam;
CmSafeMemSet( &inParam, 0, sizeof( CM_DESTROYVMESURFACE_PARAM ) );
inParam.cmVmeSurfIndexHandle = ( void *)vmeSurfaceIndex;
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_DESTROYVMESURFACE,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
vmeSurfaceIndex = nullptr;
return CM_SUCCESS;
}
CM_RT_API int32_t CmDevice_RT::GetVISAVersion(uint32_t& majorVersion, uint32_t& minorVersion)
{
INSERT_PROFILER_RECORD();
CM_DEVICE_GET_VISA_VERSION_PARAM inParam;
CmSafeMemSet(&inParam, 0, sizeof(CM_DEVICE_GET_VISA_VERSION_PARAM));
int32_t hr = OSALExtensionExecute(CM_FN_CMDEVICE_GETVISAVERSION,
&inParam, sizeof(inParam));
CHK_FAILURE_RETURN(hr);
CHK_FAILURE_RETURN(inParam.returnValue);
majorVersion = inParam.majorVersion;
minorVersion = inParam.minorVersion;
return CM_SUCCESS;
}