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	iterator
	Array iterator. More...

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

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

Protected Member Functions
template<bool host, bool device, bool initialize, typename... size_type>
void	createInternal (size_type... n)
	The internal method to initialize and allocate this array. More...
template<bool host, bool device, bool initialize>
void	createInternal (const std::vector< index_type > &n)
	The internal method to initialize and allocate this array. More...
template<bool initialize>
void	createInternal (const std::vector< index_type > &n, bool host, bool device)
	The internal method to initialize and allocate this array. More...
template<typename TargetSpace , typename SourceSpace >
void	copyInternal (T *target, const T *source, index_type n)
	The internal method to perform a memory copy. More...

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
template<bool initialize>
void	allocHost ()
	Allocate host data for an initialized array that has not allocated host data. More...
void	allocDevice ()
	Allocate device data for an initialized array that has not allocated device data. More...
void	freeHost ()
	Free host data. More...
void	freeDevice ()
	Free device data. More...

Private Attributes
std::shared_ptr< unsigned int >	_counter
	Reference counter. More...
bool	_is_init = false
	Flag whether array was initialized. More...
bool	_is_host_alloc = false
	Flag whether host data was allocated. More...
bool	_is_device_alloc = false
	Flag whether device data was allocated. More...
bool	_is_host_alias = false
	Flag whether the host data points to an external data. More...
bool	_is_device_alias = false
	Flag whether the device data points to an external data. More...
T *	_host_data = nullptr
	Host data. More...
T *	_device_data = nullptr
	Device data. More...
index_type	_size = 0
	Total size. More...
const LayoutType	_layout
	Memory layout type. More...

Detailed Description

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

The base class for Kokkos arrays.

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

Definition at line 113 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 120 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 131 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 140 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 156 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 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

)

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

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

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 776 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)));

  _is_host_alloc = true;
  _is_malloc = !initialize;
}

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

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  )

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

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

(

)

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

(

)

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

(

)

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 )

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

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

inline

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 )

inline

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 )

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

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

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

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

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

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

)

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

(

)

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

inline

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

inline

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

inline

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

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

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

  {
    KOKKOS_IF_ON_HOST(return _host_data[0];)

    return _device_data[0];
  }

freeDevice()

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

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

private

Free device data.

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

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

{
  if (!_is_host_alloc)
    return;

  if (_is_host_alias)
  {
    _host_data = nullptr;
    _is_host_alias = false;
  }
  else
  {
    if (!_is_malloc)
      // Allocated by new
      delete[] _host_data;
    else
    {
      // Allocated by malloc
      for (index_type i = 0; i < _size; ++i)
        _host_data[i].~T();

      std::free(_host_data);
    }
  }

  _is_host_alloc = false;
  _is_malloc = false;
}

hostData()

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

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

inline

Get the host data pointer.

Returns

The pointer to the underlying host data

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

inline

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 )

inline

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

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

inline

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

inline

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

inline

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

inline

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

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

)

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

)

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

inline

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

)

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

)

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

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

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

inline

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

)

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

inline

Get the reference count.

Returns

The reference count

Definition at line 173 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 584 of file KokkosArray.h.

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

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

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::begin(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::data(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deviceData(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deviceView(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::first(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::operator[](), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 608 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::begin(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::data(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deepCopy(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::first(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::hostData(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::hostView(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::operator[](), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 604 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::isDeviceAlias(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 596 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 >::isAlloc(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::isDeviceAlloc(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 600 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::isHostAlias(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 592 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 >::isAlloc(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::isHostAlloc(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, 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 588 of file KokkosArray.h.

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

protected

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

protected

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

_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 620 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().

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

protected

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

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

Referenced by Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::deviceView(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::end(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::hostView(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::last(), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::operator[](), Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::shallowCopy(), and Moose::Kokkos::ArrayBase< Moose::Kokkos::RPNEvaluator::Instruction, dimension, index_type >::size().

---

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

• include/kokkos/base/KokkosArray.h