Base class for unguarded _LoserTree implementation. More...

#include <parallel/losertree.h>

Inheritance diagram for __gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >:

Classes
struct	_Loser

Public Member Functions
	_LoserTreeUnguardedBase (unsigned int __k, const _Tp &__sentinel, _Compare __comp=std::less< _Tp >())

	~_LoserTreeUnguardedBase ()

int	__get_min_source ()

void	__insert_start (const _Tp &__key, int __source, bool)

Protected Attributes
unsigned int	_M_ik

unsigned int	_M_k

unsigned int	_M_offset

_Loser *	_M_losers

_Compare	_M_comp

Detailed Description

template<typename _Tp, typename _Compare>
class __gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >

Base class for unguarded _LoserTree implementation.

The whole element is copied into the tree structure.

No guarding is done, therefore not a single input sequence must run empty. Unused __sequence heads are marked with a sentinel which is > all elements that are to be merged.

This is a very fast variant.

Constructor & Destructor Documentation

template<typename _Tp , typename _Compare >

__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >::_LoserTreeUnguardedBase	(	unsigned int	__k,
		const _Tp &	__sentinel,
		_Compare	__comp = `std::less<_Tp>()`
	)

inline

       : _M_comp(__comp)
       {
     _M_ik = __k;
 
     // Next greater power of 2.
     _M_k = 1 << (__rd_log2(_M_ik - 1) + 1);
     _M_offset = _M_k;
     // Avoid default-constructing _M_losers[]._M_key
     _M_losers = static_cast<_Loser*>(::operator new(2 * _M_k
                             * sizeof(_Loser)));
 
         for (unsigned int __i = 0; __i < _M_k; ++__i)
           {
         ::new(&(_M_losers[__i]._M_key)) _Tp(__sentinel);
         _M_losers[__i]._M_source = -1;
       }
         for (unsigned int __i = _M_k + _M_ik - 1; __i < (2 * _M_k); ++__i)
           {
         ::new(&(_M_losers[__i]._M_key)) _Tp(__sentinel);
         _M_losers[__i]._M_source = -1;
       }
       }

template<typename _Tp , typename _Compare >

__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >::~_LoserTreeUnguardedBase ( )

inline

       {
     for (unsigned int __i = 0; __i < (2 * _M_k); ++__i)
       _M_losers[__i].~_Loser();
     ::operator delete(_M_losers);
       }

Member Function Documentation

template<typename _Tp , typename _Compare >

int __gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >::__get_min_source ( )

inline

       {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
     _GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
     return _M_losers[0]._M_source;
       }

template<typename _Tp , typename _Compare >

void __gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >::__insert_start	(	const _Tp &	__key,
		int	__source,
		bool
	)

inline

       {
     unsigned int __pos = _M_k + __source;
 
     ::new(&(_M_losers[__pos]._M_key)) _Tp(__key);
     _M_losers[__pos]._M_source = __source;
       }