Template Numerical Library: TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator > Class Template Reference

Template Numerical Library version\ main:c7077e4fd

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Attributes | List of all members
TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator > Class Template Reference

Data structure for sorted segments. More...

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

Inheritance diagram for TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >:
[legend]
Collaboration diagram for TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >:
[legend]

## Public Types
using | ConstPermutationView
using | ConstViewType = SortedSegmentsView< typename EmbeddedSegments::ConstViewType >
| Type of constant segments view.
using | DeviceType
| The device where the segments are operating.
using | EmbeddedSegmentsConstView
using | EmbeddedSegmentsType = EmbeddedSegments
using | EmbeddedSegmentsView
using | IndexAllocatorType = IndexAllocator
using | IndexType
| The type used for indexing of segments elements.
using | PermutationContainer = Containers::Vector< IndexType, DeviceType, IndexType, IndexAllocatorType >
| Type of container storing offsets of particular segments.
using | PermutationView
template<typename Device_ = DeviceType, typename Index_ = IndexType>
using | ViewTemplate = SortedSegmentsView< typename EmbeddedSegments::template ViewTemplate< Device_, Index_ > >
| Templated view type.
using | ViewType = SortedSegmentsView< typename EmbeddedSegments::ViewType >
| Type of segments view.
Public Types inherited from TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType >
using | ConstPermutationView
using | DeviceType
| The device where the segments are operating.
using | EmbeddedSegmentsConstView
using | EmbeddedSegmentsView
using | IndexType
| The type used for indexing of segments elements.
using | PermutationView
using | SegmentViewType
| Accessor type for one particular segment.

## Public Member Functions
| SortedSegments ()
| Constructor with no parameters to create empty segments.
template<typename SizesContainer, std::enable_if_t< IsArrayType< SizesContainer >::value, bool > = true>
| SortedSegments (const SizesContainer &segmentsSizes)
| Constructor that initializes segments based on their sizes.
| SortedSegments (const SortedSegments &segments)
| Copy constructor (makes deep copy).
template<typename ListIndex>
| SortedSegments (const std::initializer_list< ListIndex > &segmentsSizes)
| Constructor that initializes segments using an initializer list.
| SortedSegments (SortedSegments &&) noexcept=default
| Move constructor.
ConstViewType | getConstView () const
| Returns a constant view for this instance of segments which can by used for example in lambda functions running in GPU kernels.
const EmbeddedSegments & | getEmbeddedSegments () const
| Returns a reference on embedded segments.
const PermutationContainer & | getInverseSegmentsPermutation () const
| Returns a reference on inverse segments permutation.
const PermutationContainer & | getSegmentsPermutation () const
| Returns a reference on segments permutation.
ViewType | getView ()
| Returns a view for this instance of segments which can by used for example in lambda functions running in GPU kernels.
void | load (File &file)
| Method for loading the segments from a file in a binary form.
SortedSegments & | operator= (const SortedSegments &segments)
| Copy-assignment operator (makes a deep copy).
template<typename EmbeddedSegments_, typename IndexAllocator_>
SortedSegments & | operator= (const SortedSegments< EmbeddedSegments_, IndexAllocator_ > &segments) noexcept(false)
| Copy-assignment operator for segments with different template parameters.
SortedSegments & | operator= (SortedSegments &&) noexcept(false)
| Move-assignment operator.
template<typename EmbeddedSegments_, typename IndexAllocator_>
SortedSegments & | operator= (SortedSegments< EmbeddedSegments_, IndexAllocator_ > &&segments) noexcept(false)
| Move-assignment operator for segments with different template parameters.
void | reset ()
| Reset the segments to empty states (it means that there is no segment in the segments).
void | save (File &file) const
| Method for saving the segments to a file in a binary form.
template<typename SizesContainer>
void | setSegmentsSizes (const SizesContainer &segmentsSizes)
| Set sizes of particular segments.
Public Member Functions inherited from TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType >
__cuda_callable__ | SortedSegmentsBase ()=default
| Default constructor with no parameters to create empty segments view.
__cuda_callable__ IndexType | getElementCount () const
| Returns the number of elements managed by all segments.
__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__ 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__ 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.
__cuda_callable__ void | setSigma (IndexType value)
| Sets the value of sigma.

## Protected Attributes
EmbeddedSegments | embeddedSegments
PermutationContainer | inverseSegmentsPermutation
PermutationContainer | segmentsPermutation
Protected Attributes inherited from TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType >
EmbeddedSegmentsView | embeddedSegmentsView
PermutationView | inverseSegmentsPermutationView
PermutationView | segmentsPermutationView
| Vector view with the segments permutation.
IndexType | sigma

## Additional Inherited Members
Static Public Member Functions inherited from TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType >
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 inherited from TNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType >
__cuda_callable__ void | bind (const EmbeddedSegmentsView &embeddedSegmentsView, const PermutationView &segmentsPermutation, const PermutationView &inverseSegmentsPermutation)
| Re-initializes the internal attributes of the base class.

## Detailed Description

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>
class TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >

Data structure for sorted segments.

See TNL::Algorithms::Segments for more details about segments.

Template Parameters

  EmbeddedSegments | The type of embedded segments.
  IndexAllocator | The allocator used for managing index containers.

## Member Typedef Documentation

## ◆ ViewTemplate

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>
template<typename Device_ = DeviceType, typename Index_ = IndexType>

using TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::ViewTemplate = SortedSegmentsView< typename EmbeddedSegments::template ViewTemplate< Device_, Index_ > >

Templated view type.

Template Parameters

  Device_ | is alternative device type for the view.
  Index_ | is alternative index type for the view.

## Constructor & Destructor Documentation

## ◆ SortedSegments() [1/2]

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>
template<typename SizesContainer, std::enable_if_t< IsArrayType< SizesContainer >::value, bool > = true>

TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::SortedSegments | ( | const SizesContainer & | segmentsSizes | ) |

Constructor that initializes segments based on their sizes.

The number of segments is determined by the size of segmentsSizes. Each element in this container specifies the size of a corresponding segment.

Template Parameters

  SizesContainer | The type of container used to store segment sizes. It can be, for example, TNL::Containers::Array or TNL::Containers::Vector.

Parameters

  segmentsSizes | An instance of the container holding the sizes of the segments.

See the following example:

1#include <iostream>
2#include <TNL/Containers/Vector.h>
3#include <TNL/Algorithms/Segments/traverse.h>
4#include <TNL/Devices/Host.h>
5#include <TNL/Devices/Cuda.h>
6
7template< typename Segments >
8void
9SegmentsExample()
10{
11 using Device = typename Segments::DeviceType;
12
13 /***
14 * Create segments with given segments sizes.
15 */
16 TNL::Containers::Vector< int, Device > segmentsSizes{ 1, 2, 3, 4, 5 };
17 Segments segments( segmentsSizes );
18 std::cout << "Segments sizes are: " << segments << '\n';
19
20 /***
21 * Allocate array for the segments;
22 */
23 TNL::Containers::Array< double, Device > data( segments.getStorageSize(), 0.0 );
24
25 /***
26 * Insert data into particular segments.
27 */
28 auto data_view = data.getView();
29 TNL::Algorithms::Segments::forAllElements(
30 segments,
31 [ = ] __cuda_callable__( int segmentIdx, int localIdx, int globalIdx ) mutable
32 {
33 if( localIdx <= segmentIdx )
34 data_view[ globalIdx ] = segmentIdx;
35 } );
36
37 /***
38 * Print the data managed by the segments.
39 */
40 auto fetch = [ = ] __cuda_callable__( int globalIdx ) -> double
41 {
42 return data_view[ globalIdx ];
43 };
44 std::cout << TNL::Algorithms::Segments::print( segments, fetch ) << '\n';
45}
46
47int
48main( int argc, char* argv[] )
49{
50 std::cout << "Example of CSR segments on host:\n";
51 SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Host, int > >();
52
53 std::cout << "Example of Ellpack segments on host:\n";
54 SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Host, int > >();
55
56#ifdef __CUDACC__
57 std::cout << "Example of CSR segments on CUDA GPU:\n";
58 SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Cuda, int > >();
59
60 std::cout << "Example of Ellpack segments on CUDA GPU:\n";
61 SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Cuda, int > >();
62#endif
63 return EXIT_SUCCESS;
64}
__cuda_callable__
#define __cuda_callable__
Definition Macros.h:49
std::cout
TNL::Containers::Array
Array is responsible for memory management, access to array elements, and general array operations.
Definition Array.h:65
TNL::Containers::Vector
Vector extends Array with algebraic operations.
Definition Vector.h:37
TNL::Algorithms::Segments
Namespace for the segments data structures.
Definition _NamespaceDoxy.h:7
TNL::Algorithms::Segments::print
SegmentsPrinter< typename Segments::ConstViewType, Fetch > print(const Segments &segments, Fetch fetch)
Print segments sizes, i.e. the segments setup.
TNL::Algorithms::Segments::forAllElements
void forAllElements(const Segments &segments, Function &&function, LaunchConfiguration launchConfig=Algorithms::Segments::LaunchConfiguration())
Iterates in parallel over all elements of all segments and applies the specified lambda function.

The expected output is:

Example of CSR segments on host:
Segments sizes are: [ 1, 2, 3, 4, 5 ]
Segment 0: [ 0 ]
Segment 1: [ 1, 1 ]
Segment 2: [ 2, 2, 2 ]
Segment 3: [ 3, 3, 3, 3 ]
Segment 4: [ 4, 4, 4, 4, 4 ]
Example of Ellpack segments on host:
Segments sizes are: [ 5, 5, 5, 5, 5 ]
Segment 0: [ 0, 0, 0, 0, 0 ]
Segment 1: [ 1, 1, 0, 0, 0 ]
Segment 2: [ 2, 2, 2, 0, 0 ]
Segment 3: [ 3, 3, 3, 3, 0 ]
Segment 4: [ 4, 4, 4, 4, 4 ]

## ◆ SortedSegments() [2/2]

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>
template<typename ListIndex>

TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::SortedSegments | ( | const std::initializer_list< ListIndex > & | segmentsSizes | ) |

Constructor that initializes segments using an initializer list.

The number of segments is determined by the size of segmentsSizes. Each element in this initializer list specifies the size of a corresponding segment.

Template Parameters

  ListIndex | The type used for indexing elements in the initializer list.

Parameters

  segmentsSizes | An initializer list defining the sizes of the segments.

See the following example:

1#include <iostream>
2#include <TNL/Containers/Vector.h>
3#include <TNL/Algorithms/Segments/traverse.h>
4#include <TNL/Devices/Host.h>
5#include <TNL/Devices/Cuda.h>
6
7template< typename Segments >
8void
9SegmentsExample()
10{
11 using Device = typename Segments::DeviceType;
12
13 /***
14 * Create segments with given segments sizes.
15 */
16 Segments segments{ 1, 2, 3, 4, 5 };
17 std::cout << "Segments sizes are: " << segments << '\n';
18
19 /***
20 * Allocate array for the segments;
21 */
22 TNL::Containers::Array< double, Device > data( segments.getStorageSize(), 0.0 );
23
24 /***
25 * Insert data into particular segments.
26 */
27 auto data_view = data.getView();
28 TNL::Algorithms::Segments::forAllElements(
29 segments,
30 [ = ] __cuda_callable__( int segmentIdx, int localIdx, int globalIdx ) mutable
31 {
32 if( localIdx <= segmentIdx )
33 data_view[ globalIdx ] = segmentIdx;
34 } );
35
36 /***
37 * Print the data managed by the segments.
38 */
39 auto fetch = [ = ] __cuda_callable__( int globalIdx ) -> double
40 {
41 return data_view[ globalIdx ];
42 };
43 std::cout << TNL::Algorithms::Segments::print( segments, fetch ) << '\n';
44}
45
46int
47main( int argc, char* argv[] )
48{
49 std::cout << "Example of CSR segments on host:\n";
50 SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Host, int > >();
51
52 std::cout << "Example of Ellpack segments on host:\n";
53 SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Host, int > >();
54
55#ifdef __CUDACC__
56 std::cout << "Example of CSR segments on CUDA GPU:\n";
57 SegmentsExample< TNL::Algorithms::Segments::CSR< TNL::Devices::Cuda, int > >();
58
59 std::cout << "Example of Ellpack segments on CUDA GPU:\n";
60 SegmentsExample< TNL::Algorithms::Segments::Ellpack< TNL::Devices::Cuda, int > >();
61#endif
62 return EXIT_SUCCESS;
63}

The expected output is:

Example of CSR segments on host:
Segments sizes are: [ 1, 2, 3, 4, 5 ]
Segment 0: [ 0 ]
Segment 1: [ 1, 1 ]
Segment 2: [ 2, 2, 2 ]
Segment 3: [ 3, 3, 3, 3 ]
Segment 4: [ 4, 4, 4, 4, 4 ]
Example of Ellpack segments on host:
Segments sizes are: [ 5, 5, 5, 5, 5 ]
Segment 0: [ 0, 0, 0, 0, 0 ]
Segment 1: [ 1, 1, 0, 0, 0 ]
Segment 2: [ 2, 2, 2, 0, 0 ]
Segment 3: [ 3, 3, 3, 3, 0 ]
Segment 4: [ 4, 4, 4, 4, 4 ]

## Member Function Documentation

## ◆ load()

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>

void TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::load | ( | File & | file | ) |

Method for loading the segments from a file in a binary form.

Parameters

  file | is the source file.

## ◆ save()

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>

void TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::save | ( | File & | file | ) | const

Method for saving the segments to a file in a binary form.

Parameters

  file | is the target file.

## ◆ setSegmentsSizes()

template<typename EmbeddedSegments, typename IndexAllocator = typename EmbeddedSegments::IndexAllocatorType>
template<typename SizesContainer>

void TNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator >::setSegmentsSizes | ( | const SizesContainer & | segmentsSizes | ) |

Set sizes of particular segments.

Template Parameters

  SizesContainer | is a container with segments sizes. It can be TNL::Containers::Array or TNL::Containers::Vector for example.

Parameters

  segmentsSizes | is an instance of the container with segments sizes.

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

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