CLUtils.hpp

Go to the documentation of this file.

#ifndef CLUTILS_HPP
#define CLUTILS_HPP

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <chrono>
#include <cassert>
#include <cmath>

#define __CL_ENABLE_EXCEPTIONS

#if defined(__APPLE__) || defined(__MACOSX)
#include <OpenCL/cl.hpp>
#else
#include <CL/cl.hpp>
#endif

namespace clutils
{
    const char* getOpenCLErrorCodeString (int errorCode);

    bool checkCLGLInterop (cl::Device &device);

    void readSource (const std::vector<std::string> &kernel_filenames, 
                     std::vector<std::string> &sourceCodes);

    void split (const std::string &str, char delim, 
                std::vector<std::string> &names);


    std::pair<const char *, size_t> 
        make_kernel_pair (const std::string &kernel_filename);


    class CLEnv
    {
    public:
        CLEnv (const std::vector<std::string> &kernel_filenames = std::vector<std::string> (), 
               const char *build_options = nullptr);
        CLEnv (const std::string &kernel_filename, 
               const char *build_options = nullptr);
        virtual ~CLEnv () {};
        cl::Context& getContext (unsigned int pIdx = 0);
        cl::CommandQueue& getQueue (unsigned int ctxIdx = 0, unsigned int qIdx = 0);
        cl::Program& getProgram (unsigned int pgIdx = 0);
        cl::Kernel& getKernel (const char *kernelName, unsigned int pgIdx = 0);
        cl::Context& addContext (unsigned int pIdx, const bool gl_shared = false);
        cl::CommandQueue& addQueue (unsigned int ctxIdx, unsigned int dIdx, cl_command_queue_properties props = 0);
        cl::CommandQueue& addQueueGL (unsigned int ctxIdx, cl_command_queue_properties props = 0);
        cl::Kernel& addProgram (unsigned int ctxIdx, 
                                const std::vector<std::string> &kernel_filenames, 
                                const char *kernel_name = nullptr, 
                                const char *build_options = nullptr);
        cl::Kernel& addProgram (unsigned int ctxIdx, 
                                const std::string &kernel_filename, 
                                const char *kernel_name = nullptr, 
                                const char *build_options = nullptr);

        // Objects associated with an OpenCL environment.
        // For each of a number of objects, there is a vector that 
        // can hold all instances of that object.

        std::vector<cl::Platform> platforms;  
        std::vector< std::vector<cl::Device> > devices;

    private:
        std::vector<cl::Context> contexts;  
        std::vector< std::vector<cl::CommandQueue> > queues;
        std::vector<cl::Program> programs;  
        std::vector< std::vector<cl::Kernel> > kernels;

    protected:
        virtual void initGLMemObjects () {};

    private:
        std::vector< std::unordered_map<std::string, unsigned int> > kernelIdx;
    };


    template<unsigned int nQueues = 1>
    class CLEnvInfo
    {
    public:
        CLEnvInfo (unsigned int _pIdx = 0, unsigned int _dIdx = 0, unsigned int _ctxIdx = 0, 
                   const std::vector<unsigned int> _qIdx = { 0 }, unsigned int _pgIdx = 0) : 
            pIdx (_pIdx), dIdx (_dIdx), ctxIdx (_ctxIdx), pgIdx (_pgIdx)
        {
            try
            {
                if (_qIdx.size () != nQueues)
                    throw "The provided vector of command queue indices has the wrong size";

                qIdx = _qIdx;
            }
            catch (const char *error)
            {
                std::cerr << "Error[CLEnvInfo]: " << error << std::endl;
                exit (EXIT_FAILURE);
            }
        }


        CLEnvInfo<1> getCLEnvInfo (unsigned int idx)
        {
            try
            {
                return CLEnvInfo<1> (pIdx, dIdx, ctxIdx, { qIdx.at (idx) }, pgIdx);
            }
            catch (const std::out_of_range &error)
            {
                std::cerr << "Out of Range error: " << error.what () 
                          << " (" << __FILE__ << ":" << __LINE__ << ")" << std::endl;
                exit (EXIT_FAILURE);
            }
        }


        unsigned int pIdx;               
        unsigned int dIdx;               
        unsigned int ctxIdx;             
        std::vector<unsigned int> qIdx;  
        unsigned int pgIdx;              
    };


    template <uint nSize, typename rep = double>
    class ProfilingInfo
    {
    public:
        ProfilingInfo (std::string pLabel = std::string (), std::string pUnit = std::string ("ms")) 
            : label (pLabel), tExec (nSize), tWidth (4 + log10 (nSize)), tUnit (pUnit)
        {
        }

        rep& operator[] (const int idx)
        {
            assert (idx >= 0 && idx < nSize);
            return tExec[idx];
        }

        rep total (rep initVal = 0.0)
        {
            return std::accumulate (tExec.begin (), tExec.end (), initVal);
        }

        rep mean ()
        {
            return total() / (rep) tExec.size ();
        }

        rep min ()
        {
            return *std::min_element (tExec.begin (), tExec.end ());
        }

        rep max ()
        {
            return *std::max_element (tExec.begin (), tExec.end ());
        }

        rep speedup (ProfilingInfo &refProf)
        {
            return refProf.mean () / mean ();
        }

        void print (const char *title = nullptr, bool bLine = true)
        {
            std::ios::fmtflags f (std::cout.flags ());
            std::cout << std::fixed << std::setprecision (3);

            if (title)
                std::cout << std::endl << title << std::endl << std::endl;
            else
                std::cout << std::endl;

            std::cout << " " << label << std::endl;
            std::cout << " " << std::string (label.size (), '-') << std::endl;
            std::cout << "   Mean   : " << std::setw (tWidth) << mean ()  << " " << tUnit << std::endl;
            std::cout << "   Min    : " << std::setw (tWidth) << min ()   << " " << tUnit << std::endl;
            std::cout << "   Max    : " << std::setw (tWidth) << max ()   << " " << tUnit << std::endl;
            std::cout << "   Total  : " << std::setw (tWidth) << total () << " " << tUnit << std::endl;
            if (bLine) std::cout << std::endl;

            std::cout.flags (f);
        }

        void print (ProfilingInfo &refProf, const char *title = nullptr)
        {
            if (title)
                std::cout << std::endl << title << std::endl;

            refProf.print (nullptr, false);
            print (nullptr, false);

            std::cout << std::endl << " Benchmark" << std::endl << " ---------" << std::endl;
            
            std::cout << "   Speedup: " << std::setw (tWidth) << speedup (refProf) << std::endl << std::endl;
        }

    private:
        std::string label;  
        std::vector<rep> tExec;  
        uint8_t tWidth;  
        std::string tUnit;  
    };


    template <typename rep = int64_t, typename period = std::milli>
    class CPUTimer
    {
    public:
        CPUTimer (int initVal = 0) : tDuration (initVal)
        {
        }

        void start (bool tReset = true)
        {
            if (tReset)
                reset ();

            tReference = std::chrono::high_resolution_clock::now ();
        }

        rep stop ()
        {
            tDuration += std::chrono::duration_cast< std::chrono::duration<rep, period> > 
                (std::chrono::high_resolution_clock::now () - tReference);

            return duration ();
        }

        rep duration ()
        {
            return tDuration.count ();
        }

        void reset ()
        {
            tDuration = std::chrono::duration<rep, period>::zero ();
        }

    private:
        std::chrono::time_point<std::chrono::high_resolution_clock> tReference;
        std::chrono::duration<rep, period> tDuration;
    };


    template <typename period = std::milli>
    class GPUTimer
    {
    public:
        GPUTimer (cl::Device &device)
        {
            period tPeriod;
            size_t tRes = device.getInfo<CL_DEVICE_PROFILING_TIMER_RESOLUTION> ();  // x nanoseconds
            // Converts nanoseconds to seconds and then to the requested scale
            tUnit = (double) tPeriod.den / (double) tPeriod.num / 1000000000.0 * tRes;
        }

        cl::Event& event ()
        {
            return pEvent;
        }

        void wait ()
        {
            pEvent.wait ();
        }

        double duration ()
        {
            cl_ulong start = pEvent.getProfilingInfo<CL_PROFILING_COMMAND_START> ();
            cl_ulong end = pEvent.getProfilingInfo<CL_PROFILING_COMMAND_END> ();

            return (end - start) * tUnit;
        }

    private:
        cl::Event pEvent;  
        double tUnit;  
    };

}

#endif  // CLUTILS_HPP