就业培训     下载中心     Wiki     联络 登录   注册

---

1. 首页
2. C4D R23.110 C++ SDK

Public Types | 公共成员函数 | 私有成员函数 | 所有成员列表

ParallelSort< SORTCLASS, FLAGS, PARALLELIZATION_THRESHOLD > Class Template Reference Data Structures

#include <parallelsort.h>

Inheritance diagram for ParallelSort< SORTCLASS, FLAGS, PARALLELIZATION_THRESHOLD >:

[ legend ]

详细描述

template<typename SORTCLASS, BASESORTFLAGS FLAGS = BASESORTFLAGS::NONE, Int PARALLELIZATION_THRESHOLD = 10000>
class maxon::ParallelSort< SORTCLASS, FLAGS, PARALLELIZATION_THRESHOLD >

Template for sorting arrays and searching in sorted arrays

To use this template derive a class from it and define the member 'LessThan' that implements an element comparison. If you do searching the member 'IsEqual' needs to be implemented that does an element comparison with the search key as the first argument. If the search key is different from the element type a second LessThan routine is needed (comparing SEARCHKEY to an element).

Template Parameters

SORTCLASS	The class itself. This has to be a derived class of BaseSort .
FLAGS	See BASESORTFLAGS.
PARALLELIZATION_THRESHOLD	The minimum number of elements to start parallel sorting. if less elements are sorted a regular BaseSort 会被使用。

注意

Note that the classes that will be sorted have special requirements regarding copy and move constructors .

Example for traditional C-style arrays:

class Sort1 : public ParallelSort<Sort1> { public : static inline Bool LessThan ( Int a, Int b) { return a < b; } };

注意

LessThan can be a member of the sort class itself (not static), but needs to be const in that case.

Example for arrays:

Example for arbitrary structures with multiple sort criteria:

Searching Example:

// for searching: compare search key to array element static inline Bool LessThan ( Float weight, const MyStruct& b) { return weight < b._weight; }

// for searching: compare search key to array element static inline Bool IsEqual ( Float weight, const MyStruct& b) { return weight == b._weight; } }; ... BlockArray<MyStruct> array4; ... MySearch search; search.Sort(array4); ...

// array is now sorted, we can search it MyStruct* result = search.Find(5.0, array4);

公共成员函数
template<typename ITERATOR >
void	Sort (ITERATOR start, ITERATOR end , JobQueueInterface *queue= JOBQUEUE_CURRENT ) const
template<typename ITERATOR >
void	Sort (ITERATOR start, Int count, JobQueueInterface *queue= JOBQUEUE_CURRENT ) const
template<typename ARRAY >
void	Sort (ARRAY &arr, JobQueueInterface *queue= JOBQUEUE_CURRENT ) const
Public Member Functions inherited from BaseSort< SORTCLASS, BASESORTFLAGS::NONE >
void	Sort (ITERATOR start, ITERATOR end) const
void	Sort (ITERATOR start, Int count) const
void	Sort ( ARRAY &arr) const
Int	FindIndex (const SEARCHTYPE &key, ITERATOR arr, Int count) const
ITERATOR	Find (const SEARCHTYPE &key, ITERATOR arr, Int count) const
ARRAY::ValueType *	Find (const SEARCHTYPE &key, const ARRAY &arr) const
ITERATOR	FindInsertionIndex (const SEARCHTYPE &key, ITERATOR arr, Int count, Int &insertionIndex) const
ARRAY::ValueType *	FindInsertionIndex (const SEARCHTYPE &key, const ARRAY &arr, Int &insertionIndex) const

Member Typedef Documentation

◆  Super

成员函数文档编制

◆  Sort() [1/3]

Sort elements of an array, so that the smallest element comes first. Note that the sorting is not guaranteed to be stable (elements with the same sort value may change their order). The time for sorting is O(n * log(n)). Depending on the available number of threads and initial element distribution you can get speedups of 1 to 8 times compared to BaseSort . If the number of elements is too small less threads will be used or ultimately non-parallel sorting will be used (<1024 elements). Parallel sorting temporarily needs the same amount of memory as the sorted elements take up. If memory isn't available the algorithm will still succeed, but be slightly slower than the non-Threaded version.

参数

[in]	start	The start iterator of an array.
[in]	end	The end iterator of an array. Note that this is not the last element! It needs to be the boundary (which is last element + 1). See in the BaseSort class description for examples.
[in]	queue	Optional queue on which the parallel sort will run.

◆  Sort() [2/3]

Sort elements of an array, so that the smallest element comes first. Note that the sorting is not guaranteed to be stable (elements with the same sort value may change their order). The time for sorting is O(n * log(n)) Depending on the available number of threads and initial element distribution you can get speedups of 1 to 8 times compared to BaseSort . If the number of elements is too small less threads will be used or ultimately non-parallel sorting will be used (<1024 elements). Parallel sorting temporarily needs the same amount of memory as the sorted elements take up. If memory isn't available the algorithm will still succeed, but be slightly slower than the non-Threaded version.

参数

[in]	start	The start iterator of an array.
[in]	count	The number of elements to be sorted.
[in]	queue	Optional queue on which the parallel sort will run.

◆  Sort() [3/3]

Sort elements of an array, so that the smallest element comes first. Note that the sorting is not guaranteed to be stable (elements with the same sort value may change their order). The time for sorting is O(n * log(n)) Depending on the available number of threads and initial element distribution you can get speedups of 1 to 8 times compared to BaseSort . If the number of elements is too small less threads will be used or ultimately non-parallel sorting will be used (<1024 elements). Parallel sorting temporarily needs the same amount of memory as the sorted elements take up. If memory isn't available the algorithm will still succeed, but be slightly slower than the non-Threaded version.

参数

[in]	arr	The array to be sorted.
[in]	queue	Optional queue on which the parallel sort will run.

◆  ISort() [1/2]

◆  ISort() [2/2]

◆  ParallelSortAlgorithm()

◆  ReduceRedundantBlocks()

◆  PowerOfTwo()

• maxon
• ParallelSort