utility.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_BACKENDS_OPENCL_DETAIL_UTILITY_HPP_
#define PLSSVM_BACKENDS_OPENCL_DETAIL_UTILITY_HPP_
#pragma once
 
#include "plssvm/backends/OpenCL/detail/command_queue.hpp"  // plssvm::opencl::detail::command_queue
#include "plssvm/backends/OpenCL/detail/context.hpp"        // plssvm::opencl::detail::context
#include "plssvm/backends/OpenCL/detail/error_code.hpp"     // plssvm::opencl::detail::error_code
#include "plssvm/backends/OpenCL/detail/kernel.hpp"         // plssvm::opencl::detail::compute_kernel_name
#include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
#include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
#include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 
#include "CL/cl.h"                                          // cl_uint, cl_int, clSetKernelArg, clEnqueueNDRangeKernel, clFinish
 
#include "fmt/core.h"                                       // fmt::format
 
#include <cstddef>                                          // std::size_t
#include <string>                                           // std::string
#include <string_view>                                      // std::string_view
#include <utility>                                          // std::forward, std::pair
#include <vector>                                           // std::vector
 
#define PLSSVM_OPENCL_ERROR_CHECK(err, ...) plssvm::opencl::detail::device_assert((err), ##__VA_ARGS__)
 
namespace plssvm::opencl::detail {
 
void device_assert(error_code code, std::string_view msg = "");
 
[[nodiscard]] std::pair<std::vector<context>, target_platform> get_contexts(target_platform target);
 
void device_synchronize(const command_queue &queue);
 
[[nodiscard]] std::string get_device_name(const command_queue &queue);
 
[[nodiscard]] std::vector<std::pair<compute_kernel_name, std::string>> kernel_type_to_function_names(kernel_function_type kernel);
 
[[nodiscard]] std::vector<command_queue> create_command_queues(const std::vector<context> &contexts, target_platform target, const std::vector<std::pair<compute_kernel_name, std::string>> &kernel_names);
 
template <typename... Args>
inline void set_kernel_args(cl_kernel kernel, Args... args) {
    cl_uint i = 0;
    // iterate over parameter pack and set OpenCL kernel
    ([&](auto &arg) {
        const error_code ec = clSetKernelArg(kernel, i++, sizeof(decltype(arg)), &arg);
        PLSSVM_OPENCL_ERROR_CHECK(ec, fmt::format("error setting OpenCL kernel argument {}", i - 1));
    }(args),
     ...);
}
 
template <typename... Args>
inline void run_kernel(const command_queue &queue, cl_kernel kernel, const std::vector<std::size_t> &grid_size, const std::vector<std::size_t> &block_size, Args &&...args) {
    PLSSVM_ASSERT(grid_size.size() == block_size.size(), "grid_size and block_size must have the same number of dimensions!: {} != {}", grid_size.size(), block_size.size());
    PLSSVM_ASSERT(grid_size.size() <= 3, "The number of dimensions must be less or equal than 3!: {} > 3", grid_size.size());
 
    // set kernel arguments
    set_kernel_args(kernel, std::forward<Args>(args)...);
 
    // enqueue kernel in command queue
    PLSSVM_OPENCL_ERROR_CHECK(clEnqueueNDRangeKernel(queue, kernel, static_cast<cl_int>(grid_size.size()), nullptr, grid_size.data(), block_size.data(), 0, nullptr, nullptr), "error enqueuing OpenCL kernel");
    // wait until kernel computation finished
    PLSSVM_OPENCL_ERROR_CHECK(clFinish(queue), "error running OpenCL kernel");
}
 
template <typename... Args>
inline void run_kernel(const command_queue &queue, cl_kernel kernel, std::size_t grid_size, std::size_t block_size, Args &&...args) {
    run_kernel(queue, kernel, std::vector<std::size_t>{ grid_size }, std::vector<std::size_t>{ block_size }, std::forward<Args>(args)...);
}
 
}  // namespace plssvm::opencl::detail
 
#endif  // PLSSVM_BACKENDS_OPENCL_DETAIL_UTILITY_HPP_