current_device.hpp

Go to the documentation of this file.

#ifndef CUDA_API_WRAPPERS_CURRENT_DEVICE_HPP_
#define CUDA_API_WRAPPERS_CURRENT_DEVICE_HPP_

#include "constants.hpp"
#include "miscellany.hpp"
#include "current_context.hpp"
#include "primary_context.hpp"

#include <cuda_runtime_api.h>

namespace cuda {

class device_t;

namespace device {

namespace current {

namespace detail_ {

inline id_t get_id()
{
    static constexpr const id_t default_device_id { 0 };
    context::handle_t current_context_handle;
    auto status = cuCtxGetCurrent(&current_context_handle);
    if (status == CUDA_ERROR_NOT_INITIALIZED) {
        initialize_driver();
        // Should we activate and push the default device's context? probably not.
        return default_device_id;
    }
    throw_if_error_lazy(status,
        "Failed obtaining the current context for determining which device is active");

    if (current_context_handle == context::detail_::none) {
        // Should we activate and push the default device's context? probably not.
        return default_device_id;
    }
    return cuda::context::current::detail_::get_device_id();
    // ... which is the equivalent of doing:
    //
}


inline context::handle_t set_with_aux_info(
    id_t device_id,
    bool driver_is_initialized,
    context::handle_t current_context_handle = context::detail_::none,
    context::handle_t device_pc_handle = context::detail_::none)
{
    if (not driver_is_initialized) {
        initialize_driver();
        device_pc_handle = device::primary_context::detail_::obtain_and_increase_refcount(device_id);
        context::current::detail_::set(device_pc_handle);
        return device_pc_handle;
    }
    if (current_context_handle != context::detail_::none) {
        if (current_context_handle == device_pc_handle) {
            return device_pc_handle;
        }
    }
    device_pc_handle = device::primary_context::detail_::obtain_and_increase_refcount(device_id);
    if (current_context_handle == device_pc_handle) {
        return device_pc_handle;
    }
    context::current::detail_::set(device_pc_handle); // Remember: This _replaces_ the current context
    return device_pc_handle;
}

inline void set(id_t device_id)
{
    context::handle_t current_context_handle;
    auto status = cuCtxGetCurrent(&current_context_handle);
    bool driver_initialized = (status == CUDA_ERROR_NOT_INITIALIZED);
    set_with_aux_info(device_id, driver_initialized, current_context_handle);
    // Note: We can safely assume the refcount was increased.
}

inline void set(const id_t *device_ids, size_t num_devices)
{
    if (num_devices > static_cast<size_t>(cuda::device::count())) {
        throw cuda::runtime_error(status::invalid_device, "More devices listed than exist on the system");
    }
    auto result = cudaSetValidDevices(const_cast<int *>(device_ids), static_cast<int>(num_devices));
    throw_if_error_lazy(result,
        "Failure setting the current device to any of the list of "
        + ::std::to_string(num_devices) + " devices specified");
}

} // namespace detail

void set(const device_t& device);

inline void set_to_default() { return detail_::set(device::default_device_id); }

#define CUDA_DEVICE_FOR_THIS_SCOPE(_cuda_device) \
::cuda::device::current::scoped_override_t scoped_device_override{ _cuda_device }


} // namespace current
} // namespace device
} // namespace cuda

#endif // CUDA_API_WRAPPERS_CURRENT_DEVICE_HPP_