SYCLContext.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2026 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
 
#pragma once
 
#include <algorithm>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "open3d/core/Device.h"
 
#ifdef BUILD_SYCL_MODULE
// Host TUs forward-declare sycl::queue; SYCL-compiled TUs include the runtime.
#if defined(SYCL_LANGUAGE_VERSION)
#include <sycl/sycl.hpp>
#else
namespace sycl {
class queue;
}
#endif
#endif
 
namespace open3d {
namespace core {
namespace sy {
 
struct SYCLDevice {
    std::string name{};         
    std::string device_type{};  
    size_t max_work_group_size = 0;  
    bool fp64 = false;  
    bool usm_device_allocations =
            false;  
    bool discrete_gpu = false;
    uint64_t global_mem_size = 0;  
    uint64_t local_mem_size = 0;
    size_t compute_units = 0;
    std::vector<size_t> sub_group_sizes{};
 
    bool SupportsSubgroupSize(size_t size) const {
        return std::find(sub_group_sizes.begin(), sub_group_sizes.end(),
                         size) != sub_group_sizes.end();
    }
};
 
#ifdef BUILD_SYCL_MODULE
 
class SYCLContext {
public:
    SYCLContext(SYCLContext const&) = delete;
    void operator=(SYCLContext const&) = delete;
    ~SYCLContext();
 
    static SYCLContext& GetInstance();
 
    bool IsAvailable();
 
    bool IsDeviceAvailable(const Device& device);
 
    std::vector<Device> GetAvailableSYCLDevices();
 
    sycl::queue GetDefaultQueue(const Device& device);
 
    SYCLDevice GetDeviceProperties(const Device& device);
 
    static void Clear();
 
#if defined(SYCL_LANGUAGE_VERSION)
    size_t GetComputeUnits(const sycl::device& sycl_device);
#endif
 
private:
    SYCLContext();
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
#if defined(SYCL_LANGUAGE_VERSION)
 
sycl::queue GetQueue(const Device& device);
 
class SYCLScopedQueue {
public:
    SYCLScopedQueue(const Device& device, sycl::queue queue);
    ~SYCLScopedQueue();
 
    SYCLScopedQueue(const SYCLScopedQueue&) = delete;
    SYCLScopedQueue& operator=(const SYCLScopedQueue&) = delete;
 
private:
    Device device_;
    // Empty if there was no prior override for `device_` (sycl::queue has no
    // default constructor, so a nullable wrapper is used instead of a bool
    // flag + default-constructed queue).
    std::optional<sycl::queue> prev_queue_;
};
 
#endif  // SYCL_LANGUAGE_VERSION
 
#endif  // BUILD_SYCL_MODULE
 
}  // namespace sy
}  // namespace core
}  // namespace open3d