Template Numerical Library: TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ > Class Template Reference

Template Numerical Library version\ main:0b2c40fb1

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::SortedSegmentsBase< EmbeddedSegmentsView_ > Class Template Reference

SortedSegmentsBase serves as a base class for TNL::Algorithms::Segments::SortedSegments and TNL::Algorithms::Segments::SortedSegmentsView. More...

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

Inheritance diagram for TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >:
[legend]
Collaboration diagram for TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >:
[legend]

## Public Types
using | ConstPermutationView = typename Containers::VectorView< std::add_const_t< IndexType >, DeviceType, IndexType >
using | DeviceType = typename EmbeddedSegmentsView::DeviceType
| The device where the segments are operating.
using | EmbeddedSegmentsConstView = typename EmbeddedSegmentsView::ConstViewType
using | EmbeddedSegmentsView = EmbeddedSegmentsView_
using | IndexType = typename EmbeddedSegmentsView::IndexType
| The type used for indexing of segments elements.
using | PermutationView = typename Containers::VectorView< IndexType, DeviceType, IndexType >
using | SegmentViewType = typename EmbeddedSegmentsView::SegmentViewType
| Accessor type for one particular segment.

## Public Member Functions
__cuda_callable__ | SortedSegmentsBase ()=default
| Default constructor with no parameters to create empty segments view.
__cuda_callable__ | SortedSegmentsBase (const SortedSegmentsBase &)=default
| Copy constructor.
__cuda_callable__ | SortedSegmentsBase (SortedSegmentsBase &&) noexcept=default
| Move constructor.
__cuda_callable__ IndexType | getElementCount () const
| Returns the number of elements managed by all segments.
__cuda_callable__ EmbeddedSegmentsView | getEmbeddedSegmentsView ()
__cuda_callable__ EmbeddedSegmentsConstView | getEmbeddedSegmentsView () const
__cuda_callable__ IndexType | getGlobalIndex (IndexType segmentIdx, IndexType localIdx) const
| Computes the global index of an element managed by the segments.
__cuda_callable__ PermutationView | getInverseSegmentsPermutationView ()
| Returns a modifiable vector view with inverse segments permutation.
__cuda_callable__ ConstPermutationView | getInverseSegmentsPermutationView () const
| Returns a constant vector view with inverse segments permutation..
__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__ PermutationView | getSegmentsPermutationView ()
| Returns a modifiable vector view with segments permutation.
__cuda_callable__ ConstPermutationView | getSegmentsPermutationView () const
| Returns a constant vector view with segments permutation..
__cuda_callable__ SegmentViewType | getSegmentView (IndexType segmentIdx) const
| Returns a segment view (i.e., a segment accessor) for the specified segment index.
__cuda_callable__ IndexType | getSigma () const
| Gets the value of sigma.
__cuda_callable__ IndexType | getSize () const
| Returns the number of elements managed by all segments.
__cuda_callable__ IndexType | getStorageSize () const
| Returns number of elements that needs to be allocated by a container connected to this segments.
SortedSegmentsBase & | operator= (const SortedSegmentsBase &)=delete
| Copy-assignment operator.
SortedSegmentsBase & | operator= (SortedSegmentsBase &&)=delete
| Move-assignment operator.
__cuda_callable__ void | setSigma (IndexType value)
| Sets the value of sigma.

## Static Public Member Functions
static constexpr ElementsOrganization | getOrganization ()
| Returns the data layout (it is always row-major order).
static std::string | getSegmentsType ()
| Returns string with the segments type.
static std::string | getSerializationType ()
| Returns string with the serialization type.
static constexpr bool | havePadding ()
| This function denotes if the underlying segments use the padding elements.

## Protected Member Functions
__cuda_callable__ void | bind (const EmbeddedSegmentsView &embeddedSegmentsView, const PermutationView &segmentsPermutation, const PermutationView &inverseSegmentsPermutation)
| Re-initializes the internal attributes of the base class.

## Protected Attributes
EmbeddedSegmentsView | embeddedSegmentsView
PermutationView | inverseSegmentsPermutationView
PermutationView | segmentsPermutationView
| Vector view with the segments permutation.
IndexType | sigma = -1

## Detailed Description

template<typename EmbeddedSegmentsView_>
class TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >

SortedSegmentsBase serves as a base class for TNL::Algorithms::Segments::SortedSegments and TNL::Algorithms::Segments::SortedSegmentsView.

The sorted segments are inspired by SELL-C-sigma sparse matrix storage format:

Kreutzer, Moritz, et al. "A unified sparse matrix data format for efficient general sparse matrix-vector multiplication on modern processors with wide SIMD units." SIAM Journal on Scientific Computing 36.5 (2014): C401-C423.

Template Parameters

  EmbeddedSegments | is a type of segments used to manage the data.

## Member Function Documentation

## ◆ bind()

template<typename EmbeddedSegmentsView_>

__cuda_callable__ void TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >::bind | ( | const EmbeddedSegmentsView & | embeddedSegmentsView,
|  | const PermutationView & | segmentsPermutation,
|  | const PermutationView & | inverseSegmentsPermutation )
| 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 EmbeddedSegmentsView_>

__cuda_callable__ IndexType TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >::getGlobalIndex | ( | IndexType | segmentIdx,
|  | IndexType | 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 EmbeddedSegmentsView_>

std::string TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >::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 EmbeddedSegmentsView_>

__cuda_callable__ SegmentViewType TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >::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 EmbeddedSegmentsView_>

std::string TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ >::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/SortedSegmentsBase.h