Device.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/exception.hpp"
#include "shambackends/sycl.hpp"
#include <cstdint>
 
namespace sham {
 
    enum class Vendor { UNKNOWN, NVIDIA, AMD, INTEL, APPLE };
 
    inline std::string vendor_name(Vendor v) {
        switch (v) {
        case Vendor::UNKNOWN: return "Unknown";
        case Vendor::NVIDIA : return "Nvidia";
        case Vendor::AMD    : return "AMD";
        case Vendor::INTEL  : return "Intel";
        case Vendor::APPLE  : return "Apple";
        default:
            shambase::throw_unimplemented(
                "Unknown vendor"); // Throw an exception if the vendor is not recognized
        }
    }
 
    enum class Backend { UNKNOWN, CUDA, ROCM, OPENMP };
 
    inline std::string backend_name(Backend b) {
        switch (b) {
        case Backend::UNKNOWN: return "Unknown";
        case Backend::CUDA   : return "CUDA";
        case Backend::ROCM   : return "ROCm";
        case Backend::OPENMP : return "OpenMP";
        default:
            shambase::throw_unimplemented(
                "Unknown backend"); // Throw an exception if the backend is not recognized
        }
    }
 
    enum class DeviceType { CPU, GPU, UNKNOWN };
 
    inline std::string device_type_name(DeviceType t) {
        switch (t) {
        case DeviceType::CPU: return "CPU";
        case DeviceType::GPU: return "GPU";
        default             : return "UNKNOWN";
        }
    }
 
    struct DeviceProperties {
        Vendor vendor;
 
        Backend backend;
 
        DeviceType type;
 
        std::string name;
 
        std::string platform;
 
        usize global_mem_size;
 
        usize global_mem_cache_line_size;
 
        usize global_mem_cache_size;
 
        usize local_mem_size;
 
        uint32_t max_compute_units;
 
        uint64_t max_mem_alloc_size_dev;
 
        uint64_t max_mem_alloc_size_host;
 
        uint32_t mem_base_addr_align;
 
        std::vector<size_t> sub_group_sizes;
 
        uint32_t default_work_group_size;
 
        std::optional<std::string> pci_address;
 
        std::vector<std::string> warnings;
    };
 
    struct DeviceMPIProperties {
        bool is_mpi_direct_capable;
    };
 
    class Device {
        public:
        usize device_id;
 
        sycl::device dev;
 
        DeviceProperties prop;
 
        DeviceMPIProperties mpi_prop;
 
        void update_mpi_prop();
 
        void print_info();
    };
 
    std::vector<std::unique_ptr<Device>> get_device_list();
 
    Device sycl_dev_to_sham_dev(usize i, const sycl::device &dev);
 
} // namespace sham