t23_PipelineObuf.cpp File Reference

#include <pthread.h>
#include <iterator>
#include <vector>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <algorithm>
#include <numeric>
#include <set>
#include <list>
#include <deque>
#include <rpa/architectures/posix.h>
#include <rpa/algorithms/accumulate.h>
#include <rpa/algorithms/transform.h>
#include <rpa/containers/list.h>
#include <rpa/containers/deque.h>
#include <rpa/containers/vector.h>
#include <rpa/containers/row_buffer.h>
#include <rpa/containers/pipeline.h>

Classes
class	identity23< Type >
	For debugging how the algorithm 'transform' uses its variables. More...
struct	t23adder< Type >
	For debugging how the algorithm 'accumulate' uses its variables. More...
Defines
#define	Test(a)   _Test23(#a,a)
Typedefs
typedef rpa::posix_condition	cond_main_t
	Used everywhere.
Functions
static void	_Test23 (const char *aMsg, bool aBool)
	Simply checks a boolean condition and writes some informational message.
template<class SubThr, class Container, class PipTyp, class ObufTyp>
static void	tst23OneSubThrCirc (const Container &lstDat, typename Container::value_type sumDat, size_t nbDbls, size_t nbThrs, size_t szPipCirc)
template<class SubThr, class Container, class PipTyp, class ObufTyp>
static void	tst23OneSubThrArch (const Container &lstDat, typename Container::value_type sumDat, size_t nbDbls, size_t nbThrs)
template<class SubThr, class Cont, class PipTyp, class ObufTyp>
static void	tst23ContBuf (const Cont &lstDat, typename Cont::value_type sumDat, size_t nbDbls, size_t nbThrs)
template<class SubThr, class Cont, class ObufTyp>
static void	tst23Containers (size_t nbDbls, size_t nbThrs)
	This chooses the type of the underlying container of the pipeline.
template<class SubThr, class ObufTyp>
void	tst23Thr (size_t nbE, size_t nbThrs)
template<class SubThr>
void	tst23ThrObuf (size_t nbE, size_t nbThrs)
int	main (int aArgC, const char **aArgV)
	The default number of samples is chosen for a Pentium, about 1GHz..

---

Define Documentation

#define Test

(

a

)

_Test23(#a,a)

---

Typedef Documentation

typedef rpa::posix_condition cond_main_t

Used everywhere.

---

Function Documentation

static void _Test23	(	const char *	aMsg,
		bool	aBool
	)			[static]

Simply checks a boolean condition and writes some informational message.

This contains all the logic for bufferizing the output of an algorithm. When an algorithm writes into a std::back_inserter, it is worth to have it write into a thread-specific buffer, which is flushed into the output iterator once a sub-thread is done with its calculation of a slice of the input range. In this example, the input ranges are taken from pipelines.

int main	(	int	aArgC,
		const char **	aArgV
	)

The default number of samples is chosen for a Pentium, about 1GHz..

template<class SubThr, class Cont, class ObufTyp>

static void tst23Containers	(	size_t	nbDbls,
		size_t	nbThrs
	)			[static]

This chooses the type of the underlying container of the pipeline.

template<class SubThr, class Cont, class PipTyp, class ObufTyp>

static void tst23ContBuf	(	const Cont &	lstDat,
		typename Cont::value_type	sumDat,
		size_t	nbDbls,
		size_t	nbThrs
	)			[static]

Given the type of the input container, the pipeline underlying container, and the type of the buffer used for output, it tries various algorithms.

template<class SubThr, class Container, class PipTyp, class ObufTyp>

static void tst23OneSubThrArch	(	const Container &	lstDat,
		typename Container::value_type	sumDat,
		size_t	nbDbls,
		size_t	nbThrs
	)			[static]

Only one subthread for the input algorithm. The buffer is not big enough to store all the input data, but the main thread is running at the same time and reads from it. The difference with tst23OneSubThrCirc(), is that we use a pipe_archiver.

Finite-size pipeline. There may not be enough room to store the result of the 'transform' algorithm. The underlying parameter is not 'PipTyp' because it may be a fixed-size C-style array, and it would not work for a pipe_archiver which has an infinite size.

At the beginning, the pipeline is not shut. So, reading from it hangs, if there are no data inside.

This functor will be started in a subthread.

This is the thread tree containing just one top-level sub-thread.

This is the result of the detached execution of the functor in a sub-thread.

The output elements might not be in the right order. So we sort them before comparing. This happens if there are genuine subthreads.

template<class SubThr, class Container, class PipTyp, class ObufTyp>

static void tst23OneSubThrCirc	(	const Container &	lstDat,
		typename Container::value_type	sumDat,
		size_t	nbDbls,
		size_t	nbThrs,
		size_t	szPipCirc
	)			[static]

Only one subthread for the input algorithm. The buffer is not big enough to store all the input data, but the main thread is running at the same time and reads from it.

Finite-size pipeline. There may not be enough room to store the result of the 'transform' algorithm.

This functor will be started in a subthread.

This is the thread tree containing just one top-level sub-thread.

This is the result of the detached execution of the functor in a sub-thread.

template<class SubThr, class ObufTyp>

void tst23Thr	(	size_t	nbE,
		size_t	nbThrs
	)

There are two imbricated loop on the containers type. The external container type is always limit-less. The internal one may have a limit and will therefore never used for infinite pipelines.

template<class SubThr>

void tst23ThrObuf	(	size_t	nbE,
		size_t	nbThrs
	)

This calls the other tests with several kind of output buffers for the algorithms. The role of these output buffers is to avoid that a writing algorithm actually locks an output iterator for each write. Instead. Each thread has its own output buffer.

---