clfContext.hh

/* 
 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
 */

#ifndef OPENCLCONTEXT_HH_
#define OPENCLCONTEXT_HH_

#include <vector>
#include <Base/Common/BIASpragmaStart.hh>
#include <OpenCLFramework/clfOpenCL.hh>
#include <OpenCLFramework/clfProgram.hh>
#include <OpenCLFramework/clfBuffer.hh>
#include <OpenCLFramework/clfException.hh>
#include <OpenCLFramework/clfDeviceInfo.hh>
#include <Base/Debug/Debug.hh>

namespace BIAS {
  
  /**
   * 
   * @brief OpenCL Context wrapper
   * 
   * OpenCLContext bundles one context and one command queue.
   * After creation, use OpenCLContext to instantiate buffer
   * objects and programs valid for this context. 
   * 
   * @author fkellner 06/11
   */
class BIASOpenCLFramework_EXPORT clfContext {
    public:
      enum clfDeviceType {
        clfContextTypeCPU = 0,
        clfContextTypeGPU
      };
    public:
      /**
       * @brief Create clfContext for first GPU device found.
       * @param useGLsharing true if you want to share GL objects. A valid GL context must be available!
       */
      clfContext(bool useGLsharing = false, clfDeviceType deviceType = clfContextTypeGPU);
      
      /**
       * @brief deletes context and queue, making objects created from this context invalid!
       */
      virtual ~clfContext();
      
      /**
       * @brief create program object
       * @return program bound to context
       */
      clfProgram *CreateProgram() {
        return new clfProgram(&context_, &devices_);
      }

      /**
       * @brief create buffer object
       * @return buffer bound to context
       */
      clfBuffer *CreateBuffer() {
        return new clfBuffer(&context_, &queues_[activeQueue_]);
      }

      /**
       * @brief create buffer object
       * @return buffer bound to context
       */
      clfImage2D *CreateImage2D() {
        return new clfImage2D(&context_, &queues_[activeQueue_]);
      }

      /**
       * @brief create buffer object
       * @return buffer bound to context
       */
      clfImage3D *CreateImage3D() {
        return new clfImage3D(&context_, &queues_[activeQueue_]);
      }

      /// @brief print info on computing device
      void PrintDeviceInfo(unsigned int device=0, bool verbose = false,std::ostream& out=std::cout);
      /// @brief print info on available platforms
      void PrintPlatformsInfo(std::ostream& out=std::cout);
      
      /**
       * @brief acquire a buffer allocated from opengl, call glfinish first!
       * @param buffer the buffer object
       */
      void AcquireGLObject(clfMemory &buffer);

      /**
       * @brief release a buffer allocated from opengl, call Finish first!
       * @param buffer the buffer object
       */
      void ReleaseGLObject(clfMemory &buffer);

      /**
       * @brief run a kernel on a 1D memory range
       * @param globalrange overall memory size in byte, should be multiple of compute units on device
       * @param localrange memory range in byte handled by each thread, should be even divisor of compute units on device (or 0)
       */
      void RunOn1DRange(clfProgram &program, std::string kernelname, unsigned int globalrange, unsigned int localrange=0);
      /**
       * @brief run a kernel on a 2D memory range
       */
      void RunOn2DRange(clfProgram &program, std::string kernelname, unsigned int globalrangeX, unsigned int globalrangeY, unsigned int localrangeX=0, unsigned int localrangeY=0);

      /**
       * @brief run a kernel on a 3D memory range
       */
      void RunOn3DRange(clfProgram &program, std::string kernelname, unsigned int globalrangeX, unsigned int globalrangeY, unsigned int globalrangeZ, unsigned int localrangeX=0, unsigned int localrangeY=0, unsigned int localrangeZ=0);

      /**
       * @brief force finishing the command queue
       */
      void Finish();
      
      inline unsigned int GetNumDevices() {
        return devices_.size();
      }
      
      clfDeviceInfo GetDeviceInfo(unsigned int device = 0) {
        return devinfo_[device];
      }
      
      inline bool IsSharedGLContext() {
        return isSharedGL_;
      }

      void SetActiveDevice(unsigned int device);

      unsigned int GetActiveDevice();

      int DivUp(const int mod, int val);

    protected:

      /// @brief internal notification function for status from clf context
      static void clnotify(const char * p1, const void *p2, size_t p3, clfContext *p4);

      void QueryDeviceInfo_(unsigned int device = 0);
    private:
      
      cl::Context context_;
      std::vector<cl::Device> devices_;

      std::vector<cl::Platform> platforms_;
      
      std::vector<cl::CommandQueue> queues_;
      unsigned int activeQueue_;

      std::vector<clfDeviceInfo> devinfo_;
      bool isSharedGL_;
  };

}
#include <Base/Common/BIASpragmaEnd.hh>
#endif /* clfCONTEXT_HH_ */