sparse_vector_ops.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 <initializer_list>
#include <vector>
 
#include <openpfc/core/backend_tags.hpp>
#include <openpfc/core/sparse_vector.hpp>
 
#if defined(OpenPFC_ENABLE_CUDA)
#include <cuda_runtime.h>
#endif
 
namespace pfc {
namespace core {
 
template <typename BackendTag, typename T>
void gather(SparseVector<BackendTag, T> &sparse_vector, const T *source,
            size_t source_size) {
  if (sparse_vector.empty()) {
    return;
  }
 
  if constexpr (std::is_same_v<BackendTag, backend::CpuTag>) {
    // CPU: Direct indexed access
    const auto &indices = sparse_vector.indices();
    T *data = sparse_vector.data().data();
    for (size_t i = 0; i < sparse_vector.size(); ++i) {
      size_t idx = indices.data()[i];
      if (idx >= source_size) {
        throw std::runtime_error("gather: index out of bounds");
      }
      data[i] = source[idx];
    }
  }
#if defined(OpenPFC_ENABLE_CUDA)
  else if constexpr (std::is_same_v<BackendTag, backend::CudaTag>) {
    // CUDA: Use kernel for indexed gather
    // TODO: Implement CUDA kernel
    throw std::runtime_error("CUDA gather not yet implemented");
  }
#endif
}
 
template <typename T>
void gather(core::SparseVector<backend::CpuTag, T> &sparse_vector,
            const std::vector<T> &source) {
  gather(sparse_vector, source.data(), source.size());
}
 
template <typename T>
void gather(core::SparseVector<backend::CpuTag, T> &sparse_vector,
            std::initializer_list<T> source) {
  std::vector<T> vec(source);
  gather(sparse_vector, vec);
}
 
template <typename BackendTag, typename T>
void scatter(const SparseVector<BackendTag, T> &sparse_vector, T *dest,
             size_t dest_size) {
  if (sparse_vector.empty()) {
    return;
  }
 
  if constexpr (std::is_same_v<BackendTag, backend::CpuTag>) {
    // CPU: Direct indexed access
    const auto &indices = sparse_vector.indices();
    const T *data = sparse_vector.data().data();
    for (size_t i = 0; i < sparse_vector.size(); ++i) {
      size_t idx = indices.data()[i];
      if (idx >= dest_size) {
        throw std::runtime_error("scatter: index out of bounds");
      }
      dest[idx] = data[i];
    }
  }
#if defined(OpenPFC_ENABLE_CUDA)
  else if constexpr (std::is_same_v<BackendTag, backend::CudaTag>) {
    // CUDA: Use kernel for indexed scatter
    // TODO: Implement CUDA kernel
    throw std::runtime_error("CUDA scatter not yet implemented");
  }
#endif
}
 
template <typename T>
void scatter(const core::SparseVector<backend::CpuTag, T> &sparse_vector,
             std::vector<T> &dest) {
  scatter(sparse_vector, dest.data(), dest.size());
}
 
} // namespace core
 
// Make gather/scatter available in global namespace for backward compatibility
using core::gather;
using core::scatter;
 
} // namespace pfc