fastx_pinned_buffer.hpp

Go to the documentation of this file.

#pragma once
 
#include <cuda_runtime.h>
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string_view>
 
#include <cusbf/cuda_error.hpp>
 
namespace cusbf::detail {
 
class FastxPinnedSequenceBuffer {
   public:
    FastxPinnedSequenceBuffer() = default;
    FastxPinnedSequenceBuffer(const FastxPinnedSequenceBuffer&) = delete;
    FastxPinnedSequenceBuffer& operator=(const FastxPinnedSequenceBuffer&) = delete;
 
    FastxPinnedSequenceBuffer(FastxPinnedSequenceBuffer&& other) noexcept {
        *this = std::move(other);
    }
 
    FastxPinnedSequenceBuffer& operator=(FastxPinnedSequenceBuffer&& other) noexcept {
        if (this != &other) {
            release();
            data_ = other.data_;
            size_ = other.size_;
            capacity_ = other.capacity_;
            other.data_ = nullptr;
            other.size_ = 0;
            other.capacity_ = 0;
        }
        return *this;
    }
 
    ~FastxPinnedSequenceBuffer() {
        release();
    }
 
    [[nodiscard]] char* data() noexcept {
        return data_;
    }
 
    [[nodiscard]] const char* data() const noexcept {
        return data_;
    }
 
    [[nodiscard]] size_t size() const noexcept {
        return size_;
    }
 
    [[nodiscard]] size_t capacity() const noexcept {
        return capacity_;
    }
 
    [[nodiscard]] std::string_view view() const noexcept {
        return std::string_view{data_, size_};
    }
 
    void clear() noexcept {
        size_ = 0;
    }
 
    void release() {
        if (data_ != nullptr) {
            CUSBF_CUDA_ABORT(cudaFreeHost(data_));
            data_ = nullptr;
        }
        size_ = 0;
        capacity_ = 0;
    }
 
    [[nodiscard]] Result<void> reserve(size_t nbytes) {
        if (nbytes <= capacity_) {
            return {};
        }
 
        char* reallocated = nullptr;
        CUSBF_CUDA_TRY(cudaHostAlloc(&reallocated, nbytes, cudaHostAllocDefault));
        if (data_ != nullptr) {
            if (size_ != 0) {
                std::memcpy(reallocated, data_, size_);
            }
            CUSBF_CUDA_ABORT(cudaFreeHost(data_));
        }
        data_ = reallocated;
        capacity_ = nbytes;
        return {};
    }
 
    [[nodiscard]] Result<void> set_size(size_t nbytes) {
        if (nbytes > capacity_) {
            CUSBF_TRY(reserve(nbytes));
        }
        size_ = nbytes;
        return {};
    }
 
   private:
    char* data_{nullptr};
    size_t size_{0};
    size_t capacity_{0};
};
 
}  // namespace cusbf::detail