LinalgUtils.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 <Logging.h>
 
#include <string>
 
#include "cloudViewer/core/Device.h"
#include "cloudViewer/core/Dtype.h"
#include "cloudViewer/core/MemoryManager.h"
#include "cloudViewer/core/linalg/LinalgHeadersCPU.h"
#include "cloudViewer/core/linalg/LinalgHeadersCUDA.h"
 
namespace cloudViewer {
namespace core {
 
#define DISPATCH_LINALG_DTYPE_TO_TEMPLATE(DTYPE, ...)     \
    [&] {                                                 \
        if (DTYPE == cloudViewer::core::Float32) {        \
            using scalar_t = float;                       \
            return __VA_ARGS__();                         \
        } else if (DTYPE == cloudViewer::core::Float64) { \
            using scalar_t = double;                      \
            return __VA_ARGS__();                         \
        } else {                                          \
            utility::LogError("Unsupported data type.");  \
        }                                                 \
    }()
 
inline void OPEN3D_LAPACK_CHECK(CLOUDVIEWER_CPU_LINALG_INT info,
                                const std::string& msg) {
    if (info < 0) {
        utility::LogError("{}: {}-th parameter is invalid.", msg, -info);
    } else if (info > 0) {
        utility::LogError("{}: singular condition detected.", msg);
    }
}
 
#ifdef BUILD_CUDA_MODULE
inline void OPEN3D_CUBLAS_CHECK(cublasStatus_t status, const std::string& msg) {
    if (CUBLAS_STATUS_SUCCESS != status) {
        utility::LogError("{}", msg);
    }
}
 
inline void OPEN3D_CUSOLVER_CHECK(cusolverStatus_t status,
                                  const std::string& msg) {
    if (CUSOLVER_STATUS_SUCCESS != status) {
        utility::LogError("{}", msg);
    }
}
 
inline void OPEN3D_CUSOLVER_CHECK_WITH_DINFO(cusolverStatus_t status,
                                             const std::string& msg,
                                             int* dinfo,
                                             const Device& device) {
    int hinfo;
    MemoryManager::MemcpyToHost(&hinfo, dinfo, device, sizeof(int));
    if (status != CUSOLVER_STATUS_SUCCESS || hinfo != 0) {
        if (hinfo < 0) {
            utility::LogError("{}: {}-th parameter is invalid.", msg, -hinfo);
        } else if (hinfo > 0) {
            utility::LogError("{}: singular condition detected.", msg);
        } else {
            utility::LogError("{}: status error code = {}.", msg, status);
        }
    }
}
 
class CuSolverContext {
public:
    static CuSolverContext& GetInstance();
 
    CuSolverContext(const CuSolverContext&) = delete;
    CuSolverContext& operator=(const CuSolverContext&) = delete;
    ~CuSolverContext();
 
    cusolverDnHandle_t& GetHandle(const Device& device);
 
private:
    CuSolverContext();
    std::unordered_map<Device, cusolverDnHandle_t> map_device_to_handle_;
};
 
class CuBLASContext {
public:
    static CuBLASContext& GetInstance();
 
    CuBLASContext(const CuBLASContext&) = delete;
    CuBLASContext& operator=(const CuBLASContext&) = delete;
    ~CuBLASContext();
 
    cublasHandle_t& GetHandle(const Device& device);
 
private:
    CuBLASContext();
    std::unordered_map<Device, cublasHandle_t> map_device_to_handle_;
};
#endif
}  // namespace core
}  // namespace cloudViewer