algorithms.hpp

Go to the documentation of this file.

#ifndef OCLSLAM_ALGORITHMS_HPP
#define OCLSLAM_ALGORITHMS_HPP

#include <CLUtils.hpp>
#include <oclslam/common.hpp>
#include <RBC/data_types.hpp>
#include <RBC/algorithms.hpp>
#include <eigen3/Eigen/Dense>


namespace cl_algo
{
namespace oclslam
{

    class SplitPC8D
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,        
            H_OUT_PC3D,  
            H_OUT_RGB,   
            D_IN,        
            D_OUT_PC3D,  
            D_OUT_RGB    
        };

        SplitPC8D (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (SplitPC8D::Memory mem);
        void init (unsigned int _n, Staging _staging = Staging::IO);
        void write (SplitPC8D::Memory mem = SplitPC8D::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (SplitPC8D::Memory mem = SplitPC8D::Memory::H_OUT_PC3D, 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 *hPtrIn;       
        cl_float *hPtrOutPC3D;  
        cl_uchar *hPtrOutRGB;   
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int n;
        unsigned int bufferInSize, bufferOutPC3DSize, bufferOutRGBSize;
        cl::Buffer hBufferIn, hBufferOutPC3D, hBufferOutRGB;
        cl::Buffer dBufferIn, dBufferOutPC3D, dBufferOutRGB;

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