peer_to_peer.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_PEER_TO_PEER_HPP_
#define CUDA_API_WRAPPERS_PEER_TO_PEER_HPP_

#include "current_context.hpp"

namespace cuda {

namespace device {

namespace peer_to_peer {


constexpr const attribute_t link_performance_rank = CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK;

constexpr const attribute_t access_support = CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED;

constexpr const attribute_t native_atomics_support = CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED;

#if CUDA_VERSION >= 10000
constexpr const attribute_t array_access_support = CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED;
#endif

namespace detail_ {
inline attribute_value_t get_attribute(attribute_t attribute, id_t source, id_t destination)
{
    attribute_value_t value;
    auto status = cuDeviceGetP2PAttribute(&value, attribute, source, destination);
    throw_if_error_lazy(status, "Failed obtaining peer-to-peer device attribute for device pair ("
        + ::std::to_string(source) + ", " + ::std::to_string(destination) + ')');
    return value;
}

inline bool can_access(const device::id_t accessor, const device::id_t peer)
{
    int result;
    auto status = cuDeviceCanAccessPeer(&result, accessor, peer);
    throw_if_error_lazy(status, "Failed determining whether " + device::detail_::identify(accessor)
        + " can access " + device::detail_::identify(peer));
    return (result == 1);
}

} // namespace detail_

} // namespace peer_to_peer

} // namespace device

namespace context {

namespace current {

namespace peer_to_peer {

void enable_access_to(const context_t &peer_context);

void disable_access_to(const context_t &peer_context);

} // namespace peer_to_peer

} // namespace current

namespace peer_to_peer {

namespace detail_ {

inline void enable_access_to(context::handle_t peer_context)
{
    enum : unsigned {fixed_flags = 0 };
    // No flags are supported as of CUDA 8.0
    auto status = cuCtxEnablePeerAccess(peer_context, fixed_flags);
    throw_if_error_lazy(status, "Failed enabling access to peer " + context::detail_::identify(peer_context));
}

inline void disable_access_to(context::handle_t peer_context)
{
    auto status = cuCtxDisablePeerAccess(peer_context);
    throw_if_error_lazy(status, "Failed disabling access to peer " + context::detail_::identify(peer_context));
}

inline void enable_access(context::handle_t accessor, context::handle_t peer)
{
    context::current::detail_::scoped_override_t set_context_for_this_context(accessor);
    enable_access_to(peer);
}

inline void disable_access(context::handle_t accessor, context::handle_t peer)
{
    context::current::detail_::scoped_override_t set_context_for_this_context(accessor);
    disable_access_to(peer);
}

} // namespace detail_

bool can_access(context_t accessor, context_t peer);

void enable_access(context_t accessor, context_t peer);

void disable_access(context_t accessor, context_t peer);

void enable_bidirectional_access(context_t first, context_t second);

void disable_bidirectional_access(context_t first, context_t second);

} // namespace peer_to_peer
} // namespace context

namespace device {

namespace peer_to_peer {

inline bool can_access(const device_t& accessor, const device_t& peer);

inline void enable_access(const device_t& accessor, const device_t& peer);

inline void disable_access(const device_t& accessor, const device_t& peer);

inline bool can_access_each_other(const device_t& first, const device_t& second);

inline void enable_bidirectional_access(const device_t& first, const device_t& second);

inline void disable_bidirectional_access(const device_t& first, const device_t& second);

inline attribute_value_t get_attribute(attribute_t attribute, const device_t& first, const device_t& second);

} // namespace peer_to_peer
} // namespace device
} // namespace cuda

#endif // CUDA_API_WRAPPERS_PEER_TO_PEER_HPP_