void OclResourceServiceImpl::InvalidateStorage()
{
// do nothing if no context present, there is also no storage
if( !m_ContextCollection->CanProvideContext() )
return;
// query the map
ProgramMapType::iterator it = m_ProgramStorage.begin();
while(it != m_ProgramStorage.end() )
{
// query the program build status
cl_build_status status;
unsigned int query = clGetProgramBuildInfo( it->second.program, m_ContextCollection->m_Devices[0], CL_PROGRAM_BUILD_STATUS, sizeof(cl_int), &status, NULL );
CHECK_OCL_ERR( query )
MITK_DEBUG << "Quering status for " << it->first << std::endl;
// remove program if no succesfull build
// we need to pay attention to the increment of the iterator when erasing current element
if( status != CL_BUILD_SUCCESS )
{
MITK_DEBUG << " +-- Build failed " << std::endl;
m_ProgramStorage.erase( it++ );
}
else
{
++it;
}
}
}
void OclResourceServiceImpl::RemoveProgram(const std::string& name)
{
ProgramMapType::iterator it = m_ProgramStorage.find(name);
cl_int status = 0;
cl_program program = NULL;
if( it != m_ProgramStorage.end() )
{
it->second.mutex->Lock();
// decrease reference by one
it->second.counter -= 1;
it->second.mutex->Unlock();
// remove from the storage
if( it->second.counter == 0 )
{
program = it->second.program;
m_ProgramStorageMutex->Lock();
m_ProgramStorage.erase(it);
m_ProgramStorageMutex->Unlock();
}
// delete the program
if( program )
{
status = clReleaseProgram(program);
CHECK_OCL_ERR( status );
}
}
else
{
MITK_WARN("OpenCL.ResourceService") << "Program name [" <<name <<"] passed for deletion not found.";
}
}
void mitk::OclBinaryThresholdImageFilter::Execute()
{
cl_int clErr = 0;
try
{
this->InitExec( this->m_ckBinaryThreshold );
}
catch( const mitk::Exception& e)
{
MITK_ERROR << "Catched exception while initializing filter: " << e.what();
return;
}
// set kernel arguments
clErr = clSetKernelArg( this->m_ckBinaryThreshold, 2, sizeof(cl_int), &(this->m_LowerThreshold) );
clErr |= clSetKernelArg( this->m_ckBinaryThreshold, 3, sizeof(cl_int), &(this->m_UpperThreshold) );
clErr |= clSetKernelArg( this->m_ckBinaryThreshold, 4, sizeof(cl_int), &(this->m_OutsideValue) );
clErr |= clSetKernelArg( this->m_ckBinaryThreshold, 5, sizeof(cl_int), &(this->m_InsideValue) );
CHECK_OCL_ERR( clErr );
// execute the filter on a 3D NDRange
this->ExecuteKernel( m_ckBinaryThreshold, 3);
// signalize the GPU-side data changed
m_Output->Modified( GPU_DATA );
}
cl_mem mitk::OclDataSet::CreateGPUBuffer()
{
MITK_DEBUG << "InitializeGPUBuffer call with: BPE=" << m_BpE;
us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
m_context = resources->GetContext();
int clErr;
if (m_gpuBuffer) clReleaseMemObject(m_gpuBuffer);
m_gpuBuffer = clCreateBuffer(m_context, CL_MEM_READ_WRITE, m_bufferSize * (size_t)m_BpE, nullptr, &clErr);
#ifdef SHOW_MEM_INFO
MITK_INFO << "Created GPU Buffer Object of size: " << (size_t)m_BpE * m_bufferSize << " Bytes";
#endif
CHECK_OCL_ERR(clErr);
if (clErr != CL_SUCCESS)
mitkThrow() << "openCL Error when creating Buffer";
return m_gpuBuffer;
}
void* mitk::OclDataSet::TransferDataToCPU(cl_command_queue gpuComQueue)
{
cl_int clErr = 0;
// if image created on GPU, needs to create mitk::Image
if( m_gpuBuffer == nullptr ){
MITK_ERROR("ocl.DataSet") << "(mitk) No buffer present!\n";
return nullptr;
}
// check buffersize
char* data = new char[m_bufferSize * (size_t)m_BpE];
// debug info
#ifdef SHOW_MEM_INFO
oclPrintMemObjectInfo( m_gpuBuffer );
#endif
clErr = clEnqueueReadBuffer( gpuComQueue, m_gpuBuffer, CL_TRUE, 0, m_bufferSize * (size_t)m_BpE, data ,0, nullptr, nullptr);
CHECK_OCL_ERR(clErr);
if(clErr != CL_SUCCESS)
mitkThrow() << "openCL Error when reading Output Buffer";
clFlush( gpuComQueue );
// the cpu data is same as gpu
this->m_gpuModified = false;
return (void*) data;
}
void GetSupportedImageFormats(cl_context _context, cl_mem_object_type _type)
{
const unsigned int entries = 500;
cl_image_format* formats = new cl_image_format[entries];
cl_uint _written = 0;
// OpenCL constant to catch error IDs
cl_int ciErr1;
// Get list of supported image formats for READ_ONLY access
ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_READ_ONLY, _type, entries, formats, &_written);
CHECK_OCL_ERR(ciErr1);
MITK_INFO << "Supported Image Formats, Image: CL_MEM_READ_ONLY \n";
for (unsigned int i=0; i<_written; i++)
{
MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
}
_written = 0;
// Get list of supported image formats for READ_WRITE access
ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_READ_WRITE, _type, entries, formats, &_written);
CHECK_OCL_ERR(ciErr1);
MITK_INFO << "Supported Image Formats, Image: CL_MEM_READ_WRITE (found: " << _written <<") \n";
for (unsigned int i=0; i<_written; i++)
{
MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
}
_written = 0;
// Get list of supported image formats for WRITE_ONLY access
ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_WRITE_ONLY, _type, entries, formats, &_written);
CHECK_OCL_ERR(ciErr1);
MITK_INFO << "Supported Image Formats, Image: CL_MEM_WRITE_ONLY (found: " << _written <<") \n";
for (unsigned int i=0; i<_written; i++)
{
MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
}
}
bool mitk::OclBinaryThresholdImageFilter::Initialize()
{
bool buildErr = true;
cl_int clErr = 0;
if ( OclFilter::Initialize() )
{
this->m_ckBinaryThreshold = clCreateKernel( this->m_ClProgram, "ckBinaryThreshold", &clErr);
buildErr |= CHECK_OCL_ERR( clErr );
}
return (Superclass::IsInitialized() && buildErr );
}
void mitk::OclImageFormats::CollectAvailableFormats()
{
if( this->m_GpuContext == NULL)
{
mitkThrow() << "No GPU context was set! Use SetGPUContext() before calling this method!";
}
//todo what happens here?
const unsigned int entries = 100;
cl_image_format* formats = new cl_image_format[entries];
cl_uint written = 0;
cl_int clErr = 0;
// GET formats for R/W, 2D
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 1 );
// GET formats for R/-, 2D
written = 0;
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE2D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 2 );
// GET formats for -/W, 2D
written = 0;
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_WRITE_ONLY, CL_MEM_OBJECT_IMAGE2D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 4 );
//-----------------------
// GET formats for R/W, 3D
written = 0;
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE3D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 1, 3 );
// GET formats for R/-, 3D
written = 0;
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE3D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 2, 3 );
// GET formats for -/W, 3D
written = 0;
clErr = clGetSupportedImageFormats( m_GpuContext, CL_MEM_WRITE_ONLY, CL_MEM_OBJECT_IMAGE3D, entries, formats, &written);
CHECK_OCL_ERR( clErr );
this->SortFormats( formats, written, 4, 3 );
}
cl_mem mitk::OclDataSet::GetGPUBuffer()
{
// query image object info only if already initialized
if( this->m_gpuBuffer )
{
#ifdef SHOW_MEM_INFO
cl_int clErr = 0;
// clGetMemObjectInfo()
cl_mem_object_type memInfo;
clErr = clGetMemObjectInfo(this->m_gpuBuffer, CL_MEM_TYPE, sizeof(cl_mem_object_type), &memInfo, nullptr );
CHECK_OCL_ERR(clErr);
MITK_DEBUG << "Querying info for object, recieving: " << memInfo;
#endif
}
return m_gpuBuffer;
}
int mitk::OclDataSet::TransferDataToGPU(cl_command_queue gpuComQueue)
{
cl_int clErr = 0;
// check whether an image present
if (m_Data == nullptr){
MITK_ERROR("ocl.DataSet") << "(mitk) No data present!\n";
return -1;
}
// there is a need for copy only if RAM-Data newer then GMEM data
if (m_cpuModified)
{
//check the buffer
if(m_gpuBuffer == nullptr)
{
CreateGPUBuffer();
}
if (m_gpuBuffer != nullptr)
{
clErr = clEnqueueWriteBuffer(gpuComQueue, m_gpuBuffer, CL_TRUE, 0, m_bufferSize * (size_t)m_BpE, m_Data, 0, NULL, NULL);
MITK_DEBUG << "Wrote Data to GPU Buffer Object.";
CHECK_OCL_ERR(clErr);
m_gpuModified = true;
if (clErr != CL_SUCCESS)
mitkThrow() << "openCL Error when writing Buffer";
}
else
{
MITK_ERROR << "No GPU buffer present!";
}
}
return clErr;
}
void oclPrintMemObjectInfo(cl_mem memobj)
{
cl_int clErr = 0;
MITK_INFO << "Examining cl_mem object: " << memobj
<< "\n------------------\n";
// CL_MEM_TYPE
cl_mem_object_type objtype;
clErr = clGetMemObjectInfo( memobj, CL_MEM_TYPE, sizeof(cl_mem_object_type),&objtype, NULL);
CHECK_OCL_ERR( clErr );
switch(objtype)
{
case CL_MEM_OBJECT_BUFFER:
MITK_INFO << "CL_MEM_TYPE \t" << "BUFFER_OBJ" << "\n";
break;
case CL_MEM_OBJECT_IMAGE2D:
MITK_INFO << "CL_MEM_TYPE \t" << "2D IMAGE" << "\n";
break;
case CL_MEM_OBJECT_IMAGE3D:
MITK_INFO << "CL_MEM_TYPE \t" << "3D IMAGE" << "\n";
break;
default:
MITK_INFO << "CL_MEM_TYPE \t" << "[could not resolve]" << "\n";
break;
}
// CL_MEM_FLAGS
cl_mem_flags flags;
clErr = clGetMemObjectInfo( memobj, CL_MEM_FLAGS, sizeof(cl_mem_flags),&flags, NULL);
CHECK_OCL_ERR( clErr );
switch(flags)
{
case CL_MEM_READ_ONLY:
MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_READ_ONLY" << "\n";
break;
case CL_MEM_WRITE_ONLY:
MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_WRITE_ONLY" << "\n";
break;
case CL_MEM_READ_WRITE:
MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_READ_WRITE" << "\n";
break;
default:
MITK_INFO << "CL_MEM_FLAGS \t" << "not resolved, " << flags << "\n";
break;
}
// get CL_MEM_SIZE
size_t memsize;
clErr = clGetMemObjectInfo( memobj, CL_MEM_SIZE, sizeof(memsize),&memsize, NULL);
CHECK_OCL_ERR( clErr );
MITK_INFO << "CL_MEM_SIZE \t" << memsize << "\n";
// get CL_MEM_HOST_PTR
float *hostptr;
clErr = clGetMemObjectInfo( memobj, CL_MEM_HOST_PTR, sizeof(void*), (void*) &hostptr, NULL);
CHECK_OCL_ERR( clErr );
MITK_INFO << "CL_MEM_HOST_PTR \t" << hostptr << "\n";
// get CL_CONTEXT
cl_context gpuctxt;
clErr = clGetMemObjectInfo( memobj, CL_MEM_CONTEXT, sizeof(cl_context), &gpuctxt, NULL);
CHECK_OCL_ERR( clErr );
MITK_INFO << "CL_CONTEXT \t\t" << gpuctxt << "\n";
// get CL_MEM_REFERENCE_COUNT
cl_uint refs;
clErr = clGetMemObjectInfo( memobj, CL_MEM_REFERENCE_COUNT, sizeof(cl_uint), &refs, NULL);
CHECK_OCL_ERR(clErr);
MITK_INFO << "CL_REF_COUNT \t" << refs << "\n";
MITK_INFO << "================== \n" << std::endl;
}
