CUDAUtils.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 "open3d/core/Device.h"
#include "open3d/utility/Logging.h"
 
#ifdef BUILD_CUDA_MODULE
 
#include <cuda.h>
#include <cuda_runtime.h>
 
#include <memory>
#include <optional>
#include <vector>
 
#define OPEN3D_FORCE_INLINE __forceinline__
#define OPEN3D_HOST_DEVICE __host__ __device__
#define OPEN3D_DEVICE __device__
#define OPEN3D_ASSERT_HOST_DEVICE_LAMBDA(type)                            \
    static_assert(__nv_is_extended_host_device_lambda_closure_type(type), \
                  #type " must be a __host__ __device__ lambda")
#define OPEN3D_CUDA_CHECK(err) \
    open3d::core::__OPEN3D_CUDA_CHECK(err, __FILE__, __LINE__)
#define OPEN3D_GET_LAST_CUDA_ERROR(message) \
    __OPEN3D_GET_LAST_CUDA_ERROR(message, __FILE__, __LINE__)
#define CUDA_CALL(cuda_function, ...) cuda_function(__VA_ARGS__);
 
#else  // #ifdef BUILD_CUDA_MODULE
 
#define OPEN3D_FORCE_INLINE inline
#define OPEN3D_HOST_DEVICE
#define OPEN3D_DEVICE
#define OPEN3D_ASSERT_HOST_DEVICE_LAMBDA(type)
#define OPEN3D_CUDA_CHECK(err)
#define OPEN3D_GET_LAST_CUDA_ERROR(message)
#define CUDA_CALL(cuda_function, ...) \
    open3d::utility::LogError(        \
            "Not built with CUDA, cannot call " #cuda_function);
 
#endif  // #ifdef BUILD_CUDA_MODULE
 
namespace open3d {
namespace core {
 
#ifdef BUILD_CUDA_MODULE
 
class CUDAScopedDevice {
public:
    explicit CUDAScopedDevice(int device_id);
 
    explicit CUDAScopedDevice(const Device& device);
 
    ~CUDAScopedDevice();
 
    CUDAScopedDevice(const CUDAScopedDevice&) = delete;
    CUDAScopedDevice& operator=(const CUDAScopedDevice&) = delete;
 
private:
    int prev_device_id_;
};
 
class CUDAScopedStream {
private:
    struct CreateNewStreamTag {
        constexpr CreateNewStreamTag() = default;
        CreateNewStreamTag(const CreateNewStreamTag&) = delete;
        CreateNewStreamTag& operator=(const CreateNewStreamTag&) = delete;
        CreateNewStreamTag(CreateNewStreamTag&&) = delete;
        CreateNewStreamTag& operator=(CreateNewStreamTag&&) = delete;
    };
 
public:
    constexpr static CreateNewStreamTag CreateNewStream = {};
 
    explicit CUDAScopedStream(const CreateNewStreamTag&);
 
    explicit CUDAScopedStream(cudaStream_t stream);
 
    ~CUDAScopedStream();
 
    CUDAScopedStream(const CUDAScopedStream&) = delete;
    CUDAScopedStream& operator=(const CUDAScopedStream&) = delete;
 
private:
    cudaStream_t prev_stream_;
    cudaStream_t new_stream_;
    bool owns_new_stream_ = false;
};
 
class CUDAState {
public:
    static CUDAState& GetInstance();
 
    CUDAState(const CUDAState&) = delete;
    CUDAState& operator=(const CUDAState&) = delete;
 
    bool IsP2PEnabled(int src_id, int tar_id) const;
 
    bool IsP2PEnabled(const Device& src, const Device& tar) const;
 
    void ForceDisableP2PForTesting();
 
private:
    CUDAState();
 
    std::vector<std::vector<bool>> p2p_enabled_;
};
 
int GetCUDACurrentWarpSize();
 
int GetCUDACurrentDeviceTextureAlignment();
 
size_t GetCUDACurrentTotalMemSize();
 
#else
 
class CUDAScopedDevice {
public:
    explicit CUDAScopedDevice(int device_id) {}
    explicit CUDAScopedDevice(const Device& device) {}
    ~CUDAScopedDevice() {}
    CUDAScopedDevice(const CUDAScopedDevice&) = delete;
    CUDAScopedDevice& operator=(const CUDAScopedDevice&) = delete;
};
 
#endif
 
namespace cuda {
 
int DeviceCount();
 
bool IsAvailable();
 
void ReleaseCache();
 
void Synchronize();
 
void Synchronize(const Device& device);
 
void AssertCUDADeviceAvailable(int device_id);
 
void AssertCUDADeviceAvailable(const Device& device);
 
bool SupportsMemoryPools(const Device& device);
 
#ifdef BUILD_CUDA_MODULE
 
int GetDevice();
cudaStream_t GetStream();
cudaStream_t GetDefaultStream();
 
#endif
 
}  // namespace cuda
}  // namespace core
}  // namespace open3d
 
// Exposed as implementation detail of macros at the end of the file.
#ifdef BUILD_CUDA_MODULE
 
namespace open3d {
namespace core {
 
void __OPEN3D_CUDA_CHECK(cudaError_t err, const char* file, const int line);
 
void __OPEN3D_GET_LAST_CUDA_ERROR(const char* message,
                                  const char* file,
                                  const int line);
 
}  // namespace core
 
#if defined(__CUDA_ARCH__)
 
namespace detail {
 
OPEN3D_DEVICE __forceinline__ void Open3DCudaAssertReportAndTrap(
        const char* message) {
    static __device__ int open3d_cuda_assert_reported;
    if (atomicExch(&open3d_cuda_assert_reported, 1) == 0) {
        printf("Open3D CUDA assertion failed at block [%u,%u,%u], thread "
               "[%u,%u,%u]:\n%s\n",
               blockIdx.x, blockIdx.y, blockIdx.z, threadIdx.x, threadIdx.y,
               threadIdx.z, message);
    }
    __trap();
}
 
}  // namespace detail
 
#endif  // defined(__CUDA_ARCH__)
 
}  // namespace open3d
 
#endif