Moose::Kokkos::Array< T, 2 > Class Template Reference

#include <KokkosArray.h>

Inheritance diagram for Moose::Kokkos::Array< T, 2 >:

Public Member Functions
	Array ()=default
	Default constructor. More...
	Array (const Array< T, 2 > &array)
	Copy constructor. More...
auto &	operator= (const Array< T, 2 > &array)
	Shallow copy another Kokkos array. More...
	Array (dof_id_type n0, dof_id_type n1)
	Constructor Initialize and allocate array with given dimensions This allocates both host and device data. More...
void	init (dof_id_type n0, dof_id_type n1)
	Initialize array with given dimensions but do not allocate. More...
void	create (dof_id_type n0, dof_id_type n1)
	Initialize and allocate array with given dimensions on host and device. More...
void	createHost (dof_id_type n0, dof_id_type n1)
	Initialize and allocate array with given dimensions on host only. More...
void	createDevice (dof_id_type n0, dof_id_type n1)
	Initialize and allocate array with given dimensions on device only. More...
void	offset (dof_id_signed_type d0, dof_id_signed_type d1)
	Set starting index offsets. More...
KOKKOS_FUNCTION T &	operator() (dof_id_signed_type i0, dof_id_signed_type i1) const
	Get an array entry. 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...
KOKKOS_FUNCTION iterator	begin () const
	Get the beginning iterator. More...
KOKKOS_FUNCTION iterator	end () const
	Get the end iterator. More...

Protected Member Functions
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...
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]
	Size of each dimension. More...
dof_id_type	_s [dimension]
	Stride of each dimension. More...
dof_id_signed_type	_d [dimension]
	Offset of each dimension. More...

Private Member Functions
	usingKokkosArrayBaseMembers (T, 2)

Detailed Description

template<typename T>
class Moose::Kokkos::Array< T, 2 >

Definition at line 1190 of file KokkosArray.h.

Constructor & Destructor Documentation

Array() [1/3]

template<typename T>

Moose::Kokkos::Array< T, 2 >::Array ( )

default

Default constructor.

Array() [2/3]

template<typename T>

Moose::Kokkos::Array< T, 2 >::Array ( const Array< T, 2 > &  array )

inline

Copy constructor.

Definition at line 1204 of file KokkosArray.h.

: ArrayBase<T, 2>(array) {}

Array() [3/3]

template<typename T>

Moose::Kokkos::Array< T, 2 >::Array ( dof_id_type  n0, dof_id_type  n1  )

inline

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

Parameters

n0	The first dimension size
n1	The second dimension size

Definition at line 1224 of file KokkosArray.h.

{ create(n0, n1); }

Member Function Documentation

aliasDevice()

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

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

begin()

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

inlineinherited

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

void Moose::Kokkos::ArrayBase< T, dimension >::copyIn ( const T *  ptr, MemcpyKind  dir, dof_id_type  n, dof_id_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 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()

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

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

copyOut()

void Moose::Kokkos::ArrayBase< T, dimension >::copyOut ( T *  ptr, MemcpyKind  dir, dof_id_type  n, dof_id_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 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()

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

inherited

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

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

inherited

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

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

inherited

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() [1/2]

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

inlineinherited

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

create() [2/2]

template<typename T>

void Moose::Kokkos::Array< T, 2 >::create ( dof_id_type  n0, dof_id_type  n1  )

inline

Initialize and allocate array with given dimensions on host and device.

Parameters

n0	The first dimension size
n1	The second dimension size

Definition at line 1240 of file KokkosArray.h.

  {
    this->template createInternal<true, true>({n0, n1});
  }

createDevice() [1/2]

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

inlineinherited

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

createDevice() [2/2]

template<typename T>

void Moose::Kokkos::Array< T, 2 >::createDevice ( dof_id_type  n0, dof_id_type  n1  )

inline

Initialize and allocate array with given dimensions on device only.

Parameters

n0	The first dimension size
n1	The second dimension size

Definition at line 1258 of file KokkosArray.h.

  {
    this->template createInternal<false, true>({n0, n1});
  }

createHost() [1/2]

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

inlineinherited

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

createHost() [2/2]

template<typename T>

void Moose::Kokkos::Array< T, 2 >::createHost ( dof_id_type  n0, dof_id_type  n1  )

inline

Initialize and allocate array with given dimensions on host only.

Parameters

n0	The first dimension size
n1	The second dimension size

Definition at line 1249 of file KokkosArray.h.

  {
    this->template createInternal<true, false>({n0, n1});
  }

createInternal() [1/2]

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

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]

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

protectedinherited

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

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

  {
    KOKKOS_IF_ON_HOST(return _host_data;)

    return _device_data;
  }

deepCopy()

void Moose::Kokkos::ArrayBase< T, dimension >::deepCopy ( const ArrayBase< T, dimension > &  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 824 of file KokkosArray.h.

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

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

inherited

Free all data and reset.

Definition at line 444 of file KokkosArray.h.

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

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

inlineinherited

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

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

inlineinherited

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

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

  {
    KOKKOS_IF_ON_HOST(return _host_data[0];)

    return _device_data[0];
  }

hostData()

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

inlineinherited

Get the host data pointer.

Returns

The pointer to the underlying host data

Definition at line 218 of file KokkosArray.h.

{ return _host_data; }

init()

template<typename T>

void Moose::Kokkos::Array< T, 2 >::init ( dof_id_type  n0, dof_id_type  n1  )

inline

Initialize array with given dimensions but do not allocate.

Parameters

n0	The first dimension size
n1	The second dimension size

Definition at line 1231 of file KokkosArray.h.

  {
    this->template createInternal<false, false>({n0, n1});
  }

isAlloc()

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

{ return _is_host_alloc || _is_device_alloc; }

isDeviceAlias()

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

inlineinherited

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

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

inlineinherited

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

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

inlineinherited

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

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

inlineinherited

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

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

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

    return _device_data[_size - 1];
  }

n()

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

{ return _n[dim]; }

offset() [1/2]

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

inherited

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.

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

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

offset() [2/2]

template<typename T>

void Moose::Kokkos::Array< T, 2 >::offset ( dof_id_signed_type  d0, dof_id_signed_type  d1  )

inline

Set starting index offsets.

Parameters

d0	The first dimension offset
d1	The second dimension offset

Definition at line 1267 of file KokkosArray.h.

{ ArrayBase<T, 2>::offset({d0, d1}); }

operator()()

template<typename T>

KOKKOS_FUNCTION T& Moose::Kokkos::Array< T, 2 >::operator() ( dof_id_signed_type  i0, dof_id_signed_type  i1  ) const

inline

Get an array entry.

Parameters

i0	The first dimension index
i1	The second dimension index

Returns

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

Definition at line 1276 of file KokkosArray.h.

  {
    KOKKOS_ASSERT(i0 - _d[0] >= 0 && static_cast<dof_id_type>(i0 - _d[0]) < _n[0]);
    KOKKOS_ASSERT(i1 - _d[1] >= 0 && static_cast<dof_id_type>(i1 - _d[1]) < _n[1]);

    return this->operator[](i0 - _d[0] + (i1 - _d[1]) * _s[1]);
  }

operator=()

template<typename T>

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

inline

Shallow copy another Kokkos array.

Parameters

array

The Kokkos array to be shallow copied

Definition at line 1209 of file KokkosArray.h.

  {
    this->shallowCopy(array);

    return *this;
  }

operator[]()

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

  {
    KOKKOS_ASSERT(i < _size);

    KOKKOS_IF_ON_HOST(return _host_data[i];)

    return _device_data[i];
  }

shallowCopy()

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

inherited

Shallow copy another Kokkos array.

Parameters

array

The Kokkos array to be shallow copied

Definition at line 495 of file KokkosArray.h.

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

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

inlineinherited

Get the total array size.

Returns

The total array size

Definition at line 159 of file KokkosArray.h.

{ return _size; }

swap()

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

inherited

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

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

inlineinherited

Get the reference count.

Returns

The reference count

Definition at line 127 of file KokkosArray.h.

{ return _counter.use_count(); }

usingKokkosArrayBaseMembers()

template<typename T>

Moose::Kokkos::Array< T, 2 >::usingKokkosArrayBaseMembers ( T  , 2    )

private

Member Data Documentation

_d

dof_id_signed_type Moose::Kokkos::ArrayBase< T, dimension >::_d[dimension]

protectedinherited

Offset of each dimension.

Definition at line 362 of file KokkosArray.h.

_n

dof_id_type Moose::Kokkos::ArrayBase< T, dimension >::_n[dimension]

protectedinherited

Size of each dimension.

Definition at line 354 of file KokkosArray.h.

_s

dof_id_type Moose::Kokkos::ArrayBase< T, dimension >::_s[dimension]

protectedinherited

Stride of each dimension.

Definition at line 358 of file KokkosArray.h.

---

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

• include/kokkos/base/KokkosArray.h