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 <cuda/api/constants.hpp>
#include <cuda/api/pci_id.hpp>
#include <cuda/common/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 {

struct compute_architecture_t {
    unsigned major;

    const char* name() const;
    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 bool is_valid() const noexcept;

};

// TODO: Consider making this a non-POD struct,
// with a proper ctor checking validity, an operator converting to pair etc;
// however, that would require including at least ::std::utility, if not other
// stuff (e.g. for an ::std::hash specialization)
// TODO: If we constrained this to versions we know about, we could make the
// methods 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 { { (unsigned) major }, (unsigned) minor }; }
    compute_architecture_t compute_architecture() const noexcept { return { (unsigned) major }; };
    pci_location_t pci_id() const noexcept { return { pciDomainID, pciBusID, pciDeviceID }; }

    unsigned long long 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 <cuda/api/detail/device_properties.hpp>

#endif // CUDA_API_WRAPPERS_DEVICE_PROPERTIES_HPP_