opencl.hh

#ifndef VTESTBED_OPENCL_OPENCL_HH
#define VTESTBED_OPENCL_OPENCL_HH

#include <iosfwd>
#include <string>
#include <unordered_map>
#include <vector>

#include <openclx/svm_block>

#include <openclx/command_queue>
#include <openclx/command_stack>
#include <openclx/compiler>
#include <openclx/context>
#include <openclx/device>
#include <openclx/kernel>
#include <openclx/program>

#include <vtestbed/opencl/cl.hh>
#include <vtestbed/opencl/device_type.hh>
#include <vtestbed/opencl/pipeline.hh>

namespace vtb {

    namespace opencl {

        class Context {

        private:
            using queue_array = std::vector<clx::command_queue>;

        private:
            clx::platform _platform;
            clx::context _context;
            Pipeline _pipeline{clx::command_queue{}};
            clx::compiler _compiler{clx::context{}};
            std::string _flags;
            void* _glcontext = nullptr;
            void* _glxdisplay = nullptr;
            bool _glsharing = false;

        public:

            Context() = default;

            inline explicit
            Context(std::string filename) {
                this->open(filename);
            }

            void open(std::string filename);
            void close();
            void read(std::string filename, std::istream& in);

            inline clx::context context() { return this->_context; }
            inline clx::platform platform() { return this->_platform; }
            inline Pipeline& pipeline() { return this->_pipeline; }
            inline clx::compiler compiler_copy() { return this->_compiler; }
            inline clx::compiler& compiler() { return this->_compiler; }

            inline void
            opengl_context(void* rhs) noexcept {
                this->_glcontext = rhs;
            }

            inline void
            display(void* rhs) noexcept {
                this->_glxdisplay = rhs;
            }

            inline bool
            opengl_sharing() const noexcept {
                return this->_glsharing;
            }

            inline
            operator clx::context() {
                return this->context();
            }

            void platform(std::string suffix);
            void context(Device_type type);
            void devices(std::string name);
            void flags(std::string rhs);

            void platform(clx::platform rhs);

        };

        class Context_base {
        private:
            Context* _context = nullptr;
        public:
            Context_base() = default;
            virtual ~Context_base() = default;
            virtual void context(Context* rhs) { this->_context = rhs; }
            inline Context* context() { return this->_context; }
            inline const Context* context() const { return this->_context; }
        };

        const char* real_type_flags();

        template <class T> const char* real_type_flags();

        template <> inline const char*
        real_type_flags<float>() {
            return " -DVTB_REAL_TYPE=float -DVTB_REAL_TYPE_FLOAT";
        }

        template <> inline const char*
        real_type_flags<double>() {
            return " -DVTB_REAL_TYPE=double -DVTB_REAL_TYPE_DOUBLE";
        }

    }

}

#endif // vim:filetype=cpp