Sorting
[Dispatching large amounts of information]

Interfaces to sort distributed items. More...

Collaboration diagram for Sorting:

Classes

class  par::step::sorting< T, seqsort >
 Template wrapper for a parallel sort based on different sequential sort algorithms. More...

Functions

template<class T >
void par::step::qsort (array< T > &Tp, array< T const > &Tl, sys::str targetURL)
 Template wrapper for a parallel sort based on qsort.
template<class T >
void par::step::qsort (array< T > *&Tp, sys::str targetURL, bool destroy=false)
template<class T >
void par::step::qsort (array< T > &Tp, sys::str targetURL, bool destroy=false)
 Template wrapper for a parallel sort based on qsort.
template<class T >
void par::step::quicksort (array< T > &Tp, array< T const > &Tl)
template<class T >
void par::step::quicksort (array< T > &Tp, array< T const > &Tl, sys::str targetURL)
template<class T >
void par::step::quicksort (array< T > *&Tp, bool destroy=false)
template<class T >
void par::step::quicksort (array< T > *&Tp, sys::str targetURL, bool destroy=false)
template<class T >
void par::step::quicksort (array< T > &Tp, bool destroy=false)
template<class T >
void par::step::quicksort (array< T > &Tp, sys::str targetURL, bool destroy=false)
 Template wrapper for a parallel sort based on par::sys::quicksort.
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > *&Tp, bool destroy=false)
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > *&Tp, sys::str targetURL, bool destroy=false)
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > &Tt, array< T const > &Ts)
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > &Tt, array< T const > &Ts, sys::str targetURL)
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > &Tp, bool destroy=false)
template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort (array< T > &Tp, sys::str targetURL, bool destroy=false)
static array< T > * par::step::sorting::sortGV (array< T const > *&Input, sys::str const &targetURL=NULL, bool destroy=false)
static array< T > * par::step::sorting::sortGV (array< T const > &Input, sys::str const &targetURL=NULL)
static bool par::step::sorting::testSort (array< T const > &Input)
 Test whether an array is really sorted locally.

Detailed Description

Interfaces to sort distributed items.

Function Documentation

template<class T >
void par::step::qsort ( array< T > &  Tp,
array< T const > &  Tl,
sys::str  targetURL 
) [inline]

Template wrapper for a parallel sort based on qsort.

Definition at line 345 of file par_step_sort.h.

template<class T >
void par::step::qsort ( array< T > *&  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Definition at line 337 of file par_step_sort.h.

template<class T >
void par::step::qsort ( array< T > &  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Template wrapper for a parallel sort based on qsort.

Template wrapper for a parallel sort based on different sequential sort algorithms.

Parameters:
Tp is input and output of the sorting
targetURL,if valid, is an URL that represents an object that is accessible by all processes. On return Tp will span the whole object that is designated by targetURL, the part on each processor convering a different part of the object.
This imlements a generic sample sort algorithm as was described by

Gerbessiotis and Valiant, 1994, J. of Parallel and Distributed Computing, p 251-267

The implementation uses the class par::step::sorting, which see for details.

Currently there are two different templates implemented for the parameter seqsort. par::sys::quicksort which implements quicksort with an expected running time of $O(n \log n)$, and par::sys::qsort which wraps the system routine qsort.

Definition at line 329 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > &  Tp,
array< T const > &  Tl 
) [inline]

Definition at line 239 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > &  Tp,
array< T const > &  Tl,
sys::str  targetURL 
) [inline]

Definition at line 369 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > *&  Tp,
bool  destroy = false 
) [inline]

Definition at line 223 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > *&  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Definition at line 361 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > &  Tp,
bool  destroy = false 
) [inline]

Definition at line 207 of file par_step_sort.h.

template<class T >
void par::step::quicksort ( array< T > &  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Template wrapper for a parallel sort based on par::sys::quicksort.

Template wrapper for a parallel sort based on different sequential sort algorithms.

Parameters:
Tp is input and output of the sorting
targetURL,if valid, is an URL that represents an object that is accessible by all processes. On return Tp will span the whole object that is designated by targetURL, the part on each processor convering a different part of the object.
This imlements a generic sample sort algorithm as was described by

Gerbessiotis and Valiant, 1994, J. of Parallel and Distributed Computing, p 251-267

The implementation uses the class par::step::sorting, which see for details.

Currently there are two different templates implemented for the parameter seqsort. par::sys::quicksort which implements quicksort with an expected running time of $O(n \log n)$, and par::sys::qsort which wraps the system routine qsort.

Definition at line 353 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > *&  Tp,
bool  destroy = false 
) [inline]

Definition at line 91 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > *&  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Definition at line 304 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > &  Tt,
array< T const > &  Ts 
) [inline]

Definition at line 72 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > &  Tt,
array< T const > &  Ts,
sys::str  targetURL 
) [inline]

Definition at line 291 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > &  Tp,
bool  destroy = false 
) [inline]

Definition at line 54 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
void par::step::sort ( array< T > &  Tp,
sys::str  targetURL,
bool  destroy = false 
) [inline]

Template wrapper for a parallel sort based on different sequential sort algorithms.

Parameters:
Tp is input and output of the sorting
targetURL,if valid, is an URL that represents an object that is accessible by all processes. On return Tp will span the whole object that is designated by targetURL, the part on each processor convering a different part of the object.
This imlements a generic sample sort algorithm as was described by

Gerbessiotis and Valiant, 1994, J. of Parallel and Distributed Computing, p 251-267

The implementation uses the class par::step::sorting, which see for details.

Currently there are two different templates implemented for the parameter seqsort. par::sys::quicksort which implements quicksort with an expected running time of $O(n \log n)$, and par::sys::qsort which wraps the system routine qsort.

Definition at line 277 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
array< T > * par::step::sorting< T, seqsort >::sortGV ( array< T const > *&  Input,
sys::str const &  targetURL = NULL,
bool  destroy = false 
) [inline, static, inherited]

Depending on destroy this wrapper destroys the Input array just after redistribution to ensure that we don't use up too much memory.

Definition at line 655 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
array< T > * par::step::sorting< T, seqsort >::sortGV ( array< T const > &  Input,
sys::str const &  targetURL = NULL 
) [inline, static, inherited]

One of the principal user interfaces. It redistributes and then sorts locally. The original Input array is not changed so in fact at the end we have two copies of our data.

Definition at line 644 of file par_step_sort.h.

template<class T , PAR_SYS_SORT_F(T) const seqsort>
bool par::step::sorting< T, seqsort >::testSort ( array< T const > &  Input  )  [inline, static, inherited]

Test whether an array is really sorted locally.

Definition at line 695 of file par_step_sort.h.


Generated on Tue Oct 13 22:03:53 2009 for parXXL by  doxygen 1.5.8