device.hpp

Go to the documentation of this file.

// Copyright (c) 2023--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#pragma once
 
#include <string_view>
 
#ifdef NDA_HAVE_CUDA
#include "./concepts.hpp"
#include "./exceptions.hpp"
 
#include <cuda_runtime.h>
#include <cublas_v2.h>
 
#include <complex>
#include <exception>
#include <string>
#include <type_traits>
#endif // NDA_HAVE_CUDA
 
namespace nda {


  template <bool flag = false>
  void compile_error_no_gpu() {
    static_assert(flag, "Using device functionality without gpu support! Configure project with -DCudaSupport=ON.");
  }
 
#ifdef NDA_HAVE_CUDA

  static constexpr bool have_device = true;

  static constexpr bool have_cuda = true;

  inline void device_error_check(cudaError_t success, std::string message = "") {
    if (success != cudaSuccess) {
      NDA_RUNTIME_ERROR << "Cuda runtime error: " << std::to_string(success) << "\n"
                        << " message: " << message << "\n"
                        << " cudaGetErrorName: " << std::string(cudaGetErrorName(success)) << "\n"
                        << " cudaGetErrorString: " << std::string(cudaGetErrorString(success)) << "\n";
    }
  }

  inline void cuda_device_sync(bool do_sync = true, std::string_view func = "") {
    if (!do_sync) return;
    std::string msg = "cudaDeviceSynchronize failed";
    if (!func.empty()) {
      msg += " after call to ";
      msg.append(func);
    }
    device_error_check(cudaDeviceSynchronize(), std::move(msg));
  }

  inline cublasOperation_t get_cublas_op(char op) {
    switch (op) {
      case 'N': return CUBLAS_OP_N;
      case 'T': return CUBLAS_OP_T;
      case 'C': return CUBLAS_OP_C;
      default: std::terminate(); return {};
    }
  }

  template <FloatOrDouble T>
  using cuda_complex_t = std::conditional_t<std::is_same_v<T, float>, cuComplex, cuDoubleComplex>;

  template <FloatOrDouble T>
  cuda_complex_t<T> cucplx(std::complex<T> c) {
    return {c.real(), c.imag()};
  }

  template <typename T>
  using cuda_scalar_t = std::conditional_t<std::is_same_v<T, std::complex<float>>, cuComplex,
                                           std::conditional_t<std::is_same_v<T, std::complex<double>>, cuDoubleComplex, T>>;

  template <typename T>
  struct alignas(16) cuscalar {
    cuda_scalar_t<T> value;

    explicit cuscalar(T x) {
      if constexpr (is_complex_v<T>)
        value = cucplx(x);
      else
        value = x;
    }

    operator cuda_scalar_t<T> const *() const { return &value; } // NOLINT (implicit conversion is the point)
  };

  template <FloatOrDouble T>
  cuda_complex_t<T> *cucplx(std::complex<T> *c) {
    return reinterpret_cast<cuda_complex_t<T> *>(c); // NOLINT
  }

  template <FloatOrDouble T>
  cuda_complex_t<T> const *cucplx(std::complex<T> const *c) {
    return reinterpret_cast<cuda_complex_t<T> const *>(c); // NOLINT
  }

  template <FloatOrDouble T>
  cuda_complex_t<T> **cucplx(std::complex<T> **c) {
    return reinterpret_cast<cuda_complex_t<T> **>(c); // NOLINT
  }

  template <FloatOrDouble T>
  cuda_complex_t<T> const **cucplx(std::complex<T> const **c) {
    return reinterpret_cast<cuda_complex_t<T> const **>(c); // NOLINT
  }
 
#else

#define device_error_check(ARG1, ARG2) compile_error_no_gpu()

  static constexpr bool have_device = false;

  static constexpr bool have_cuda = false;

  inline void cuda_device_sync([[maybe_unused]] bool do_sync = true, [[maybe_unused]] std::string_view func = "") {}
 
#endif // NDA_HAVE_CUDA

 
} // namespace nda