icl.hpp

 
#ifndef __FISH_POND_OPENCL_ICL_HPP
#define __FISH_POND_OPENCL_ICL_HPP
 
#ifndef HAVE_NO_PRAGMA_ONCE
#pragma once
#endif
 
#include <cstdint>
#include <memory>
#include <unordered_map>
#include <chrono>
 
#if defined(__APPLE__) || defined(__MACOSX)
    #include "fish/pond/OpenCL/cl.hpp"
#else
    #include "fish/pond/OpenCL/cl.hpp"
#endif
 
 
#include "fish/fiber/FiberHDF5/mtoolslib/MDefs.hpp"
 
#include "api.h"
 
namespace icl 
{
 
        #define checkError(__errorCode, __message) \
        if(!(__errorCode == CL_SUCCESS)) { \
        MTOOLS_ERR_OUT( "=============================" ); \
        MTOOLS_ERR_OUT( "OpenCL Error:\n\t" << __message << ": " << errorString(__errorCode) ); \
        MTOOLS_ERR_OUT(  __FILE__ "#"<< __LINE__ << ":" ); \
        MTOOLS_ERR_OUT( "=============================" ); \
        std::exit(EXIT_FAILURE); \
        }
        
        #define raiseError(__message) \
        { \
        MTOOLS_ERR_OUT(  "=============================" ); \
        MTOOLS_ERR_OUT( "OpenCL Error:\n\t" << __message << "" ); \
        MTOOLS_ERR_OUT(  __FILE__ "#"<< __LINE__ << ":" ); \
        MTOOLS_ERR_OUT(  "=============================" ); \
        std::exit(EXIT_FAILURE); \
        }
        
        MYAPI enum device_type : cl_ulong
        {
                CPU = (1 << 1),
                GPU = (1 << 2),
                ACL = (1 << 3),
                ALL = (0xFFFFFFFF)
        };
        
        MYAPI enum buffer_flag : cl_ulong
        {
                READ_WRITE      = (1 << 0),
                READ            = (1 << 1),
                WRITE           = (1 << 2)
        };
    
        MYAPI enum print_flag : cl_int
        {
                SHORT   = 0,
                LONG    = 1
        };
        
        MYAPI enum kernel_flag : cl_int
        {
                STRING  = 0,
                FILE    = 1
        };
        
        MYAPI enum time_flag : cl_int
        {
                NANO    = 0,
                MILLI   = 1,
                MICRO   = 2,
                SEC     = 3
        };
        
        MYAPI using NDRange = cl::NDRange;
        MYAPI static const NDRange NullRange;
        
        MYAPI const std::string errorString (cl_int err);
        
        MYAPI class Device
        {
                
                class Buffer 
                {
                        friend class Device;
                        cl::Buffer cl_buffer;
                        buffer_flag flag;
                        size_t size;
                        
                public:
                        Buffer(){}
                        Buffer(cl::Buffer b, buffer_flag f, size_t s) 
                        : cl_buffer(b), flag(f), size(s){}
                };
                
                class Kernel 
                {
                        friend class Device;
                        cl::Kernel cl_kernel;
                        
                public:
                        Kernel(){}
                        Kernel(cl::Kernel k) 
                        : cl_kernel(k) {}
                };
        
                friend class Platform;
                cl::Device cl_device;
                cl::Context cl_context;
                cl::CommandQueue cl_queue;
                
                std::string name;
                std::string vendor;
                cl_ulong type;
                cl_ulong max_buffer_size;
                cl_ulong memory_size;
                cl_ulong used_memory;
                
                std::unordered_map<std::string, Buffer> buffer_map;
                std::unordered_map<std::string, Kernel> kernel_map;
                
                Device(cl::Device d, cl::Context c, cl::CommandQueue q) 
                        : cl_device(d), cl_context(c), cl_queue(q), used_memory(0)
                {
                        cl_device.getInfo(CL_DEVICE_NAME, &name); 
                        cl_device.getInfo(CL_DEVICE_VENDOR, &vendor); 
                        cl_device.getInfo(CL_DEVICE_TYPE, &type); 
                        cl_device.getInfo(CL_DEVICE_MAX_MEM_ALLOC_SIZE, &max_buffer_size); 
                        cl_device.getInfo(CL_DEVICE_GLOBAL_MEM_SIZE, &memory_size);
                }
                
                cl::Program buildProgram(const std::string& file_name, kernel_flag flag);
                void buildKernel(const std::string& kernel_name, const cl::Program& cl_program);
                
                
                template <typename T>
                cl_int setArg(cl::Kernel& cl_kernel, cl_uint pos, const T arg)
                {
                        return cl_kernel.setArg( pos, arg );
                }
                
 
 
                void setArguments(cl::Kernel& cl_kernel, cl_uint pos)
                {
                        return;
                }
                
                template <typename T, typename... Ts>
                void setArguments(cl::Kernel& cl_kernel, cl_uint pos, const T& arg, const Ts&... arguments)
                {
                        cl_int err = setArg(cl_kernel, pos, arg);
 
                        checkError(err, "Error setting the kernel argument with index " << pos);
                        setArguments(cl_kernel, pos+1, arguments...);
                }
 
        public:
                void print () const;
                
                void createBuffer(const std::string& key, buffer_flag flag, size_t size);
                
                void writeBuffer(const std::string& key, size_t size, const void* source_ptr);
                
                void readBuffer(const std::string& key,  size_t size, void* source_ptr);
                
                void deleteBuffer(const std::string& key);
                void deleteBuffer(const std::initializer_list<std::string>& keys);
                
                void createKernel(const std::string& kernel_name, const std::string& file_name, kernel_flag flag);
                void createKernel(const std::initializer_list<std::string>& kernel_names, const std::string& file_name, kernel_flag flag);
 
                void deleteKernel(const std::string& key);
                void deleteKernel(const std::initializer_list<std::string>& keys);
                
                template <typename... Ts>
                void runKernel(const std::string& key, const NDRange& global, const NDRange& local, const Ts&... arguments)
                {
                        const auto& result = kernel_map.find(key);
                        if (result == kernel_map.end()) 
                        {
                                raiseError("Kernel \"" << key << "\" not found!!");
                        }
                        else 
                        {
                                cl::Kernel cl_kernel((kernel_map[key]).cl_kernel); // making a copy
                                setArguments(cl_kernel, 0, arguments...);
 
                                cl_int err = cl_queue.enqueueNDRangeKernel(cl_kernel, NullRange, global, local);
 
                                checkError(err, "Error running the kernel " << key);
                                //err = cl_queue.finish();
                                //checkError(err, "Error during the finish operation");
                                err = cl_queue.flush();
                                checkError(err, "Error during the flush operation");
                        }
                }
 
                void finishKernels(){
                        cl_int err = cl_queue.finish();
                        checkError(err, "Error during the finish operation");
                }
                
        };
        
        template<>
        cl_int Device::setArg<const char*>(cl::Kernel& cl_kernel, cl_uint pos, const char* key);
 
        template<>
        cl_int Device::setArg<std::string>(cl::Kernel& cl_kernel, cl_uint pos, std::string key);
 
        MYAPI class Platform
        {
        private:
                std::vector<Device> devices;
 
                Platform();
                Platform(Platform const&);
                void operator=(Platform const&);
        public:
                static Platform& getInstance() {
                        static Platform instance;
                        return instance;
                }
                
                const cl_ulong getNumDevices() const;
                
                Device& getDevice(uint32_t id);
                
                Device& getGPU();
                
                Device& getCPU();
 
                Device& getGPUPreferred();
 
                Device& getCPUPreferred();
 
                std::vector<Device>& getDevices();
                
                void printDevices(print_flag flag = SHORT) const;
        };
        
        
        using namespace std::chrono;
        
        MYAPI class Timer
        {
        private:
                high_resolution_clock::time_point time;
                nanoseconds duration;
        public:
                Timer() : duration(nanoseconds::zero()){};
                
                void start(){
                        time = high_resolution_clock::now();
                }
                
                void reset()
                {
                        time = high_resolution_clock::now();
                        duration = nanoseconds::zero();
                }
                
                double stop(icl::time_flag time_flag = icl::MILLI)
                {
                        duration += (high_resolution_clock::now() - time);
                        double value = 0;
                        switch(time_flag) {
                                case icl::NANO:
                                        value = nanoseconds(duration).count();
                                        break;
                                case icl::MICRO:
                                        value = duration_cast<microseconds>(duration).count();
                                        break;
                                case icl::MILLI:
                                        value = duration_cast<milliseconds>(duration).count();
                                        break;
                                case icl::SEC:
                                        value = duration_cast<seconds>(duration).count();
                                        break;
                        }
                        return value;
                }
        };
}
#endif