Template Numerical Library: TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize > Class Template Reference

Template Numerical Library version\ main:c7077e4fd

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize > Class Template Reference

SlicedEllpackBase serves as a base class for TNL::Algorithms::Segments::SlicedEllpack and TNL::Algorithms::Segments::SlicedEllpackView. More...

`#include <TNL/Algorithms/Segments/SlicedEllpackBase.h>`

Inheritance diagram for TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >:
[legend]
Collaboration diagram for TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >:
[legend]

## Public Types
using | ConstOffsetsView = typename OffsetsView::ConstViewType
| The type for representing the constant vector view with segment offsets.
using | DeviceType = Device
| The device where the segments are operating.
using | IndexType = std::remove_const_t< Index >
| The type used for indexing of segments elements.
using | OffsetsView = Containers::VectorView< Index, DeviceType, IndexType >
| The type for representing the vector view with segment offsets.
using | SegmentViewType = SegmentView< IndexType, Organization >
| Accessor type for one particular segment.

## Public Member Functions
__cuda_callable__ | SlicedEllpackBase ()=default
| Default constructor with no parameters to create empty segments view.
__cuda_callable__ | SlicedEllpackBase (const SlicedEllpackBase &)=default
| Copy constructor.
__cuda_callable__ | SlicedEllpackBase (IndexType size, IndexType storageSize, IndexType segmentsCount, OffsetsView &&sliceOffsets, OffsetsView &&sliceSegmentSizes)
| Constructor that initializes segments based on all necessary data.
__cuda_callable__ | SlicedEllpackBase (SlicedEllpackBase &&) noexcept=default
| Move constructor.
template<typename Function>
void | forAllElements (Function &&function) const
template<typename Condition, typename Function>
void | forAllElementsIf (Condition condition, Function function) const
template<typename Function>
void | forAllSegments (Function &&function) const
template<typename Array, typename Function>
void | forElements (const Array &segmentIndexes, Function function) const
template<typename Array, typename Function>
void | forElements (const Array &segmentIndexes, Index begin, Index end, Function function) const
template<typename Function>
void | forElements (IndexType begin, IndexType end, Function &&function) const
template<typename Condition, typename Function>
void | forElementsIf (IndexType begin, IndexType end, Condition condition, Function function) const
template<typename Function>
void | forSegments (IndexType begin, IndexType end, Function &&function) const
__cuda_callable__ IndexType | getElementCount () const
| Returns the number of elements managed by all segments.
__cuda_callable__ IndexType | getGlobalIndex (Index segmentIdx, Index localIdx) const
| Computes the global index of an element managed by the segments.
__cuda_callable__ IndexType | getSegmentCount () const
| Returns the number of segments.
__cuda_callable__ IndexType | getSegmentsCount () const
| Returns the number of segments. Deprecated, use getSegmentCount().
__cuda_callable__ IndexType | getSegmentSize (IndexType segmentIdx) const
| Returns the size of a particular segment denoted by segmentIdx.
__cuda_callable__ SegmentViewType | getSegmentView (IndexType segmentIdx) const
| Returns a segment view (i.e., a segment accessor) for the specified segment index.
__cuda_callable__ IndexType | getSize () const
| Returns the number of elements managed by all segments.
__cuda_callable__ OffsetsView | getSliceOffsetsView ()
| Returns a modifiable vector view with the offsets of particular slices.
__cuda_callable__ ConstOffsetsView | getSliceOffsetsView () const
| Returns a constant vector view with the offsets of particular slices.
__cuda_callable__ OffsetsView | getSliceSegmentSizesView ()
| Returns a modifiable vector view with the segment sizes in particular slices.
__cuda_callable__ ConstOffsetsView | getSliceSegmentSizesView () const
| Returns a constant vector view with the segment sizes in particular slices.
__cuda_callable__ IndexType | getStorageSize () const
| Returns number of elements that needs to be allocated by a container connected to this segments.
SlicedEllpackBase & | operator= (const SlicedEllpackBase &)=delete
| Copy-assignment operator.
SlicedEllpackBase & | operator= (SlicedEllpackBase &&)=delete
| Move-assignment operator.

## Static Public Member Functions
static constexpr ElementsOrganization | getOrganization ()
| Returns the data layout.
static std::string | getSegmentsType ()
| Returns string with the segments type.
static std::string | getSerializationType ()
| Returns string with the serialization type.
static constexpr int | getSliceSize ()
| Returns the size of each slice.
static constexpr bool | havePadding ()
| This function denotes that the SlicedEllpack format use padding elements.

## Protected Member Functions
__cuda_callable__ void | bind (IndexType size, IndexType storageSize, IndexType segmentsCount, OffsetsView sliceOffsets, OffsetsView sliceSegmentSizes)
| Re-initializes the internal attributes of the base class.

## Protected Attributes
IndexType | segmentsCount = 0
IndexType | size = 0
OffsetsView | sliceOffsets
OffsetsView | sliceSegmentSizes
IndexType | storageSize = 0

## Detailed Description

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>
class TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >

SlicedEllpackBase serves as a base class for TNL::Algorithms::Segments::SlicedEllpack and TNL::Algorithms::Segments::SlicedEllpackView.

Template Parameters

  Device | is type of device where the segments will be operating.
  Index | is type for indexing of the elements managed by the segments.
  Organization | is the organization of the elements in the segments—either row-major or column-major order.
  SliceSize | is the size of each slice.

## Member Function Documentation

## ◆ bind()

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>

__cuda_callable__ void TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >::bind | ( | IndexType | size,
|  | IndexType | storageSize,
|  | IndexType | segmentsCount,
|  | OffsetsView | sliceOffsets,
|  | OffsetsView | sliceSegmentSizes )
| protected

Re-initializes the internal attributes of the base class.

Note that this function is protected to ensure that the user cannot modify the base class of segments. For the same reason, in future code development we also need to make sure that all non-const functions in the base class return by value and not by reference.

## ◆ getGlobalIndex()

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>

__cuda_callable__ IndexType TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >::getGlobalIndex | ( | Index | segmentIdx,
|  | Index | localIdx ) const
| nodiscard

Computes the global index of an element managed by the segments.

The global index serves as a reference to the element within its container.

Parameters

  segmentIdx | The index of the segment containing the element.
  localIdx | The local index of the element within the segment.

Returns
  The global index of the element.

## ◆ getSegmentsType()

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>

std::string TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >::getSegmentsType | ( |  | ) |
| staticnodiscard

Returns string with the segments type.

Example
  #include <iostream>
  #include <functional>
  #include <TNL/Algorithms/Segments/CSR.h>
  #include <TNL/Algorithms/Segments/Ellpack.h>
  #include <TNL/Devices/Host.h>
  #include <TNL/Devices/Cuda.h>
  template< typename Segments >
  void
  SegmentsExample()
  {
  /***
  * Create segments and print the segments type.
  */
  Segments segments;
  std::cout << "The segments type is: " << segments.getSegmentsType() << '\n';
  }
  int
  main( int argc, char* argv[] )
  {
  std::cout << "Example of CSR segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Host, int > >();
  std::cout << "Example of Ellpack segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Host, int > >();
  #ifdef __CUDACC__
  std::cout << "Example of CSR segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Cuda, int > >();
  std::cout << "Example of Ellpack segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Cuda, int > >();
  #endif
  return EXIT_SUCCESS;
  }
  std::cout
  TNL::Algorithms::Segments
  Namespace for the segments data structures.
  Definition _NamespaceDoxy.h:7

Output
  Example of CSR segments on host:
  The segments type is: CSR
  Example of Ellpack segments on host:
  The segments type is: Ellpack

## ◆ getSegmentView()

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>

__cuda_callable__ SegmentViewType TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >::getSegmentView | ( | IndexType | segmentIdx | ) | const
| nodiscard

Returns a segment view (i.e., a segment accessor) for the specified segment index.

Parameters

  segmentIdx | The index of the requested segment.

Returns
  The segment view of the specified segment.

Example
  #include <iostream>
  #include <TNL/Containers/Vector.h>
  #include <TNL/Algorithms/Segments/CSR.h>
  #include <TNL/Algorithms/Segments/Ellpack.h>
  #include <TNL/Algorithms/SequentialFor.h>
  #include <TNL/Devices/Host.h>
  #include <TNL/Devices/Cuda.h>
  template< typename Segments >
  void
  SegmentsExample()
  {
  using Device = typename Segments::DeviceType;
  /***
  * Create segments with given segments sizes.
  */
  const int size( 5 );
  Segments segments{ 1, 2, 3, 4, 5 };
  auto view = segments.getView();
  /***
  * Print the elements mapping using segment view.
  */
  std::cout << "Mapping of local indexes to global indexes:\n";
  auto f = [ = ] __cuda_callable__( int segmentIdx )
  {
  printf( "Segment idx. %d: ", segmentIdx ); // printf works even in GPU kernels
  auto segment = view.getSegmentView( segmentIdx );
  for( auto element : segment )
  printf( "%d -> %d \t", element.localIndex(), element.globalIndex() );
  printf( "\n" );
  };
  TNL::Algorithms::SequentialFor< Device >::exec( 0, size, f );
  }
  int
  main( int argc, char* argv[] )
  {
  std::cout << "Example of CSR segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Host, int > >();
  std::cout << "Example of Ellpack segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Host, int > >();
  #ifdef __CUDACC__
  std::cout << "Example of CSR segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Cuda, int > >();
  std::cout << "Example of Ellpack segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Cuda, int > >();
  #endif
  return EXIT_SUCCESS;
  }
  __cuda_callable__
  #define __cuda_callable__
  Definition Macros.h:49
  TNL::Algorithms::SequentialFor::exec
  static void exec(Index start, Index end, Function f)
  Static method for execution of the loop.
  Definition SequentialFor.h:36

Output
  Example of CSR segments on host:
  Mapping of local indexes to global indexes:
  Segment idx. 0: 0 -> 0
  Segment idx. 1: 0 -> 1 1 -> 2
  Segment idx. 2: 0 -> 3 1 -> 4 2 -> 5
  Segment idx. 3: 0 -> 6 1 -> 7 2 -> 8 3 -> 9
  Segment idx. 4: 0 -> 10 1 -> 11 2 -> 12 3 -> 13 4 -> 14
  Example of Ellpack segments on host:
  Mapping of local indexes to global indexes:
  Segment idx. 0: 0 -> 0 1 -> 1 2 -> 2 3 -> 3 4 -> 4
  Segment idx. 1: 0 -> 5 1 -> 6 2 -> 7 3 -> 8 4 -> 9
  Segment idx. 2: 0 -> 10 1 -> 11 2 -> 12 3 -> 13 4 -> 14
  Segment idx. 3: 0 -> 15 1 -> 16 2 -> 17 3 -> 18 4 -> 19
  Segment idx. 4: 0 -> 20 1 -> 21 2 -> 22 3 -> 23 4 -> 24

## ◆ getSerializationType()

template<typename Device, typename Index, ElementsOrganization Organization, int SliceSize>

std::string TNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize >::getSerializationType | ( |  | ) |
| staticnodiscard

Returns string with the serialization type.

Example
  #include <iostream>
  #include <functional>
  #include <TNL/Algorithms/Segments/CSR.h>
  #include <TNL/Algorithms/Segments/Ellpack.h>
  #include <TNL/Devices/Host.h>
  #include <TNL/Devices/Cuda.h>
  template< typename Segments >
  void
  SegmentsExample()
  {
  /***
  * Create segments and print the serialization type.
  */
  Segments segments;
  std::cout << "The serialization type is: " << segments.getSerializationType() << '\n';
  }
  int
  main( int argc, char* argv[] )
  {
  std::cout << "Example of CSR segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Host, int > >();
  std::cout << "Example of Ellpack segments on host:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Host, int > >();
  #ifdef __CUDACC__
  std::cout << "Example of CSR segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Cuda, int > >();
  std::cout << "Example of Ellpack segments on CUDA GPU:\n";
  SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Cuda, int > >();
  #endif
  return EXIT_SUCCESS;
  }

Output
  Example of CSR segments on host:
  The serialization type is: CSR< int >
  Example of Ellpack segments on host:
  The serialization type is: Ellpack< int, RowMajorOrder, 32 >

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

- src/TNL/Algorithms/Segments/SlicedEllpackBase.h