AthCUDA/AthCUDAServices/src/Stream.cxx

Go to the documentation of this file.

//
// Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
//
 
// Local include(s).
#include "Stream.h"
 
// Framework include(s).
#include "CxxUtils/checker_macros.h"
 
// System include(s).
#include <format>
#include <stdexcept>

#define CUDA_ERROR_CHECK(EXP)                                                  \
  do {                                                                         \
    cudaError_t errorCode = EXP;                                               \
    if (errorCode != cudaSuccess) {                                            \
      throw std::runtime_error(std::format("{}:{} Failed to execute: {} ({})", \
                                           __FILE__, __LINE__, #EXP,           \
                                           cudaGetErrorString(errorCode)));    \
    }                                                                          \
  } while (false)
 
namespace AthCUDA::Details {
 
Stream::Stream() {
  CUDA_ERROR_CHECK(cudaStreamCreate(&m_stream));
}

Stream::~Stream() {
  cudaStreamDestroy(m_stream);
}
 
cudaStream_t Stream::stream() const {
 
  // The CUDA runtime promises thread safety for handling streams in parallel
  // from different CPU threads. Returning a non-const pointer of course allows
  // us to cause harm. But as long as user code is not trying to actively break
  // things, we should be fine.
  cudaStream_t result ATLAS_THREAD_SAFE = m_stream;
  return result;
}
 
std::string Stream::name() const {
 
  // Get the device's properties.
  int device = -1;
  CUDA_ERROR_CHECK(cudaStreamGetDevice(stream(), &device));
  cudaDeviceProp props;
  CUDA_ERROR_CHECK(cudaGetDeviceProperties(&props, device));
 
  // Construct a unique name out of those properties.
  return std::format("{} [id: {}, bus: {}, device: {}]", props.name, device,
                     props.pciBusID, props.pciDeviceID);
}
 
}  // namespace AthCUDA::Details