コード例 #1
0
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;
    }
  }
}
コード例 #2
0
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.";
  }
}
コード例 #3
0
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 );
}
コード例 #4
0
ファイル: mitkOclDataSet.cpp プロジェクト: Cdebus/MITK
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;
}
コード例 #5
0
ファイル: mitkOclDataSet.cpp プロジェクト: Cdebus/MITK
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;
}
コード例 #6
0
ファイル: mitkOclUtils.cpp プロジェクト: 151706061/MITK
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";
  }
}
コード例 #7
0
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 );
}
コード例 #8
0
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 );
}
コード例 #9
0
ファイル: mitkOclDataSet.cpp プロジェクト: Cdebus/MITK
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;
}
コード例 #10
0
ファイル: mitkOclDataSet.cpp プロジェクト: Cdebus/MITK
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;
}
コード例 #11
0
ファイル: mitkOclUtils.cpp プロジェクト: 151706061/MITK
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;
}