plain_wave_generator_opencl.cc

#include <vtestbed/config/real_type.hh>
#include <vtestbed/core/cosine_wave.hh>
#include <vtestbed/core/stokes_wave.hh>
#include <vtestbed/core/plain_wave_generator.hh>
#include <vtestbed/opencl/opencl.hh>
#include <vtestbed/opencl/vector.hh>

using namespace vtb::opencl;

namespace {

    template <class T> struct Function_name;

    template <class T,int N>
    struct Function_name<vtb::core::Propagating_cosine_wave<T,N>> {
        static constexpr const char* value = "propagating_cosine_wave";
    };

    template <class T,int N>
    struct Function_name<vtb::core::Standing_cosine_wave<T,N>> {
        static constexpr const char* value = "standing_cosine_wave";
    };

    template <class T,int N>
    struct Function_name<vtb::core::Propagating_stokes_wave<T,N>> {
        static constexpr const char* value = "propagating_stokes_wave";
    };

}

namespace vtb {

    namespace core {

        template <class T, int N, class Wave>
        class Plain_wave_generator_opencl:
            public Plain_wave_generator<T,N,Wave,Policy::OpenCL>,
            public Context_base {

        private:
            using base_type = Plain_wave_generator<T,N,Wave,Policy::OpenCL>;
            using typename base_type::grid_type;
            using typename base_type::array_type;

        private:
            clx::kernel _kernel;
            clx::buffer _d_surface;

        public:
            using base_type::base_type;

            void generate(const grid_type& grid, array_type& result) override {
                using vtb::opencl::resize;
                auto context = this->context();
                auto& ppl = context->pipeline();
                auto& kernel = this->_kernel;
                resize<T>(context->context(), this->_d_surface, result.size());
                kernel.argument(0, this->wave());
                kernel.argument(1, make_vector(grid.lbound()));
                kernel.argument(2, make_vector(grid.delta()));
                kernel.argument(3, make_vector(grid.shape()));
                kernel.argument(4, this->_d_surface);
                ppl.kernel(kernel, grid.shape());
                ppl.step();
                ppl.copy(this->_d_surface.slice(0,result.size()*sizeof(T)), result.data());
                ppl.wait();
            }

            using Context_base::context;

            void context(Context* rhs) override {
                Context_base::context(rhs);
                auto cc = context()->compiler_copy();
                if (!std::is_same<T,VTB_REAL_TYPE>::value) {
                    auto options = cc.options();
                    std::string old_flags = real_type_flags();
                    auto pos = options.find(old_flags);
                    if (pos != std::string::npos) {
                        options.erase(pos, old_flags.size());
                        options += real_type_flags<T>();
                        cc.options(options);
                    }
                }
                auto prog = cc.compile("plain_wave_generator.cl");
                this->_kernel = prog.kernel(Function_name<Wave>::value);
            };

        };

        template <class T, int N>
        std::unique_ptr<Wavy_surface_generator<T,N>>
        make_plain_wave_generator_opencl(std::any wave);

    }

}

#define VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(T,N,Wave) \
template <> \
auto \
vtb::core::make_plain_wave_generator(const Wave<T,N>& wave) \
-> std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenCL>> { \
    return std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenCL>>( \
        new Plain_wave_generator_opencl<T,N,Wave<T,N>>(wave) \
    ); \
} \
template <> \
auto \
vtb::core::make_plain_wave_generator() \
-> std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenCL>> { \
    return std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenCL>>( \
        new Plain_wave_generator_opencl<T,N,Wave<T,N>>() \
    ); \
}

VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,Propagating_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,Standing_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,Propagating_stokes_wave);
#if defined(VTB_REAL_TYPE_FLOAT)
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,Propagating_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,Standing_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,Propagating_stokes_wave);
#endif

template <class T, int N>
std::unique_ptr<vtb::core::Wavy_surface_generator<T,N>>
vtb::core::make_plain_wave_generator_opencl(std::any wave) {
    using pointer = std::unique_ptr<Wavy_surface_generator<T,N>>;
    using propagating_cosine = Propagating_cosine_wave<T,N>;
    using standing_cosine = Standing_cosine_wave<T,N>;
    using propagating_stokes = Propagating_stokes_wave<T,N>;
    if (wave.type() == typeid(propagating_cosine)) {
        return pointer(new Plain_wave_generator_opencl<T,N,propagating_cosine>(
                std::any_cast<propagating_cosine>(wave)));
    }
    if (wave.type() == typeid(standing_cosine)) {
        return pointer(new Plain_wave_generator_opencl<T,N,standing_cosine>(
                std::any_cast<standing_cosine>(wave)));
    }
    if (wave.type() == typeid(propagating_stokes)) {
        return pointer(new Plain_wave_generator_opencl<T,N,propagating_stokes>(
                std::any_cast<propagating_stokes>(wave)));
    }
    throw std::invalid_argument("bad wave");
}

template std::unique_ptr<vtb::core::Wavy_surface_generator<VTB_REAL_TYPE,3>>
vtb::core::make_plain_wave_generator_opencl<VTB_REAL_TYPE,3>(std::any wave);
#if defined(VTB_REAL_TYPE_FLOAT)
template std::unique_ptr<vtb::core::Wavy_surface_generator<double,3>>
vtb::core::make_plain_wave_generator_opencl<double,3>(std::any wave);
#endif