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

The base class for Kokkos arrays. More...

#include <KokkosArray.h>

Classes
class	iterator
	Array iterator. More...

Public Member Functions
	ArrayBase ()=default
	Default constructor. More...
	ArrayBase (const ArrayBase< T, dimension > &array)
	Copy constructor. More...
	~ArrayBase ()
	Destructor. More...
void	destroy ()
	Free all data and reset. More...
void	shallowCopy (const ArrayBase< T, dimension > &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 dof_id_type	size () const
	Get the total array size. More...
KOKKOS_FUNCTION dof_id_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[] (dof_id_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...
void	create (const std::vector< dof_id_type > &n)
	Allocate array on host and device. More...
void	createHost (const std::vector< dof_id_type > &n)
	Allocate array on host only. More...
void	createDevice (const std::vector< dof_id_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< dof_id_signed_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, MemcpyKind dir, dof_id_type n, dof_id_type offset=0)
	Copy data from an external data to this array. More...
void	copyOut (T *ptr, MemcpyKind dir, dof_id_type n, dof_id_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	deepCopy (const ArrayBase< T, dimension > &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 > &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>
void	createInternal (const std::vector< dof_id_type > &n)
	The internal method to initialize and allocate this array. More...
void	createInternal (const std::vector< dof_id_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, dof_id_type n)
	The internal method to perform a memory copy. More...

Protected Attributes
dof_id_type	_n [dimension] = {0}
	Size of each dimension. More...
dof_id_type	_s [dimension] = {0}
	Stride of each dimension. More...
dof_id_signed_type	_d [dimension] = {0}
	Offset of each dimension. More...

Private Member Functions
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...

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...
dof_id_type	_size = 0
	Total size. More...

Detailed Description

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

The base class for Kokkos arrays.

Definition at line 83 of file KokkosArray.h.

Constructor & Destructor Documentation

ArrayBase() [1/2]

template<typename T, unsigned int dimension>

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

default

Default constructor.

ArrayBase() [2/2]

template<typename T, unsigned int dimension>

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

inline

Copy constructor.

Definition at line 94 of file KokkosArray.h.

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

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

inline

Destructor.

Definition at line 110 of file KokkosArray.h.

{ destroy(); }

Member Function Documentation

aliasDevice()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::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 538 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>

void Moose::Kokkos::ArrayBase< T, dimension >::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 523 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>

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

private

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

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

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

private

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

Definition at line 553 of file KokkosArray.h.

{
  if (_is_host_alloc)
    return;

  if constexpr (std::is_default_constructible<T>::value)
    _host_data = new T[_size];
  else
    _host_data = static_cast<T *>(std::malloc(_size * sizeof(T)));

  _is_host_alloc = true;
}

begin()

template<typename T, unsigned int dimension>

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

inline

Get the beginning iterator.

Returns

The beginning iterator

Definition at line 332 of file KokkosArray.h.

  {
    KOKKOS_IF_ON_HOST(return iterator(_host_data);)

    return iterator(_device_data);
  }

copyIn()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::copyIn	(	const T *	ptr,
		MemcpyKind	dir,
		dof_id_type	n,
		dof_id_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 705 of file KokkosArray.h.

{
  if (n > _size)
    mooseError("Kokkos array error: cannot copyin data larger than the array size.");

  if (offset > _size)
    mooseError("Kokkos array error: offset cannot be larger than the array size.");

  if (dir == MemcpyKind::HOST_TO_HOST)
  {
    // If host side memory is not allocated, do nothing
    if (!_is_host_alloc)
      return;

    // Copy from host to host
    copyInternal<::Kokkos::HostSpace, ::Kokkos::HostSpace>(_host_data + offset, ptr, n);
  }
  else if (dir == MemcpyKind::HOST_TO_DEVICE)
  {
    // If device side memory is not allocated, do nothing
    if (!_is_device_alloc)
      return;

    // Copy from host to device
    copyInternal<MemSpace, ::Kokkos::HostSpace>(_device_data + offset, ptr, n);
  }
  else if (dir == MemcpyKind::DEVICE_TO_HOST)
  {
    // If host side memory is not allocated, do nothing
    if (!_is_host_alloc)
      return;

    // Copy from device to host
    copyInternal<::Kokkos::HostSpace, MemSpace>(_host_data + offset, ptr, n);
  }
  else if (dir == MemcpyKind::DEVICE_TO_DEVICE)
  {
    // If device side memory is not allocated, do nothing
    if (!_is_device_alloc)
      return;

    // Copy from device to device
    copyInternal<MemSpace, MemSpace>(_device_data + offset, ptr, n);
  }
}

copyInternal()

template<typename T, unsigned int dimension>

template<typename TargetSpace , typename SourceSpace >

void Moose::Kokkos::ArrayBase< T, dimension >::copyInternal ( T *  target, const T *  source, dof_id_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 634 of file KokkosArray.h.

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

copyOut()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::copyOut	(	T *	ptr,
		MemcpyKind	dir,
		dof_id_type	n,
		dof_id_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 753 of file KokkosArray.h.

{
  if (n > _size)
    mooseError("Kokkos array error: cannot copyout data larger than the array size.");

  if (offset > _size)
    mooseError("Kokkos array error: offset cannot be larger than the array size.");

  if (dir == MemcpyKind::HOST_TO_HOST)
  {
    // If host side memory is not allocated, do nothing
    if (!_is_host_alloc)
      return;

    // Copy from host to host
    copyInternal<::Kokkos::HostSpace, ::Kokkos::HostSpace>(ptr, _host_data + offset, n);
  }
  else if (dir == MemcpyKind::HOST_TO_DEVICE)
  {
    // If host side memory is not allocated, do nothing
    if (!_is_host_alloc)
      return;

    // Copy from host to device
    copyInternal<MemSpace, ::Kokkos::HostSpace>(ptr, _host_data + offset, n);
  }
  else if (dir == MemcpyKind::DEVICE_TO_HOST)
  {
    // If device side memory is not allocated, do nothing
    if (!_is_device_alloc)
      return;

    // Copy from device to host
    copyInternal<::Kokkos::HostSpace, MemSpace>(ptr, _device_data + offset, n);
  }
  else if (dir == MemcpyKind::DEVICE_TO_DEVICE)
  {
    // If device side memory is not allocated, do nothing
    if (!_is_device_alloc)
      return;

    // Copy from device to device
    copyInternal<MemSpace, MemSpace>(ptr, _device_data + offset, n);
  }
}

copyToDevice()

template<typename T , unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::copyToDevice

(

)

Copy data from host to device.

Definition at line 657 of file KokkosArray.h.

{
  // If host side memory is not allocated, do nothing
  if (!_is_host_alloc)
    return;

  // If device side memory is not allocated,
  if (!_is_device_alloc)
  {
    if (_counter.use_count() == 1)
      // allocate memory if this array is not shared with other arrays
      allocDevice();
    else
      // print error if this array is shared with other arrays
      mooseError("Kokkos array error: cannot copy from host to device because device side memory "
                 "was not allocated and array is being shared with other arrays.");
  }

  // Copy from host to device
  copyInternal<MemSpace, ::Kokkos::HostSpace>(_device_data, _host_data, _size);
}

copyToDeviceNested()

template<typename T , unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::copyToDeviceNested

(

)

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

Definition at line 814 of file KokkosArray.h.

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

  copyToDevice();
}

copyToHost()

template<typename T , unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::copyToHost

(

)

Copy data from device to host.

Definition at line 681 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();
    else
      // print error if this array is shared with other arrays
      mooseError("Kokkos array error: cannot copy from device to host because host side memory "
                 "was not allocated and array is being shared with other arrays.");
  }

  // Copy from device to host
  copyInternal<::Kokkos::HostSpace, MemSpace>(_host_data, _device_data, _size);
}

create()

template<typename T, unsigned int dimension>

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

inline

Allocate array on host and device.

Parameters

n	The vector containing the size of each dimension

Definition at line 228 of file KokkosArray.h.

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

createDevice()

template<typename T, unsigned int dimension>

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

inline

Allocate array on device only.

Parameters

n	The vector containing the size of each dimension

Definition at line 238 of file KokkosArray.h.

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

createHost()

template<typename T, unsigned int dimension>

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

inline

Allocate array on host only.

Parameters

n	The vector containing the size of each dimension

Definition at line 233 of file KokkosArray.h.

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

createInternal() [1/2]

template<typename T , unsigned int dimension>

template<bool host, bool device>

void Moose::Kokkos::ArrayBase< T, dimension >::createInternal ( const std::vector< dof_id_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

Parameters

n	The vector containing the size of each dimension

Definition at line 582 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>();

  _size = 1;
  _s[0] = 1;

  for (const auto i : make_range(dimension))
  {
    _n[i] = n[i];
    _size *= n[i];

    if (i)
      _s[i] = _s[i - 1] * _n[i - 1];
  }

  if constexpr (host)
    allocHost();

  if constexpr (device)
    allocDevice();

  _is_init = true;
}

createInternal() [2/2]

template<typename T , unsigned int dimension>

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

protected

The internal method to initialize and allocate this array.

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

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

data()

template<typename T, unsigned int dimension>

KOKKOS_FUNCTION T* Moose::Kokkos::ArrayBase< T, dimension >::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 171 of file KokkosArray.h.

  {
    KOKKOS_IF_ON_HOST(return _host_data;)

    return _device_data;
  }

deepCopy()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::deepCopy

(

const ArrayBase< T, dimension > &

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

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

{
  if (ArrayDeepCopy<T>::value && !array._is_host_alloc)
    mooseError(
        "Kokkos array error: cannot deep copy using constructor from array without host data.");

  std::vector<dof_id_type> n(std::begin(array._n), std::end(array._n));

  createInternal(n, array._is_host_alloc, array._is_device_alloc);

  if constexpr (ArrayDeepCopy<T>::value)
  {
    for (dof_id_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];
  }
}

destroy()

template<typename T , unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::destroy

(

)

Free all data and reset.

Definition at line 444 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::~ArrayBase().

{
  if (!_counter)
    return;

  if (_counter.use_count() > 1)
  {
    _host_data = nullptr;
    _device_data = nullptr;
  }
  else if (_counter.use_count() == 1)
  {
    if (_is_host_alloc && !_is_host_alias)
    {
      if constexpr (std::is_default_constructible<T>::value)
        // Allocated by new
        delete[] _host_data;
      else
      {
        // Allocated by malloc
        for (dof_id_type i = 0; i < _size; ++i)
          _host_data[i].~T();

        std::free(_host_data);
      }
    }

    if (_is_device_alloc && !_is_device_alias)
      Moose::Kokkos::free(_device_data);
  }

  _size = 0;

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

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

  _counter.reset();
}

deviceData()

template<typename T, unsigned int dimension>

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

inline

Get the device data pointer.

Returns

The pointer to the underlying device data

Definition at line 223 of file KokkosArray.h.

{ return _device_data; }

end()

template<typename T, unsigned int dimension>

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

inline

Get the end iterator.

Returns

The end iterator

Definition at line 342 of file KokkosArray.h.

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

    return iterator(_device_data + _size);
  }

first()

template<typename T, unsigned int dimension>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension >::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 182 of file KokkosArray.h.

  {
    KOKKOS_IF_ON_HOST(return _host_data[0];)

    return _device_data[0];
  }

hostData()

template<typename T, unsigned int dimension>

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

inline

Get the host data pointer.

Returns

The pointer to the underlying host data

Definition at line 218 of file KokkosArray.h.

{ return _host_data; }

isAlloc()

template<typename T, unsigned int dimension>

KOKKOS_FUNCTION bool Moose::Kokkos::ArrayBase< T, dimension >::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 134 of file KokkosArray.h.

{ return _is_host_alloc || _is_device_alloc; }

isDeviceAlias()

template<typename T, unsigned int dimension>

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

inline

Get whether the device array was aliased.

Returns

Whether the device array was aliased

Definition at line 154 of file KokkosArray.h.

{ return _is_device_alias; }

isDeviceAlloc()

template<typename T, unsigned int dimension>

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

inline

Get whether the array was allocated on device.

Returns

Whether the array was allocated on device

Definition at line 144 of file KokkosArray.h.

{ return _is_device_alloc; }

isHostAlias()

template<typename T, unsigned int dimension>

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

inline

Get whether the host array was aliased.

Returns

Whether the host array was aliased

Definition at line 149 of file KokkosArray.h.

{ return _is_host_alias; }

isHostAlloc()

template<typename T, unsigned int dimension>

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

inline

Get whether the array was allocated on host.

Returns

Whether the array was allocated on host

Definition at line 139 of file KokkosArray.h.

{ return _is_host_alloc; }

last()

template<typename T, unsigned int dimension>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension >::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 193 of file KokkosArray.h.

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

    return _device_data[_size - 1];
  }

n()

template<typename T, unsigned int dimension>

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

inline

Get the size of a dimension.

Parameters

dim	The dimension index

Returns

The array size of the dimension

Definition at line 165 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::create(), Moose::Kokkos::ArrayBase< T, 4 >::createDevice(), and Moose::Kokkos::ArrayBase< T, 4 >::createHost().

{ return _n[dim]; }

offset()

template<typename T , unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::offset

(

const std::vector< dof_id_signed_type > &

d

)

Apply starting index offsets to each dimension.

Parameters

d	The vector containing the offset of each dimension

Definition at line 642 of file KokkosArray.h.

Referenced by Moose::Kokkos::Array< T, 1 >::offset(), Moose::Kokkos::Array< T, 2 >::offset(), Moose::Kokkos::Array< T, 3 >::offset(), Moose::Kokkos::Array< T, 4 >::offset(), and Moose::Kokkos::Array< T, 5 >::offset().

{
  if (d.size() > dimension)
    mooseError("Kokkos array error: the number of offsets provided (",
               d.size(),
               ") cannot be larger than the array dimension (",
               dimension,
               ").");

  for (const auto i : index_range(d))
    _d[i] = d[i];
}

operator=()

template<typename T, unsigned int dimension>

auto & Moose::Kokkos::ArrayBase< T, dimension >::operator=

(

const T &

scalar

)

Assign a scalar value uniformly.

Parameters

scalar

The scalar value to be assigned

Definition at line 870 of file KokkosArray.h.

{
  if (_is_host_alloc)
    std::fill_n(_host_data, _size, scalar);

  if (_is_device_alloc)
  {
    ::Kokkos::View<T *, MemSpace, ::Kokkos::MemoryTraits<::Kokkos::Unmanaged>> data(_device_data,
                                                                                    _size);
    ::Kokkos::Experimental::fill_n(ExecSpace(), data, _size, scalar);
  }

  return *this;
}

operator[]()

template<typename T, unsigned int dimension>

KOKKOS_FUNCTION T& Moose::Kokkos::ArrayBase< T, dimension >::operator[] ( dof_id_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 205 of file KokkosArray.h.

  {
    KOKKOS_ASSERT(i < _size);

    KOKKOS_IF_ON_HOST(return _host_data[i];)

    return _device_data[i];
  }

shallowCopy()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::shallowCopy

(

const ArrayBase< T, dimension > &

array

)

Shallow copy another Kokkos array.

Parameters

array

The Kokkos array to be shallow copied

Definition at line 495 of file KokkosArray.h.

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

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

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

inline

Get the total array size.

Returns

The total array size

Definition at line 159 of file KokkosArray.h.

{ return _size; }

swap()

template<typename T, unsigned int dimension>

void Moose::Kokkos::ArrayBase< T, dimension >::swap

(

ArrayBase< T, dimension > &

array

)

Swap with another Kokkos array.

Parameters

array

The Kokkos array to be swapped

Definition at line 859 of file KokkosArray.h.

{
  ArrayBase<T, dimension> clone;

  clone.shallowCopy(*this);
  this->shallowCopy(array);
  array.shallowCopy(clone);
}

useCount()

template<typename T, unsigned int dimension>

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

inline

Get the reference count.

Returns

The reference count

Definition at line 127 of file KokkosArray.h.

{ return _counter.use_count(); }

Member Data Documentation

_counter

template<typename T, unsigned int dimension>

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

private

Reference counter.

Definition at line 407 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy(), and Moose::Kokkos::ArrayBase< T, 4 >::useCount().

_d

template<typename T, unsigned int dimension>

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

protected

Offset of each dimension.

Definition at line 362 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_device_data

template<typename T, unsigned int dimension>

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

private

Device data.

Definition at line 435 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::begin(), Moose::Kokkos::ArrayBase< T, 4 >::data(), Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), Moose::Kokkos::ArrayBase< T, 4 >::deviceData(), Moose::Kokkos::ArrayBase< T, 4 >::end(), Moose::Kokkos::ArrayBase< T, 4 >::first(), Moose::Kokkos::ArrayBase< T, 4 >::last(), Moose::Kokkos::ArrayBase< T, 4 >::operator[](), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_host_data

template<typename T, unsigned int dimension>

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

private

Host data.

Definition at line 431 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::begin(), Moose::Kokkos::ArrayBase< T, 4 >::data(), Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), Moose::Kokkos::ArrayBase< T, 4 >::end(), Moose::Kokkos::ArrayBase< T, 4 >::first(), Moose::Kokkos::ArrayBase< T, 4 >::hostData(), Moose::Kokkos::ArrayBase< T, 4 >::last(), Moose::Kokkos::ArrayBase< T, 4 >::operator[](), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_is_device_alias

template<typename T, unsigned int dimension>

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

private

Flag whether the device data points to an external data.

Definition at line 427 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::isDeviceAlias(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_is_device_alloc

template<typename T, unsigned int dimension>

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

private

Flag whether device data was allocated.

Definition at line 419 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), Moose::Kokkos::ArrayBase< T, 4 >::isAlloc(), Moose::Kokkos::ArrayBase< T, 4 >::isDeviceAlloc(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_is_host_alias

template<typename T, unsigned int dimension>

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

private

Flag whether the host data points to an external data.

Definition at line 423 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::isHostAlias(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_is_host_alloc

template<typename T, unsigned int dimension>

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

private

Flag whether host data was allocated.

Definition at line 415 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), Moose::Kokkos::ArrayBase< T, 4 >::isAlloc(), Moose::Kokkos::ArrayBase< T, 4 >::isHostAlloc(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_is_init

template<typename T, unsigned int dimension>

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

private

Flag whether array was initialized.

Definition at line 411 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_n

template<typename T, unsigned int dimension>

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

protected

Size of each dimension.

Definition at line 354 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), Moose::Kokkos::ArrayBase< T, 4 >::n(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_s

template<typename T, unsigned int dimension>

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

protected

Stride of each dimension.

Definition at line 358 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::deepCopy(), and Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy().

_size

template<typename T, unsigned int dimension>

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

private

Total size.

Definition at line 439 of file KokkosArray.h.

Referenced by Moose::Kokkos::ArrayBase< T, 4 >::end(), Moose::Kokkos::ArrayBase< T, 4 >::last(), Moose::Kokkos::ArrayBase< T, 4 >::operator[](), Moose::Kokkos::ArrayBase< T, 4 >::shallowCopy(), and Moose::Kokkos::ArrayBase< T, 4 >::size().

---

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

• include/kokkos/base/KokkosArray.h