Device.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <string>
#include <vector>
 
namespace cloudViewer {
namespace core {
 
class Device {
public:
    enum class DeviceType {
        CPU = 0,
        CUDA = 1,
        SYCL = 2,  // SYCL gpu_selector_v.
    };
 
    Device() = default;
 
    explicit Device(DeviceType device_type, int device_id);
 
    explicit Device(const std::string& device_type, int device_id);
 
    explicit Device(const std::string& type_colon_id);
 
    bool operator==(const Device& other) const;
 
    bool operator!=(const Device& other) const;
 
    bool operator<(const Device& other) const;
 
    inline bool IsCPU() const { return device_type_ == DeviceType::CPU; }
 
    inline bool IsCUDA() const { return device_type_ == DeviceType::CUDA; }
 
    inline bool IsSYCL() const { return device_type_ == DeviceType::SYCL; }
 
    std::string ToString() const;
 
    inline DeviceType GetType() const { return device_type_; }
 
    inline int GetID() const { return device_id_; }
 
    bool IsAvailable() const;
 
    static std::vector<Device> GetAvailableDevices();
 
    static std::vector<Device> GetAvailableCPUDevices();
 
    static std::vector<Device> GetAvailableCUDADevices();
 
    static std::vector<Device> GetAvailableSYCLDevices();
 
    static void PrintAvailableDevices();
 
protected:
    DeviceType device_type_ = DeviceType::CPU;
    int device_id_ = 0;
};
 
class IsDevice {
public:
    IsDevice() = default;
    virtual ~IsDevice() = default;
 
    virtual core::Device GetDevice() const = 0;
 
    inline bool IsCPU() const {
        return GetDevice().GetType() == Device::DeviceType::CPU;
    }
 
    inline bool IsCUDA() const {
        return GetDevice().GetType() == Device::DeviceType::CUDA;
    }
 
    inline bool IsSYCL() const {
        return GetDevice().GetType() == Device::DeviceType::SYCL;
    }
};
 
}  // namespace core
}  // namespace cloudViewer
 
namespace std {
template <>
struct hash<cloudViewer::core::Device> {
    std::size_t operator()(const cloudViewer::core::Device& device) const {
        return std::hash<std::string>{}(device.ToString());
    }
};
 
template <>
struct less<cloudViewer::core::Device> {
    bool operator()(const cloudViewer::core::Device& lhs,
                    const cloudViewer::core::Device& rhs) const {
        return lhs.ToString() < rhs.ToString();
    }
};
}  // namespace std