device.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
namespace uni20::cuda
{
 
struct DeviceCapabilities
{
    std::string name{};
 
    std::array<std::uint8_t, 16> uuid{};
 
    std::size_t total_global_memory = 0;
 
    int compute_capability_major = 0;
 
    int compute_capability_minor = 0;
 
    int multiprocessor_count = 0;
 
    int warp_size = 0;
 
    int max_threads_per_block = 0;
 
    int max_threads_per_multiprocessor = 0;
 
    std::size_t shared_memory_per_block = 0;
 
    std::size_t shared_memory_per_multiprocessor = 0;
 
    int async_engine_count = 0;
 
    int pci_domain = 0;
 
    int pci_bus = 0;
 
    int pci_device = 0;
 
    bool concurrent_kernels = false;
 
    bool unified_addressing = false;
 
    bool can_map_host_memory = false;
 
    bool managed_memory = false;
 
    bool concurrent_managed_access = false;
 
    bool pageable_memory_access = false;
 
    bool memory_pools_supported = false;
 
    bool stream_priorities_supported = false;
 
    bool cooperative_launch = false;
 
    bool ecc_enabled = false;
};
 
class Device {
  public:
    [[nodiscard]] static Device get(int ordinal);
 
    [[nodiscard]] static int count();
 
    [[nodiscard]] static std::vector<Device> enumerate();
 
    [[nodiscard]] static Device current();
 
    [[nodiscard]] constexpr int ordinal() const noexcept { return ordinal_; }
 
    [[nodiscard]] DeviceCapabilities const& capabilities() const;
 
    friend constexpr bool operator==(Device const&, Device const&) = default;
 
  private:
    explicit constexpr Device(int ordinal) noexcept : ordinal_(ordinal) {}
 
    int ordinal_;
};
 
} // namespace uni20::cuda