cl_manager.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/opencl/cl_manager.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_OPENCL_CL_MANAGER_HPP
#define VSMC_OPENCL_CL_MANAGER_HPP

#include <vsmc/internal/common.hpp>
#include <vsmc/opencl/cl_setup.hpp>
#include <vsmc/opencl/cl_manip.hpp>
#include <vsmc/opencl/cl_query.hpp>
#include <vsmc/opencl/internal/cl_wrapper.hpp>
#include <vsmc/utility/stop_watch.hpp>

#define VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(func) \
    VSMC_RUNTIME_ASSERT((setup()),                                           \
            ("**CLManager::"#func"** CAN ONLY BE CALLED AFTER TRUE "         \
             "**CLManager::setup**"));

#define VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_PLATFORM \
    VSMC_RUNTIME_WARNING(setup_platform,                                     \
            ("**CLManager::setup** FAILED TO SETUP A PLATFORM"));

#define VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_CONTEXT \
    VSMC_RUNTIME_WARNING(setup_context,                                      \
            ("**CLManager::setup** FAILED TO SETUP A CONTEXT"));

#define VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_DEVICE \
    VSMC_RUNTIME_WARNING(setup_device,                                       \
            ("**CLManager::setup** FAILED TO SETUP A DEVICE"));

#define VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_COMMAND_QUEUE \
    VSMC_RUNTIME_WARNING(setup_command_queue,                                \
            ("**CLManager::setup** FAILED TO SETUP A COMMAND_QUEUE"));

#define VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(func, block, event) \
    VSMC_RUNTIME_WARNING((block || event != VSMC_NULLPTR),                   \
            ("**CLManager::"#func" NOT BLOCKING BUT WITH NULL EVENT"))

namespace vsmc {

template <typename ID = CLDefault>
class CLManager
{
    public :

    typedef ID cl_id;

    static CLManager<ID> &instance ()
    {
        static CLManager<ID> manager;

        return manager;
    }

    int opencl_version () const {return opencl_version_;}

    int opencl_c_version () const {return opencl_c_version_;}

    const ::cl::Platform &platform () const {return platform_;}

    const ::cl::Context &context () const {return context_;}

    const ::cl::Device &device () const {return device_;}

    const std::vector< ::cl::Device> &device_vec () const {return device_vec_;}

    const ::cl::CommandQueue &command_queue () const {return command_queue_;}

    bool setup () const {return setup_;}

    bool setup (::cl_device_type dev)
    {
        setup_ = false;
        setup_cl_manager(dev);

        return setup_;
    }

    bool setup (const ::cl::Platform &plat, const ::cl::Context &ctx,
            const ::cl::Device &dev, const ::cl::CommandQueue &cmd)
    {
        setup_ = false;
        platform_ = plat;
        context_ = ctx;
        device_ = dev;
        device_vec_ = context_.getInfo<CL_CONTEXT_DEVICES>();
        command_queue_ = cmd;
        check_opencl_version();
        setup_ = true;

        return setup_;
    }

    template <typename CLType>
    ::cl::Buffer create_buffer (std::size_t num,
            ::cl_mem_flags flag = CL_MEM_READ_WRITE,
            void *host_ptr = VSMC_NULLPTR) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(create_buffer);

        if (num == 0)
            return ::cl::Buffer();

        return ::cl::Buffer(context_, flag, sizeof(CLType) * num, host_ptr);
    }

    template <typename CLType, typename OutputIter>
    void read_buffer (const ::cl::Buffer &buf, std::size_t num,
            OutputIter first, std::size_t offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(read_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(read_buffer, block,
                event);

        std::vector<CLType> buffer(num);
        command_queue_.enqueueReadBuffer(buf, static_cast< ::cl_bool>(block),
                sizeof(CLType) * offset, sizeof(CLType) * num,
                &buffer[0], events, event);
        std::copy(buffer.begin(), buffer.end(), first);
    }

    template <typename CLType>
    void read_buffer (const ::cl::Buffer &buf, std::size_t num,
            CLType *first, std::size_t offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(read_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(read_buffer, block,
                event);

        command_queue_.enqueueReadBuffer(buf, static_cast< ::cl_bool>(block),
                sizeof(CLType) * offset, sizeof(CLType) * num,
                first, events, event);
    }

    template <typename CLType, typename InputIter>
    void write_buffer (const ::cl::Buffer &buf, std::size_t num,
            InputIter first, std::size_t offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(write_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(write_buffer, block,
                event);

        std::vector<CLType> buffer(num);
#if VSMC_HAS_CXX11LIB_ALGORITHM
        std::copy_n(first, num, &buffer[0]);
#else
        for (std::size_t i = 0; i != num; ++i, ++first)
            buffer[i] = *first;
#endif
        command_queue_.enqueueWriteBuffer(buf, static_cast< ::cl_bool>(block),
                sizeof(CLType) * offset, sizeof(CLType) * num,
                &buffer[0], events, event);
    }

    template <typename CLType>
    void write_buffer (const ::cl::Buffer &buf, std::size_t num,
            const CLType *first, std::size_t offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(write_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(write_buffer, block,
                event);

        command_queue_.enqueueWriteBuffer(buf, static_cast< ::cl_bool>(block),
                sizeof(CLType) * offset, sizeof(CLType) * num,
                const_cast<CLType *>(first), events, event);
    }

    template <typename CLType>
    void write_buffer (const ::cl::Buffer &buf, std::size_t num,
            CLType *first, std::size_t offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(write_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(write_buffer, block,
                event);

        command_queue_.enqueueWriteBuffer(buf, static_cast< ::cl_bool>(block),
                sizeof(CLType) * offset, sizeof(CLType) * num,
                first, events, event);
    }

    template <typename CLType>
    void copy_buffer (const ::cl::Buffer &src, const ::cl::Buffer &dst,
            std::size_t num,
            std::size_t src_offset = 0, std::size_t dst_offset = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_ASSERT_OPENCL_CL_MANAGER_SETUP(copy_buffer);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(copy_buffer, block,
                event);

        ::cl::Event e;
        ::cl::Event *eptr = event == VSMC_NULLPTR ? &e : event;
        command_queue_.enqueueCopyBuffer(src, dst,
                sizeof(CLType) * src_offset, sizeof(CLType) * dst_offset,
                sizeof(CLType) * num, events, eptr);
        if (block)
            eptr->wait();
    }

    void run_kernel (const ::cl::Kernel &kern, std::size_t N,
            std::size_t local_size = 0,
            const std::vector< ::cl::Event> *events = VSMC_NULLPTR,
            ::cl::Event *event = VSMC_NULLPTR, bool block = true) const
    {
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_BLOCK(run_kernel, block, event);

        ::cl::Event e;
        ::cl::Event *eptr = event == VSMC_NULLPTR ? &e : event;
        command_queue_.enqueueNDRangeKernel(kern, ::cl::NullRange,
                get_global_nd_range(N, local_size),
                get_local_nd_range(local_size), events, eptr);
        if (block)
            eptr->wait();
    }

    template <typename Func>
    typename cxx11::enable_if<
    !cxx11::is_same<Func, std::size_t>::value &&
    !cxx11::is_convertible<Func, std::size_t>::value, std::size_t>::type
    profile_kernel (::cl::Kernel &kern, std::size_t N,
            const Func &func, std::size_t lmin = 0, std::size_t repeat = 10)
    {
        cl::size_t<3> reqd_size;
        try {
            kern.getWorkGroupInfo(device_,
                    CL_KERNEL_COMPILE_WORK_GROUP_SIZE, &reqd_size);
        } catch (const ::cl::Error &) {
            reqd_size[0] = 0;
        }

        if (reqd_size[0] != 0)
            return reqd_size[0];

        std::size_t factor;
        std::size_t lmax;
        std::size_t mmax;
        cl_minmax_local_size(kern, device_, factor, lmax, mmax);
        if (lmax == 0)
            return 0;

        if (lmin != 0 && lmin <= lmax) {
            factor = lmin;
            mmax = lmax / factor;
            lmax = mmax * factor;
        }

        if (mmax < 2)
            return lmax;

        double time = std::numeric_limits<double>::max VSMC_MNE ();
        std::size_t lsize = lmax;
        vsmc::StopWatch watch;
        Func f(func);
        for (std::size_t m = mmax; m >= 1; --m) {
            std::size_t l = m * factor;
            f(kern);
            run_kernel(kern, N, l);
            watch.reset();
            watch.start();
            for (std::size_t r = 0; r != repeat; ++r) {
                f(kern);
                run_kernel(kern, N, l);
            }
            watch.stop();
            if (time > watch.milliseconds()) {
                time = watch.milliseconds();
                lsize = l;
            }
        }

        return lsize;
    }

    std::size_t profile_kernel (::cl::Kernel &kern, std::size_t N,
            std::size_t lmin = 0, std::size_t repeat = 3)
    {return profile_kernel(kern, N, profile_kernel_func_(), lmin, repeat);}

    ::cl::Program create_program (const std::string &source) const
    {return ::cl::Program(context_, source);}

    ::cl::Program create_program (const std::vector<std::string> &source) const
    {
        std::vector<std::pair<const char *, std::size_t> > src(source.size());
        for (std::size_t i = 0; i != source.size(); ++i)
            src[i] = std::make_pair(source[i].data(), source[i].size());

        return ::cl::Program(context_, src);
    }

    ::cl::Program create_program (const std::vector<std::string> &binary,
            const std::vector< ::cl::Device> *devices,
            std::vector< ::cl_int> *status = VSMC_NULLPTR) const
    {
        std::vector<std::pair<const void *, std::size_t> > bin(binary.size());
        for (std::size_t i = 0; i != binary.size(); ++i) {
            bin[i] = std::make_pair(
                    static_cast<const void *>(binary[i].data()),
                    binary[i].size());
        }

        return devices == VSMC_NULLPTR ?
            ::cl::Program(context_, device_vec_, bin, status):
            ::cl::Program(context_, *devices, bin, status);
    }

    private :

    struct profile_kernel_func_ {void operator() (::cl::Kernel &) const {}};

    ::cl::Platform platform_;
    ::cl::Context context_;
    ::cl::Device device_;
    std::vector< ::cl::Device> device_vec_;
    ::cl::CommandQueue command_queue_;

    bool setup_;
    CLSetup<ID> &setup_default_;
    int opencl_version_;
    int opencl_c_version_;

    CLManager () : setup_(false), setup_default_(CLSetup<ID>::instance())
    {setup_cl_manager(setup_default_.device_type());}

    CLManager (const CLManager<ID> &);

    CLManager<ID> &operator= (const CLManager<ID> &);

    void check_opencl_version ()
    {
        opencl_version_ = CLQuery::opencl_version(device_);
        opencl_c_version_ = CLQuery::opencl_c_version(device_);
        for (std::size_t i = 0; i != device_vec_.size(); ++i) {
            int ocl = CLQuery::opencl_version(device_vec_[i]);
            int oclc = CLQuery::opencl_c_version(device_vec_[i]);
            if (opencl_version_ > ocl)
                opencl_version_ = ocl;
            if (opencl_c_version_ > ocl)
                opencl_c_version_ = oclc;
        }
    }

    void setup_cl_manager (::cl_device_type dev_type)
    {
        setup_ = false;

        bool setup_platform = platform_filter(dev_type);
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_PLATFORM;
        if (!setup_platform) return;

        bool setup_context = false;
        bool setup_device = false;
        try {
            std::vector< ::cl::Device> dev_pool;
            std::vector< ::cl::Device> dev_select;
            platform_.getDevices(dev_type, &dev_pool);
            device_filter(dev_pool, dev_select);
            if (dev_select.size() != 0) {
                ::cl_context_properties context_properties[] = {
                    CL_CONTEXT_PLATFORM,
                    reinterpret_cast< ::cl_context_properties>(platform_()), 0
                };
                context_ = ::cl::Context(dev_select, context_properties);
                setup_context = true;
                device_vec_ = context_.getInfo<CL_CONTEXT_DEVICES>();
                device_ = device_vec_[0];
                setup_device = true;
            }
        } catch (const ::cl::Error &) {}
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_CONTEXT;
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_DEVICE;
        if (!setup_context) return;
        if (!setup_device) return;

        bool setup_command_queue = false;
        try {
            command_queue_ = ::cl::CommandQueue(context_, device_, 0);
            setup_command_queue = true;
        } catch (const ::cl::Error &) {}
        VSMC_RUNTIME_WARNING_OPENCL_CL_MANAGER_SETUP_COMMAND_QUEUE;
        if (!setup_command_queue) return;

        check_opencl_version();

        setup_ = true;
    }

    bool platform_filter (::cl_device_type dev_type)
    {
        std::vector< ::cl::Platform> platform_vec;
        try {
            ::cl::Platform::get(&platform_vec);
        } catch (const ::cl::Error &) {
            platform_vec.clear();
        }
        if (platform_vec.size() == 0)
            return false;

        // If not using default platform
        if (!setup_default_.default_platform()) {
            for (std::size_t p = 0; p != platform_vec.size(); ++p) {
                try {
                    std::string name;
                    platform_vec[p].getInfo(CL_PLATFORM_NAME, &name);
                    if (setup_default_.check_platform(name)) {
                        platform_ = platform_vec[p];
                        return true;
                    }
                } catch (const ::cl::Error &) {}
            }

            return false;
        }

        // Using default platform: finding the first that has the device type
        for (std::size_t p = 0; p != platform_vec.size(); ++p) {
            try {
                std::vector< ::cl::Device> dev_pool;
                std::vector< ::cl::Device> dev_select;
                platform_vec[p].getDevices(dev_type, &dev_pool);
                device_filter(dev_pool, dev_select);
                if (dev_select.size() != 0) {
                    platform_ = platform_vec[p];
                    return true;
                }
            } catch (const ::cl::Error &) {}
        }

        return false;
    }

    void device_filter (const std::vector< ::cl::Device> &dev_pool,
            std::vector< ::cl::Device> &dev_select)
    {
        std::vector<bool> dev_select_idx(dev_pool.size(), true);

        // Not using the default device vendor
        if (!setup_default_.default_device_vendor()) {
            for (std::size_t d = 0; d != dev_pool.size(); ++d) {
                try {
                    std::string str;
                    dev_pool[d].getInfo(CL_DEVICE_VENDOR, &str);
                    if (!setup_default_.check_device_vendor(str))
                        dev_select_idx[d] = false;
                } catch (const ::cl::Error &) {
                    dev_select_idx[d] = false;
                }
            }
        }

        // Not using the default device
        if (!setup_default_.default_device()) {
            for (std::size_t d = 0; d != dev_pool.size(); ++d) {
                try {
                    std::string str;
                    dev_pool[d].getInfo(CL_DEVICE_NAME, &str);
                    if (!setup_default_.check_device(str))
                        dev_select_idx[d] = false;
                } catch (const ::cl::Error &) {
                    dev_select_idx[d] = false;
                }
            }
        }

        for (std::size_t d = 0; d != dev_pool.size(); ++d) {
            if (dev_select_idx[d]) {
                try {
                    dev_select.push_back(dev_pool[d]);
                } catch (const ::cl::Error &) {}
            }
        }
    }

    ::cl::NDRange get_global_nd_range (
            std::size_t N, std::size_t local_size) const
    {
        if (local_size == 0)
            return ::cl::NDRange(N);

        if (N % local_size == 0)
            return ::cl::NDRange(N);

        return ::cl::NDRange((N / local_size + 1) * local_size);
    }

    ::cl::NDRange get_local_nd_range (std::size_t local_size) const
    {return local_size == 0 ? ::cl::NullRange : ::cl::NDRange(local_size);}
}; // clss CLManager

} // namespace vsmc

#endif // VSMC_OPENCL_CL_MANAGER_HPP