unique_region.hpp

Go to the documentation of this file.

#ifndef CUDA_API_WRAPPERS_UNIQUE_REGION_HPP_
#define CUDA_API_WRAPPERS_UNIQUE_REGION_HPP_

#include "memory.hpp"
#include <cassert>

namespace cuda {
namespace memory {

template<typename Deleter>
class unique_region : public region_t {
public: // types
    using parent = region_t;
    using region_t::pointer;
    using region_t::const_pointer;
    using region_t::size_type;
    using deleter_type = Deleter;
    // and _no_ element_type!

public:

    constexpr unique_region() noexcept = default;

    constexpr unique_region(::std::nullptr_t) noexcept : unique_region() { }

    explicit unique_region(region_t region) noexcept : region_t{region} { }

    // Note: No constructor which also takes a deleter. We do not hold a deleter
    // member - unlike unique_ptr's. If we wanted a general-purpose unique region
    // that's not just GPU allocation-oriented, we might have had one of those.

    unique_region(unique_region&& other) noexcept : unique_region(other.release()) { }
    // Disable copy construction
    unique_region(const unique_region&) = delete;

    // Note: No conversion from "another type" like with ::std::unique_pointer, since
    // this class is not variant with the element type; and there's not much sense in
    // supporting conversion of memory between different deleters (/ allocators).

    ~unique_region() noexcept
    {
        if (data() != nullptr) {
            get_deleter()(data());
        }
        static_cast<region_t&>(*this) = region_t{ nullptr, 0 };
    }

    unique_region& operator=(const unique_region&) = delete;

    unique_region& operator=(unique_region&& other) noexcept
    {
        reset(other.release());
        return *this;
    }

    unique_region&
    operator=(::std::nullptr_t) noexcept
    {
        reset();
        return *this;
    }



    operator const_region_t() const noexcept { return *this; }

    region_t get() const noexcept { return *this; }

    deleter_type get_deleter() const noexcept { return deleter_type{}; }

    explicit operator bool() const noexcept { return data() != nullptr; }

    // Modifiers.

    region_t release() noexcept
    {
        // TODO: Shouldn't I use move construction for release?
        region_t released { *this };
        static_cast<region_t&>(*this) = region_t{ nullptr, 0 };
        return released;
    }

    void reset(region_t region = region_t{})
    {
        ::std::swap<region_t>(*this, region);
        if (region.start() != nullptr) {
            get_deleter()(region.data());
        }
    }

    void swap(unique_region& other) noexcept
    {
        ::std::swap<region_t>(*this, other);
    }
}; // class unique_region

namespace device {

using unique_region = memory::unique_region<detail_::deleter>;

namespace detail_ {

inline unique_region make_unique_region(const context::handle_t context_handle, size_t num_bytes)
{
    CAW_SET_SCOPE_CONTEXT(context_handle);
    return unique_region{ allocate_in_current_context(num_bytes) };
}

} // namespace detail_

unique_region make_unique_region(const context_t& context, size_t num_bytes);

unique_region make_unique_region(const device_t& device, size_t num_bytes);

unique_region make_unique_region(size_t num_bytes);

} // namespace device


inline device::unique_region make_unique_region(const context_t& context, size_t num_elements)
{
    return device::make_unique_region(context, num_elements);
}

inline device::unique_region make_unique_region(const device_t& device, size_t num_elements)
{
    return device::make_unique_region(device, num_elements);
}

namespace host {

using unique_region = memory::unique_region<detail_::deleter>;

inline unique_region make_unique_region(size_t num_bytes);

} // namespace host

namespace managed {

using unique_region = memory::unique_region<detail_::deleter>;

namespace detail_ {

inline unique_region make_unique_region(
    const context::handle_t  context_handle,
    size_t                   num_bytes,
    initial_visibility_t     initial_visibility = initial_visibility_t::to_all_devices)
{
    CAW_SET_SCOPE_CONTEXT(context_handle);
    return unique_region { allocate_in_current_context(num_bytes, initial_visibility) };
}

} // namespace detail_

inline unique_region make_unique_region(
    const context_t&      context,
    size_t                num_bytes,
    initial_visibility_t  initial_visibility = initial_visibility_t::to_all_devices);

inline unique_region make_unique_region(
    const device_t&       device,
    size_t                num_bytes,
    initial_visibility_t  initial_visibility = initial_visibility_t::to_all_devices);

inline unique_region make_unique_region(
    size_t                num_bytes);

} // namespace managed

} // namespace memory

} // namespace cuda

#endif // CUDA_API_WRAPPERS_UNIQUE_REGION_HPP_