texture_view.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_TEXTURE_VIEW_HPP
#define CUDA_API_WRAPPERS_TEXTURE_VIEW_HPP

#include "array.hpp"
#include "error.hpp"
#include "memory.hpp"

namespace cuda {

class texture_view;

namespace texture {

using raw_handle_t = CUtexObject;

namespace detail_ {

inline void destroy_view(raw_handle_t handle, context::handle_t context_handle) noexcept(false)
{
    CAW_SET_SCOPE_CONTEXT(context_handle);
    auto status = cuTexObjectDestroy(handle);
    throw_if_error_lazy(status, "Failed destroying texture object ");
}

}
struct descriptor_t : public CUDA_TEXTURE_DESC {
    inline descriptor_t()
    {
        using parent = CUDA_TEXTURE_DESC;
        memset(static_cast<parent*>(this), 0, sizeof(parent));
        // Note: This should set the fields directly listed in the CUDA Runtime API
        // version of this structure to 0.
        this->addressMode[0] = CU_TR_ADDRESS_MODE_BORDER;
        this->addressMode[1] = CU_TR_ADDRESS_MODE_BORDER;
        this->addressMode[2] = CU_TR_ADDRESS_MODE_BORDER;
        this->filterMode = CU_TR_FILTER_MODE_POINT;
    }
};

inline texture_view wrap(
    device::id_t           device_id,
    context::handle_t      context_handle,
    texture::raw_handle_t  handle,
    bool                   take_ownership) noexcept;

}  // namespace texture

class texture_view {
    using raw_handle_type = texture::raw_handle_t;
    using scoped_context_setter = cuda::context::current::detail_::scoped_override_t;

public:
    device::id_t device_id() const noexcept { return device_id_; }
    context::handle_t context_handle() const noexcept { return context_handle_; }
    raw_handle_type raw_handle() const noexcept { return raw_view_handle; }
    bool is_owning() const noexcept { return owning_; }

public: // constructors and destructors

    texture_view(const texture_view& other) = delete;

    texture_view(texture_view&& other) noexcept :
        device_id_(other.device_id_),
        context_handle_(other.context_handle_),
        raw_view_handle(other.raw_view_handle),
        owning_(other.raw_view_handle)
    {
        other.owning_ = false;
    };

    template <typename T, dimensionality_t NumDimensions>
    texture_view(
        const cuda::array_t<T, NumDimensions>& arr,
        texture::descriptor_t descriptor = texture::descriptor_t()) :
        device_id_(arr.device_id()),
        context_handle_(arr.context_handle()),
        owning_(true)
    {
        scoped_context_setter set_context(context_handle_);
        CUDA_RESOURCE_DESC resource_descriptor;
        memset(&resource_descriptor, 0, sizeof(resource_descriptor));
        resource_descriptor.resType = CU_RESOURCE_TYPE_ARRAY;
        resource_descriptor.res.array.hArray = arr.get();

        auto status = cuTexObjectCreate(&raw_view_handle, &resource_descriptor, &descriptor, nullptr);
        throw_if_error_lazy(status, "failed creating a CUDA texture object");
    }

public: // operators

    ~texture_view() DESTRUCTOR_EXCEPTION_SPEC
    {
        if (owning_) {
#ifdef THROW_IN_DESTRUCTORS
            try
#endif
            {
                texture::detail_::destroy_view(raw_view_handle, context_handle_);
            }
#ifdef THROW_IN_DESTRUCTORS
            catch (...) {}
#endif
        }
    }

    texture_view& operator=(const texture_view& other) = delete;
    texture_view& operator=(texture_view& other) = delete;

protected: // constructor

    // Usable by the wrap function
    texture_view(
        device::id_t       device_id,
        context::handle_t  context_handle,
        raw_handle_type    handle ,
        bool               take_ownership) noexcept
    :
        device_id_(device_id),
        context_handle_(context_handle),
        raw_view_handle(handle),
        owning_(take_ownership) { }

public: // non-mutating getters

    context_t context() const;

    device_t device() const;

public: // friendship

    friend texture_view texture::wrap(device::id_t, context::handle_t, raw_handle_type, bool) noexcept;

protected:
    device::id_t device_id_;
    context::handle_t context_handle_;
    raw_handle_type raw_view_handle;
    bool owning_;
};

inline bool operator==(const texture_view& lhs, const texture_view& rhs) noexcept
{
    return lhs.raw_handle() == rhs.raw_handle();
}

inline bool operator!=(const texture_view& lhs, const texture_view& rhs) noexcept
{
    return lhs.raw_handle() != rhs.raw_handle();
}
namespace texture {

inline texture_view wrap(
    device::id_t           device_id,
    context::handle_t      context_handle,
    texture::raw_handle_t  handle,
    bool                   take_ownership) noexcept
{
    return { device_id, context_handle, handle, take_ownership };
}

} // namespace texture

} // namespace cuda

#endif // CUDA_API_WRAPPERS_TEXTURE_VIEW_HPP