math.hpp

Go to the documentation of this file.

#ifndef GF_MATH_HPP
#define GF_MATH_HPP

#include <CLUtils.hpp>
#include <GuidedFilter/common.hpp>


namespace cl_algo
{
namespace GF
{
namespace Math
{

    class Mult
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN_A,  
            H_IN_B,  
            H_OUT,   
            D_IN_A,  
            D_IN_B,  
            D_OUT    
        };

        Mult (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (Mult::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (Mult::Memory mem = Mult::Memory::D_IN_A, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (Mult::Memory mem = Mult::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrInA;  
        cl_float *hPtrInB;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> &info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int length, bufferSize;
        cl::Buffer hBufferInA, hBufferInB, hBufferOut;
        cl::Buffer dBufferInA, dBufferInB, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();
            return timer.duration ();
        }

    };


    class Pown
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        Pown (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (Pown::Memory mem);
        void init (unsigned int _width, unsigned int _height, int _n, Staging _staging = Staging::IO);
        void write (Pown::Memory mem = Pown::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (Pown::Memory mem = Pown::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        int getPower ();
        void setPower (int _n);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> &info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int length, bufferSize;
        int n;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();
            return timer.duration ();
        }

    };

}
}
}

#endif  // GF_MATH_HPP