opencl_backend.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file opencl_backend.h

#ifndef __OPENCL_BACKEND_H__
#define __OPENCL_BACKEND_H__

#define __CL_ENABLE_EXCEPTIONS
//#if defined(__APPLE__) || defined(__MACOSX)
//#include <OpenCL/cl.hpp>
//#else
//#include <CL/cl.hpp>
//#endif
#include "cl.hpp"
#include "Config.h"

#include <map>
#include <ctime>
#include <algorithm>
#include <random>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <type_traits>

namespace clvisc {

#ifdef USE_SINGLE_PRECISION

 typedef cl_float cl_real;
 typedef cl_float2 cl_real2;
 typedef cl_float4 cl_real4;
 typedef cl_float3 cl_real3;
 typedef cl_float8 cl_real8;
#else
 typedef cl_double cl_real;
 typedef cl_double2 cl_real2;
 typedef cl_double4 cl_real4;
 typedef cl_double3 cl_real3;
 typedef cl_double8 cl_real8;
#endif


/* compile options to build opencl kernel files on device*/
class CompileOption {
    public:
        std::stringstream opt;

        CompileOption();
        CompileOption(bool use_single_precision, bool optimize);


        std::string str();

        void Define(std::string name);
        void SetDoubleConst(std::string name, double value);
        void SetFloatConst(std::string name, float value);
        void SetIntConst(std::string name, int value);
        void KernelIncludePath(std::string abs_path);
};

class OpenclBackend {
  public:
    OpenclBackend(std::string device_type, int device_id);

    // make context_ and queue_ public in case one wants 
    // to use the native opencl APIs.
    cl::Context context_;
    cl::CommandQueue queue_;

    std::map<std::string, cl::Program> programs;
    std::map<std::string, cl::Kernel> kernel_funcs;
    std::map<std::string, cl::Buffer> buffers;

    cl::Program BuildProgram(std::string fname, const std::string & option);

    cl::Kernel CreateKernel(const cl::Program & prg, std::string func_name) {
        return cl::Kernel(prg, func_name.c_str());
    }

    inline cl::Context Context() {return context_;};

    inline cl::CommandQueue Queue() {return queue_;};

    void DeviceInfo();

    cl_int DeviceType();
 
    float ExcutionTime(cl::Event & event);

    cl::Buffer CreateBuffer(size_t bytes_of_buffer);

    cl::Image2D CreateImage2DByCopyVector(std::vector<cl_float4> & source_vector,
                                          size_t width, size_t height, bool read_only);

    template <typename ValueType>
    cl::Buffer CreateBufferByCopyVector(std::vector<ValueType> & source_vector,
                                        bool read_only);

    void enqueue_run(const cl::Kernel  & kernel_,
                     const cl::NDRange & global_size,
                     const cl::NDRange & local_size);

    template <typename ValueType>
    void enqueue_copy(const std::vector<ValueType> & src_vector,  cl::Buffer & dst_buffer);

    template <typename ValueType>
    void enqueue_copy(const cl::Buffer & src_buffer, std::vector<ValueType> & dst_vector);

    // copy cl::Buffer to cl::Buffer
    void enqueue_copy(const cl::Buffer & src_buffer, cl::Buffer & dst_buffer, size_t size);
  private:
    cl_int device_type_;
    std::vector<cl::Device> devices_;
    cl_int device_id_;
    cl::Device device_;
    cl::Context CreateContext_(const cl_int & device_type);
    
};

} // end namespace clvisc

#endif