sycl_usm.hpp

Go to the documentation of this file.

#pragma once

 
#ifdef ORRERY_ENABLE_SYCL
 
#    include <cstddef>
#    include <cstdint>
#    include <new>
#    include <span>
#    include <utility>
 
#    include <sycl/sycl.hpp>
 
namespace orrery::backend {

enum class UsmKind : std::uint8_t {
    kUnknown,

    kHost,

    kDevice,

    kShared,
};
 
[[nodiscard]] constexpr const char* to_string(UsmKind kind) noexcept {
    switch (kind) {
    case UsmKind::kHost:
        return "host";
    case UsmKind::kDevice:
        return "device";
    case UsmKind::kShared:
        return "shared";
    case UsmKind::kUnknown:
        break;
    }
    return "unknown";
}

[[nodiscard]] UsmKind allocation_kind(const void* pointer, const sycl::queue& queue) noexcept;

template<typename T> class UsmArray {
public:
    UsmArray() noexcept = default;

    UsmArray(sycl::queue& queue, std::size_t count)
        : queue_(&queue),
          size_(count),
          data_(count == 0 ? nullptr
                           : sycl::aligned_alloc_shared<T>(kAlignmentBytes, count, queue)) {
        if (count != 0 && data_ == nullptr) {
            throw std::bad_alloc{};
        }
    }
 
    ~UsmArray() { release(); }
 
    UsmArray(const UsmArray&) = delete;
    UsmArray& operator=(const UsmArray&) = delete;
 
    UsmArray(UsmArray&& other) noexcept
        : queue_(std::exchange(other.queue_, nullptr)),
          size_(std::exchange(other.size_, 0)),
          data_(std::exchange(other.data_, nullptr)) {}
 
    UsmArray& operator=(UsmArray&& other) noexcept {
        if (this != &other) {
            release();
            queue_ = std::exchange(other.queue_, nullptr);
            size_ = std::exchange(other.size_, 0);
            data_ = std::exchange(other.data_, nullptr);
        }
        return *this;
    }

    [[nodiscard]] T* data() const noexcept { return data_; }
 
    [[nodiscard]] std::size_t size() const noexcept { return size_; }
 
    [[nodiscard]] bool empty() const noexcept { return size_ == 0; }
 
    [[nodiscard]] std::span<T> span() const noexcept { return {data_, size_}; }
 
private:
    static constexpr std::size_t kAlignmentBytes = 64;
 
    void release() noexcept {
        if (data_ != nullptr && queue_ != nullptr) {
            sycl::free(data_, *queue_);
        }
        data_ = nullptr;
        size_ = 0;
        queue_ = nullptr;
    }

    sycl::queue* queue_{nullptr};
    std::size_t size_{0};
    T* data_{nullptr};
};
 
} // namespace orrery::backend
 
#endif // ORRERY_ENABLE_SYCL