current_context.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_CURRENT_CONTEXT_HPP_
#define CUDA_API_WRAPPERS_CURRENT_CONTEXT_HPP_

#include "error.hpp"
#include "constants.hpp"
#include "types.hpp"

namespace cuda {

class device_t;
class context_t;
namespace device {
class primary_context_t;
} // namespace device

namespace context {

namespace current {

inline bool exists()
{
    context::handle_t handle;
    auto status = cuCtxGetCurrent(&handle);
    if (status == cuda::status::not_yet_initialized) {
        return false;
    }
    throw_if_error_lazy(status, "Failed obtaining the current context's handle");
    return (handle != context::detail_::none);
}


namespace detail_ {
inline bool is_(handle_t handle)
{
    handle_t current_context_handle;
    auto status = cuCtxGetCurrent(&current_context_handle);
    switch(status) {
    case CUDA_ERROR_NOT_INITIALIZED:
    case CUDA_ERROR_INVALID_CONTEXT:
        return false;
    case CUDA_SUCCESS:
        return (handle == current_context_handle);
    default:
        throw cuda::runtime_error(status,
            "Failed determining whether there's a current context, or what it is");
    }
}

struct status_and_handle_pair {
    status_t status;
    handle_t handle;
};

inline status_and_handle_pair get_with_status()
{
    handle_t handle;
    auto status = cuCtxGetCurrent(&handle);
    if (status == status::not_yet_initialized) {
        handle = context::detail_::none;
    }
    return { status, handle };
}

inline handle_t get_handle()
{
    auto p = get_with_status();
    throw_if_error_lazy(p.status, "Failed obtaining the current context's handle");
    return p.handle;
}

// Note: not calling this get_ since flags are read-only anyway
inline context::flags_t get_flags()
{
    context::flags_t result;
    auto status = cuCtxGetFlags(&result);
    throw_if_error_lazy(status, "Failed obtaining the current context's flags");
    // Note: Not sanitizing the flags from having CU_CTX_MAP_HOST set
    return result;
}

inline device::id_t get_device_id()
{
    device::id_t device_id;
    auto result = cuCtxGetDevice(&device_id);
    throw_if_error_lazy(result, "Failed obtaining the current context's device");
    return device_id;
}

inline void push(handle_t context_handle)
{
    auto status = cuCtxPushCurrent(context_handle);
    throw_if_error_lazy(status, "Failed pushing to the top of the context stack: "
        + context::detail_::identify(context_handle));
}

inline bool push_if_not_on_top(handle_t context_handle)
{
    if (get_handle() == context_handle) { return false; }
    push(context_handle);
    return true;
}

inline context::handle_t pop()
{
    handle_t popped_context_handle;
    auto status = cuCtxPopCurrent(&popped_context_handle);
    throw_if_error_lazy(status, "Failed popping the current CUDA context");
    return popped_context_handle;
}

inline void set(handle_t context_handle)
{
    // Thought about doing this:
    // if (detail_::get_handle() == context_handle_) { return; }
    // ... but decided against it.
    auto status = cuCtxSetCurrent(context_handle);
    throw_if_error_lazy(status,
        "Failed setting the current context to " + context::detail_::identify(context_handle));
}

} // namespace detail_

namespace detail_ {
class scoped_override_t {
public:
    bool hold_primary_context_ref_unit_;
    device::id_t device_id_or_0_;

    explicit scoped_override_t(handle_t context_handle) : scoped_override_t(false, 0, context_handle) {}
    scoped_override_t(device::id_t device_for_which_context_is_primary, handle_t context_handle)
        : scoped_override_t(true, device_for_which_context_is_primary, context_handle) {}
    explicit scoped_override_t(bool hold_primary_context_ref_unit, device::id_t device_id, handle_t context_handle);
    scoped_override_t(const scoped_override_t&) = delete;
    scoped_override_t(scoped_override_t&&) = delete;
    scoped_override_t& operator=(const scoped_override_t&) = delete;
    scoped_override_t& operator=(scoped_override_t&&) = delete;
    ~scoped_override_t() noexcept(false);
};


/*
 * This macro is intended for use inside the cuda-api-wrappers implementation, to 
 * save us some typing; it's quite usable on the outside, but you probably want to
 * use the context_t objects, and for safety (e.g. w.r.t. primary device contexts),
 * prefer @ref SET_CUDA_CONTEXT_FOR_THIS_SCOPE instead.
 */
#define CAW_SET_SCOPE_CONTEXT(context_handle_expr_) \
const ::cuda::context::current::detail_::scoped_override_t caw_context_for_this_scope_(context_handle_expr_)

class scoped_ensurer_t {
public:
    bool context_was_pushed_on_construction;

    explicit scoped_ensurer_t(bool force_push, handle_t fallback_context_handle)
        : context_was_pushed_on_construction(force_push)
    {
        if (force_push) { push(fallback_context_handle); }
    }

    explicit scoped_ensurer_t(handle_t fallback_context_handle)
        : scoped_ensurer_t(not exists(), fallback_context_handle)
    {}

    scoped_ensurer_t(const scoped_ensurer_t&) = delete;
    scoped_ensurer_t(scoped_ensurer_t&&) = delete;

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

    ~scoped_ensurer_t() { if (context_was_pushed_on_construction) { pop(); } }
};

} // namespace detail_

class scoped_override_t : private detail_::scoped_override_t {
protected:
    using parent = detail_::scoped_override_t;
public:

    explicit scoped_override_t(device::primary_context_t&& primary_context);
    explicit scoped_override_t(const context_t& context);
    explicit scoped_override_t(context_t&& context);
    ~scoped_override_t() = default;
};



#define CUDA_CONTEXT_FOR_THIS_SCOPE(_cuda_context) \
::cuda::context::current::scoped_override_t set_context_for_this_scope{ _cuda_context }

inline void synchronize()
{
    auto status = cuCtxSynchronize();
    if (not is_success(status)) {
        throw cuda::runtime_error(status, "Failed synchronizing current context");
    }
}

namespace detail_ {

// Just like context::current::synchronize(), but with an argument
// allowing for throwing a more informative exception on failure
inline void synchronize(context::handle_t current_context_handle)
{
    auto status = cuCtxSynchronize();
    if (not is_success(status)) {
        throw cuda::runtime_error(status,"Failed synchronizing "
            + context::detail_::identify(current_context_handle));
    }
}

// Just like context::current::synchronize(), but with arguments
// allowing for throwing a more informative exception on failure
inline void synchronize(
    device::id_t current_context_device_id,
    context::handle_t current_context_handle)
{
    auto status = cuCtxSynchronize();
    if (not is_success(status)) {
        throw cuda::runtime_error(status, "Failed synchronizing "
            + context::detail_::identify(current_context_handle, current_context_device_id));
    }
}

} // namespace detail

} // namespace current

} // namespace context

} // namespace cuda

#endif // CUDA_API_WRAPPERS_CURRENT_CONTEXT_HPP_