The base class for Kokkos arrays. More...

#include <KokkosArray.h>

Inheritance diagram for Moose::Kokkos::ArrayBase< T, dimension, index_type >:

Classes
class	constructed_entry_iterator
	Iterator over tracked constructed entries. More...

class	constructed_entry_range
	Range over tracked constructed entries. More...

class	iterator
	Array iterator. More...

Public Types
using	unsigned_index_type = index_type

using	signed_index_type = typename std::make_signed< index_type >::type

Public Member Functions
	ArrayBase (const LayoutType layout)
	Constructor. More...

template<typename... size_type>
	ArrayBase (const LayoutType layout, size_type... n)
	Constructor Initialize and allocate array with given dimensions This allocates both host and device data. More...

	ArrayBase (const ArrayBase< T, dimension, index_type > &array)
	Copy constructor. More...

	~ArrayBase ()
	Destructor. More...

void	destroy ()
	Free all data and reset. More...

void	shallowCopy (const ArrayBase< T, dimension, index_type > &array)
	Shallow copy another Kokkos array. More...

unsigned int	useCount () const
	Get the reference count. More...

bool	isSlotConstructed (index_type i) const
	Get whether slot i is tracked as constructed. More...

constructed_entry_range< false >	constructedEntries ()
	Get host-side range over entries tracked as constructed. More...

constructed_entry_range< true >	constructedEntries () const
	Get host-side range over entries tracked as constructed. More...

KOKKOS_FUNCTION bool	isAlloc () const
	Get whether the array was allocated either on host or device. More...

KOKKOS_FUNCTION bool	isHostAlloc () const
	Get whether the array was allocated on host. More...

KOKKOS_FUNCTION bool	isDeviceAlloc () const
	Get whether the array was allocated on device. More...

KOKKOS_FUNCTION bool	isHostAlias () const
	Get whether the host array was aliased. More...

KOKKOS_FUNCTION bool	isDeviceAlias () const
	Get whether the device array was aliased. More...

KOKKOS_FUNCTION index_type	size () const
	Get the total array size. More...

KOKKOS_FUNCTION index_type	n (unsigned int dim) const
	Get the size of a dimension. More...

KOKKOS_FUNCTION T *	data () const
	Get the data pointer. More...

KOKKOS_FUNCTION T &	first () const
	Get the first element. More...

KOKKOS_FUNCTION T &	last () const
	Get the last element. More...

KOKKOS_FUNCTION T &	operator[] (index_type i) const
	Get an array entry. More...

T *	hostData () const
	Get the host data pointer. More...

T *	deviceData () const
	Get the device data pointer. More...

auto	hostView () const
	Get the host unmanaged view. More...

auto	deviceView () const
	Get the device unmanaged view. More...

template<typename... size_type>
void	init (size_type... n)
	Initialize array with given dimensions but do not allocate. More...

template<bool initialize = true>
void	create (const std::vector< index_type > &n)
	Allocate array on host and device. More...

template<bool initialize = true, typename... size_type>
void	create (size_type... n)
	Allocate array on host and device. More...

template<bool initialize = true>
void	createHost (const std::vector< index_type > &n)
	Allocate array on host only. More...

template<bool initialize = true, typename... size_type>
void	createHost (size_type... n)
	Allocate array on host only. More...

void	createDevice (const std::vector< index_type > &n)
	Allocate array on device only. More...

template<typename... size_type>
void	createDevice (size_type... n)
	Allocate array on device only. More...

void	aliasHost (T *ptr)
	Point the host data to an external data instead of allocating it. More...

void	aliasDevice (T *ptr)
	Point the device data to an external data instead of allocating it. More...

void	offset (const std::vector< signed_index_type > &d)
	Apply starting index offsets to each dimension. More...

template<typename... offset_type>
void	offset (offset_type... d)
	Apply starting index offsets to each dimension. More...

void	copyToDevice ()
	Copy data from host to device. More...

void	copyToHost ()
	Copy data from device to host. More...

void	copyIn (const T *ptr, MemcpyType dir, index_type n, index_type offset=0)
	Copy data from an external data to this array. More...

void	copyOut (T *ptr, MemcpyType dir, index_type n, index_type offset=0)
	Copy data to an external data from this array. More...

void	copyToDeviceNested ()
	Copy all the nested Kokkos arrays including self from host to device. More...

void	moveToDevice (bool should_free_host=true)
	Copy data from host to device and deallocate host. More...

void	moveToHost (bool should_free_device=true)
	Copy data from device to host and deallocate device. More...

void	deepCopy (const ArrayBase< T, dimension, index_type > &array)
	Deep copy another Kokkos array If ArrayDeepCopy<T>::value is true, it will copy-construct each entry If ArrayDeepCopy<T>::value is false, it will do a memory copy. More...

void	swap (ArrayBase< T, dimension, index_type > &array)
	Swap with another Kokkos array. More...

auto &	operator= (const T &scalar)
	Assign a scalar value uniformly. More...

KOKKOS_FUNCTION iterator	begin () const
	Get the beginning iterator. More...

KOKKOS_FUNCTION iterator	end () const
	Get the end iterator. More...

Protected Member Functions
template<bool host, bool device, bool initialize, typename... size_type>
void	createInternal (size_type... n)
	The internal method to initialize and allocate this array. More...

template<bool host, bool device, bool initialize>
void	createInternal (const std::vector< index_type > &n)
	The internal method to initialize and allocate this array. More...

template<bool initialize>
void	createInternal (const std::vector< index_type > &n, bool host, bool device)
	The internal method to initialize and allocate this array. More...

template<typename TargetSpace , typename SourceSpace >
void	copyInternal (T target, const T source, index_type n)
	The internal method to perform a memory copy. More...

template<typename... Args>
T &	emplaceAt (index_type i, Args &&... args)
	Placement-new construct slot i from args, recording initialization. More...

Protected Attributes
index_type	_n [dimension] = {0}
	Size of each dimension. More...

index_type	_s [dimension] = {0}
	Stride of each dimension. More...

signed_index_type	_d [dimension] = {0}
	Offset of each dimension. More...

Private Member Functions
template<bool initialize>
void	allocHost ()
	Allocate host data for an initialized array that has not allocated host data. More...

void	allocDevice ()
	Allocate device data for an initialized array that has not allocated device data. More...

void	freeHost ()
	Free host data. More...

void	freeDevice ()
	Free device data. More...

Private Attributes
std::shared_ptr< unsigned int >	_counter
	Reference counter. More...

std::shared_ptr< std::vector< bool > >	_slots_constructed
	Non-null only for malloc-allocated arrays; tracks which slots have been emplace-constructed. More...

bool	_is_init = false
	Flag whether array was initialized. More...

bool	_is_host_alloc = false
	Flag whether host data was allocated. More...

bool	_is_device_alloc = false
	Flag whether device data was allocated. More...

bool	_is_host_alias = false
	Flag whether the host data points to an external data. More...

bool	_is_device_alias = false
	Flag whether the device data points to an external data. More...

T *	_host_data = nullptr
	Host data. More...

T *	_device_data = nullptr
	Device data. More...

index_type	_size = 0
	Total size. More...

const LayoutType	_layout
	Memory layout type. More...

Detailed Description

template<typename T, unsigned int dimension, typename index_type>
class Moose::Kokkos::ArrayBase< T, dimension, index_type >

The base class for Kokkos arrays.

Definition at line 107 of file KokkosArray.h.

Member Typedef Documentation

◆ signed_index_type

template<typename T, unsigned int dimension, typename index_type>

using Moose::Kokkos::ArrayBase< T, dimension, index_type >::signed_index_type = typename std::make_signed<index_type>::type

Definition at line 115 of file KokkosArray.h.

◆ unsigned_index_type

template<typename T, unsigned int dimension, typename index_type>

using Moose::Kokkos::ArrayBase< T, dimension, index_type >::unsigned_index_type = index_type

Definition at line 114 of file KokkosArray.h.

Constructor & Destructor Documentation

◆ ArrayBase() [1/3]

template<typename T, unsigned int dimension, typename index_type>

Moose::Kokkos::ArrayBase< T, dimension, index_type >::ArrayBase ( const LayoutType layout )

inline

Constructor.

Parameters

layout The memory layout type

Definition at line 121 of file KokkosArray.h.

121 : _layout(layout) {}

Moose::Kokkos::ArrayBase::_layout

const LayoutType _layout

Memory layout type.

Definition: KokkosArray.h:713

◆ ArrayBase() [2/3]

template<typename T, unsigned int dimension, typename index_type>

template<typename... size_type>

Moose::Kokkos::ArrayBase< T, dimension, index_type >::ArrayBase	(	const LayoutType	layout,
		size_type...	n
	)

inline

Constructor Initialize and allocate array with given dimensions This allocates both host and device data.

Parameters

layout	The memory layout type
n	The size of each dimension

Definition at line 132 of file KokkosArray.h.

                                                      : _layout(layout)
   {
     create(n...);
   }

◆ ArrayBase() [3/3]

template<typename T, unsigned int dimension, typename index_type>

Moose::Kokkos::ArrayBase< T, dimension, index_type >::ArrayBase ( const ArrayBase< T, dimension, index_type > & array )

inline

Copy constructor.

Definition at line 141 of file KokkosArray.h.

                                                                : _layout(array._layout)
   {
 #ifndef MOOSE_KOKKOS_SCOPE
     static_assert(!ArrayDeepCopy<T>::value,
                   "Kokkos array cannot be deep copied outside the Kokkos compilation scope");
 #endif
 
     if constexpr (ArrayDeepCopy<T>::value)
       deepCopy(array);
     else
       shallowCopy(array);
   }

◆ ~ArrayBase()

template<typename T, unsigned int dimension, typename index_type>

Moose::Kokkos::ArrayBase< T, dimension, index_type >::~ArrayBase ( )

inline

Destructor.

Definition at line 157 of file KokkosArray.h.

157 { destroy(); }

Moose::Kokkos::ArrayBase::destroy

void destroy()

Free all data and reset.

Definition: KokkosArray.h:896

Member Function Documentation

◆ aliasDevice()

template<typename T, unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasDevice ( T * ptr )

Point the device data to an external data instead of allocating it.

Parameters

ptr	The pointer to the external device data

Definition at line 980 of file KokkosArray.h.

 {
   if (!_is_init)
     mooseError("Kokkos array error: attempted to alias device data before array initialization.");
 
   if (_is_device_alloc && !_is_device_alias)
     mooseError("Kokkos array error: cannot alias device data because device data was not aliased.");
 
   _device_data = ptr;
   _is_device_alloc = true;
   _is_device_alias = true;
 }

◆ aliasHost()

template<typename T, unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasHost ( T * ptr )

Point the host data to an external data instead of allocating it.

Parameters

ptr	The pointer to the external host data

Definition at line 965 of file KokkosArray.h.

 {
   if (!_is_init)
     mooseError("Kokkos array error: attempted to alias host data before array initialization.");
 
   if (_is_host_alloc && !_is_host_alias)
     mooseError("Kokkos array error: cannot alias host data because host data was not aliased.");
 
   _host_data = ptr;
   _is_host_alloc = true;
   _is_host_alias = true;
 }

◆ allocDevice()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocDevice ( )

private

Allocate device data for an initialized array that has not allocated device data.

Definition at line 1020 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::copyToDevice(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::createInternal().

 {
   if (_is_device_alloc)
     return;
 
   _device_data =
       static_cast<T *>(::Kokkos::kokkos_malloc<ExecSpace::memory_space>(_size * sizeof(T)));
 
   _is_device_alloc = true;
 }

◆ allocHost()

template<typename T , unsigned int dimension, typename index_type >

template<bool initialize>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocHost ( )

private

Allocate host data for an initialized array that has not allocated host data.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Definition at line 996 of file KokkosArray.h.

 {
   if (_is_host_alloc)
     return;
 
   if constexpr (initialize)
   {
     static_assert(
         std::is_default_constructible<T>::value,
         "Data type is not default-constructible. Initialization argument should be set to false.");
 
     _host_data = new T[_size];
   }
   else
   {
     _host_data = static_cast<T *>(std::malloc(_size * sizeof(T)));
     _slots_constructed = std::make_shared<std::vector<bool>>(_size, false);
   }
 
   _is_host_alloc = true;
 }

◆ begin()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION iterator Moose::Kokkos::ArrayBase< T, dimension, index_type >::begin ( ) const

inline

Get the beginning iterator.

Returns: The beginning iterator

Definition at line 568 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copySet(), and Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copyVector().

   {
     KOKKOS_IF_ON_HOST(return iterator(_host_data);)
 
     return iterator(_device_data);
   }

◆ constructedEntries() [1/2]

template<typename T , unsigned int dimension, typename index_type >

ArrayBase< T, dimension, index_type >::template constructed_entry_range< false > Moose::Kokkos::ArrayBase< T, dimension, index_type >::constructedEntries ( )

Get host-side range over entries tracked as constructed.

Returns: Range that skips slots for which isSlotConstructed() is false

Definition at line 802 of file KokkosArray.h.

 {
   return constructed_entry_range<false>(*this);
 }

◆ constructedEntries() [2/2]

template<typename T , unsigned int dimension, typename index_type >

ArrayBase< T, dimension, index_type >::template constructed_entry_range< true > Moose::Kokkos::ArrayBase< T, dimension, index_type >::constructedEntries ( ) const

Get host-side range over entries tracked as constructed.

Returns: Range that skips slots for which isSlotConstructed() is false

Definition at line 809 of file KokkosArray.h.

 {
   return constructed_entry_range<true>(*this);
 }

◆ copyIn()

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn	(	const T *	ptr,
		MemcpyType	dir,
		index_type	n,
		index_type	offset = `0`
	)

Copy data from an external data to this array.

Parameters

ptr	The pointer to the external data
dir	The copy direction
n	The number of entries to copy
offset	The starting offset of this array

Definition at line 1248 of file KokkosArray.h.

Referenced by Moose::Kokkos::dataLoad().

 {
   if (n > _size)
     mooseError("Kokkos array error: cannot copy in data larger than the array size.");
 
   if (offset > _size)
     mooseError("Kokkos array error: offset cannot be larger than the array size.");
 
   if (dir == MemcpyType::HOST_TO_HOST)
   {
     // If host side memory is not allocated, print error
     if (!_is_host_alloc)
       mooseError(
           "Kokkos array error: cannot copy in to the array because host memory was not allocated.");
 
     // Copy from host to host
     copyInternal<::Kokkos::HostSpace, ::Kokkos::HostSpace>(_host_data + offset, ptr, n);
   }
   else if (dir == MemcpyType::HOST_TO_DEVICE)
   {
     // If device side memory is not allocated, print error
     if (!_is_device_alloc)
       mooseError("Kokkos array error: cannot copy in to the array because device memory was not "
                  "allocated.");
 
     // Copy from host to device
     copyInternal<MemSpace, ::Kokkos::HostSpace>(_device_data + offset, ptr, n);
   }
   else if (dir == MemcpyType::DEVICE_TO_HOST)
   {
     // If host side memory is not allocated, print error
     if (!_is_host_alloc)
       mooseError(
           "Kokkos array error: cannot copy in to the array because host memory was not allocated.");
 
     // Copy from device to host
     copyInternal<::Kokkos::HostSpace, MemSpace>(_host_data + offset, ptr, n);
   }
   else if (dir == MemcpyType::DEVICE_TO_DEVICE)
   {
     // If device side memory is not allocated, print error
     if (!_is_device_alloc)
       mooseError("Kokkos array error: cannot copy in to the array because device memory was not "
                  "allocated.");
 
     // Copy from device to device
     copyInternal<MemSpace, MemSpace>(_device_data + offset, ptr, n);
   }
 }

◆ copyInternal()

template<typename T, unsigned int dimension, typename index_type>

template<typename TargetSpace , typename SourceSpace >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyInternal	(	T *	target,
		const T *	source,
		index_type	n
	)

protected

The internal method to perform a memory copy.

Template Parameters

TargetSpace	The Kokkos memory space of target data
Sourcespace	The Kokkos memory space of source data

Parameters

target	The pointer to the target data
source	The pointer to the source data
n	The number of entries to copy

Definition at line 1129 of file KokkosArray.h.

 {
   ::Kokkos::Impl::DeepCopy<TargetSpace, SourceSpace>(target, source, n * sizeof(T));
   ::Kokkos::fence();
 }

◆ copyOut()

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut	(	T *	ptr,
		MemcpyType	dir,
		index_type	n,
		index_type	offset = `0`
	)

Copy data to an external data from this array.

Parameters

ptr	The pointer to the external data
dir	The copy direction
n	The number of entries to copy
offset	The starting offset of this array

Definition at line 1303 of file KokkosArray.h.

Referenced by Moose::Kokkos::dataStore().

 {
   if (n > _size)
     mooseError("Kokkos array error: cannot copy out data larger than the array size.");
 
   if (offset > _size)
     mooseError("Kokkos array error: offset cannot be larger than the array size.");
 
   if (dir == MemcpyType::HOST_TO_HOST)
   {
     // If host side memory is not allocated, print error
     if (!_is_host_alloc)
       mooseError("Kokkos array error: cannot copy out from the array because host memory was not "
                  "allocated.");
 
     // Copy from host to host
     copyInternal<::Kokkos::HostSpace, ::Kokkos::HostSpace>(ptr, _host_data + offset, n);
   }
   else if (dir == MemcpyType::HOST_TO_DEVICE)
   {
     // If host side memory is not allocated, print error
     if (!_is_host_alloc)
       mooseError("Kokkos array error: cannot copy out from the array because host memory was not "
                  "allocated.");
 
     // Copy from host to device
     copyInternal<MemSpace, ::Kokkos::HostSpace>(ptr, _host_data + offset, n);
   }
   else if (dir == MemcpyType::DEVICE_TO_HOST)
   {
     // If device side memory is not allocated, print error
     if (!_is_device_alloc)
       mooseError("Kokkos array error: cannot copy out from the array because device memory was not "
                  "allocated.");
 
     // Copy from device to host
     copyInternal<::Kokkos::HostSpace, MemSpace>(ptr, _device_data + offset, n);
   }
   else if (dir == MemcpyType::DEVICE_TO_DEVICE)
   {
     // If device side memory is not allocated, print error
     if (!_is_device_alloc)
       mooseError("Kokkos array error: cannot copy out from the array because device memory was not "
                  "allocated.");
 
     // Copy from device to device
     copyInternal<MemSpace, MemSpace>(ptr, _device_data + offset, n);
   }
 }

◆ copyToDevice()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice ( )

Copy data from host to device.

Definition at line 1167 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::copyToDeviceNested(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::moveToDevice(), Moose::Kokkos::VariableGradientTempl< is_ad >::VariableGradientTempl(), and Moose::Kokkos::VariableValueTempl< is_ad >::VariableValueTempl().

 {
   // If host side memory is not allocated, do nothing
   if (!_is_host_alloc)
     return;
 
   // If device side memory is not allocated,
   if (!_is_device_alloc)
   {
     if (_counter.use_count() == 1)
       // allocate memory if this array is not shared with other arrays
       allocDevice();
     else
       // print error if this array is shared with other arrays
       mooseError("Kokkos array error: cannot copy from host to device because device memory "
                  "was not allocated. Cannot allocate device memory for copy because the array is "
                  "being shared.");
   }
 
   // Copy from host to device
   copyInternal<MemSpace, ::Kokkos::HostSpace>(_device_data, _host_data, _size);
 }

◆ copyToDeviceNested()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDeviceNested ( )

Copy all the nested Kokkos arrays including self from host to device.

Definition at line 1371 of file KokkosArray.h.

 {
   for (const auto i : make_range(_size))
     copyToDeviceInner(_host_data[i]);
 
   copyToDevice();
 }

◆ copyToHost()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost ( )

Copy data from device to host.

Definition at line 1192 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::moveToHost().

 {
   // If device side memory is not allocated, do nothing
   if (!_is_device_alloc)
     return;
 
   // If host side memory is not allocated,
   if (!_is_host_alloc)
   {
     if (_counter.use_count() == 1)
       // allocate memory if this array is not shared with other arrays
       allocHost<false>();
     else
       // print error if this array is shared with other arrays
       mooseError("Kokkos array error: cannot copy from device to host because host memory "
                  "was not allocated. Cannot allocate host memory for copy because the array is "
                  "being shared.");
   }
 
   // Copy from device to host
   copyInternal<::Kokkos::HostSpace, MemSpace>(_host_data, _device_data, _size);
 }

◆ create() [1/2]

template<typename T, unsigned int dimension, typename index_type>

template<bool initialize = true>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::create ( const std::vector< index_type > & n )

inline

Allocate array on host and device.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Parameters

n	The vector containing the size of each dimension

Definition at line 392 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::ArrayBase(), Moose::Kokkos::VariableGradientTempl< is_ad >::VariableGradientTempl(), and Moose::Kokkos::VariableValueTempl< is_ad >::VariableValueTempl().

   {
     createInternal<true, true, initialize>(n);
   }

◆ create() [2/2]

template<typename T, unsigned int dimension, typename index_type>

template<bool initialize = true, typename... size_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::create ( size_type... n )

inline

Allocate array on host and device.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Parameters

n	The size of each dimension

Definition at line 402 of file KokkosArray.h.

   {
     createInternal<true, true, initialize>(n...);
   }

◆ createDevice() [1/2]

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createDevice ( const std::vector< index_type > & n )

inline

Allocate array on device only.

Parameters

n	The vector containing the size of each dimension

Definition at line 430 of file KokkosArray.h.

430 { createInternal<false, true, false>(n); }

Moose::Kokkos::ArrayBase::n

KOKKOS_FUNCTION index_type n(unsigned int dim) const

Get the size of a dimension.

Definition: KokkosArray.h:300

◆ createDevice() [2/2]

template<typename T, unsigned int dimension, typename index_type>

template<typename... size_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createDevice ( size_type... n )

inline

Allocate array on device only.

Parameters

n	The size of each dimension

Definition at line 436 of file KokkosArray.h.

   {
     createInternal<false, true, false>(n...);
   }

◆ createHost() [1/2]

template<typename T, unsigned int dimension, typename index_type>

template<bool initialize = true>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createHost ( const std::vector< index_type > & n )

inline

Allocate array on host only.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Parameters

n	The vector containing the size of each dimension

Definition at line 412 of file KokkosArray.h.

   {
     createInternal<true, false, initialize>(n);
   }

◆ createHost() [2/2]

template<typename T, unsigned int dimension, typename index_type>

template<bool initialize = true, typename... size_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createHost ( size_type... n )

inline

Allocate array on host only.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Parameters

n	The size of each dimension

Definition at line 422 of file KokkosArray.h.

   {
     createInternal<true, false, initialize>(n...);
   }

◆ createInternal() [1/3]

template<typename T , unsigned int dimension, typename index_type >

template<bool host, bool device, bool initialize, typename... size_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal ( size_type... n )

protected

The internal method to initialize and allocate this array.

Template Parameters

host	Whether host data will be allocated
device	Whether device data will be allocated
initialize	Whether to initialize host data (calls default constructor)

Parameters

n	The size of each dimension

Definition at line 1114 of file KokkosArray.h.

 {
   static_assert((std::is_convertible<size_type, index_type>::value && ...),
                 "All arguments must be convertible to index_type");
   static_assert(sizeof...(n) == dimension, "Number of arguments should match array dimension");
 
   std::vector<index_type> dims;
   (dims.push_back(n), ...);
 
   createInternal<host, device, initialize>(dims);
 }

◆ createInternal() [2/3]

template<typename T , unsigned int dimension, typename index_type>

template<bool host, bool device, bool initialize>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal ( const std::vector< index_type > & n )

protected

The internal method to initialize and allocate this array.

Template Parameters

host	Whether host data will be allocated
device	Whether device data will be allocated
initialize	Whether to initialize host data (calls default constructor)

Parameters

n	The vector containing the size of each dimension

Definition at line 1034 of file KokkosArray.h.

 {
   if (n.size() != dimension)
     mooseError("Kokkos array error: the number of dimensions provided (",
                n.size(),
                ") must match the array dimension (",
                dimension,
                ").");
 
   if (_counter)
     destroy();
 
   _counter = std::make_shared<unsigned int>();
 
   uint64_t overflow_checker = 1;
 
   _size = 1;
   _s[0] = 1;
 
   for (const auto i : make_range(dimension))
   {
     overflow_checker *= n[i];
 
     _n[i] = n[i];
     _size *= n[i];
   }
 
   if (overflow_checker > std::numeric_limits<index_type>::max())
     mooseError("Kokkos array error: the dimensions provided (",
                Moose::stringify(n),
                ") has the total size of ",
                overflow_checker,
                " which exceeds the limit of ",
                MooseUtils::prettyCppType<index_type>(),
                ".");
 
   if (_layout == LayoutType::LEFT)
   {
     _s[0] = 1;
 
     for (const auto i : make_range(1u, dimension))
       _s[i] = _s[i - 1] * _n[i - 1];
   }
   else
   {
     _s[dimension - 1] = 1;
 
     for (int i = dimension - 2; i >= 0; --i)
       _s[i] = _s[i + 1] * _n[i + 1];
   }
 
   if constexpr (host)
     allocHost<initialize>();
 
   if constexpr (device)
     allocDevice();
 
   _is_init = true;
 }

◆ createInternal() [3/3]

template<typename T , unsigned int dimension, typename index_type>

template<bool initialize>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal	(	const std::vector< index_type > &	n,
		bool	host,
		bool	device
	)

protected

The internal method to initialize and allocate this array.

Template Parameters

initialize Whether to initialize host data (calls default constructor)

Parameters

n	The vector containing the size of each dimension
host	The flag whether host data will be allocated
device	The flag whether device data will be allocated

Definition at line 1097 of file KokkosArray.h.

 {
   if (host && device)
     createInternal<true, true, initialize>(n);
   else if (host && !device)
     createInternal<true, false, initialize>(n);
   else if (!host && device)
     createInternal<false, true, initialize>(n);
   else
     createInternal<false, false, initialize>(n);
 }

◆ data()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION T* Moose::Kokkos::ArrayBase< T, dimension, index_type >::data ( ) const

inline

Get the data pointer.

Returns: The pointer to the underlying data depending on the architecture this function is being called on

Definition at line 306 of file KokkosArray.h.

Referenced by Moose::Kokkos::copyToDeviceInner(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), and Moose::Kokkos::Matrix::find().

   {
     KOKKOS_IF_ON_HOST(return _host_data;)
 
     return _device_data;
   }

◆ deepCopy()

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy ( const ArrayBase< T, dimension, index_type > & array )

Deep copy another Kokkos array If ArrayDeepCopy<T>::value is true, it will copy-construct each entry If ArrayDeepCopy<T>::value is false, it will do a memory copy.

Parameters

array The Kokkos array to be deep copied

Definition at line 1381 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::ArrayBase().

 {
   if (_layout != array._layout)
     mooseError("Kokkos array error: cannot deep copy arrays with different layouts.");
 
   if (ArrayDeepCopy<T>::value && !array._is_host_alloc)
     mooseError(
         "Kokkos array error: cannot deep copy using constructor from array without host data.");
 
   std::vector<index_type> n(std::begin(array._n), std::end(array._n));
 
   createInternal<false>(n, array._is_host_alloc, array._is_device_alloc);
 
   if (_is_host_alloc)
     for (const auto i : make_range(_size))
       if (array.isSlotConstructed(i))
         emplaceAt(i, array._host_data[i]);
 
   if (ArrayDeepCopy<T>::value)
     copyToDevice();
   else if (_is_device_alloc)
     copyInternal<MemSpace, MemSpace>(_device_data, array._device_data, _size);
 
   for (const auto i : make_range(dimension))
   {
     _d[i] = array._d[i];
     _s[i] = array._s[i];
   }
 }

◆ destroy()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy ( )

Free all data and reset.

Definition at line 896 of file KokkosArray.h.

Referenced by Moose::Kokkos::System::clearActiveMatrixTags(), Moose::Kokkos::System::clearActiveResidualTags(), Moose::Kokkos::System::clearActiveSolutionTags(), Moose::Kokkos::System::clearActiveVariables(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::~ArrayBase().

 {
   if (!_counter)
     return;
 
   if (_counter.use_count() > 1)
   {
     _host_data = nullptr;
     _device_data = nullptr;
   }
   else if (_counter.use_count() == 1)
   {
     freeHost();
     freeDevice();
   }
 
   _size = 0;
 
   for (const auto i : make_range(dimension))
   {
     _n[i] = 0;
     _s[i] = 0;
     _d[i] = 0;
   }
 
   _is_init = false;
   _is_host_alloc = false;
   _is_device_alloc = false;
   _is_host_alias = false;
   _is_device_alias = false;
 
   _counter.reset();
   _slots_constructed.reset();
 }

◆ deviceData()

template<typename T, unsigned int dimension, typename index_type>

T* Moose::Kokkos::ArrayBase< T, dimension, index_type >::deviceData ( ) const

inline

Get the device data pointer.

Returns: The pointer to the underlying device data

Definition at line 358 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copyVector().

358 { return _device_data; }

Moose::Kokkos::ArrayBase::_device_data

T * _device_data

Device data.

Definition: KokkosArray.h:705

◆ deviceView()

template<typename T, unsigned int dimension, typename index_type>

auto Moose::Kokkos::ArrayBase< T, dimension, index_type >::deviceView ( ) const

inline

Get the device unmanaged view.

Returns: The device unmanaged view

Definition at line 372 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::operator=().

   {
     return ::Kokkos::View<T *, MemSpace, ::Kokkos::MemoryTraits<::Kokkos::Unmanaged>>(_device_data,
                                                                                       _size);
   }

◆ emplaceAt()

template<typename T , unsigned int dimension, typename index_type>

template<typename... Args>

T & Moose::Kokkos::ArrayBase< T, dimension, index_type >::emplaceAt	(	index_type	i,
		Args &&...	args
	)

protected

Placement-new construct slot i from args, recording initialization.

Parameters

i	The dimensionless slot index
args	Arguments forwarded to T's constructor

Returns: Reference to the constructed element

Definition at line 830 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::deepCopy(), Moose::Kokkos::Array< ContiguousElementID >::emplace(), and Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::emplace().

 {
   mooseAssert(_is_host_alloc && _slots_constructed,
               "emplaceAt requires a malloc-allocated array (create<false>)");
   mooseAssert(i < _size, "emplaceAt index out of bounds");
 
   new (_host_data + i) T(std::forward<Args>(args)...);
   (*_slots_constructed)[i] = true;
 
   return _host_data[i];
 }

◆ end()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION iterator Moose::Kokkos::ArrayBase< T, dimension, index_type >::end ( ) const

inline

Get the end iterator.

Returns: The end iterator

Definition at line 578 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copySet().

   {
     KOKKOS_IF_ON_HOST(return iterator(_host_data + _size);)
 
     return iterator(_device_data + _size);
   }

◆ first()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension, index_type >::first ( ) const

inline

Get the first element.

Returns: The reference of the first element depending on the architecture this function is being called on

Definition at line 317 of file KokkosArray.h.

Referenced by Moose::Kokkos::RPNEvaluator::eval().

   {
     KOKKOS_IF_ON_HOST(return _host_data[0];)
 
     return _device_data[0];
   }

◆ freeDevice()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeDevice ( )

private

Free device data.

Definition at line 878 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::destroy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::moveToHost().

 {
   if (!_is_device_alloc)
     return;
 
   if (_is_device_alias)
   {
     _device_data = nullptr;
     _is_device_alias = false;
   }
   else
     Moose::Kokkos::free(_device_data);
 
   _is_device_alloc = false;
 }

◆ freeHost()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost ( )

private

Free host data.

Definition at line 845 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::destroy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::moveToDevice().

 {
   if (!_is_host_alloc)
     return;
 
   if (_is_host_alias)
   {
     _host_data = nullptr;
     _is_host_alias = false;
   }
   else
   {
     if (!_slots_constructed)
       // Allocated by new
       delete[] _host_data;
     else
     {
       // Allocated by malloc
       for (const auto i : make_range(_size))
         if (isSlotConstructed(i))
           _host_data[i].~T();
 
       std::free(_host_data);
 
       _slots_constructed.reset();
     }
   }
 
   _is_host_alloc = false;
 }

◆ hostData()

template<typename T, unsigned int dimension, typename index_type>

T* Moose::Kokkos::ArrayBase< T, dimension, index_type >::hostData ( ) const

inline

Get the host data pointer.

Returns: The pointer to the underlying host data

Definition at line 353 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copyVector().

353 { return _host_data; }

Moose::Kokkos::ArrayBase::_host_data

T * _host_data

Host data.

Definition: KokkosArray.h:701

◆ hostView()

template<typename T, unsigned int dimension, typename index_type>

auto Moose::Kokkos::ArrayBase< T, dimension, index_type >::hostView ( ) const

inline

Get the host unmanaged view.

Returns: The host unmanaged view

Definition at line 363 of file KokkosArray.h.

   {
     return ::Kokkos::View<T *, ::Kokkos::HostSpace, ::Kokkos::MemoryTraits<::Kokkos::Unmanaged>>(
         _host_data, _size);
   }

◆ init()

template<typename T, unsigned int dimension, typename index_type>

template<typename... size_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::init ( size_type... n )

inline

Initialize array with given dimensions but do not allocate.

Parameters

n	The size of each dimension

Definition at line 382 of file KokkosArray.h.

   {
     createInternal<false, false, false>(n...);
   }

◆ isAlloc()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isAlloc ( ) const

inline

Get whether the array was allocated either on host or device.

Returns: Whether the array was allocated either on host or device

Definition at line 269 of file KokkosArray.h.

Referenced by Moose::Kokkos::dataStore(), Moose::Kokkos::VariableGradientTempl< is_ad >::VariableGradientTempl(), and Moose::Kokkos::VariableValueTempl< is_ad >::VariableValueTempl().

269 { return _is_host_alloc || _is_device_alloc; }

Moose::Kokkos::ArrayBase::_is_device_alloc

bool _is_device_alloc

Flag whether device data was allocated.

Definition: KokkosArray.h:689

Moose::Kokkos::ArrayBase::_is_host_alloc

bool _is_host_alloc

Flag whether host data was allocated.

Definition: KokkosArray.h:685

◆ isDeviceAlias()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isDeviceAlias ( ) const

inline

Get whether the device array was aliased.

Returns: Whether the device array was aliased

Definition at line 289 of file KokkosArray.h.

289 { return _is_device_alias; }

Moose::Kokkos::ArrayBase::_is_device_alias

bool _is_device_alias

Flag whether the device data points to an external data.

Definition: KokkosArray.h:697

◆ isDeviceAlloc()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isDeviceAlloc ( ) const

inline

Get whether the array was allocated on device.

Returns: Whether the array was allocated on device

Definition at line 279 of file KokkosArray.h.

Referenced by Moose::Kokkos::dataStore().

279 { return _is_device_alloc; }

Moose::Kokkos::ArrayBase::_is_device_alloc

bool _is_device_alloc

Flag whether device data was allocated.

Definition: KokkosArray.h:689

◆ isHostAlias()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isHostAlias ( ) const

inline

Get whether the host array was aliased.

Returns: Whether the host array was aliased

Definition at line 284 of file KokkosArray.h.

284 { return _is_host_alias; }

Moose::Kokkos::ArrayBase::_is_host_alias

bool _is_host_alias

Flag whether the host data points to an external data.

Definition: KokkosArray.h:693

◆ isHostAlloc()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isHostAlloc ( ) const

inline

Get whether the array was allocated on host.

Returns: Whether the array was allocated on host

Definition at line 274 of file KokkosArray.h.

Referenced by Moose::Kokkos::dataLoad().

274 { return _is_host_alloc; }

Moose::Kokkos::ArrayBase::_is_host_alloc

bool _is_host_alloc

Flag whether host data was allocated.

Definition: KokkosArray.h:685

◆ isSlotConstructed()

template<typename T , unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::isSlotConstructed ( index_type i ) const

Get whether slot i is tracked as constructed.

For an array created with initialization (initialize = true) every slot is default-constructed at allocation, so all slots are reported as constructed. For an array created without initialization (initialize = false) only slots constructed through emplace() are tracked; placement-new directly into the storage is not recorded here, so such a slot is reported as not constructed and its destructor is skipped on free (a leak for types that own resources).

Parameters

i	The slot index

Returns: true if the slot is tracked as constructed

Definition at line 816 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::deepCopy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::freeHost().

 {
   mooseAssert(i < _size, "isSlotConstructed index out of bounds");
 
   if (!_slots_constructed)
     return _is_host_alloc;
 
   return (*_slots_constructed)[i];
 }

◆ last()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension, index_type >::last ( ) const

inline

Get the last element.

Returns: The reference of the last element depending on the architecture this function is being called on

Definition at line 328 of file KokkosArray.h.

   {
     KOKKOS_IF_ON_HOST(return _host_data[_size - 1];)
 
     return _device_data[_size - 1];
   }

◆ moveToDevice()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::moveToDevice ( bool should_free_host = true )

Copy data from host to device and deallocate host.

Parameters

should_free_host Whether the host memory should be freed. Host memory cannot be freed when there are shallow copies of this array that are still alive. If should_free_host is true, and we cannot free for above reason, it will error.

Definition at line 1217 of file KokkosArray.h.

Referenced by Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::moveToDevice().

 {
   static_assert(!is_kokkos_array<T>::value,
                 "moveToDevice() not allowed for a nested array whose data type is another array.");
 
   if (should_free_host && _counter.use_count() > 1)
     mooseError("Kokkos array error: cannot move array from host to device because there is at "
                "least one shallow copy of this array still alive.");
 
   copyToDevice();
 
   if (_counter.use_count() == 1)
     freeHost();
 }

◆ moveToHost()

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::moveToHost ( bool should_free_device = true )

Copy data from device to host and deallocate device.

Parameters

should_free_device Whether the device memory should be freed. Device memory cannot be freed when there are shallow copies of this array that are still alive. If should_free_device is true, and we cannot free for above reason, it will error.

Definition at line 1234 of file KokkosArray.h.

Referenced by Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::moveToHost().

 {
   if (should_free_device && _counter.use_count() > 1)
     mooseError("Kokkos array error: cannot move array from device to host because there is at "
                "least one shallow copy of this array still alive.");
 
   copyToHost();
 
   if (_counter.use_count() == 1)
     freeDevice();
 }

◆ n()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::n ( unsigned int dim ) const

inline

Get the size of a dimension.

Parameters

dim	The dimension index

Returns: The size of the dimension

Definition at line 300 of file KokkosArray.h.

300 { return _n[dim]; }

Moose::dim

static constexpr std::size_t dim

This is the dimension of all vector and tensor datastructures used in MOOSE.

Definition: Moose.h:165

Moose::Kokkos::ArrayBase::_n

index_type _n[dimension]

Size of each dimension.

Definition: KokkosArray.h:590

◆ offset() [1/2]

template<typename T , unsigned int dimension, typename index_type >

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::offset ( const std::vector< signed_index_type > & d )

Apply starting index offsets to each dimension.

Parameters

d	The vector containing the offset of each dimension

Definition at line 1137 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::copyOut(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::offset().

 {
   if (d.size() > dimension)
     mooseError("Kokkos array error: the number of offsets provided (",
                d.size(),
                ") cannot be larger than the array dimension (",
                dimension,
                ").");
 
   for (const auto i : index_range(d))
     _d[i] = d[i];
 }

◆ offset() [2/2]

template<typename T , unsigned int dimension, typename index_type >

template<typename... offset_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::offset ( offset_type... d )

Apply starting index offsets to each dimension.

Parameters

d	The offset of each dimension

Definition at line 1153 of file KokkosArray.h.

 {
   static_assert((std::is_convertible<offset_type, signed_index_type>::value && ...),
                 "All arguments must be convertible to signed_index_type");
   static_assert(sizeof...(d) == dimension, "Number of arguments should match array dimension");
 
   std::vector<signed_index_type> offsets;
   (offsets.push_back(d), ...);
 
   offset(offsets);
 }

◆ operator=()

template<typename T, unsigned int dimension, typename index_type >

auto & Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator= ( const T & scalar )

Assign a scalar value uniformly.

Parameters

scalar The scalar value to be assigned

Definition at line 1424 of file KokkosArray.h.

 {
   if (_is_host_alloc)
     std::fill_n(_host_data, _size, scalar);
 
   if (_is_device_alloc)
     ::Kokkos::Experimental::fill_n(ExecSpace(), deviceView(), _size, scalar);
 
   return *this;
 }

◆ operator[]()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator[] ( index_type i ) const

inline

Get an array entry.

Parameters

i	The dimensionless index

Returns: The reference of the entry depending on the architecture this function is being called on

Definition at line 340 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< ContiguousElementID >::operator()(), and Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::operator()().

   {
     KOKKOS_ASSERT(i < _size);
 
     KOKKOS_IF_ON_HOST(return _host_data[i];)
 
     return _device_data[i];
   }

◆ shallowCopy()

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy ( const ArrayBase< T, dimension, index_type > & array )

Shallow copy another Kokkos array.

Parameters

array The Kokkos array to be shallow copied

Definition at line 933 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::ArrayBase(), Moose::Kokkos::Array< ContiguousElementID >::operator=(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::operator=(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::swap().

 {
   if (_layout != array._layout)
     mooseError("Kokkos array error: cannot shallow copy arrays with different layouts.");
 
   destroy();
 
   _counter = array._counter;
   _slots_constructed = array._slots_constructed;
 
   _size = array._size;
 
   for (const auto i : make_range(dimension))
   {
     _n[i] = array._n[i];
     _s[i] = array._s[i];
     _d[i] = array._d[i];
   }
 
   _is_init = array._is_init;
   _is_host_alloc = array._is_host_alloc;
   _is_device_alloc = array._is_device_alloc;
   _is_host_alias = array._is_host_alias;
   _is_device_alias = array._is_device_alias;
 
   _host_data = array._host_data;
   _device_data = array._device_data;
 }

◆ size()

template<typename T, unsigned int dimension, typename index_type>

KOKKOS_FUNCTION index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::size ( ) const

inline

Get the total array size.

Returns: The total array size

Definition at line 294 of file KokkosArray.h.

Referenced by Moose::Kokkos::ResidualObject::accumulateTaggedElementalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedElementalResidual(), Moose::Kokkos::LinearSystemContributionObject::accumulateTaggedMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalResidual(), Moose::Kokkos::LinearSystemContributionObject::accumulateTaggedVector(), Moose::Kokkos::ResidualObject::accumulateTaggedVectorNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedVectorNodalResidual(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copyVector(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), KokkosPiecewiseBase::functionSize(), Moose::Kokkos::Mesh::getElementVolume(), Moose::Kokkos::Variable::mooseVar(), Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::n(), BlockRestrictable::numKokkosBlockElements(), BlockRestrictable::numKokkosBlockNodes(), BlockRestrictable::numKokkosBlockSides(), BoundaryRestrictable::numKokkosBoundaryNodes(), BoundaryRestrictable::numKokkosBoundarySides(), Moose::Kokkos::MaterialBase::numKokkosElements(), Moose::Kokkos::MaterialBase::numKokkosElementSides(), Moose::Kokkos::Vector::operator()(), Moose::Kokkos::Vector::operator[](), Moose::Kokkos::MapBase< unsigned int, unsigned int >::size(), and KokkosBoundNodalKernel::skipOnBoundary().

294 { return _size; }

Moose::Kokkos::ArrayBase::_size

index_type _size

Total size.

Definition: KokkosArray.h:709

◆ swap()

template<typename T, unsigned int dimension, typename index_type>

void Moose::Kokkos::ArrayBase< T, dimension, index_type >::swap ( ArrayBase< T, dimension, index_type > & array )

Swap with another Kokkos array.

Parameters

array The Kokkos array to be swapped

Definition at line 1413 of file KokkosArray.h.

 {
   ArrayBase<T, dimension, index_type> clone(_layout);
 
   clone.shallowCopy(*this);
   this->shallowCopy(array);
   array.shallowCopy(clone);
 }

◆ useCount()

template<typename T, unsigned int dimension, typename index_type>

unsigned int Moose::Kokkos::ArrayBase< T, dimension, index_type >::useCount ( ) const

inline

Get the reference count.

Returns: The reference count

Definition at line 174 of file KokkosArray.h.

174 { return _counter.use_count(); }

Moose::Kokkos::ArrayBase::_counter

std::shared_ptr< unsigned int > _counter

Reference counter.

Definition: KokkosArray.h:673

Member Data Documentation

◆ _counter

template<typename T, unsigned int dimension, typename index_type>

std::shared_ptr<unsigned int> Moose::Kokkos::ArrayBase< T, dimension, index_type >::_counter

private

Reference counter.

Definition at line 673 of file KokkosArray.h.

◆ _d

template<typename T, unsigned int dimension, typename index_type>

signed_index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::_d[dimension] = {0}

protected

Offset of each dimension.

Definition at line 598 of file KokkosArray.h.

◆ _device_data

template<typename T, unsigned int dimension, typename index_type>

T* Moose::Kokkos::ArrayBase< T, dimension, index_type >::_device_data = nullptr

private

Device data.

Definition at line 705 of file KokkosArray.h.

◆ _host_data

template<typename T, unsigned int dimension, typename index_type>

T* Moose::Kokkos::ArrayBase< T, dimension, index_type >::_host_data = nullptr

private

Host data.

Definition at line 701 of file KokkosArray.h.

◆ _is_device_alias

template<typename T, unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::_is_device_alias = false

private

Flag whether the device data points to an external data.

Definition at line 697 of file KokkosArray.h.

◆ _is_device_alloc

template<typename T, unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::_is_device_alloc = false

private

Flag whether device data was allocated.

Definition at line 689 of file KokkosArray.h.

◆ _is_host_alias

template<typename T, unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::_is_host_alias = false

private

Flag whether the host data points to an external data.

Definition at line 693 of file KokkosArray.h.

◆ _is_host_alloc

template<typename T, unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::_is_host_alloc = false

private

Flag whether host data was allocated.

Definition at line 685 of file KokkosArray.h.

◆ _is_init

template<typename T, unsigned int dimension, typename index_type>

bool Moose::Kokkos::ArrayBase< T, dimension, index_type >::_is_init = false

private

Flag whether array was initialized.

Definition at line 681 of file KokkosArray.h.

◆ _layout

template<typename T, unsigned int dimension, typename index_type>

const LayoutType Moose::Kokkos::ArrayBase< T, dimension, index_type >::_layout

private

Memory layout type.

Definition at line 713 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::Array< Moose::Kokkos::Array< Moose::Kokkos::Real33 > >, dimension, index_type >::swap().

◆ _n

template<typename T, unsigned int dimension, typename index_type>

index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::_n[dimension] = {0}

protected

Size of each dimension.

Definition at line 590 of file KokkosArray.h.

◆ _s

template<typename T, unsigned int dimension, typename index_type>

index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::_s[dimension] = {0}

protected

Stride of each dimension.

Definition at line 594 of file KokkosArray.h.

◆ _size

template<typename T, unsigned int dimension, typename index_type>

index_type Moose::Kokkos::ArrayBase< T, dimension, index_type >::_size = 0

private

Total size.

Definition at line 709 of file KokkosArray.h.

◆ _slots_constructed

template<typename T, unsigned int dimension, typename index_type>

std::shared_ptr<std::vector<bool> > Moose::Kokkos::ArrayBase< T, dimension, index_type >::_slots_constructed

private

Non-null only for malloc-allocated arrays; tracks which slots have been emplace-constructed.

Definition at line 677 of file KokkosArray.h.

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

include/kokkos/base/KokkosArray.h

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

template<typename T, unsigned int dimension, typename index_type> class Moose::Kokkos::ArrayBase< T, dimension, index_type >

Member Typedef Documentation

◆ signed_index_type

◆ unsigned_index_type

Constructor & Destructor Documentation

◆ ArrayBase() [1/3]

◆ ArrayBase() [2/3]

◆ ArrayBase() [3/3]

◆ ~ArrayBase()

Member Function Documentation

◆ aliasDevice()

◆ aliasHost()

◆ allocDevice()

◆ allocHost()

◆ begin()

◆ constructedEntries() [1/2]

◆ constructedEntries() [2/2]

◆ copyIn()

◆ copyInternal()

◆ copyOut()

◆ copyToDevice()

◆ copyToDeviceNested()

◆ copyToHost()

◆ create() [1/2]

◆ create() [2/2]

◆ createDevice() [1/2]

◆ createDevice() [2/2]

◆ createHost() [1/2]

◆ createHost() [2/2]

◆ createInternal() [1/3]

◆ createInternal() [2/3]

◆ createInternal() [3/3]

◆ data()

◆ deepCopy()

◆ destroy()

◆ deviceData()

◆ deviceView()

◆ emplaceAt()

◆ end()

◆ first()

◆ freeDevice()

◆ freeHost()

◆ hostData()

◆ hostView()

◆ init()

◆ isAlloc()

◆ isDeviceAlias()

◆ isDeviceAlloc()

◆ isHostAlias()

◆ isHostAlloc()

◆ isSlotConstructed()

◆ last()

◆ moveToDevice()

◆ moveToHost()

◆ n()

◆ offset() [1/2]

◆ offset() [2/2]

◆ operator=()

◆ operator[]()

◆ shallowCopy()

◆ size()

◆ swap()

◆ useCount()

Member Data Documentation

◆ _counter

◆ _d

◆ _device_data

◆ _host_data

◆ _is_device_alias

◆ _is_device_alloc

◆ _is_host_alias

◆ _is_host_alloc

template<typename T, unsigned int dimension, typename index_type>
class Moose::Kokkos::ArrayBase< T, dimension, index_type >