clfContext.cpp

/* 
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Gui/biasgl.h>
#include <Base/Common/BIASpragma.hh>
#ifndef WIN32
  #include <GL/glx.h>
#else
  #include <GL/gl.h>
#endif
#include <OpenCLFramework/clfContext.hh>
#include <string.h>
#include <iostream>

using namespace std;
namespace BIAS {

  clfContext::clfContext(bool useGLsharing, clfDeviceType deviceType) {
    isSharedGL_ = false;
    activeQueue_ = 0;

    cl_device_type cldt;
    switch (deviceType) {
    case clfContextTypeCPU:
      cldt = (cl_device_type)CL_DEVICE_TYPE_CPU;
      break;
    case clfContextTypeGPU:
    default:
      cldt = (cl_device_type)CL_DEVICE_TYPE_GPU;
      break;
    }

    try { 
       // Get available platforms
       cl::Platform::get(&platforms_);
       
       if (useGLsharing) {
         // Select the default platform and create a context using this platform and the GPU
#ifdef WIN32
           cl_context_properties cps[] = { 
               CL_GL_CONTEXT_KHR,(cl_context_properties)wglGetCurrentContext(),
               CL_WGL_HDC_KHR,(cl_context_properties)wglGetCurrentDC(),
               CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms_[0]()),
               0};
#else
           cl_context_properties cps[] = { 
             CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(), 
             CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(), 
             CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms_[0]()),
             0};
#endif
         std::vector<cl::Device> devices;
         platforms_[0].getDevices(cldt, &devices);
         if (devices.size()>1) {
           BIASWARN("more than one GPU detected, selecting first one for sharing GL context");
           devices[0] = devices[1];
           devices.resize(1);
         }
#ifdef WIN32
         context_ = cl::Context(devices, cps, (void (__stdcall*)(const char*, const void*, size_t, void*))clfContext::clnotify, this);
#else
         context_ = cl::Context(devices, cps, (void (*)(const char*, const void*, size_t, void*))clfContext::clnotify, (void*)this);
#endif
       isSharedGL_ = true;
       } else {
         // Select the default platform and create a context using this platform and the GPU
         cl_context_properties cps[] = { 
             CL_CONTEXT_PLATFORM, 
             (cl_context_properties)(platforms_[0])(), 
             0 
         };
#ifdef WIN32
         context_ = cl::Context(cldt, cps, (void (__stdcall *)(const char*, const void*, size_t, void*))clfContext::clnotify, (void*)this);
#else
         context_ = cl::Context(cldt, cps, (void (*)(const char*, const void*, size_t, void*))clfContext::clnotify, (void*)this);
#endif
       }

       // Get a list of devices on this platform
       devices_ = context_.getInfo<CL_CONTEXT_DEVICES>();

       // Create command queues and use the first device
       for (unsigned int i=0;i<devices_.size();i++) {
         queues_.push_back( cl::CommandQueue(context_, devices_[i]) );
       }
       
       devinfo_.resize( devices_.size() );
       for (unsigned int i=0;i<devices_.size();i++) {
         QueryDeviceInfo_( i );
       }

    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }

  clfContext::~clfContext() {
  }
  
  void clfContext::clnotify(const char * p1, const void *p2, size_t p3, clfContext *p4) {
#ifdef BIAS_DEBUG
    cout << "[OpenCL Context] " << p1;
#endif
  }

  void clfContext::PrintDeviceInfo(unsigned int device, bool verbose,std::ostream& out)
  {
    if (device >= devices_.size()) {
      return;
    }
    
    {
      out << "Device:                   " << device << endl;
      out << "Name:                     " << devinfo_[device].name << endl;
      out << "OpenCL Version:           " << devinfo_[device].clfver << endl;
      out << "Driver Version:           " << devinfo_[device].driverVersion << endl;
      out << "Max Compute Units:        " << devinfo_[device].maxComputeUnits << endl;
    }
    if (verbose) {

      string memdim = "Byte";
      double memreadable = (double)devinfo_[device].globalMemSize;
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "KByte";
      } 
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "MByte";
      }
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "GByte";
      }
      out << "Global Memory:            " << devinfo_[device].globalMemSize << " (" << std::setprecision(2)<<memreadable << " "<<memdim<<")"<<endl;
      memdim = "Byte";
      memreadable = devinfo_[device].localMemSize;
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "KByte";
      } 
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "MByte";
      }
      if (memreadable > 1024) {
        memreadable /= 1024.0;
        memdim = "GByte";
      }
      out << "Local Memory:             " << devinfo_[device].localMemSize << " (" <<std::setprecision(2)<< memreadable << " "<<memdim<<")"<<endl;
      out << "Max Workgroup Size:       " << devinfo_[device].maxWorkgroupSize << endl;
      out << "Max Workitem Dimensions:  " << devinfo_[device].maxWorkitemDimensions << endl;
      out << "Max Workitem Sizes:       "; 
      if (devinfo_[device].maxWorkitemSizes[0] != 0) {
        for (unsigned int i=0;i<devinfo_[device].maxWorkitemSizes.size();i++) {
          out << devinfo_[device].maxWorkitemSizes[i] << " "; 
        }
        out << endl;
      } else {
        out << "Query failed." << endl;
      }
      out << "Image Support:            ";
      if (devinfo_[device].imageSupport) {
        out << "Yes." << endl;
      } else {
        out << "No. (maybe query failed.)" << endl;
      }
      out << "Image Max Width:          " << devinfo_[device].maxImg2DWidth << endl;
      out << "Image Max Height:         " << devinfo_[device].maxImg2DHeight << endl;
      out << "Max Nr of Read Images     " << devinfo_[device].maxReadImgs << endl;
      out << "Max Nr of Write Images    " << devinfo_[device].maxWriteImgs << endl;
      out << "OpenGL Sharing Available: ";
      if (devinfo_[device].hasGLsharing) {
        out << "Yes." << endl;
      } else {
        out << "No." << endl;
      }
      out << "Extensions:               " << devinfo_[device].extensions << endl;
    }
    out << endl;
  }
  
  void clfContext::PrintPlatformsInfo(std::ostream& out) {
    try {
      for (unsigned int i=0;i<platforms_.size();i++) {
        string name;            // Name of Device
        string vendor;      // The Extensions the Device Supports
        platforms_[i].getInfo( (cl_platform_info)CL_PLATFORM_NAME, &name);
        platforms_[i].getInfo( (cl_platform_info)CL_PLATFORM_VENDOR, &vendor);
        out << " Platform " << i << endl;
        out << " Vendor:  " << vendor << endl;
        out << " Name:    " << name << endl;
      }
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }
  
  void clfContext::RunOn1DRange(clfProgram &program, string kernelname, unsigned int globalrange, unsigned int localrange) {
    if (localrange != 0) {
      globalrange = DivUp(localrange, globalrange);
    }
    cl::NDRange global(globalrange);
    cl::NDRange local(localrange);
    if (localrange == 0) local = cl::NullRange;
    try {
      queues_[activeQueue_].enqueueNDRangeKernel(program(kernelname), cl::NullRange, global, local);
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }
  
  void clfContext::RunOn2DRange(clfProgram &program, string kernelname, unsigned int globalrangeX, unsigned int globalrangeY, unsigned int localrangeX, unsigned int localrangeY) {
    if (localrangeX != 0) {
      globalrangeX = DivUp(localrangeX, globalrangeX);
    }
    if (localrangeY != 0) {
      globalrangeY = DivUp(localrangeY, globalrangeY);
    }
    cl::NDRange global(globalrangeX, globalrangeY);
    cl::NDRange local(localrangeX, localrangeY);
    if (localrangeX == 0 || localrangeY == 0) local = cl::NullRange;
    try {
      queues_[activeQueue_].enqueueNDRangeKernel(program(kernelname), cl::NullRange, global, local);
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }
  
  void clfContext::RunOn3DRange(clfProgram &program, string kernelname, unsigned int globalrangeX, unsigned int globalrangeY, unsigned int globalrangeZ, unsigned int localrangeX, unsigned int localrangeY, unsigned int localrangeZ) {
    if (localrangeX != 0) {
      globalrangeX = DivUp(localrangeX, globalrangeX);
    }
    if (localrangeY != 0) {
      globalrangeY = DivUp(localrangeY, globalrangeY);
    }
    if (localrangeZ != 0) {
      globalrangeZ = DivUp(localrangeZ, globalrangeZ);
    }
    cl::NDRange global(globalrangeX, globalrangeY, globalrangeZ);
    cl::NDRange local(localrangeX, localrangeY, localrangeZ);
    if (localrangeX == 0 || localrangeY == 0 || localrangeZ == 0) local = cl::NullRange;
    try {
      queues_[activeQueue_].enqueueNDRangeKernel(program(kernelname), cl::NullRange, global, local);
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }

  void clfContext::AcquireGLObject(clfMemory &buffer) {
    vector<cl::Memory> buf(1, buffer.memory());
    try {
      queues_[activeQueue_].enqueueAcquireGLObjects( &buf );
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }
  
  void clfContext::ReleaseGLObject(clfMemory &buffer) {
    vector<cl::Memory> buf(1, buffer.memory());
    try {
      queues_[activeQueue_].enqueueReleaseGLObjects( &buf );  
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }

  void clfContext::Finish() {
    try {
      queues_[activeQueue_].finish();     
    } catch (cl::Error &error) {
      THROW_CL_EXCEPTION(error);
    }
  }

  void clfContext::QueryDeviceInfo_(unsigned int device) {
  
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_NAME,
           &devinfo_[device].name );
    } catch (cl::Error &error) {
      devinfo_[device].name = "";
    }
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_EXTENSIONS,
           &devinfo_[device].extensions );
    } catch (cl::Error &error) {
      devinfo_[device].extensions = "";
    }
    try {
      cl_bool test;
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_IMAGE_SUPPORT, &test);
      devinfo_[device].imageSupport = (bool)test;
    } catch (cl::Error &error) {
      devinfo_[device].imageSupport = false;
    }
    try {
      devices_[device].getInfo((cl_device_info)CL_DEVICE_MAX_COMPUTE_UNITS, 
        &devinfo_[device].maxComputeUnits);
    } catch (cl::Error &error) {
      devinfo_[device].maxComputeUnits = 0;
    }
    cl_ulong memsize;
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_GLOBAL_MEM_SIZE, &memsize);
      devinfo_[device].globalMemSize = (unsigned long long)memsize;
    } catch (cl::Error &error) {
      devinfo_[device].globalMemSize = 0;
    }
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_LOCAL_MEM_SIZE, &memsize);
      devinfo_[device].localMemSize = (unsigned long long)memsize;
    } catch (cl::Error &error) {
      devinfo_[device].localMemSize = 0;
    }
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_MAX_WORK_GROUP_SIZE,
        &devinfo_[device].maxWorkgroupSize);
    } catch (cl::Error &error) {
      devinfo_[device].maxWorkgroupSize = 0;
    }
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
        &devinfo_[device].maxWorkitemDimensions);
    } catch (cl::Error &error) {
      devinfo_[device].maxWorkitemDimensions = 1;
    }
    //size_t *sizes = new size_t[devinfo_[device].maxWorkitemDimensions];
    size_t sizes[3];
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_MAX_WORK_ITEM_SIZES,
        &sizes);
      for (unsigned int i=0;i<devinfo_[device].maxWorkitemDimensions;i++) {
        devinfo_[device].maxWorkitemSizes.push_back(sizes[i]);
      }
    } catch (cl::Error &error) {
      // todo fkellner this fails always BIASERR("cl::Error : " <<  error.what() << endl)
      devinfo_[device].maxWorkitemSizes.resize(devinfo_[device].maxWorkitemDimensions,0);
    }
    //delete[] sizes;
    try {
      devices_[device].getInfo( (cl_device_info)CL_DRIVER_VERSION,
        &devinfo_[device].driverVersion);
    } catch (cl::Error &error) {
      devinfo_[device].driverVersion = "1.0";
    }
    try {
      devices_[device].getInfo( (cl_device_info)CL_DEVICE_IMAGE2D_MAX_WIDTH,
        &devinfo_[device].maxImg2DWidth);
    } catch (cl::Error &error) {
      devinfo_[device].maxImg2DWidth = 0;
    }
    try {
    devices_[device].getInfo( (cl_device_info)CL_DEVICE_IMAGE2D_MAX_HEIGHT,
        &devinfo_[device].maxImg2DHeight);
    } catch (cl::Error &error) {
      devinfo_[device].maxImg2DHeight = 0;
    }
    try {
      devices_[device].getInfo((cl_device_info)CL_DEVICE_OPENCL_C_VERSION, &devinfo_[device].clfver );
    } catch (cl::Error &error) {
      devinfo_[device].clfver = "OpenCL C 1.0";
    }
    try {
      devices_[device].getInfo((cl_device_info)CL_DEVICE_MAX_WRITE_IMAGE_ARGS, &devinfo_[device].maxWriteImgs );
    } catch (cl::Error &error) {
      devinfo_[device].maxWriteImgs = 0;
    }
    try {
      devices_[device].getInfo((cl_device_info)CL_DEVICE_MAX_READ_IMAGE_ARGS, &devinfo_[device].maxReadImgs );
    } catch (cl::Error &error) {
      devinfo_[device].maxReadImgs = 0;
    }

    if (devinfo_[device].extensions.find("cl_khr_gl_sharing") == string::npos) {
      devinfo_[device].hasGLsharing = false;
    } else {
      devinfo_[device].hasGLsharing = true;
    }
  }

  void clfContext::SetActiveDevice(unsigned int device) {
    if (device >= queues_.size()) {
      THROW_CL_EXCEPTION(cl::Error(-100, "device does not exist."));
    } else {
      activeQueue_ = device;
    }
  }

  unsigned int clfContext::GetActiveDevice()
  {
    return activeQueue_;
  }

  int clfContext::DivUp(const int mod, int val) {
    if (val % mod != 0) val += mod - (val%mod);
    return val;
  }

}