Template Numerical Library: TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator

Data structure for CSR segments format. More...

#include <TNL/Algorithms/Segments/CSR.h>

Inheritance diagram for TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >:

Collaboration diagram for TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >:

[legend]

Public Types
using	ConstViewType = CSRView< Device, std::add_const_t< Index > >
	Type of constant segments view.

using	OffsetsContainer = Containers::Vector< Index, Device, typename Base::IndexType, IndexAllocator >
	Type of container storing offsets of particular rows.

template<typename Device_ , typename Index_ >
using	ViewTemplate = CSRView< Device_, Index_ >
	Templated view type.

using	ViewType = CSRView< Device, Index >
	Type of segments view.

Public Types inherited from TNL::Algorithms::Segments::CSRBase< Device, Index >
using	ConstOffsetsView = typename OffsetsView::ConstViewType
	The type for representing the constant vector view with row offsets used in the CSR format.

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 row offsets used in the CSR format.

using	SegmentViewType = SegmentView< IndexType, RowMajorOrder >
	Accessor type fro one particular segment.

Public Member Functions
	CSR ()=default
	Constructor with no parameters to create empty segments.

	CSR (const CSR &segments)
	Copy constructor (makes deep copy).

template<typename SizesContainer >
	CSR (const SizesContainer &segmentsSizes)
	Construct with segments sizes.

template<typename ListIndex >
	CSR (const std::initializer_list< ListIndex > &segmentsSizes)
	Construct with segments sizes in initializer list..

	CSR (CSR &&) noexcept=default
	Move constructor.

ConstViewType	getConstView () const
	Returns a constant view for this instance of CSR segments which can by used for example in lambda functions running in GPU kernels.

ViewType	getView ()
	Returns a view for this instance of CSR 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.

CSR &	operator= (const CSR &segments)
	Copy-assignment operator (makes a deep copy).

template<typename Device_ , typename Index_ , typename IndexAllocator_ >
CSR &	operator= (const CSR< Device_, Index_, IndexAllocator_ > &segments)
	Assignment operator with CSR segments with different template parameters.

template<typename Device_ , typename Index_ , typename IndexAllocator_ >
CSR< Device, Index, IndexAllocator > &	operator= (const CSR< Device_, Index_, IndexAllocator_ > &segments)

CSR &	operator= (CSR &&) noexcept(false)
	Move-assignment operator.

void	reset ()
	Reset the segments to empty states.

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.

template<typename SizesHolder >
void	setSegmentsSizes (const SizesHolder &sizes)

Public Member Functions inherited from TNL::Algorithms::Segments::CSRBase< Device, Index >
__cuda_callable__	CSRBase ()=default
	Default constructor with no parameters to create empty segments view.

__cuda_callable__	CSRBase (const CSRBase &)=default
	Copy constructor.

__cuda_callable__	CSRBase (const OffsetsView &offsets)
	Binds a new CSR view to an offsets vector.

__cuda_callable__	CSRBase (CSRBase &&) noexcept=default
	Move constructor.

__cuda_callable__	CSRBase (OffsetsView &&offsets)
	Binds a new CSR view to an offsets vector.

template<typename Function >
void	forAllElements (Function &&function) const
	Call TNL::Algorithms::Segments::CSR::forElements for all elements of the segments.

template<typename Function >
void	forAllSegments (Function &&function) const
	Call TNL::Algorithms::Segments::CSR::forSegments for all segments.

template<typename Function >
void	forElements (IndexType begin, IndexType end, Function &&function) const
	Iterate over all elements of given segments in parallel and call given lambda function.

template<typename Function >
void	forSegments (IndexType begin, IndexType end, Function &&function) const
	Iterate over all segments in parallel and call given lambda function.

__cuda_callable__ IndexType	getGlobalIndex (Index segmentIdx, Index localIdx) const
	Computes the global index of an element managed by the segments.

__cuda_callable__ OffsetsView	getOffsets ()
	Returns a modifiable vector view with row offsets used in the CSR format.

__cuda_callable__ ConstOffsetsView	getOffsets () const
	Returns a constant vector view with row offsets used in the CSR format.

__cuda_callable__ IndexType	getSegmentsCount () const
	Returns the number of segments.

__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 segment view (i.e. segment accessor) of segment with given index.

__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.

CSRBase &	operator= (const CSRBase &)=delete
	Copy-assignment operator.

CSRBase &	operator= (CSRBase &&)=delete
	Move-assignment operator.

template<typename Function >
void	sequentialForAllSegments (Function &&function) const
	Call TNL::Algorithms::Segments::CSR::sequentialForSegments for all segments.

template<typename Function >
void	sequentialForSegments (IndexType begin, IndexType end, Function &&function) const
	Call TNL::Algorithms::Segments::CSR::forSegments sequentially for particular segments.

Protected Attributes
OffsetsContainer	offsets

Protected Attributes inherited from TNL::Algorithms::Segments::CSRBase< Device, Index >
OffsetsView	offsets
	Vector view with row offsets used in the CSR format.

Additional Inherited Members
Static Public Member Functions inherited from TNL::Algorithms::Segments::CSRBase< Device, Index >
static constexpr ElementsOrganization	getOrganization ()
	Returns the data layout for the CSR format (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 that the CSR format does not use padding elements.

Protected Member Functions inherited from TNL::Algorithms::Segments::CSRBase< Device, Index >
__cuda_callable__ void	bind (OffsetsView offsets)
	Re-initializes the internal attributes of the base class.

Detailed Description

template<typename Device, typename Index, typename IndexAllocator = typename Allocators::Default< Device >::template Allocator< Index >>
class TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >

Data structure for CSR segments format.

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

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.
IndexAllocator	is allocator for supporting index containers.

Member Typedef Documentation

◆ ViewTemplate

template<typename Device , typename Index , typename IndexAllocator = typename Allocators::Default< Device >::template Allocator< Index >>

template<typename Device_ , typename Index_ >

using TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::ViewTemplate = CSRView< 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

◆ CSR() [1/2]

template<typename Device , typename Index , typename IndexAllocator >

template<typename SizesContainer >

TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::CSR ( const SizesContainer & segmentsSizes )

Construct with segments sizes.

The number of segments is given by the size of segmentsSizes. Particular elements of this container define sizes of particular segments.

Template Parameters

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

Parameters

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

See the following example:

#include <iostream>
#include <functional>
#include <TNL/Containers/Vector.h>
#include <TNL/Algorithms/Segments/CSR.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
SegmentsExample()
{
   using SegmentsType = typename TNL::Algorithms::Segments::CSR< Device, int >;
 
   /***
    * Create segments with given segments sizes.
    */
   TNL::Containers::Vector< int, Device > segmentsSizes{ 1, 2, 3, 4, 5 };
   SegmentsType segments( segmentsSizes );
   std::cout << "Segments sizes are: " << segments << std::endl;
 
   /***
    * Allocate array for the segments;
    */
   TNL::Containers::Array< double, Device > data( segments.getStorageSize(), 0.0 );
 
   /***
    * Insert data into particular segments.
    */
   auto data_view = data.getView();
   segments.forAllElements(
      [ = ] __cuda_callable__( int segmentIdx, int localIdx, int globalIdx ) mutable
      {
         if( localIdx <= segmentIdx )
            data_view[ globalIdx ] = segmentIdx;
      } );
 
   /***
    * Print the data managed by the segments.
    */
   auto fetch = [ = ] __cuda_callable__( int globalIdx ) -> double
   {
      return data_view[ globalIdx ];
   };
   printSegments( std::cout, segments, fetch );
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Example of CSR segments on host: " << std::endl;
   SegmentsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Example of CSR segments on CUDA GPU: " << std::endl;
   SegmentsExample< TNL::Devices::Cuda >();
#endif
   return EXIT_SUCCESS;
}

The result looks as follows:

Example of CSR segments on host: 
Segments sizes are:  [ 1, 2, 3, 4, 5, ] 
Seg. 0: [ 0 ] 
Seg. 1: [ 1, 1 ] 
Seg. 2: [ 2, 2, 2 ] 
Seg. 3: [ 3, 3, 3, 3 ] 
Seg. 4: [ 4, 4, 4, 4, 4 ] 
Example of CSR segments on CUDA GPU: 
Segments sizes are:  [ 1, 2, 3, 4, 5, ] 
Seg. 0: [ 0 ] 
Seg. 1: [ 1, 1 ] 
Seg. 2: [ 2, 2, 2 ] 
Seg. 3: [ 3, 3, 3, 3 ] 
Seg. 4: [ 4, 4, 4, 4, 4 ] 

◆ CSR() [2/2]

template<typename Device , typename Index , typename IndexAllocator >

template<typename ListIndex >

TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::CSR ( const std::initializer_list< ListIndex > & segmentsSizes )

Construct with segments sizes in initializer list..

The number of segments is given by the size of segmentsSizes. Particular elements of this initializer list define sizes of particular segments.

Template Parameters

ListIndex is a type of indexes of the initializer list.

Parameters

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

See the following example:

#include <iostream>
#include <functional>
#include <TNL/Containers/Vector.h>
#include <TNL/Algorithms/Segments/CSR.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
SegmentsExample()
{
   using SegmentsType = typename TNL::Algorithms::Segments::CSR< Device, int >;
 
   /***
    * Create segments with given segments sizes.
    */
   SegmentsType segments{ 1, 2, 3, 4, 5 };
   std::cout << "Segments sizes are: " << segments << std::endl;
 
   /***
    * Allocate array for the segments;
    */
   TNL::Containers::Array< double, Device > data( segments.getStorageSize(), 0.0 );
 
   /***
    * Insert data into particular segments.
    */
   auto data_view = data.getView();
   segments.forAllElements(
      [ = ] __cuda_callable__( int segmentIdx, int localIdx, int globalIdx ) mutable
      {
         if( localIdx <= segmentIdx )
            data_view[ globalIdx ] = segmentIdx;
      } );
 
   /***
    * Print the data managed by the segments.
    */
   auto fetch = [ = ] __cuda_callable__( int globalIdx ) -> double
   {
      return data_view[ globalIdx ];
   };
   printSegments( std::cout, segments, fetch );
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Example of CSR segments on host: " << std::endl;
   SegmentsExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Example of CSR segments on CUDA GPU: " << std::endl;
   SegmentsExample< TNL::Devices::Cuda >();
#endif
   return EXIT_SUCCESS;
}

The result looks as follows:

Example of CSR segments on host: 
Segments sizes are:  [ 1, 2, 3, 4, 5, ] 
Seg. 0: [ 0 ] 
Seg. 1: [ 1, 1 ] 
Seg. 2: [ 2, 2, 2 ] 
Seg. 3: [ 3, 3, 3, 3 ] 
Seg. 4: [ 4, 4, 4, 4, 4 ] 
Example of CSR segments on CUDA GPU: 
Segments sizes are:  [ 1, 2, 3, 4, 5, ] 
Seg. 0: [ 0 ] 
Seg. 1: [ 1, 1 ] 
Seg. 2: [ 2, 2, 2 ] 
Seg. 3: [ 3, 3, 3, 3 ] 
Seg. 4: [ 4, 4, 4, 4, 4 ] 

Member Function Documentation

◆ load()

template<typename Device , typename Index , typename IndexAllocator >

void TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::load ( File & file )

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

Parameters

file	is the source file.

◆ operator=()

template<typename Device , typename Index , typename IndexAllocator = typename Allocators::Default< Device >::template Allocator< Index >>

template<typename Device_ , typename Index_ , typename IndexAllocator_ >

CSR & TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::operator= ( const CSR< Device_, Index_, IndexAllocator_ > & segments )

Assignment operator with CSR segments with different template parameters.

It makes a deep copy of the source segments.

Template Parameters

Device_	is device type of the source segments.
Index_	is the index type of the source segments.
IndexAllocator_	is the index allocator of the source segments.

Parameters

segments is the source segments object.

Returns: reference to this instance.

◆ reset()

template<typename Device , typename Index , typename IndexAllocator >

void TNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator >::reset ( )

Reset the segments to empty states.

It means that there is no segment in the CSR segments.

◆ save()

template<typename Device , typename Index , typename IndexAllocator >

void TNL::Algorithms::Segments::CSR< Device, Index, 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 Device , typename Index , typename IndexAllocator = typename Allocators::Default< Device >::template Allocator< Index >>

template<typename SizesContainer >

void TNL::Algorithms::Segments::CSR< Device, Index, 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 files:

src/TNL/Algorithms/Segments/CSR.h
src/TNL/Algorithms/Segments/CSR.hpp

Public Types

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ViewTemplate

Constructor & Destructor Documentation

◆ CSR() [1/2]

◆ CSR() [2/2]

Member Function Documentation

◆ load()

◆ operator=()

◆ reset()

◆ save()

◆ setSegmentsSizes()