Gaudi::CUDA::DeviceArray< T > Class Template Reference

#include </builds/gaudi/Gaudi/GaudiCUDA/src/CUDADeviceArray.h>

Collaboration diagram for Gaudi::CUDA::DeviceArray< T >:

Public Member Functions
	DeviceArray (Stream &stream, std::size_t len)
	Construct DeviceArray local to a Stream (i.e. Algorithm). May not be stored in whiteboard.
	DeviceArray (DeviceArrayGlobalTag_t globalTag, std::size_t len)
	Construct global DeviceArray (may be stored in whiteboard).
	~DeviceArray ()
	Destructor.
template<HostRange< T > R>
DeviceArray &	operator= (const R &src)
	Copy from a HostRange.
DeviceArray &	operator= (const T &src)
	Copy from a host value (for size 1).
DeviceArray &	operator= (const DeviceArray &rhs)
	Copy from another DeviceArray You can copy between arrays in the same stream, or between a local and a global DeviceArray.
template<HostRange< T > R>
void	toHost (R &dest)
	Copy to a HostRange.
void	toHost (T &dest)
	Copy to a host value (for size 1).
T *	devPtr ()
	Return raw device pointer.
T *	operator& ()
	Alias for devPtr.
T *	operator-> ()
	Allow access to struct members.
template<HostRange< T > R>
DeviceArray< T > &	operator= (const R &src)

Private Attributes
T *	m_ptr
const std::size_t	m_len
const std::size_t	m_size
Stream *const	m_stream

Detailed Description

template<TriviallyCopyable T>
class Gaudi::CUDA::DeviceArray< T >

Definition at line 44 of file CUDADeviceArray.h.

Constructor & Destructor Documentation

DeviceArray() [1/2]

template<TriviallyCopyable T>

Gaudi::CUDA::DeviceArray< T >::DeviceArray	(	Stream &	stream,
		std::size_t	len )

Construct DeviceArray local to a Stream (i.e. Algorithm). May not be stored in whiteboard.

Definition at line 100 of file CUDADeviceArray.h.

      : m_ptr( static_cast<T*>( Detail::allocateWithStream( len * sizeof( T ), stream ) ) )
      , m_len( len )
      , m_size( len * sizeof( T ) )
      , m_stream( &stream ) {
    stream.registerDependency();
  }

DeviceArray() [2/2]

template<TriviallyCopyable T>

Gaudi::CUDA::DeviceArray< T >::DeviceArray	(	DeviceArrayGlobalTag_t	globalTag,
		std::size_t	len )

Construct global DeviceArray (may be stored in whiteboard).

Definition at line 109 of file CUDADeviceArray.h.

      : m_ptr( static_cast<T*>(
            Detail::allocateNoStream( len * sizeof( T ), globalTag.hasAsyncParent ? globalTag.asyncPtr : nullptr ) ) )
      , m_len( len )
      , m_size( len * sizeof( T ) )
      , m_stream( nullptr ) {}

~DeviceArray()

template<TriviallyCopyable T>

Gaudi::CUDA::DeviceArray< T >::~DeviceArray

(

)

Destructor.

Definition at line 117 of file CUDADeviceArray.h.

                               {
    if ( m_stream == nullptr ) {
      Detail::freeNoStream( m_ptr );
    } else {
      Detail::freeWithStream( m_ptr, *m_stream );
      m_stream->removeDependency();
    }
  }

Member Function Documentation

devPtr()

template<TriviallyCopyable T>

T * Gaudi::CUDA::DeviceArray< T >::devPtr ( )

inline

Return raw device pointer.

Definition at line 69 of file CUDADeviceArray.h.

{ return m_ptr; };

operator&()

template<TriviallyCopyable T>

T * Gaudi::CUDA::DeviceArray< T >::operator& ( )

inline

Alias for devPtr.

Definition at line 71 of file CUDADeviceArray.h.

{ return m_ptr; }

operator->()

template<TriviallyCopyable T>

T * Gaudi::CUDA::DeviceArray< T >::operator-> ( )

inline

Allow access to struct members.

Definition at line 73 of file CUDADeviceArray.h.

{ return m_ptr; }

operator=() [1/4]

template<TriviallyCopyable T>

DeviceArray< T > & Gaudi::CUDA::DeviceArray< T >::operator=

(

const DeviceArray< T > &

rhs

)

Copy from another DeviceArray You can copy between arrays in the same stream, or between a local and a global DeviceArray.

You cannot copy between arrays in different streams.

Definition at line 149 of file CUDADeviceArray.h.

                                                                     {
    if ( this == &rhs ) { return *this; }
    if ( m_stream != nullptr && rhs.m_stream != nullptr && m_stream != rhs.m_stream ) {
      m_stream->parent()->error()
          << "Device to device copies between DeviceArrays on different streams are not allowed!" << endmsg;
      throw GaudiException( "Device to device copy with mismatched streams", "CUDADeviceArrayException",
                            StatusCode::FAILURE );
    }
    if ( m_len != rhs.m_len ) {
      if ( m_stream != nullptr ) {
        m_stream->parent()->error() << "Device to device copy with mismatched sizes: " << rhs.m_len << " and " << m_len
                                    << endmsg;
        throw GaudiException( "Device to device copy with mismatched sizes", "CUDADeviceArrayException",
                              StatusCode::FAILURE );
      }
      if ( rhs.m_stream != nullptr ) {
        rhs.m_stream->parent()->error() << "Device to device copy with mismatched sizes: " << rhs.m_len << " and "
                                        << m_len << endmsg;
        throw GaudiException( "Device to device copy with mismatched sizes", "CUDADeviceArrayException",
                              StatusCode::FAILURE );
      }
      // We want the error message so we throw an exception
      throw GaudiException( "Device to device copy with mismatched sizes", "CUDADeviceArrayException",
                            StatusCode::FAILURE );
    }
 
    // Do the copy
    if ( m_stream != nullptr ) {
      Detail::copyDeviceToDeviceWithStream( m_ptr, rhs.m_ptr, m_size, *m_stream );
    } else if ( rhs.m_stream != nullptr ) {
      Detail::copyDeviceToDeviceWithStream( m_ptr, rhs.m_ptr, m_size, *rhs.m_stream );
    } else {
      Detail::copyDeviceToDeviceNoStream( m_ptr, rhs.m_ptr, m_size );
    }
    return *this;
  }

operator=() [2/4]

template<TriviallyCopyable T>

template<HostRange< T > R>

DeviceArray< T > & Gaudi::CUDA::DeviceArray< T >::operator=

(

const R &

src

)

Definition at line 128 of file CUDADeviceArray.h.

                                                        {
    // Guard against mismatched sizes
    if ( std::ranges::size( src ) != m_len ) {
      if ( m_stream != nullptr ) {
        m_stream->parent()->error() << "Host to device copy with mismatched sizes: " << std::ranges::size( src )
                                    << " on host and " << m_len << " on device" << endmsg;
        throw GaudiException( "Host to device copy with mismatched sizes", "CUDADeviceArrayException",
                              StatusCode::FAILURE );
      } // We want the error message so we throw an exception
      throw GaudiException( "Host to device copy with mismatched sizes", "CUDADeviceArrayException",
                            StatusCode::FAILURE );
    }
    if ( m_stream == nullptr ) {
      Detail::copyHostToDeviceNoStream( m_ptr, std::ranges::data( src ), m_size );
      return *this;
    }
    Detail::copyHostToDeviceWithStream( m_ptr, std::ranges::data( src ), m_size, *m_stream );
    return *this;
  }

operator=() [3/4]

template<TriviallyCopyable T>

template<HostRange< T > R>

DeviceArray & Gaudi::CUDA::DeviceArray< T >::operator=

(

const R &

src

)

Copy from a HostRange.

operator=() [4/4]

template<TriviallyCopyable T>

DeviceArray & Gaudi::CUDA::DeviceArray< T >::operator= ( const T & src )

inline

Copy from a host value (for size 1).

Definition at line 57 of file CUDADeviceArray.h.

{ return this->operator=( std::span<T, 1>( &src, 1 ) ); }

toHost() [1/2]

template<TriviallyCopyable T>

template<HostRange< T > R>

void Gaudi::CUDA::DeviceArray< T >::toHost

(

R &

dest

)

Copy to a HostRange.

Definition at line 188 of file CUDADeviceArray.h.

                                       {
    // Guard against mismatched sizes
    if ( std::ranges::size( dest ) != m_len ) {
      if ( m_stream != nullptr ) {
        m_stream->parent()->error() << "Device to host copy with mismatched sizes: " << m_len << " on device and "
                                    << std::ranges::size( dest ) << " on host" << endmsg;
        throw GaudiException( "Device to host copy with mismatched sizes", "CUDADeviceArrayException",
                              StatusCode::FAILURE );
      } // We want the error message so we throw an exception
      throw GaudiException( "Device to host copy with mismatched sizes", "CUDADeviceArrayException",
                            StatusCode::FAILURE );
    }
    if ( m_stream == nullptr ) {
      Detail::copyDeviceToHostNoStream( std::ranges::data( dest ), m_ptr, m_size );
      return;
    }
    Detail::copyDeviceToHostWithStream( std::ranges::data( dest ), m_ptr, m_size, *m_stream );
  }

toHost() [2/2]

template<TriviallyCopyable T>

void Gaudi::CUDA::DeviceArray< T >::toHost

(

T &

dest

)

Copy to a host value (for size 1).

Definition at line 208 of file CUDADeviceArray.h.

                                       {
    std::span<T, 1> dest_span( &dest, 1 );
    this->toHost( dest_span );
  }

Member Data Documentation

m_len

template<TriviallyCopyable T>

const std::size_t Gaudi::CUDA::DeviceArray< T >::m_len

private

Definition at line 77 of file CUDADeviceArray.h.

m_ptr

template<TriviallyCopyable T>

T* Gaudi::CUDA::DeviceArray< T >::m_ptr

private

Definition at line 76 of file CUDADeviceArray.h.

m_size

template<TriviallyCopyable T>

const std::size_t Gaudi::CUDA::DeviceArray< T >::m_size

private

Definition at line 78 of file CUDADeviceArray.h.

m_stream

template<TriviallyCopyable T>

Stream* const Gaudi::CUDA::DeviceArray< T >::m_stream

private

Definition at line 79 of file CUDADeviceArray.h.

---

The documentation for this class was generated from the following file:

• GaudiCUDA/src/CUDADeviceArray.h