TNL::Algorithms::ParallelFor3D< Device > Struct Template Reference

Parallel for loop for three dimensional domain of indices. More...

#include <TNL/Algorithms/ParallelFor.h>

Static Public Member Functions
template<typename Index , typename Function , typename... FunctionArgs>
static void	exec (Index startX, Index startY, Index startZ, Index endX, Index endY, Index endZ, Function f, FunctionArgs... args)
	Static method for the execution of the loop. More...
template<typename Index , typename Function , typename... FunctionArgs>
static void	exec (Index startX, Index startY, Index startZ, Index endX, Index endY, Index endZ, typename Device::LaunchConfiguration launch_config, Function f, FunctionArgs... args)
	Overload with custom launch configuration (which is ignored for TNL::Devices::Sequential).

Detailed Description

template<typename Device = Devices::Sequential>
struct TNL::Algorithms::ParallelFor3D< Device >

Parallel for loop for three dimensional domain of indices.

Template Parameters

Device

specifies the device where the for-loop will be executed. It can be TNL::Devices::Host, TNL::Devices::Cuda or TNL::Devices::Sequential.

Member Function Documentation

exec()

template<typename Device = Devices::Sequential>

template<typename Index , typename Function , typename... FunctionArgs>

static void TNL::Algorithms::ParallelFor3D< Device >::exec ( Index  startX, Index  startY, Index  startZ, Index  endX, Index  endY, Index  endZ, Function  f, FunctionArgs...  args  )

inlinestatic

Static method for the execution of the loop.

Template Parameters

Index	is the type of the loop indices.
Function	is the type of the functor to be called in each iteration (it is usually deduced from the argument used in the function call).
FunctionArgs	is a variadic pack of types for additional parameters that are forwarded to the functor in every iteration.

Parameters

startX	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
startY	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
startZ	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
endX	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
endY	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
endZ	the for-loop iterates over index domain [startX,endX) x [startY,endY) x [startZ,endZ).
f	is the function to be called in each iteration
args	are additional parameters to be passed to the function f.

The function f is called for each iteration as

f( i, j, k, args... )

where the first parameter is changing the most often.

Example

#include <iostream>
#include <TNL/Containers/Vector.h>
#include <TNL/Algorithms/ParallelFor.h>
 
using namespace TNL;
using namespace TNL::Containers;
using namespace TNL::Algorithms;
 
template< typename Device >
void initMeshFunction( const int xSize,
                       const int ySize,
                       const int zSize,
                       Vector< double, Device >& v,
                       const double& c )
{
   auto view = v.getView();
   auto init = [=] __cuda_callable__ ( int i, int j, int k ) mutable
   {
      view[ ( k * ySize + j ) * xSize + i ] = c;
   };
   ParallelFor3D< Device >::exec( 0, 0, 0, xSize, ySize, zSize, init );
}
 
int main( int argc, char* argv[] )
{
   /***
    * Define dimensions of a 3D mesh function.
    */
   const int xSize( 10 ), ySize( 10 ), zSize( 10 );
   const int size = xSize * ySize * zSize;
 
   /***
    * Firstly, test the mesh function initiation on CPU.
    */
   Vector< double, Devices::Host > host_v( size );
   initMeshFunction( xSize, ySize, zSize, host_v, 1.0 );
 
   /***
    * And then also on GPU.
    */
#ifdef __CUDACC__
   Vector< double, Devices::Cuda > cuda_v( size );
   initMeshFunction( xSize, ySize, zSize, cuda_v, 1.0 );
#endif
   return EXIT_SUCCESS;
}

Output

---

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

• src/TNL/Algorithms/ParallelFor.h