gpu_device_ptr.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_BACKENDS_GPU_DEVICE_PTR_HPP_
#define PLSSVM_BACKENDS_GPU_DEVICE_PTR_HPP_
#pragma once
 
#include <cstddef>      // std::size_t
#include <type_traits>  // std::is_same_v
#include <vector>       // std::vector
 
namespace plssvm::detail {
 
template <typename T, typename queue_t, typename device_pointer_t = T *>
class gpu_device_ptr {
    // any non-reference arithmetic type
    static_assert(std::is_same_v<float, T> || std::is_same_v<double, T>, "Currently only 'float' or 'double' are allowed!");
 
  public:
    using value_type = T;
    using host_pointer_type = value_type *;
    using const_host_pointer_type = const value_type *;
    using size_type = std::size_t;
    using queue_type = queue_t;
    using device_pointer_type = device_pointer_t;
 
    gpu_device_ptr() = default;
    gpu_device_ptr(size_type size, const queue_type queue);
 
    gpu_device_ptr(const gpu_device_ptr &) = delete;
    gpu_device_ptr(gpu_device_ptr &&other) noexcept;
 
    gpu_device_ptr &operator=(const gpu_device_ptr &) = delete;
    gpu_device_ptr &operator=(gpu_device_ptr &&other) noexcept;
 
    virtual ~gpu_device_ptr() = default;
 
    void swap(gpu_device_ptr &other) noexcept;
    friend void swap(gpu_device_ptr &lhs, gpu_device_ptr &rhs) noexcept { lhs.swap(rhs); }
 
    [[nodiscard]] explicit operator bool() const noexcept {
        return data_ != device_pointer_type{};
    }
    [[nodiscard]] device_pointer_type get() noexcept {
        return data_;
    }
    [[nodiscard]] device_pointer_type get() const noexcept {
        return data_;
    }
    [[nodiscard]] size_type size() const noexcept {
        return size_;
    }
    [[nodiscard]] bool empty() const noexcept {
        return size_ == 0;
    }
    [[nodiscard]] queue_type queue() const noexcept {
        return queue_;
    }
 
    void memset(int pattern, size_type pos = 0);
    virtual void memset(int pattern, size_type pos, size_type num_bytes) = 0;
 
    void fill(value_type value, size_type pos = 0);
    virtual void fill(value_type value, size_type pos, size_type count) = 0;
 
    void copy_to_device(const std::vector<value_type> &data_to_copy);
    void copy_to_device(const std::vector<value_type> &data_to_copy, size_type pos, size_type count);
    void copy_to_device(const_host_pointer_type data_to_copy);
    virtual void copy_to_device(const_host_pointer_type data_to_copy, size_type pos, size_type count) = 0;
 
    void copy_to_host(std::vector<value_type> &buffer) const;
    void copy_to_host(std::vector<value_type> &buffer, size_type pos, size_type count) const;
    void copy_to_host(host_pointer_type buffer) const;
    virtual void copy_to_host(host_pointer_type buffer, size_type pos, size_type count) const = 0;
 
  protected:
    queue_type queue_{};
    device_pointer_type data_{};
    size_type size_{ 0 };
};
 
}  // namespace plssvm::detail
 
#endif  // PLSSVM_BACKENDS_GPU_DEVICE_PTR_HPP_