databuffer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <stdexcept>
#include <vector>
 
#include <openpfc/core/backend_tags.hpp>
 
// CUDA headers (only when CUDA is enabled)
#if defined(OpenPFC_ENABLE_CUDA)
#include <cuda_runtime.h>
#endif
 
namespace pfc {
namespace core {
 
template <typename BackendTag, typename T> struct DataBuffer;
 
template <typename T> struct DataBuffer<backend::CpuTag, T> {
private:
  std::vector<T> m_data;
 
public:
  explicit DataBuffer(size_t size) : m_data(size) {}
 
  DataBuffer() = default;
 
  DataBuffer(const DataBuffer &) = default;
 
  DataBuffer &operator=(const DataBuffer &) = default;
 
  DataBuffer(DataBuffer &&) noexcept = default;
 
  DataBuffer &operator=(DataBuffer &&) noexcept = default;
 
  ~DataBuffer() = default;
 
  T *data() { return m_data.data(); }
 
  const T *data() const { return m_data.data(); }
 
  size_t size() const { return m_data.size(); }
 
  bool empty() const { return m_data.empty(); }
 
  T &operator[](size_t i) { return m_data[i]; }
 
  const T &operator[](size_t i) const { return m_data[i]; }
 
  std::vector<T> &as_vector() { return m_data; }
 
  const std::vector<T> &as_vector() const { return m_data; }
 
  void copy_from_host(const std::vector<T> &src) {
    if (src.size() != m_data.size()) {
      throw std::runtime_error("Size mismatch in copy_from_host: expected " +
                               std::to_string(m_data.size()) + ", got " +
                               std::to_string(src.size()));
    }
    std::copy(src.begin(), src.end(), m_data.begin());
  }
 
  std::vector<T> to_host() const { return m_data; }
 
  void resize(size_t new_size) { m_data.resize(new_size); }
};
 
#if defined(OpenPFC_ENABLE_CUDA)
template <typename T> struct DataBuffer<backend::CudaTag, T> {
private:
  T *m_device_ptr = nullptr;
  size_t m_size = 0;
 
public:
  explicit DataBuffer(size_t size) : m_size(size) {
    if (size > 0) {
      cudaError_t err = cudaMalloc(&m_device_ptr, size * sizeof(T));
      if (err != cudaSuccess) {
        throw std::runtime_error("CUDA allocation failed: " +
                                 std::string(cudaGetErrorString(err)));
      }
    }
  }
 
  DataBuffer() = default;
 
  ~DataBuffer() {
    if (m_device_ptr != nullptr) {
      cudaFree(m_device_ptr);
    }
  }
 
  DataBuffer(const DataBuffer &) = delete;
 
  DataBuffer &operator=(const DataBuffer &) = delete;
 
  DataBuffer(DataBuffer &&other) noexcept
      : m_device_ptr(other.m_device_ptr), m_size(other.m_size) {
    other.m_device_ptr = nullptr;
    other.m_size = 0;
  }
 
  DataBuffer &operator=(DataBuffer &&other) noexcept {
    if (this != &other) {
      if (m_device_ptr != nullptr) {
        cudaFree(m_device_ptr);
      }
      m_device_ptr = other.m_device_ptr;
      m_size = other.m_size;
      other.m_device_ptr = nullptr;
      other.m_size = 0;
    }
    return *this;
  }
 
  T *data() { return m_device_ptr; }
 
  const T *data() const { return m_device_ptr; }
 
  size_t size() const { return m_size; }
 
  bool empty() const { return m_size == 0; }
 
  // Note: No operator[] - can't dereference device pointer on host!
 
  void copy_from_host(const std::vector<T> &src) {
    if (src.size() != m_size) {
      throw std::runtime_error("Size mismatch in copy_from_host: expected " +
                               std::to_string(m_size) + ", got " +
                               std::to_string(src.size()));
    }
    if (m_size > 0) {
      cudaError_t err = cudaMemcpy(m_device_ptr, src.data(), m_size * sizeof(T),
                                   cudaMemcpyHostToDevice);
      if (err != cudaSuccess) {
        throw std::runtime_error("CUDA copy failed: " +
                                 std::string(cudaGetErrorString(err)));
      }
    }
  }
 
  std::vector<T> to_host() const {
    std::vector<T> result(m_size);
    if (m_size > 0) {
      cudaError_t err = cudaMemcpy(result.data(), m_device_ptr, m_size * sizeof(T),
                                   cudaMemcpyDeviceToHost);
      if (err != cudaSuccess) {
        throw std::runtime_error("CUDA copy failed: " +
                                 std::string(cudaGetErrorString(err)));
      }
    }
    return result;
  }
 
  void resize(size_t new_size) {
    if (m_device_ptr != nullptr) {
      cudaFree(m_device_ptr);
      m_device_ptr = nullptr;
    }
    m_size = new_size;
    if (new_size > 0) {
      cudaError_t err = cudaMalloc(&m_device_ptr, new_size * sizeof(T));
      if (err != cudaSuccess) {
        throw std::runtime_error("CUDA allocation failed: " +
                                 std::string(cudaGetErrorString(err)));
      }
    }
  }
};
#endif // OpenPFC_ENABLE_CUDA
 
#if defined(OpenPFC_ENABLE_HIP)
template <typename T> struct DataBuffer<backend::HipTag, T> {
private:
  T *m_device_ptr = nullptr;
  size_t m_size = 0;
 
public:
  explicit DataBuffer(size_t size) : m_size(size) {
    if (size > 0) {
      hipError_t err = hipMalloc(&m_device_ptr, size * sizeof(T));
      if (err != hipSuccess) {
        throw std::runtime_error("HIP allocation failed: " +
                                 std::string(hipGetErrorString(err)));
      }
    }
  }
 
  DataBuffer() = default;
 
  ~DataBuffer() {
    if (m_device_ptr != nullptr) {
      hipFree(m_device_ptr);
    }
  }
 
  DataBuffer(const DataBuffer &) = delete;
 
  DataBuffer &operator=(const DataBuffer &) = delete;
 
  DataBuffer(DataBuffer &&other) noexcept
      : m_device_ptr(other.m_device_ptr), m_size(other.m_size) {
    other.m_device_ptr = nullptr;
    other.m_size = 0;
  }
 
  DataBuffer &operator=(DataBuffer &&other) noexcept {
    if (this != &other) {
      if (m_device_ptr != nullptr) {
        hipFree(m_device_ptr);
      }
      m_device_ptr = other.m_device_ptr;
      m_size = other.m_size;
      other.m_device_ptr = nullptr;
      other.m_size = 0;
    }
    return *this;
  }
 
  T *data() { return m_device_ptr; }
 
  const T *data() const { return m_device_ptr; }
 
  size_t size() const { return m_size; }
 
  bool empty() const { return m_size == 0; }
 
  // Note: No operator[] - can't dereference device pointer on host!
 
  void copy_from_host(const std::vector<T> &src) {
    if (src.size() != m_size) {
      throw std::runtime_error("Size mismatch in copy_from_host: expected " +
                               std::to_string(m_size) + ", got " +
                               std::to_string(src.size()));
    }
    if (m_size > 0) {
      hipError_t err = hipMemcpy(m_device_ptr, src.data(), m_size * sizeof(T),
                                 hipMemcpyHostToDevice);
      if (err != hipSuccess) {
        throw std::runtime_error("HIP copy failed: " +
                                 std::string(hipGetErrorString(err)));
      }
    }
  }
 
  std::vector<T> to_host() const {
    std::vector<T> result(m_size);
    if (m_size > 0) {
      hipError_t err = hipMemcpy(result.data(), m_device_ptr, m_size * sizeof(T),
                                 hipMemcpyDeviceToHost);
      if (err != hipSuccess) {
        throw std::runtime_error("HIP copy failed: " +
                                 std::string(hipGetErrorString(err)));
      }
    }
    return result;
  }
 
  void resize(size_t new_size) {
    if (m_device_ptr != nullptr) {
      hipFree(m_device_ptr);
      m_device_ptr = nullptr;
    }
    m_size = new_size;
    if (new_size > 0) {
      hipError_t err = hipMalloc(&m_device_ptr, new_size * sizeof(T));
      if (err != hipSuccess) {
        throw std::runtime_error("HIP allocation failed: " +
                                 std::string(hipGetErrorString(err)));
      }
    }
  }
};
#endif // OpenPFC_ENABLE_HIP
 
} // namespace core
} // namespace pfc