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

The Kokkos array class. More...

#include <KokkosArray.h>

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

Public Types
using	unsigned_index_type = index_type
using	signed_index_type = typename std::make_signed< index_type >::type

Public Member Functions
	Array ()
	Default constructor. More...
	Array (const Array< T, dimension, index_type, layout > &array)
	Copy constructor. More...
template<typename... size_type>
	Array (size_type... n)
	Constructor Initialize and allocate array with given dimensions This allocates both host and device data. More...
auto &	operator= (const Array< T, dimension, index_type, layout > &array)
	Shallow copy another Kokkos array. More...
KOKKOS_FUNCTION T &	operator() (const signed_index_type(&idx)[dimension]) const
	Get an array entry using indices stored in an array. 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...
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...
KOKKOS_FUNCTION iterator	begin () const
	Get the beginning iterator. More...
KOKKOS_FUNCTION iterator	end () const
	Get the end iterator. More...
template<typename... indices>
KOKKOS_FUNCTION T &	operator() (indices... i) const
	Get an array entry. 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...

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...
bool	_is_offset = false
	Flag whether the array indices are offset. More...
bool	_is_malloc = false
	Flag whether host data was allocated using malloc. More...

Private Member Functions
	usingKokkosArrayBaseMembers (T, dimension, index_type)
template<unsigned int... i>
KOKKOS_FUNCTION T &	operatorInternal (const signed_index_type(&idx)[dimension], std::integer_sequence< unsigned int, i... >) const
	Internal method for calling operator() with array indices. More...

Detailed Description

template<typename T, unsigned int dimension, typename index_type, LayoutType layout>
class Moose::Kokkos::Array< T, dimension, index_type, layout >

The Kokkos array class.

The specialization of the Kokkos array class for each dimension.

All array data that needs to be accessed on device in Kokkos objects should use this class. If the array is populated on host and is to be accessed on device, make sure to call copyToDevice() after populating data. For a nested Kokkos array, either copyToDeviceNested() should be called for the outermost array or copyToDevice() should be called for each instance of Kokkos array from the innermost to the outermost. Do not store this object as reference in your Kokkos object if it is used on device, because the reference refers to a host object and therefore is not accessible on device. If storing it as a reference is required, see ReferenceWrapper.

Template Parameters

T	The data type
dimension	The array dimension size
index_type	The array index type
layout	The memory layout type

Definition at line 64 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

inherited

Definition at line 114 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

inherited

Definition at line 113 of file KokkosArray.h.

Constructor & Destructor Documentation

Array() [1/3]

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

Moose::Kokkos::Array< T, dimension, index_type, layout >::Array ( )

inline

Default constructor.

Definition at line 1362 of file KokkosArray.h.

: ArrayBase<T, dimension, index_type>(layout) {}

Array() [2/3]

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

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

inline

Copy constructor.

Definition at line 1366 of file KokkosArray.h.

    : ArrayBase<T, dimension, index_type>(array)
  {
  }

Array() [3/3]

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

template<typename... size_type>

Moose::Kokkos::Array< T, dimension, index_type, layout >::Array ( size_type...  n )

inline

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

Parameters

n	The size of each dimension

Definition at line 1378 of file KokkosArray.h.

                        : ArrayBase<T, dimension, index_type>(layout, n...)
  {
  }

Member Function Documentation

aliasDevice()

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

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

inherited

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

Parameters

ptr	The pointer to the external device data

Definition at line 760 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 )

inherited

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

Parameters

ptr	The pointer to the external host data

Definition at line 745 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;
}

begin()

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

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

inlineinherited

Get the beginning iterator.

Returns

The beginning iterator

Definition at line 479 of file KokkosArray.h.

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

  {
    KOKKOS_IF_ON_HOST(return iterator(_host_data);)

    return iterator(_device_data);
  }

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  )

inherited

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 1028 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  )

protectedinherited

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 907 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  )

inherited

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 1083 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 ( )

inherited

Copy data from host to device.

Definition at line 947 of file KokkosArray.h.

Referenced by 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 ( )

inherited

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

Definition at line 1151 of file KokkosArray.h.

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

{
  for (index_type i = 0; i < _size; ++i)
    copyToDeviceInner(_host_data[i]);

  copyToDevice();
}

copyToHost()

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

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

inherited

Copy data from device to host.

Definition at line 972 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);
}

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 )

inlineinherited

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 303 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 )

inlineinherited

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 313 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 )

inlineinherited

Allocate array on device only.

Parameters

n	The vector containing the size of each dimension

Definition at line 341 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 )

inlineinherited

Allocate array on device only.

Parameters

n	The size of each dimension

Definition at line 347 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 )

inlineinherited

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 323 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 )

inlineinherited

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 333 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 )

protectedinherited

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 892 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 )

protectedinherited

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 812 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 (unsigned int i = 1; i < dimension; ++i)
      _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  )

protectedinherited

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 875 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

inlineinherited

Get the data pointer.

Returns

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

Definition at line 217 of file KokkosArray.h.

Referenced by 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 )

inherited

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 1161 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 constexpr (ArrayDeepCopy<T>::value)
  {
    for (index_type i = 0; i < _size; ++i)
      new (_host_data + i) T(array._host_data[i]);

    copyToDevice();
  }
  else
  {
    if (_is_host_alloc)
      std::memcpy(_host_data, array._host_data, _size * sizeof(T));

    if (_is_device_alloc)
      copyInternal<MemSpace, MemSpace>(_device_data, array._device_data, _size);
  }

  for (unsigned int i = 0; i < dimension; ++i)
  {
    _d[i] = array._d[i];
    _s[i] = array._s[i];
  }

  _is_offset = array._is_offset;
}

destroy()

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

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

inherited

Free all data and reset.

Definition at line 674 of file KokkosArray.h.

Referenced by Moose::Kokkos::System::clearActiveMatrixTags(), Moose::Kokkos::System::clearActiveResidualTags(), Moose::Kokkos::System::clearActiveSolutionTags(), Moose::Kokkos::System::clearActiveVariables(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 (unsigned int i = 0; i < dimension; ++i)
  {
    _n[i] = 0;
    _s[i] = 0;
    _d[i] = 0;
  }

  _is_init = false;
  _is_offset = false;
  _is_malloc = false;
  _is_host_alloc = false;
  _is_device_alloc = false;
  _is_host_alias = false;
  _is_device_alias = false;

  _counter.reset();
}

deviceData()

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

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

inlineinherited

Get the device data pointer.

Returns

The pointer to the underlying device data

Definition at line 269 of file KokkosArray.h.

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

{ return _device_data; }

deviceView()

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

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

inlineinherited

Get the device unmanaged view.

Returns

The device unmanaged view

Definition at line 283 of file KokkosArray.h.

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

end()

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

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

inlineinherited

Get the end iterator.

Returns

The end iterator

Definition at line 489 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

inlineinherited

Get the first element.

Returns

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

Definition at line 228 of file KokkosArray.h.

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

  {
    KOKKOS_IF_ON_HOST(return _host_data[0];)

    return _device_data[0];
  }

hostData()

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

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

inlineinherited

Get the host data pointer.

Returns

The pointer to the underlying host data

Definition at line 264 of file KokkosArray.h.

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

{ return _host_data; }

hostView()

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

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

inlineinherited

Get the host unmanaged view.

Returns

The host unmanaged view

Definition at line 274 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 )

inlineinherited

Initialize array with given dimensions but do not allocate.

Parameters

n	The size of each dimension

Definition at line 293 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

inlineinherited

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 180 of file KokkosArray.h.

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

{ return _is_host_alloc || _is_device_alloc; }

isDeviceAlias()

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

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

inlineinherited

Get whether the device array was aliased.

Returns

Whether the device array was aliased

Definition at line 200 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

inlineinherited

Get whether the array was allocated on device.

Returns

Whether the array was allocated on device

Definition at line 190 of file KokkosArray.h.

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

{ return _is_device_alloc; }

isHostAlias()

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

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

inlineinherited

Get whether the host array was aliased.

Returns

Whether the host array was aliased

Definition at line 195 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

inlineinherited

Get whether the array was allocated on host.

Returns

Whether the array was allocated on host

Definition at line 185 of file KokkosArray.h.

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

{ return _is_host_alloc; }

last()

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

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

inlineinherited

Get the last element.

Returns

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

Definition at line 239 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 )

inherited

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 997 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 )

inherited

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 1014 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

inlineinherited

Get the size of a dimension.

Parameters

dim	The dimension index

Returns

The size of the dimension

Definition at line 211 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::ArrayBase(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::create(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::createDevice(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::createHost(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::init(), Moose::Kokkos::MaterialPropertyValueBase< T, 0 >::n(), and Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::n().

{ return _n[dim]; }

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 )

inherited

Apply starting index offsets to each dimension.

Parameters

d	The vector containing the offset of each dimension

Definition at line 915 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];

  _is_offset = true;
}

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 )

inherited

Apply starting index offsets to each dimension.

Parameters

d	The offset of each dimension

Definition at line 933 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()() [1/2]

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

template<typename... indices>

KOKKOS_FUNCTION T & Moose::Kokkos::Array< T, dimension, index_type, layout >::operator()

(

indices...

i

)

const

Get an array entry.

Parameters

i	The index of each dimension

Returns

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

Definition at line 1433 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< ContiguousElementID >::operatorInternal().

{
  static_assert((std::is_convertible<indices, signed_index_type>::value && ...),
                "All arguments must be convertible to signed_index_type");
  static_assert(sizeof...(i) == dimension, "Number of arguments should match array dimension");

#ifndef NDEBUG
  {
    signed_index_type idx[dimension] = {static_cast<signed_index_type>(i)...};

    for (unsigned int d = 0; d < sizeof...(i); ++d)
      KOKKOS_ASSERT(idx[d] - _d[d] >= 0 && static_cast<index_type>(idx[d] - _d[d]) < _n[d]);
  }
#endif

  index_type idx = 0;
  unsigned int d = 0;

  if (_is_offset)
  {
    if constexpr (layout == LayoutType::LEFT)
      (((idx += (d == 0 ? static_cast<signed_index_type>(i) - _d[d]
                        : (static_cast<signed_index_type>(i) - _d[d]) * _s[d])),
        ++d),
       ...);
    else
      (((idx += (d == dimension - 1 ? static_cast<signed_index_type>(i) - _d[d]
                                    : (static_cast<signed_index_type>(i) - _d[d]) * _s[d])),
        ++d),
       ...);
  }
  else
  {
    if constexpr (layout == LayoutType::LEFT)
      (((idx +=
         (d == 0 ? static_cast<signed_index_type>(i) : static_cast<signed_index_type>(i) * _s[d])),
        ++d),
       ...);
    else
      (((idx += (d == dimension - 1 ? static_cast<signed_index_type>(i)
                                    : static_cast<signed_index_type>(i) * _s[d])),
        ++d),
       ...);
  }

  return this->operator[](idx);
}

operator()() [2/2]

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

KOKKOS_FUNCTION T& Moose::Kokkos::Array< T, dimension, index_type, layout >::operator() ( const signed_index_type(&)  idx[dimension] ) const

inline

Get an array entry using indices stored in an array.

Parameters

idx	The array storing the indices

Returns

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

Definition at line 1409 of file KokkosArray.h.

  {
    return operatorInternal(idx, std::make_integer_sequence<unsigned int, dimension>{});
  }

operator=()

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

auto& Moose::Kokkos::Array< T, dimension, index_type, layout >::operator= ( const Array< T, dimension, index_type, layout > &  array )

inline

Shallow copy another Kokkos array.

Parameters

array

The Kokkos array to be shallow copied

Definition at line 1387 of file KokkosArray.h.

  {
    this->shallowCopy(array);

    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

inlineinherited

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 251 of file KokkosArray.h.

Referenced by 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];
  }

operatorInternal()

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

template<unsigned int... i>

KOKKOS_FUNCTION T& Moose::Kokkos::Array< T, dimension, index_type, layout >::operatorInternal ( const signed_index_type(&)  idx[dimension], std::integer_sequence< unsigned int, i... >    ) const

inlineprivate

Internal method for calling operator() with array indices.

Definition at line 1421 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< ContiguousElementID >::operator()().

  {
    return operator()(idx[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 )

inherited

Shallow copy another Kokkos array.

Parameters

array

The Kokkos array to be shallow copied

Definition at line 712 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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::RPNEvaluator::Instruction, dimension, index_type >::swap().

{
  if (_layout != array._layout)
    mooseError("Kokkos array error: cannot shallow copy arrays with different layouts.");

  destroy();

  _counter = array._counter;

  _size = array._size;

  for (unsigned int i = 0; i < dimension; ++i)
  {
    _n[i] = array._n[i];
    _s[i] = array._s[i];
    _d[i] = array._d[i];
  }

  _is_init = array._is_init;
  _is_offset = array._is_offset;
  _is_malloc = array._is_malloc;
  _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

inlineinherited

Get the total array size.

Returns

The total array size

Definition at line 205 of file KokkosArray.h.

Referenced by Moose::Kokkos::ResidualObject::accumulateTaggedElementalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedElementalResidual(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalMatrix(), Moose::Kokkos::ResidualObject::accumulateTaggedNodalResidual(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::copyVector(), Moose::Kokkos::dataLoad(), Moose::Kokkos::dataStore(), KokkosPiecewiseBase::functionSize(), 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::Vector::operator()(), Moose::Kokkos::Vector::operator[](), Moose::Kokkos::MapBase< unsigned int, unsigned int >::size(), and KokkosBoundNodalKernel::skipOnBoundary().

{ return _size; }

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 )

inherited

Swap with another Kokkos array.

Parameters

array

The Kokkos array to be swapped

Definition at line 1201 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

inlineinherited

Get the reference count.

Returns

The reference count

Definition at line 173 of file KokkosArray.h.

{ return _counter.use_count(); }

usingKokkosArrayBaseMembers()

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

Moose::Kokkos::Array< T, dimension, index_type, layout >::usingKokkosArrayBaseMembers ( T  , dimension  , index_type    )

private

Member Data Documentation

_d

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

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

protectedinherited

Offset of each dimension.

Definition at line 509 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::operator()(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::shallowCopy().

_is_malloc

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

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

protectedinherited

Flag whether host data was allocated using malloc.

Definition at line 517 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::shallowCopy().

_is_offset

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

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

protectedinherited

Flag whether the array indices are offset.

Definition at line 513 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::operator()(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::shallowCopy().

_n

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

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

protectedinherited

Size of each dimension.

Definition at line 501 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::n(), Moose::Kokkos::Array< T, 1, index_type, LayoutType::LEFT >::operator()(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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}

protectedinherited

Stride of each dimension.

Definition at line 505 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::shallowCopy().

---

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

• include/kokkos/base/KokkosArray.h