pipeline.hh

#ifndef VTESTBED_OPENCL_PIPELINE_HH
#define VTESTBED_OPENCL_PIPELINE_HH

#include <vector>

#include <blitz/array.h>

#include <openclx/array_view>
#include <openclx/buffer>
#include <openclx/command_queue_flags>
#include <openclx/command_stack>
#include <openclx/kernel>
#include <openclx/memory_flags>

namespace vtb {

    namespace opencl {

        void
        resize(
            const clx::context& context,
            clx::buffer& buffer,
            size_t size_in_bytes,
            clx::memory_flags flags=clx::memory_flags::read_write
        );

        template <class T>
        inline void
        resize(
            const clx::context& context,
            clx::buffer& buffer,
            size_t size,
            clx::memory_flags flags=clx::memory_flags::read_write
        ) { ::vtb::opencl::resize(context, buffer, size*sizeof(T), flags); }

        template <class T>
        class Buffer: public clx::buffer {

        public:
            using clx::buffer::buffer;

            inline void resize(clx::context ctx, size_t size,
                               clx::memory_flags flags=clx::memory_flags::read_write) {
                ::vtb::opencl::resize(ctx, *this, size*sizeof(T), flags);
            }
        };

        class NDRange: public clx::range {

        public:

            inline explicit NDRange(): clx::range{} {}
            inline explicit NDRange(size_t rhs): clx::range{rhs} {}

            inline explicit
            NDRange(const blitz::TinyVector<size_t,1>& rhs):
            clx::range{rhs(0)} {}

            inline explicit
            NDRange(const blitz::TinyVector<size_t,2>& rhs):
            clx::range{rhs(0),rhs(1)} {}

            inline explicit
            NDRange(const blitz::TinyVector<size_t,3>& rhs):
            clx::range{rhs(0),rhs(1),rhs(2)} {}

        };

        class Pipeline: public clx::command_stack {

        private:
            clx::context _context;

        public:
            using clx::command_stack::command_stack;
            using clx::command_stack::copy;
            using clx::command_stack::kernel;

            inline void context(clx::context rhs) { this->_context = rhs; }
            inline const clx::context& context() const { return this->_context; }

            template <class T, int N>
            inline void allocate(const blitz::Array<T,N>& src, Buffer<T>& dst) {
                const auto& tmp = src.isStorageContiguous() ? src : src.copy();
                if (!tmp.isStorageContiguous()) {
                    throw std::logic_error("array is not contiguous");
                }
                dst.resize(context(), src.size());
            }

            template <class T, int N>
            inline void copy(const blitz::Array<T,N>& src, Buffer<T>& dst) {
                this->allocate<T,N>(src, dst);
                this->copy(src.data(), dst.slice(0, src.size()*sizeof(T)));
            }

            template <class T, int N>
            inline void copy(const Buffer<T>& src, blitz::Array<T,N>& dst) {
                if (!dst.isStorageContiguous()) {
                    throw std::logic_error("array is not contiguous");
                }
                this->copy(src.slice(0,dst.size()*sizeof(T)), dst.data());
            }

            template <class T>
            inline void allocate(const std::vector<T>& src, Buffer<T>& dst) {
                dst.resize(context(), src.size());
            }

            template <class T>
            inline void copy(const std::vector<T>& src, Buffer<T>& dst) {
                const auto size = src.size();
                dst.resize(context(), size);
                this->copy(src.data(), dst.slice(0, size*sizeof(T)));
            }

            template <class T>
            inline void copy(const Buffer<T>& src, std::vector<T>& dst) {
                this->copy(src.slice(0,dst.size()*sizeof(T)), dst.data());
            }

            inline void copy(const void* src, size_t size, clx::buffer& dst) {
                ::vtb::opencl::resize(context(), dst, size);
                this->copy(src, dst.slice(0, size));
            }

            template <class T>
            inline void allocate(size_t size, Buffer<T>& dst) {
                dst.resize(context(), size);
            }

            template <class T, int N>
            inline void allocate(const blitz::TinyVector<int,N>& shape, Buffer<T>& dst) {
                dst.resize(context(), product(shape));
            }

            template <int N>
            inline void
            kernel(const clx::kernel& k, const blitz::TinyVector<int,N>& global) {
                this->kernel(k, NDRange{global});
            }

            template <int N>
            inline void
            kernel(
                const clx::kernel& k,
                const blitz::TinyVector<int,N>& global,
                const blitz::TinyVector<int,N>& local
            ) {
                this->kernel(k, NDRange{global}, NDRange{local});
            }

            template <int N>
            inline void
            kernel(
                const clx::kernel& k,
                const blitz::TinyVector<int,N>& offset,
                const blitz::TinyVector<int,N>& global,
                const blitz::TinyVector<int,N>& local
            ) {
                this->kernel(k, NDRange{offset}, NDRange{global}, NDRange{local});
            }

        };

    }

}

#endif // vim:filetype=cpp