Moose::Kokkos::ArrayBase< T, dimension, index_type > Class Template Reference

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.
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.
	ArrayBase (const ArrayBase< T, dimension, index_type > &array)
	Copy constructor.
	~ArrayBase ()
	Destructor.
void	destroy ()
	Free all data and reset.
void	shallowCopy (const ArrayBase< T, dimension, index_type > &array)
	Shallow copy another Kokkos array.
unsigned int	useCount () const
	Get the reference count.
bool	isSlotConstructed (index_type i) const
	Get whether slot i is tracked as constructed.
constructed_entry_range< false >	constructedEntries ()
	Get host-side range over entries tracked as constructed.
constructed_entry_range< true >	constructedEntries () const
	Get host-side range over entries tracked as constructed.
KOKKOS_FUNCTION bool	isAlloc () const
	Get whether the array was allocated either on host or device.
KOKKOS_FUNCTION bool	isHostAlloc () const
	Get whether the array was allocated on host.
KOKKOS_FUNCTION bool	isDeviceAlloc () const
	Get whether the array was allocated on device.
KOKKOS_FUNCTION bool	isHostAlias () const
	Get whether the host array was aliased.
KOKKOS_FUNCTION bool	isDeviceAlias () const
	Get whether the device array was aliased.
KOKKOS_FUNCTION index_type	size () const
	Get the total array size.
KOKKOS_FUNCTION index_type	n (unsigned int dim) const
	Get the size of a dimension.
KOKKOS_FUNCTION T *	data () const
	Get the data pointer.
KOKKOS_FUNCTION T &	first () const
	Get the first element.
KOKKOS_FUNCTION T &	last () const
	Get the last element.
KOKKOS_FUNCTION T &	operator[] (index_type i) const
	Get an array entry.
T *	hostData () const
	Get the host data pointer.
T *	deviceData () const
	Get the device data pointer.
auto	hostView () const
	Get the host unmanaged view.
auto	deviceView () const
	Get the device unmanaged view.
template<typename... size_type>
void	init (size_type... n)
	Initialize array with given dimensions but do not allocate.
template<bool initialize = true>
void	create (const std::vector< index_type > &n)
	Allocate array on host and device.
template<bool initialize = true, typename... size_type>
void	create (size_type... n)
	Allocate array on host and device.
template<bool initialize = true>
void	createHost (const std::vector< index_type > &n)
	Allocate array on host only.
template<bool initialize = true, typename... size_type>
void	createHost (size_type... n)
	Allocate array on host only.
void	createDevice (const std::vector< index_type > &n)
	Allocate array on device only.
template<typename... size_type>
void	createDevice (size_type... n)
	Allocate array on device only.
void	aliasHost (T *ptr)
	Point the host data to an external data instead of allocating it.
void	aliasDevice (T *ptr)
	Point the device data to an external data instead of allocating it.
void	offset (const std::vector< signed_index_type > &d)
	Apply starting index offsets to each dimension.
template<typename... offset_type>
void	offset (offset_type... d)
	Apply starting index offsets to each dimension.
void	copyToDevice ()
	Copy data from host to device.
void	copyToHost ()
	Copy data from device to host.
void	copyIn (const T *ptr, MemcpyType dir, index_type n, index_type offset=0)
	Copy data from an external data to this array.
void	copyOut (T *ptr, MemcpyType dir, index_type n, index_type offset=0)
	Copy data to an external data from this array.
void	copyToDeviceNested ()
	Copy all the nested Kokkos arrays including self from host to device.
void	moveToDevice (bool should_free_host=true)
	Copy data from host to device and deallocate host.
void	moveToHost (bool should_free_device=true)
	Copy data from device to host and deallocate device.
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.
void	swap (ArrayBase< T, dimension, index_type > &array)
	Swap with another Kokkos array.
auto &	operator= (const T &scalar)
	Assign a scalar value uniformly.
KOKKOS_FUNCTION iterator	begin () const
	Get the beginning iterator.
KOKKOS_FUNCTION iterator	end () const
	Get the end iterator.

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.
template<bool host, bool device, bool initialize>
void	createInternal (const std::vector< index_type > &n)
	The internal method to initialize and allocate this array.
template<bool initialize>
void	createInternal (const std::vector< index_type > &n, bool host, bool device)
	The internal method to initialize and allocate this array.
template<typename TargetSpace , typename SourceSpace >
void	copyInternal (T *target, const T *source, index_type n)
	The internal method to perform a memory copy.
template<typename... Args>
T &	emplaceAt (index_type i, Args &&... args)
	Placement-new construct slot i from args, recording initialization.

Protected Attributes
index_type	_n [dimension] = {0}
	Size of each dimension.
index_type	_s [dimension] = {0}
	Stride of each dimension.
signed_index_type	_d [dimension] = {0}
	Offset of each dimension.

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

Private Attributes
std::shared_ptr< unsigned int >	_counter
	Reference counter.
std::shared_ptr< std::vector< bool > >	_slots_constructed
	Non-null only for malloc-allocated arrays; tracks which slots have been emplace-constructed.
bool	_is_init = false
	Flag whether array was initialized.
bool	_is_host_alloc = false
	Flag whether host data was allocated.
bool	_is_device_alloc = false
	Flag whether device data was allocated.
bool	_is_host_alias = false
	Flag whether the host data points to an external data.
bool	_is_device_alias = false
	Flag whether the device data points to an external data.
T *	_host_data = nullptr
	Host data.
T *	_device_data = nullptr
	Device data.
index_type	_size = 0
	Total size.
const LayoutType	_layout
	Memory layout type.

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.

: _layout(layout) {}

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.

{ destroy(); }

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.

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

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

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.

  {
    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.

{
  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);
  }
}

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

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.

{
  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);
  }
}

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

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.

{
  // 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);
}

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

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.

{
  // 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);
}

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

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.

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

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

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.

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

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>

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() [2/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);
}

createInternal() [3/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);
}

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.

  {
    KOKKOS_IF_ON_HOST(return _host_data;)
 
    return _device_data;
  }

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

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.

{
  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];
  }
}

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

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.

{
  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();
}

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

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.

{ return _device_data; }

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.

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

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

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.

{
  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];
}

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

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.

  {
    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.

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

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

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.

{
  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;
}

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

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.

{
  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;
}

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

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.

{ return _host_data; }

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.

{ return _is_host_alloc || _is_device_alloc; }

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

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.

{ return _is_device_alias; }

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.

{ return _is_device_alloc; }

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

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.

{ return _is_host_alias; }

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.

{ return _is_host_alloc; }

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

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.

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

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

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.

{
  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.

{
  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.

{ return _n[dim]; }

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::ArrayBase(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::create(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::create(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::init(), and Moose::Kokkos::MaterialPropertyValueBase< T, dimension >::n().

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.

{
  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];
}

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

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.

  {
    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.

{
  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;
}

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::ArrayBase(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::swap().

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.

{ return _size; }

Referenced by Moose::Kokkos::ResidualObject::accumulateTaggedElementalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedElementalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedElementalResidual(), Moose::Kokkos::LinearSystemContributionObject::accumulateTaggedMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalResidual(), Moose::Kokkos::LinearSystemContributionObject::accumulateTaggedVector(), Moose::Kokkos::ResidualObject::accumulateTaggedVectorNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedVectorNodalResidual(), Moose::Kokkos::MemoryPool::allocate(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), KokkosPiecewiseBase::functionSize(), Moose::Kokkos::Mesh::getElementVolume(), Moose::Kokkos::Variable::mooseVar(), 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< T1, T2, MapType >::size(), and KokkosBoundNodalKernel::skipOnBoundary().

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.

{ return _counter.use_count(); }

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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::moveToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::moveToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::useCount().

_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.

{0};

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::Array< T, dimension, index_type, layout >::linearIndex(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::linearIndex(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::offset(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::begin(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::data(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deviceData(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deviceView(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::first(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator[](), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::begin(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDeviceNested(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::data(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::emplaceAt(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::first(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::hostData(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::hostView(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator=(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator[](), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isDeviceAlias(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isAlloc(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isDeviceAlloc(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator=(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isHostAlias(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::emplaceAt(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isAlloc(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isHostAlloc(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isSlotConstructed(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator=(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::aliasHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< T, 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.

{0};

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::Array< T, dimension, index_type, layout >::linearIndex(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::linearIndex(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::n(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

{0};

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::Array< T, dimension, index_type, layout >::linearIndex(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyIn(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyOut(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDevice(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToDeviceNested(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::copyToHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::deviceView(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::emplaceAt(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::hostView(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isSlotConstructed(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator=(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::operator[](), Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::size().

_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.

Referenced by Moose::Kokkos::ArrayBase< T, dimension, index_type >::allocHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::destroy(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::emplaceAt(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::freeHost(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::isSlotConstructed(), and Moose::Kokkos::ArrayBase< T, dimension, index_type >::shallowCopy().

---

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

• include/kokkos/base/KokkosArray.h