device_properties.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_DEVICE_PROPERTIES_HPP_
#define CUDA_API_WRAPPERS_DEVICE_PROPERTIES_HPP_

#include "constants.hpp"
#include "pci_id.hpp"

#include "types.hpp"

#include <cuda_runtime_api.h>

#include <stdexcept>


// The following un-definitions avoid warnings about
// the use of `major` and `minor` in certain versions
// of the GNU C library
#ifdef major
#undef major
#endif

#ifdef minor
#undef minor
#endif

namespace cuda {

namespace device {

using multiprocessor_count_t = int;

struct compute_architecture_t {
    unsigned major;

    const char* name() const;

    constexpr bool is_valid() const noexcept;

};

struct compute_capability_t {

    compute_architecture_t architecture;

    unsigned minor_;

    constexpr static compute_capability_t from_combined_number(unsigned combined) noexcept;

    constexpr unsigned major() const { return architecture.major; }
    unsigned constexpr minor() const { return minor_; }

    constexpr unsigned as_combined_number() const noexcept;

    constexpr bool is_valid() const noexcept;

    unsigned max_warp_schedulings_per_processor_cycle() const;
    unsigned max_resident_warps_per_processor() const;

    unsigned max_in_flight_threads_per_processor() const;

    memory::shared::size_t max_shared_memory_per_block() const;
};

constexpr compute_capability_t make_compute_capability(unsigned combined) noexcept;

constexpr compute_capability_t make_compute_capability(unsigned major, unsigned minor) noexcept;

struct properties_t : public cudaDeviceProp {

    properties_t() = default;
    properties_t(const cudaDeviceProp& cdp) noexcept : cudaDeviceProp(cdp) { };
    properties_t(cudaDeviceProp&& cdp) noexcept : cudaDeviceProp(cdp) { };

    bool usable_for_compute() const noexcept;
    compute_capability_t compute_capability() const noexcept
    {
        return { { static_cast<unsigned>(major) }, static_cast<unsigned>(minor) };
    }
    compute_architecture_t compute_architecture() const noexcept { return { static_cast<unsigned>(major) }; };
    pci_location_t pci_id() const noexcept { return { pciDomainID, pciBusID, pciDeviceID, {} }; }

    unsigned max_in_flight_threads_on_device() const
    {
        return compute_capability().max_in_flight_threads_per_processor() * multiProcessorCount;
    }

    grid::block_dimension_t max_threads_per_block() const noexcept { return maxThreadsPerBlock; }
    grid::block_dimension_t max_warps_per_block() const noexcept { return maxThreadsPerBlock / warp_size; }
    size_t max_shared_memory_per_block() const noexcept { return sharedMemPerBlock; }
    size_t global_memory_size() const noexcept { return totalGlobalMem; }
    bool can_map_host_memory() const noexcept { return canMapHostMemory != 0; }
};

} // namespace device
} // namespace cuda

#include "detail/device_properties.hpp"

#endif // CUDA_API_WRAPPERS_DEVICE_PROPERTIES_HPP_