__gnu_parallel(3cxx)

📦

version 14-20240412 · 13 versions

✨ NAME ✨

okay bestie, welcome to the __gnu_parallel(3cxx) page 💅 — __gnu_parallel is literally the GNU parallel code for public use. that's the whole name vibe, no cap.

🌸 SYNOPSIS 🌸

this page is the master list of the public parallel machinery: a whole pile of classes and structs, some typedefs, and the enums. it's giving legendary template energy, so stay with me ✨

💅 Classes

__accumulate_binop_reduct — general reduction using a binary operator. lowkey the reduce bestie.
__accumulate_selector — the std::accumulate() selector. slay.
__adjacent_difference_selector — selector that gives back the difference between two adjacent __elements.
__adjacent_find_selector — tests a predicate on two adjacent elements.
__binder1st — like std::binder1st, but it hands the argument types over explicitly.
__binder2nd — same deal as std::binder2nd, with the argument types given explicitly.
__count_if_selector — the std::count_if () selector.
__count_selector — the std::count() selector.
__fill_selector — the std::fill() selector.
__find_first_of_selector — tests a predicate on several elements.
__find_if_selector — tests a predicate on a single element, and it's used for std::find() and std::find_if ().
__for_each_selector — the std::for_each() selector.
__generate_selector — the std::generate() selector.
__generic_find_selector — base class of all __gnu_parallel::__find_template selectors.
__generic_for_each_selector — generic __selector for embarrassingly parallel functions.
__identity_selector — selector that just returns the iterator you passed in. no thoughts, just vibes.
__inner_product_selector — the std::inner_product() selector.
__max_element_reduct — reduction for finding the maximum element, using a comparator.
__min_element_reduct — reduction for finding the maximum element, using a comparator. yes, the page says maximum here too — I'm just reporting the facts 🫶
__mismatch_selector — tests an inverted predicate on a single element.
__multiway_merge_3_variant_sentinel_switch — switch for 3-way merging with __sentinels turned off.
__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > — switch for 3-way merging with __sentinels turned on.
__multiway_merge_4_variant_sentinel_switch — switch for 4-way merging with __sentinels turned off.
__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > — switch for 4-way merging with __sentinels turned on.
__multiway_merge_k_variant_sentinel_switch — switch for k-way merging with __sentinels turned on.
__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > — switch for k-way merging with __sentinels turned off.
__replace_if_selector — the std::replace() selector.
__replace_selector — the std::replace() selector.
__transform1_selector — std::transform() __selector, one input sequence variant.
__transform2_selector — std::transform() __selector, two input sequences variant.
__unary_negate — like std::unary_negate, but with the argument types given explicitly.
_DRandomShufflingGlobalData — data known to every thread participating in __gnu_parallel::__parallel_random_shuffle().
_DRSSorterPU — local data for a thread participating in __gnu_parallel::__parallel_random_shuffle().
_DummyReduct — reduction function doing absolutely nothing. iconic.
_EqualFromLess — builds an equality predicate from a strict weak ordering predicate.
_EqualTo — like std::equal_to, but it allows two different types.
_GuardedIterator — _Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons.
_IteratorPair — a pair of iterators. the usual iterator operations are applied to both child iterators.
_IteratorTriple — a triple of iterators. the usual iterator operations are applied to all three child iterators.
_Job — one __job for a certain thread.
_Less — like std::less, but it allows two different types.
_Lexicographic — compares a pair of types lexicographically, ascending.
_LexicographicReverse — compares a pair of types lexicographically, descending.
_LoserTree — stable _LoserTree variant.
_LoserTree< false, _Tp, _Compare > — unstable _LoserTree variant.
_LoserTreeBase — guarded loser/tournament tree.
_LoserTreePointer — stable _LoserTree implementation.
_LoserTreePointer< false, _Tp, _Compare > — unstable _LoserTree implementation.
_LoserTreePointerBase — base class of _Loser Tree implementation using pointers.
_LoserTreePointerUnguarded — stable unguarded _LoserTree variant storing pointers.
_LoserTreePointerUnguarded< false, _Tp, _Compare > — unstable unguarded _LoserTree variant storing pointers.
_LoserTreePointerUnguardedBase — unguarded loser tree, keeping only pointers to the elements in the tree structure.
_LoserTreeTraits — traits for determining whether the loser tree should use pointers or copies.
_LoserTreeUnguarded — stable implementation of unguarded _LoserTree.
_LoserTreeUnguarded< false, _Tp, _Compare > — non-stable implementation of unguarded _LoserTree.
_LoserTreeUnguardedBase — base class for unguarded _LoserTree implementation.
_Multiplies — like std::multiplies, but it allows two different types.
_Nothing — functor doing nothing.
_Piece — subsequence description.
_Plus — like std::plus, but it allows two different types.
_PMWMSSortingData — data accessed by all threads.
_PseudoSequence — sequence that conceptually consists of multiple copies of the same element. the copies are not stored explicitly, of course.
_PseudoSequenceIterator — _Iterator associated with __gnu_parallel::_PseudoSequence. it features the usual random-access iterator functionality.
_QSBThreadLocal — information local to one thread in the parallel quicksort run.
_RandomNumber — random number generator based on the Mersenne twister.
_RestrictedBoundedConcurrentQueue — double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided — calling them would not make sense in a concurrent setting. periodt.
_SamplingSorter — stable sorting functor.
_SamplingSorter< false, _RAIter, _StrictWeakOrdering > — non-__stable sorting functor.
_Settings — class _Settings run-time settings for the parallel mode, including all tunable parameters.
_SplitConsistently — split consistently.
_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator > — split by sampling.
_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator > — split by exact splitting.
balanced_quicksort_tag — forces parallel sorting using balanced quicksort at compile time.
balanced_tag — recommends parallel execution using dynamic load-balancing at compile time.
constant_size_blocks_tag — selects the constant block size variant for std::find().
default_parallel_tag — recommends parallel execution using the default parallel algorithm.
equal_split_tag — selects the equal splitting variant for std::find().
exact_tag — forces parallel merging with exact splitting, at compile time.
find_tag — base class for for std::find() variants.
growing_blocks_tag — selects the growing block size variant for std::find().
multiway_mergesort_exact_tag — forces parallel sorting using multiway mergesort with exact splitting at compile time.
multiway_mergesort_sampling_tag — forces parallel sorting using multiway mergesort with splitting by sampling at compile time.
multiway_mergesort_tag — forces parallel sorting using multiway mergesort at compile time.
omp_loop_static_tag — recommends parallel execution using OpenMP static load-balancing at compile time.
omp_loop_tag — recommends parallel execution using OpenMP dynamic load-balancing at compile time.
parallel_tag — recommends parallel execution at compile time, optionally using a user-specified number of threads.
quicksort_tag — forces parallel sorting using unbalanced quicksort at compile time.
sampling_tag — forces parallel merging with exact splitting, at compile time.
sequential_tag — forces sequential execution at compile time.
unbalanced_tag — recommends parallel execution using static load-balancing at compile time.

✨ Typedefs

_BinIndex — typedef unsigned short. type to hold the index of a bin.
_CASable — typedef int64_t. longest compare-and-swappable integer type on this platform.
_SequenceIndex — typedef uint64_t. unsigned integer to index __elements. the total number of elements for each algorithm must fit into this type.
_ThreadIndex — typedef uint16_t. unsigned integer to index a thread number. the maximum thread number (for each processor) must fit into this type.

🎀 Enumerations

_AlgorithmStrategy { heuristic, force_sequential, force_parallel } — strategies for run-time algorithm selection.
_FindAlgorithm { GROWING_BLOCKS, CONSTANT_SIZE_BLOCKS, EQUAL_SPLIT } — find algorithms.
_MultiwayMergeAlgorithm { LOSER_TREE } — merging algorithms.
_Parallelism { sequential, parallel_unbalanced, parallel_balanced, parallel_omp_loop, parallel_omp_loop_static, parallel_taskqueue } — run-time equivalents for the compile-time tags.
_PartialSumAlgorithm { RECURSIVE, LINEAR } — partial sum algorithms: recursive, linear.
_SortAlgorithm { MWMS, QS, QS_BALANCED } — sorting algorithms.
_SplittingAlgorithm { SAMPLING, EXACT } — sorting/merging algorithms: sampling, __exact.

✨ Functions ✨

Okay bestie, buckle up 💖 — this is the big function list, like the entire backstage crew of the library, and every single signature is coming with us. Some of them have a lil blurb attached, some are just the signature and the vibes, and honestly? We respect both.

template<typename _Tp > _Tp __add_omp (volatile _Tp *__ptr, _Tp __addend) — no description on this one, just the signature doing its thing 🫶
template<typename _RAIter , typename _DifferenceTp > void __calc_borders (_RAIter __elements, _DifferenceTp __length, _DifferenceTp *__off) — precalculates the __advances for the Knuth-Morris-Pratt algorithm. Literally the prep work so KMP can slay later ✨
template<typename _Tp > bool __cas_omp (volatile _Tp *__ptr, _Tp __comparand, _Tp __replacement) — signature only, no extra notes, we move 💅
template<typename _Tp > bool __compare_and_swap (volatile _Tp *__ptr, _Tp __comparand, _Tp __replacement) — compare-and-swap. That's the entire note, short and iconic 👑
template<typename _IIter , typename _OutputIterator > _OutputIterator __copy_tail (std::pair< _IIter, _IIter > __b, std::pair< _IIter, _IIter > __e, _OutputIterator __r) — no blurb here either, just take the signature as given 🎀
void __decode2 (_CASable __x, int &__a, int &__b) — decodes two integers out of one gnu_parallel::_CASable. Two-for-one situation, lowkey efficient 🦋
template<typename _RAIter , typename _DifferenceTp > void __determine_samples (_PMWMSSortingData< _RAIter > *__sd, _DifferenceTp __num_samples) — selects _M_samples from a sequence. Note the underscore, bestie, it's _M_samples, don't come for me 💀
_CASable __encode2 (int __a, int __b) — encodes two integers into one gnu_parallel::_CASable. The exact reverse of the girl above, we love a matching set 🌸
template<typename _DifferenceType , typename _OutputIterator > _OutputIterator __equally_split (_DifferenceType __n, _ThreadIndex __num_threads, _OutputIterator __s) — a function to split a sequence into parts of almost equal size. Almost, okay, nobody's perfect 🙈
template<typename _DifferenceType > _DifferenceType __equally_split_point (_DifferenceType __n, _ThreadIndex __num_threads, _ThreadIndex __thread_no) — also a function to split a sequence into parts of almost equal size, except this one hands you the point ✨
template<typename _Tp > _Tp __fetch_and_add (volatile _Tp *__ptr, _Tp __addend) — adds a value to a variable, atomically. No race conditions invited to this party 🔥
template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename _Selector > std::pair< _RAIter1, _RAIter2 > __find_template (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _Pred __pred, _Selector __selector) — parallel std::find, switching between different algorithms depending on what you hand it 🧚
template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename _Selector > std::pair< _RAIter1, _RAIter2 > __find_template (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _Pred __pred, _Selector __selector, constant_size_blocks_tag) — parallel std::find, the constant block size variant 🎀
template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename _Selector > std::pair< _RAIter1, _RAIter2 > __find_template (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _Pred __pred, _Selector __selector, equal_split_tag) — parallel std::find, the equal splitting variant 💜
template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename _Selector > std::pair< _RAIter1, _RAIter2 > __find_template (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _Pred __pred, _Selector __selector, growing_blocks_tag) — parallel std::find, the growing block size variant. Four flavours, all valid 🌈
template<typename _IIter , typename _UserOp , typename _Functionality , typename _Red , typename _Result > _UserOp __for_each_template_random_access (_IIter __begin, _IIter __end, _UserOp __user_op, _Functionality &__functionality, _Red __reduction, _Result __reduction_start, _Result &__output, typename std::iterator_traits< _IIter >::difference_type __bound, _Parallelism __parallelism_tag) — picks the algorithm you want by checking out __parallelism_tag 👑
template<typename _RAIter , typename _Op , typename _Fu , typename _Red , typename _Result > _Op __for_each_template_random_access_ed (_RAIter __begin, _RAIter __end, _Op __o, _Fu &__f, _Red __r, _Result __base, _Result &__output, typename std::iterator_traits< _RAIter >::difference_type __bound) — the embarrassingly parallel algorithm for random access iterators, using hand-crafted parallelization by equal splitting the work. Hand-crafted, bestie, artisanal parallelization 💅
template<typename _RAIter , typename _Op , typename _Fu , typename _Red , typename _Result > _Op __for_each_template_random_access_omp_loop (_RAIter __begin, _RAIter __end, _Op __o, _Fu &__f, _Red __r, _Result __base, _Result &__output, typename std::iterator_traits< _RAIter >::difference_type __bound) — the embarrassingly parallel algorithm for random access iterators, using an OpenMP for loop ✨
template<typename _RAIter , typename _Op , typename _Fu , typename _Red , typename _Result > _Op __for_each_template_random_access_omp_loop_static (_RAIter __begin, _RAIter __end, _Op __o, _Fu &__f, _Red __r, _Result __base, _Result &__output, typename std::iterator_traits< _RAIter >::difference_type __bound) — same embarrassingly parallel algorithm for random access iterators, but with an OpenMP for loop using static scheduling 🦋
template<typename _RAIter , typename _Op , typename _Fu , typename _Red , typename _Result > _Op __for_each_template_random_access_workstealing (_RAIter __begin, _RAIter __end, _Op __op, _Fu &__f, _Red __r, _Result __base, _Result &__output, typename std::iterator_traits< _RAIter >::difference_type __bound) — the work stealing algorithm for random access iterators. Note it's __op here, not __o — little details, we notice them 🙈
_ThreadIndex __get_max_threads () — signature only, no blurb, mysterious main character energy 💀
bool __is_parallel (const _Parallelism __p) — also just the signature. Giving nothing, serving everything 🌸
template<typename _IIter , typename _Compare > bool __is_sorted (_IIter __begin, _IIter __end, _Compare __comp) — checks whether [__begin, __end) is sorted according to __comp. The vibe check of sequences ✅
template<typename _RAIter , typename _Compare > _RAIter __median_of_three_iterators (_RAIter __a, _RAIter __b, _RAIter __c, _Compare __comp) — computes the median of three referenced elements, according to __comp 🎀
template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator , typename _DifferenceTp , typename _Compare > _OutputIterator __merge_advance (_RAIter1 &__begin1, _RAIter1 __end1, _RAIter2 &__begin2, _RAIter2 __end2, _OutputIterator __target, _DifferenceTp __max_length, _Compare __comp) — a merge routine that can only merge the __max_length smallest elements 🔥
template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator , typename _DifferenceTp , typename _Compare > _OutputIterator __merge_advance_movc (_RAIter1 &__begin1, _RAIter1 __end1, _RAIter2 &__begin2, _RAIter2 __end2, _OutputIterator __target, _DifferenceTp __max_length, _Compare __comp) — another merge routine that can only merge the __max_length smallest elements 🧚
template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator , typename _DifferenceTp , typename _Compare > _OutputIterator __merge_advance_usual (_RAIter1 &__begin1, _RAIter1 __end1, _RAIter2 &__begin2, _RAIter2 __end2, _OutputIterator __target, _DifferenceTp __max_length, _Compare __comp) — and a third merge routine that can only merge the __max_length smallest elements. Three of them, all saying the same line, iconic behaviour honestly 🌈
template<typename _RAIter1 , typename _RAIter3 , typename _Compare > _RAIter3 __parallel_merge_advance (_RAIter1 &__begin1, _RAIter1 __end1, _RAIter1 &__begin2, _RAIter1 __end2, _RAIter3 __target, typename std::iterator_traits< _RAIter1 >::difference_type __max_length, _Compare __comp) — a parallel merge routine that can only merge the __max_length smallest elements 👑
template<typename _RAIter1 , typename _RAIter2 , typename _RAIter3 , typename _Compare > _RAIter3 __parallel_merge_advance (_RAIter1 &__begin1, _RAIter1 __end1, _RAIter2 &__begin2, _RAIter2 __end2, _RAIter3 __target, typename std::iterator_traits< _RAIter1 >::difference_type __max_length, _Compare __comp) — the merge routine that falls back to sequential in case the iterators of the two input sequences are of different type. Plan B, but make it cute 💜
template<typename _RAIter , typename _Compare > void __parallel_nth_element (_RAIter __begin, _RAIter __nth, _RAIter __end, _Compare __comp) — parallel implementation of std::nth_element() ✨
template<typename _RAIter , typename _Compare > void __parallel_partial_sort (_RAIter __begin, _RAIter __middle, _RAIter __end, _Compare __comp) — parallel implementation of std::partial_sort() 💅
template<typename _IIter , typename _OutputIterator , typename _BinaryOperation > _OutputIterator __parallel_partial_sum (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __bin_op) — parallel partial sum, front-__end. Yes the original says front-__end, we're keeping it 🫶
template<typename _IIter , typename _OutputIterator , typename _BinaryOperation > _OutputIterator __parallel_partial_sum_basecase (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __bin_op, typename std::iterator_traits< _IIter >::value_type __value) — the base case prefix sum routine, the lil foundation of the whole thing 🎀
template<typename _IIter , typename _OutputIterator , typename _BinaryOperation > _OutputIterator __parallel_partial_sum_linear (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __bin_op, typename std::iterator_traits< _IIter >::difference_type __n) — the parallel partial sum implementation: two-phase approach, and no recursion 🌸
template<typename _RAIter , typename _Predicate > std::iterator_traits< _RAIter >::difference_type __parallel_partition (_RAIter __begin, _RAIter __end, _Predicate __pred, _ThreadIndex __num_threads) — parallel implementation of std::partition 🔥
template<typename _RAIter , typename _RandomNumberGenerator > void __parallel_random_shuffle (_RAIter __begin, _RAIter __end, _RandomNumberGenerator __rng=_RandomNumber()) — parallel random public call. Default arg is right there, __rng=_RandomNumber(), don't miss it 👀
template<typename _RAIter , typename _RandomNumberGenerator > void __parallel_random_shuffle_drs (_RAIter __begin, _RAIter __end, typename std::iterator_traits< _RAIter >::difference_type __n, _ThreadIndex __num_threads, _RandomNumberGenerator &__rng) — the main parallel random shuffle step, the big one 🧚
template<typename _RAIter , typename _RandomNumberGenerator > void __parallel_random_shuffle_drs_pu (_DRSSorterPU< _RAIter, _RandomNumberGenerator > *__pus) — the random shuffle code that each thread actually executes. Teamwork, but make it shuffling 💜
template<typename _IIter , typename _OutputIterator , typename _Compare > _OutputIterator __parallel_set_difference (_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, _OutputIterator __result, _Compare __comp) — signature only, no blurb attached, we take it 💀
template<typename _IIter , typename _OutputIterator , typename _Compare > _OutputIterator __parallel_set_intersection (_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, _OutputIterator __result, _Compare __comp) — same deal, no description, just vibes 🌈
template<typename _IIter , typename _OutputIterator , typename _Operation > _OutputIterator __parallel_set_operation (_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, — this one's signature trails right off the edge of the page 😭 hold that thought, it keeps going in a sec.
template<typename _IIter , typename _OutputIterator , typename _Compare > _OutputIterator __parallel_set_symmetric_difference (_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, _OutputIterator __result, _Compare __comp) — the symmetric-difference set op, parallel-flavored. The page gives it no blurb, so that's all we've got, bestie ✨
template<typename _IIter , typename _OutputIterator , typename _Compare > _OutputIterator __parallel_set_union (_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, _OutputIterator __result, _Compare __comp) — and the union one, same deal. No description in the source, no cap 🫶

the `__parallel_sort` glow-up squad 👑

Okay so there's one generic __parallel_sort and then a whole little clique of overloads that each pick a different algorithm for you based on the tag you hand over. It's giving "choose your fighter."

template<bool __stable, typename _RAIter , typename _Compare , typename _Parallelism > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, _Parallelism __parallelism) — the generic one, takes whatever _Parallelism you throw at it.
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, balanced_quicksort_tag __parallelism) — choose balanced quicksort for parallel sorting 💅
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, default_parallel_tag __parallelism) — choose multiway mergesort with exact splitting, for parallel sorting.
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, multiway_mergesort_exact_tag __parallelism) — choose multiway mergesort with exact splitting, for parallel sorting (yes, same wording as the default one — that's genuinely what the page says 🫠).
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, multiway_mergesort_sampling_tag __parallelism) — choose multiway mergesort with splitting by sampling, for parallel sorting.
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, multiway_mergesort_tag __parallelism) — choose multiway mergesort, splitting variant decided at run-time, for parallel sorting.
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, parallel_tag __parallelism) — choose a parallel sorting algorithm. Vague on purpose, iconic behavior.
template<bool __stable, typename _RAIter , typename _Compare > void __parallel_sort (_RAIter __begin, _RAIter __end, _Compare __comp, quicksort_tag __parallelism) — choose quicksort for parallel sorting.

the quicksort internals 🌀

These are the machinery behind the quicksort tags — lowkey the main characters of the sort implementation, highkey not something you call yourself.

template<typename _RAIter , typename _Compare > void __parallel_sort_qs (_RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __num_threads) — unbalanced quicksort main call.
template<typename _RAIter , typename _Compare > void __parallel_sort_qs_conquer (_RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __num_threads) — unbalanced quicksort conquer step.
template<typename _RAIter , typename _Compare > std::iterator_traits< _RAIter >::difference_type __parallel_sort_qs_divide (_RAIter __begin, _RAIter __end, _Compare __comp, typename std::iterator_traits< _RAIter >::difference_type __pivot_rank, typename std::iterator_traits< _RAIter >::difference_type __num_samples, _ThreadIndex __num_threads) — unbalanced quicksort divide step.
template<typename _RAIter , typename _Compare > void __parallel_sort_qsb (_RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __num_threads) — top-level quicksort routine ✨
template<typename _RAIter , typename _Compare > void __qsb_conquer (_QSBThreadLocal< _RAIter > **__tls, _RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __iam, _ThreadIndex __num_threads, bool __parent_wait) — quicksort conquer step (the qsb branch this time).
template<typename _RAIter , typename _Compare > std::iterator_traits< _RAIter >::difference_type __qsb_divide (_RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __num_threads) — balanced quicksort divide step.
template<typename _RAIter , typename _Compare > void __qsb_local_sort_with_helping (_QSBThreadLocal< _RAIter > **__tls, _Compare &__comp, _ThreadIndex __iam, bool __wait) — quicksort step doing load-balanced local sort. Helping hands fr fr 🫶

tiny math + random helpers 🎀

template<typename _RandomNumberGenerator > int __random_number_pow2 (int __logp, _RandomNumberGenerator &__rng) — generate a random number in [0,2^__logp).
template<typename _Size > _Size __rd_log2 (_Size __n) — calculates the rounded-down logarithm of __n for base 2.
template<typename _Tp > _Tp __round_up_to_pow2 (_Tp __x) — round up to the next greater power of 2 ⭐

search, merge-ish, and shuffle-adjacent 🌈

template<typename __RAIter1 , typename __RAIter2 , typename _Pred > __RAIter1 __search_template (__RAIter1 __begin1, __RAIter1 __end1, __RAIter2 __begin2, __RAIter2 __end2, _Pred __pred) — parallel std::search.
template<bool __stable, bool __sentinels, typename _RAIterIterator , typename _RAIter3 , typename _DifferenceTp , typename _Compare > _RAIter3 __sequential_multiway_merge (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, const typename std::iterator_traits< typename std::iterator_traits< _RAIterIterator >::value_type::first_type >::value_type &__sentinel, _DifferenceTp __length, _Compare __comp) — the sequential multi-way merging switch (the one that decides the strategy).
template<typename _RAIter , typename _RandomNumberGenerator > void __sequential_random_shuffle (_RAIter __begin, _RAIter __end, _RandomNumberGenerator &__rng) — sequential, cache-efficient random shuffle. Yes bestie, cache-efficient and random 💅

range-shrinking era 🦋

template<typename _IIter > void __shrink (std::vector< _IIter > &__os_starts, size_t &__count_to_two, size_t &__range_length) — combines two ranges into one, and thus halves the number of ranges.
template<typename _IIter > void __shrink_and_double (std::vector< _IIter > &__os_starts, size_t &__count_to_two, size_t &__range_length, const bool __make_twice) — shrinks and doubles the ranges. Growth mindset, honestly.

odds and ends 🍓

void __yield () — yield control to another thread, without waiting for the end of the time slice. Politely stepping aside, no waiting around.
template<typename _IIter , typename _FunctorType > size_t list_partition (const _IIter __begin, const _IIter __end, _IIter *__starts, size_t *__lengths, const int __num_parts, _FunctorType &__f, int __oversampling=0) — splits a sequence given by input iterators into parts of almost equal size. Note the default: __oversampling=0.
template<typename _Tp > const _Tp & max (const _Tp &__a, const _Tp &__b) — equivalent to std::max.
template<typename _Tp > const _Tp & min (const _Tp &__a, const _Tp &__b) — equivalent to std::min.
template<typename _RanSeqs , typename _RankType , typename _RankIterator , typename _Compare > void multiseq_partition (_RanSeqs __begin_seqs, _RanSeqs __end_seqs, _RankType __rank, _RankIterator __begin_offsets, _Compare __comp=std::less< typename std::iterator_traits< typename std::iterator_traits< _RanSeqs >::value_type::first_type >::value_type >()) — splits several sorted sequences at a certain global __rank, resulting in a splitting point for each sequence. The sequences are passed via a sequence of random-access iterator pairs, and none of the sequences may be empty ⚠️ — that's a hard requirement, not a vibe suggestion. If there are several equal elements across the split, the ones on the __left side will be chosen from sequences with smaller number.
template<typename _Tp , typename _RanSeqs , typename _RankType , typename _Compare > _Tp multiseq_selection (_RanSeqs __begin_seqs, _RanSeqs __end_seqs, _RankType __rank, _RankType &__offset, _Compare __comp=std::less< _Tp >()) — selects the element at a certain global __rank from several sorted sequences.

multiway_merge frontends 👑

So multiway_merge is one name with a million tag-based personalities. The page only labels the sequential_tag one; the rest are just overloads sitting there looking pretty:

template<typename _RAIterPairIterator , typename _RAIterOut , typename _DifferenceTp , typename _Compare > _RAIterOut multiway_merge (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp __length, _Compare __comp, __gnu_parallel::exact_tag __tag)
template<typename _RAIterPairIterator , typename _RAIterOut , typename _DifferenceTp , typename _Compare > _RAIterOut multiway_merge (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp __length, _Compare __comp, __gnu_parallel::sampling_tag __tag)
template<typename _RAIterPairIterator , typename _RAIterOut , typename _DifferenceTp , typename _Compare > _RAIterOut multiway_merge (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp __length, _Compare __comp, __gnu_parallel::sequential_tag) — multiway merge frontend. That's the whole blurb, and honestly, respect for the brevity 🎀
template<typename _RAIterPairIterator , typename _RAIterOut , typename _DifferenceTp , typename _Compare > _RAIterOut multiway_merge (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp __length, _Compare __comp, default_parallel_tag __tag)
template<typename _RAIterPairIterator , typename _RAIterOut , typename _DifferenceTp , typename _Compare > _RAIterOut multiway_merge (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp __length, _Compare __comp, parallel_tag __tag=parallel_tag(0))

heads up, the source page really does end that last signature with parallel_tag(0)) — the extra paren is copy-pasted straight from the manpage, iykyk 🙈

the variant algorithms ✨

template<template< typename _RAI, typename _Cp > class iterator, typename _RAIterIterator , typename _RAIter3 , typename _DifferenceTp , typename _Compare > _RAIter3 multiway_merge_3_variant (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, _DifferenceTp __length, _Compare __comp) — highly efficient 3-way merging procedure 🔥
template<template< typename _RAI, typename _Cp > class iterator, typename _RAIterIterator , typename _RAIter3 , typename _DifferenceTp , typename _Compare > _RAIter3 multiway_merge_4_variant (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, _DifferenceTp __length, _Compare __comp) — highly efficient 4-way merging procedure 🔥
template<bool __stable, typename _RAIterIterator , typename _Compare , typename _DifferenceType > void multiway_merge_exact_splitting (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, — and the page just… stops there mid-signature 😭 that's literally where this chunk ends, bestie, so we pick it up next part.
that one whose signature got cut off mid-argument (the manpage does that, not me, don't @ me 🙈) —

_DifferenceType __length, _DifferenceType __total_length, _Compare
__comp, std::vector< std::pair< _DifferenceType, _DifferenceType > >
*__pieces)

Exact splitting for parallel multiway-merge routine. okay so it's exact, no vibes-based guessing here 💅

multiway_merge_loser_tree

template<typename _LT , typename _RAIterIterator , typename _RAIter3 ,
    typename _DifferenceTp , typename _Compare > _RAIter3
    multiway_merge_loser_tree (_RAIterIterator __seqs_begin,
    _RAIterIterator __seqs_end, _RAIter3 __target, _DifferenceTp
    __length, _Compare __comp)

Multi-way merging procedure for a high branching factor, guarded case. 🛡️

multiway_merge_loser_tree_sentinel

template<typename _UnguardedLoserTree , typename _RAIterIterator ,
    typename _RAIter3 , typename _DifferenceTp , typename _Compare >
    _RAIter3 multiway_merge_loser_tree_sentinel (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, const
    typename std::iterator_traits< typename std::iterator_traits<
    _RAIterIterator >::value_type::first_type >::value_type &__sentinel,
    _DifferenceTp __length, _Compare __comp)

Multi-way merging procedure for a high branching factor, requiring sentinels to exist. sentinels are the little bodyguards fr fr 🫶

multiway_merge_loser_tree_unguarded

template<typename _LT , typename _RAIterIterator , typename _RAIter3 ,
    typename _DifferenceTp , typename _Compare > _RAIter3
    multiway_merge_loser_tree_unguarded (_RAIterIterator __seqs_begin,
    _RAIterIterator __seqs_end, _RAIter3 __target, const typename
    std::iterator_traits< typename std::iterator_traits< _RAIterIterator
    >::value_type::first_type >::value_type &__sentinel, _DifferenceTp
    __length, _Compare __comp)

Multi-way merging procedure for a high branching factor, unguarded case. living dangerously, no guard rails, no cap 😭

multiway_merge_sampling_splitting

template<bool __stable, typename _RAIterIterator , typename _Compare ,
    typename _DifferenceType > void multiway_merge_sampling_splitting
    (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end,
    _DifferenceType __length, _DifferenceType __total_length, _Compare
    __comp, std::vector< std::pair< _DifferenceType, _DifferenceType > >
    *__pieces)

Sampling based splitting for parallel multiway-merge routine. it's giving "just take a lil sample, bestie" ✨

multiway_merge_sentinels (the __gnu_parallel::exact_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, __gnu_parallel::exact_tag __tag)

multiway_merge_sentinels (the __gnu_parallel::sequential_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, __gnu_parallel::sequential_tag)

Multiway Merge Frontend. this is the main character entry point 👑

multiway_merge_sentinels (the default_parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, default_parallel_tag __tag)

multiway_merge_sentinels (the parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, parallel_tag __tag=parallel_tag(0))

multiway_merge_sentinels (the sampling_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, sampling_tag __tag)

yes bestie, that's five overloads of the same name — it's the tag-dispatch buffet, pick your flavor 🍓

parallel_multiway_merge

template<bool __stable, bool __sentinels, typename _RAIterIterator ,
    typename _RAIter3 , typename _DifferenceTp , typename _Splitter ,
    typename _Compare > _RAIter3 parallel_multiway_merge
    (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3
    __target, _Splitter __splitter, _DifferenceTp __length, _Compare
    __comp, _ThreadIndex __num_threads)

Parallel multi-way merge routine. the whole point of the function tbh 🔥

parallel_sort_mwms

template<bool __stable, bool __exact, typename _RAIter , typename
    _Compare > void parallel_sort_mwms (_RAIter __begin, _RAIter __end,
    _Compare __comp, _ThreadIndex __num_threads)

PMWMS main call. that acronym will live in my head rent free 🧠✨

parallel_sort_mwms_pu

template<bool __stable, bool __exact, typename _RAIter , typename
    _Compare > void parallel_sort_mwms_pu (_PMWMSSortingData< _RAIter >
    *__sd, _Compare &__comp)

PMWMS code executed by each thread. every thread gets a lil job, teamwork makes the dream work 🫶

stable_multiway_merge (the __gnu_parallel::exact_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut stable_multiway_merge
    (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end,
    _RAIterOut __target, _DifferenceTp __length, _Compare __comp,
    __gnu_parallel::exact_tag __tag)

stable_multiway_merge (the __gnu_parallel::sequential_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut stable_multiway_merge
    (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end,
    _RAIterOut __target, _DifferenceTp __length, _Compare __comp,
    __gnu_parallel::sequential_tag)

stable_multiway_merge (the default_parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut stable_multiway_merge
    (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end,
    _RAIterOut __target, _DifferenceTp __length, _Compare __comp,
    default_parallel_tag __tag)

stable_multiway_merge (the parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut stable_multiway_merge
    (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end,
    _RAIterOut __target, _DifferenceTp __length, _Compare __comp,
    parallel_tag __tag=parallel_tag(0))

stable_multiway_merge (the sampling_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut stable_multiway_merge
    (_RAIterPairIterator __seqs_begin, _RAIterPairIterator __seqs_end,
    _RAIterOut __target, _DifferenceTp __length, _Compare __comp,
    sampling_tag __tag)

stable_multiway_merge_sentinels (the __gnu_parallel::exact_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    stable_multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, __gnu_parallel::exact_tag __tag)

stable_multiway_merge_sentinels (the __gnu_parallel::sequential_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    stable_multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, __gnu_parallel::sequential_tag)

stable_multiway_merge_sentinels (the default_parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    stable_multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, default_parallel_tag __tag)

stable_multiway_merge_sentinels (the parallel_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    stable_multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, parallel_tag __tag=parallel_tag(0))

stable_multiway_merge_sentinels (the sampling_tag one)

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    stable_multiway_merge_sentinels (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, sampling_tag __tag)

🧮 Variables

static const int _CASable_bits — Number of bits of _CASable. bestie, it's literally just counting bits 💅
static const _CASable _CASable_mask — _CASable with the right half of bits set to 1. mask era 🎭

🌸 Detailed Description

GNU parallel code for public use. that's it, that's the whole vibe check — this is the public-facing surface of the GNU parallel machinery ✨

🎀 Typedef Documentation

`typedef unsigned short __gnu_parallel::_BinIndex`

Type to hold the index of a bin. Since many variables of this type are allocated, it should be chosen as small as possible. tiny type, big responsibility — it's giving efficiency queen 👑

`typedef int64_t __gnu_parallel::_CASable`

Longest compare-and-swappable integer type on this platform. as long as it can legally get on this machine, no cap 🫶

`typedef uint64_t __gnu_parallel::_SequenceIndex`

Unsigned integer to index __elements. The total number of elements for each algorithm must fit into this type. so like, mind the capacity, bestie 😭

`typedef uint16_t __gnu_parallel::_ThreadIndex`

Unsigned integer to index a thread number. The maximum thread number (for each processor) must fit into this type. 🧵

🌈 Enumeration Type Documentation

`enum __gnu_parallel::_AlgorithmStrategy`

Strategies for run-time algorithm selection:

`enum __gnu_parallel::_FindAlgorithm`

Find algorithms:

`enum __gnu_parallel::_MultiwayMergeAlgorithm`

Merging algorithms:

`enum __gnu_parallel::_Parallelism`

Run-time equivalents for the compile-time tags. this is how you say "compile-time vibe" at runtime 💀

Enumerator

sequential — Not parallel. just you and the algorithm, alone together 🙈
parallel_unbalanced — Parallel unbalanced (equal-sized chunks). everyone gets the same size plate, even if some are starving 🍽️
parallel_balanced — Parallel balanced (work-stealing). stealing work but make it a feature ✨
parallel_omp_loop — Parallel with OpenMP dynamic load-balancing. 🔄
parallel_omp_loop_static — Parallel with OpenMP static load-balancing.
parallel_taskqueue — Parallel with OpenMP taskqueue construct. the queue is queuing 💅

`enum __gnu_parallel::_PartialSumAlgorithm`

Partial sum algorithms: recursive, linear.

`enum __gnu_parallel::_SortAlgorithm`

Sorting algorithms:

`enum __gnu_parallel::_SplittingAlgorithm`

Sorting/merging algorithms: sampling, __exact. two flavors, pick your fighter 🥊

⭐ Function Documentation

`template<typename _RAIter , typename _DifferenceTp > void __gnu_parallel::__calc_borders (_RAIter __elements, _DifferenceTp __length, _DifferenceTp * __off)`

Precalculate __advances for Knuth-Morris-Pratt algorithm. yes THE Knuth-Morris-Pratt, we love a legendary string-searching moment 👑

Parameters

__elements — Begin iterator of sequence to search for.
__length — Length of sequence to search for.
__off — Returned __offsets.

Referenced by __search_template().

`template<typename _Tp > bool __gnu_parallel::__compare_and_swap (volatile _Tp * __ptr, _Tp __comparand, _Tp __replacement) [inline]`

Compare-and-swap. Compare *__ptr and __comparand. If equal, let *__ptr=__replacement and return true, return false otherwise. literally the "are we the same? then swap, slay" of atomic operations 💅

Parameters

__ptr — Pointer to signed integer.
__comparand — Compare value.
__replacement — Replacement value.

Referenced by __parallel_partition(), __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_back(), and __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_front().

`void __gnu_parallel::__decode2 (_CASable x, int & a, int & __b) [inline]`

Decode two integers from one gnu_parallel::_CASable. two-for-one, we love a bundle deal 🎀

Okay so the parameter deets for that decode one, bestie — here's what goes where 💅

Parameters:

__x — the __gnu_parallel::_CASable you're pulling integers out of. It's giving "the source of truth" ✨
__a — first integer, decoded from the most-significant _CASable_bits/2 bits of __x
__b — second integer, encoded in the least-significant _CASable_bits/2 bits of __x

See also: __encode2 (its whole mirror-image moment 🪞)

References: _CASable_bits, and _CASable_mask.

Referenced by: __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_back(), __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_front(), and __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::push_front().

🎀 `__determine_samples` — picking the samples, lowkey iconic

template<typename _RAIter , typename _DifferenceTp > void
__gnu_parallel::__determine_samples (_PMWMSSortingData< _RAIter > *
__sd, _DifferenceTp __num_samples)

Literally just: select _M_samples from a sequence. That's the whole vibe check ✅

Parameters:

__sd — pointer to the algorithm data. The _Result gets placed in __sd->_M_samples, no cap 🫶
__num_samples — how many _M_samples you want to select

References: __equally_split(), __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_samples, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_source, and __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_starts.

🌈 `__encode2` — squish two ints into one, [inline]

_CASable __gnu_parallel::__encode2 (int __a, int __b) [inline]

Encode two integers into one gnu_parallel::_CASable. Two besties, one slot — it's giving compression 💖

Parameters:

__a — first integer, encoded in the most-significant _CASable_bits/2 bits
__b — second integer, encoded in the least-significant _CASable_bits/2 bits

Returns: the value encoding __a and __b ✨

See also: __decode2 (the un-squisher)

References: _CASable_bits.

Referenced by: __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::_RestrictedBoundedConcurrentQueue(), __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_back(), __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_front(), and __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::push_front().

🦋 `__equally_split` — slice it into (almost) equal parts, periodt

template<typename _DifferenceType , typename _OutputIterator >
_OutputIterator __gnu_parallel::__equally_split (_DifferenceType __n,
_ThreadIndex __num_threads, _OutputIterator __s)

So this is the function that splits a sequence into parts of almost equal size. The resulting sequence __s of length __num_threads+1 contains the splitting positions when splitting the range [0,__n) into parts of almost equal size (plus minus 1). The first entry is 0, the last one is n. Heads up though — there may result empty parts, and that's just a thing that happens 🙈

Parameters:

__n — number of elements
__num_threads — number of parts
__s — splitters

Returns: end of __splitter sequence, i.e. __s+__num_threads+1

Referenced by: __determine_samples(), __find_template(), __parallel_partial_sum_linear(), __parallel_unique_copy(), __search_template(), and multiway_merge_exact_splitting().

⭐ `__equally_split_point` — the single split point you asked for

template<typename _DifferenceType > _DifferenceType
__gnu_parallel::__equally_split_point (_DifferenceType __n, _ThreadIndex
__num_threads, _ThreadIndex __thread_no)

Same splitting-a-sequence-into-parts-of-almost-equal-size energy, but this one hands you back the position of the splitting point between thread number __thread_no (included) and thread number __thread_no+1 (excluded). One number, zero drama 💅

Parameters:

__n — number of elements
__num_threads — number of parts
__thread_no — number of threads

Returns: the splitting point 🎯

Referenced by: __for_each_template_random_access_ed().

🔥 `__fetch_and_add` — atomic add, [inline]

template<typename _Tp > _Tp __gnu_parallel::__fetch_and_add (volatile _Tp *
__ptr, _Tp __addend) [inline]

Add a value to a variable, atomically. Like, nobody can sneak in and ruin the math mid-update. Main character energy for real 👑

Parameters:

__ptr — pointer to a signed integer
__addend — value to add

Referenced by: __parallel_partition(), and __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::push_front().

🧚 `__find_template` — parallel `std::find`, the switchboard edition, [inline]

template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename
_Selector > std::pair< _RAIter1, _RAIter2 >
__gnu_parallel::__find_template (_RAIter1 __begin1, _RAIter1 __end1,
_RAIter2 __begin2, _Pred __pred, _Selector __selector) [inline]

Parallel std::find, and it's the switch for different algorithms. She picks the strategy, babes ✨

Parameters:

__begin1 — begin iterator of first sequence
__end1 — end iterator of first sequence
__begin2 — begin iterator of second sequence. Must have same length as first sequence ⚠️
__pred — find predicate
__selector — _Functionality (e. g. std::find_if(), std::equal(),...)

Returns: place of finding in both sequences 🫶

References: __find_template(), and __gnu_parallel::_Settings::get().

Referenced by: __find_template().

🍓 `__find_template` — constant size blocks variant

template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename
_Selector > std::pair< _RAIter1, _RAIter2 >
__gnu_parallel::__find_template (_RAIter1 __begin1, _RAIter1 __end1,
_RAIter2 __begin2, _Pred __pred, _Selector __selector,
constant_size_blocks_tag)

Parallel std::find, constant block size variant. Same search, different chunking strategy 💖

Parameters:

__begin1 — begin iterator of first sequence
__end1 — end iterator of first sequence
__begin2 — begin iterator of second sequence. Second __sequence must have same length as first sequence
__pred — find predicate
__selector — _Functionality (e. g. std::find_if(), std::equal(),...)

Returns: place of finding in both sequences

See also: __gnu_parallel::_Settings::find_sequential_search_size

__gnu_parallel::_Settings::find_block_size

There are two main differences between the growing blocks and the constant-size blocks variants, and yes you need both of them in your head:

For GB, the block size grows; for CSB, the block size is fixed.
For GB, the blocks are allocated dynamically; for CSB, the blocks are allocated in a predetermined manner, namely spacial round-robin.

References: _GLIBCXX_CALL, __gnu_parallel::_Settings::find_initial_block_size, __gnu_parallel::_Settings::find_sequential_search_size, std::pair< _T1, _T2 >::first, and __gnu_parallel::_Settings::get().

🌸 `__find_template` — equal splitting variant

template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename
_Selector > std::pair< _RAIter1, _RAIter2 >
__gnu_parallel::__find_template (_RAIter1 __begin1, _RAIter1 __end1,
_RAIter2 __begin2, _Pred __pred, _Selector __selector, equal_split_tag)

Parallel std::find, equal splitting variant. Everyone gets the same slice, fair and square 🤝

Parameters:

__begin1 — begin iterator of first sequence
__end1 — end iterator of first sequence
__begin2 — begin iterator of second sequence. Second __sequence must have same length as first sequence
__pred — find predicate
__selector — _Functionality (e. g. std::find_if(), std::equal(),...)

Returns: place of finding in both sequences

References: __equally_split(), and _GLIBCXX_CALL.

🎀 `__find_template` — growing blocks variant

template<typename _RAIter1 , typename _RAIter2 , typename _Pred , typename
_Selector > std::pair< _RAIter1, _RAIter2 >
__gnu_parallel::__find_template (_RAIter1 __begin1, _RAIter1 __end1,
_RAIter2 __begin2, _Pred __pred, _Selector __selector,
growing_blocks_tag)

Parallel std::find, growing block size variant. The blocks start small and just… grow up 😭💕

Parameters:

__begin1 — begin iterator of first sequence
__end1 — end iterator of first sequence
__begin2 — begin iterator of second sequence. Second __sequence must have same length as first sequence
__pred — find predicate
__selector — _Functionality (e. g. std::find_if(), std::equal(),...)

Returns: place of finding in both sequences

See also: __gnu_parallel::_Settings::find_sequential_search_size

__gnu_parallel::_Settings::find_scale_factor

The same two main differences between growing blocks and constant-size blocks, once more for the people in the back:

For GB, the block size grows; for CSB, the block size is fixed.
For GB, the blocks are allocated dynamically; for CSB, the blocks are allocated in a predetermined manner, namely spacial round-robin.

References: _GLIBCXX_CALL, __gnu_parallel::_Settings::find_scale_factor, __gnu_parallel::_Settings::find_sequential_search_size, std::pair< _T1, _T2 >::first, and __gnu_parallel::_Settings::get().

👑 `__for_each_template_random_access` — pick your algorithm by tag

template<typename _IIter , typename _UserOp , typename _Functionality ,
typename _Red , typename _Result > _UserOp
__gnu_parallel::__for_each_template_random_access (_IIter __begin,
_IIter __end, _UserOp __user_op, _Functionality & __functionality, _Red
__reduction, _Result __reduction_start, _Result & __output, typename
std::iterator_traits< _IIter >::difference_type __bound, _Parallelism
__parallelism_tag)

Choose the desired algorithm by evaluating __parallelism_tag. She reads the tag, she picks the whole strategy — it's giving "I contain multitudes" 🌈

Parameters:

__begin — begin iterator of input sequence
__end — end iterator of input sequence
__user_op — a user-specified functor (comparator, predicate, associative operator,...)
__functionality — functor to process an element with __user_op (depends on desired functionality, e. g. accumulate, for_each,...
__reduction — reduction functor
__reduction_start — initial value for reduction
__output — output iterator
__bound — maximum number of elements processed
__parallelism_tag — parallelization method

References: __for_each_template_random_access_ed(), __for_each_template_random_access_omp_loop(), __for_each_template_random_access_workstealing(), parallel_omp_loop, parallel_omp_loop_static, and parallel_unbalanced.

💜 `__for_each_template_random_access_ed` — embarrassingly parallel, hand-crafted

template<typename _RAIter , typename _Op , typename _Fu , typename _Red ,
typename _Result > _Op
__gnu_parallel::__for_each_template_random_access_ed (_RAIter __begin,
_RAIter __end, _Op __o, _Fu & __f, _Red __r, _Result __base, _Result &
__output, typename std::iterator_traits< _RAIter >::difference_type
__bound)

Embarrassingly parallel algorithm for random access iterators, using hand-crafted parallelization by equal splitting the work. Hand-crafted!! Like a lil artisanal parallel algorithm, we love her 🧚✨

Parameters:

__begin — begin iterator of element sequence
__end — end iterator of element sequence
__o — user-supplied functor (comparator, predicate, adding functor, ...)
__f — functor to 'process' an element with __op (depends on desired functionality, e. g. for std::for_each(), ...)
__r — functor to 'add' a single __result to the already processed elements (depends on functionality)
__base — base value for reduction
__output — pointer to position where final result is written to
__bound — maximum number of elements processed (e. g. for std::count_n())

Returns: user-supplied functor (that may contain a part of the result) 💖

References: __equally_split_point().

Referenced by: __for_each_template_random_access().

🌈 `__for_each_template_random_access_omp_loop`

template<typename _RAIter , typename _Op , typename _Fu , typename _Red ,
    typename _Result > _Op
    __gnu_parallel::__for_each_template_random_access_omp_loop (_RAIter
    __begin, _RAIter __end, _Op __o, _Fu & __f, _Red __r, _Result __base,
    _Result & __output, typename std::iterator_traits< _RAIter
    >::difference_type __bound)

Okay bestie, this one is the embarrassingly parallel algorithm for random access iterators, and it does the whole thing with an OpenMP for loop. It's giving "I have never known struggle" energy honestly 💅

Parameters — let's go through them, no skips:

__begin — begin iterator of element sequence.
__end — end iterator of element sequence.
__o — your user-supplied functor (comparator, predicate, adding functor, etc.).
__f — functor to process an element with __op (depends on what functionality you want, e.g. for std::for_each(), ...).
__r — functor to add a single __result to the already processed elements (depends on functionality).
__base — base value for reduction.
__output — pointer to the position where the final result is written to.
__bound — maximum number of elements processed (e.g. for std::count_n()).

Returns — your user-supplied functor, which may contain a part of the result. ✨

Referenced by __for_each_template_random_access().

🦋 `__for_each_template_random_access_omp_loop_static`

template<typename _RAIter , typename _Op , typename _Fu , typename _Red ,
    typename _Result > _Op
    __gnu_parallel::__for_each_template_random_access_omp_loop_static
    (_RAIter __begin, _RAIter __end, _Op __o, _Fu & __f, _Red __r, _Result
    __base, _Result & __output, typename std::iterator_traits< _RAIter
    >::difference_type __bound)

Same embarrassingly parallel algorithm for random access iterators, except it's an OpenMP for loop with static scheduling. Same vibes, more predictable, iykyk 🎀

Parameters:

__begin — begin iterator of element sequence.
__end — end iterator of element sequence.
__o — user-supplied functor (comparator, predicate, adding functor, ...).
__f — functor to process an element with __op (depends on desired functionality, e.g. for std::for_each(), ...).
__r — functor to add a single __result to the already processed __elements (depends on functionality).
__base — base value for reduction.
__output — pointer to position where final result is written to.
__bound — maximum number of elements processed (e.g. for std::count_n()).

Returns — the user-supplied functor, may contain a part of the result 💖

🔥 `__for_each_template_random_access_workstealing`

template<typename _RAIter , typename _Op , typename _Fu , typename _Red ,
    typename _Result > _Op
    __gnu_parallel::__for_each_template_random_access_workstealing (_RAIter
    __begin, _RAIter __end, _Op __op, _Fu & __f, _Red __r, _Result __base,
    _Result & __output, typename std::iterator_traits< _RAIter
    >::difference_type __bound)

The work stealing algorithm for random access iterators, and she is so efficient it hurts — uses O(1) additional memory, no cap. Synchronization at job lists is done with atomic operations, which is basically the flex of the century 👑

Parameters:

__begin — begin iterator of element sequence.
__end — end iterator of element sequence.
__op — user-supplied functor (comparator, predicate, adding functor, ...).
__f — functor to process an element with __op (depends on desired functionality, e.g. for std::for_each(), ...).
__r — functor to add a single __result to the already processed elements (depends on functionality).
__base — base value for reduction.
__output — pointer to position where final result is written to.
__bound — maximum number of elements processed (e.g. for std::count_n()).

Returns — the user-supplied functor (may contain a part of the result).

References: __yield(), _GLIBCXX_CALL, __gnu_parallel::_Job< _DifferenceTp >::_M_first, __gnu_parallel::_Job< _DifferenceTp >::_M_last, __gnu_parallel::_Job< _DifferenceTp >::_M_load, __gnu_parallel::_Settings::cache_line_size, __gnu_parallel::_Settings::get(), and min().

Referenced by __for_each_template_random_access().

⭐ `__is_sorted`

template<typename _IIter , typename _Compare > bool
    __gnu_parallel::__is_sorted (_IIter __begin, _IIter __end, _Compare
    __comp)

A little vibe check: is [__begin, __end) sorted according to __comp? That's literally it, that's the whole job 🫶

Parameters:

__begin — begin iterator of sequence.
__end — end iterator of sequence.
__comp — comparator.

Returns — true if sorted, false otherwise.

Referenced by __sequential_multiway_merge(), multiway_merge_loser_tree_sentinel(), and parallel_multiway_merge().

🧚 `__median_of_three_iterators`

template<typename _RAIter , typename _Compare > _RAIter
    __gnu_parallel::__median_of_three_iterators (_RAIter __a, _RAIter __b,
    _RAIter __c, _Compare __comp)

Computes the median of three referenced elements, according to __comp. Three candidates walk in, one middle child walks out 😭

Parameters:

__a — first iterator.
__b — second iterator.
__c — third iterator.
__comp — comparator.

Referenced by __qsb_divide().

💜 `__merge_advance`

template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator ,
    typename _DifferenceTp , typename _Compare > _OutputIterator
    __gnu_parallel::__merge_advance (_RAIter1 & __begin1, _RAIter1 __end1,
    _RAIter2 & __begin2, _RAIter2 __end2, _OutputIterator __target,
    _DifferenceTp __max_length, _Compare __comp) [inline]

A merge routine that can only merge the __max_length smallest elements. The __begin iterators get advanced accordingly, so heads up: they might not reach __end, in contrast to the usual variant. It also does a static switch on whether to use the conditional-move variant. She contains multitudes ✨

Parameters:

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__target — target begin iterator.
__max_length — maximum number of elements to merge.
__comp — comparator.

Returns — output end iterator.

References __merge_advance_movc(), and _GLIBCXX_CALL.

Referenced by __parallel_merge_advance(), and __sequential_multiway_merge().

🌸 `__merge_advance_movc`

template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator ,
    typename _DifferenceTp , typename _Compare > _OutputIterator
    __gnu_parallel::__merge_advance_movc (_RAIter1 & __begin1, _RAIter1
    __end1, _RAIter2 & __begin2, _RAIter2 __end2, _OutputIterator __target,
    _DifferenceTp __max_length, _Compare __comp)

Another merge-only-the-__max_length-smallest-elements routine, and the __begin iterators advance the same way — again, they might not reach __end, unlike the usual variant. The difference? The code is specially designed so the compiler can generate conditional moves instead of branches. It's giving "I was built different on purpose" 💅

Parameters:

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__target — target begin iterator.
__max_length — maximum number of elements to merge.
__comp — comparator.

Returns — output end iterator.

Referenced by __merge_advance().

🎀 `__merge_advance_usual`

template<typename _RAIter1 , typename _RAIter2 , typename _OutputIterator ,
    typename _DifferenceTp , typename _Compare > _OutputIterator
    __gnu_parallel::__merge_advance_usual (_RAIter1 & __begin1, _RAIter1
    __end1, _RAIter2 & __begin2, _RAIter2 __end2, _OutputIterator __target,
    _DifferenceTp __max_length, _Compare __comp)

The plain-jane one: merges only the __max_length smallest elements, the __begin iterators get advanced accordingly and might not reach __end, in contrast to the usual variant. (Yes, the description says "in contrast to the usual variant" and this is the usual variant, don't come for me, I'm just the messenger 🙈)

Parameters:

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__target — target begin iterator.
__max_length — maximum number of elements to merge.
__comp — comparator.

Returns — output end iterator.

🌈 `__parallel_merge_advance` (first overload)

template<typename _RAIter1 , typename _RAIter3 , typename _Compare >
    _RAIter3 __gnu_parallel::__parallel_merge_advance (_RAIter1 & __begin1,
    _RAIter1 __end1, _RAIter1 & __begin2, _RAIter1 __end2, _RAIter3
    __target, typename std::iterator_traits< _RAIter1 >::difference_type
    __max_length, _Compare __comp) [inline]

The parallel merge routine, merging only the __max_length smallest elements. The __begin iterators are advanced accordingly and might not reach __end, in contrast to the usual variant — and the whole functionality is projected onto parallel_multiway_merge. Fancy, honestly 🔥

Parameters:

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__target — target begin iterator.
__max_length — maximum number of elements to merge.
__comp — comparator.

Returns — output end iterator.

References multiway_merge_exact_splitting(), and parallel_multiway_merge().

🫶 `__parallel_merge_advance` (second overload)

template<typename _RAIter1 , typename _RAIter2 , typename _RAIter3 ,
    typename _Compare > _RAIter3 __gnu_parallel::__parallel_merge_advance
    (_RAIter1 & __begin1, _RAIter1 __end1, _RAIter2 & __begin2, _RAIter2
    __end2, _RAIter3 __target, typename std::iterator_traits< _RAIter1
    >::difference_type __max_length, _Compare __comp) [inline]

Samesies name, different template params — and this one is the fallback to sequential in case the iterators of the two input sequences are of different types. Like, it tried parallelism, saw a type mismatch, and said "bestie I got you, we're doing this the chill way" 😌

Parameters:

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__target — target begin iterator.
__max_length — maximum number of elements to merge.
__comp — comparator.

Returns — output end iterator.

References __merge_advance().

👑 `__parallel_nth_element`

template<typename _RAIter , typename _Compare > void
    __gnu_parallel::__parallel_nth_element (_RAIter __begin, _RAIter __nth,
    _RAIter __end, _Compare __comp)

The parallel implementation of std::nth_element(). She finds the one ✨iconic✨ element that has to be in a specific position and makes it happen.

Parameters:

__begin — begin iterator of input sequence.
__nth — Iterator of element that must be in position afterwards.
__end — end iterator of input sequence.
__comp — comparator.

References __parallel_partition(), _GLIBCXX_CALL, __gnu_parallel::_Settings::get(), std::max(), __gnu_parallel::_Settings::nth_element_minimal_n, and __gnu_parallel::_Settings::partition_minimal_n.

Referenced by __parallel_partial_sort().

💖 `__parallel_partial_sort`

template<typename _RAIter , typename _Compare > void
    __gnu_parallel::__parallel_partial_sort (_RAIter __begin, _RAIter
    __middle, _RAIter __end, _Compare __comp)

The parallel implementation of std::partial_sort() — sort everything up to __middle and then just vibe 🌸

Parameters:

__begin — begin iterator of input sequence.
__middle — sort until this position.
__end — end iterator of input sequence.
__comp — comparator.

References __parallel_nth_element().

🌊 `__parallel_partial_sum`

template<typename _IIter, typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
__gnu_parallel::__parallel_partial_sum(_IIter __begin, _IIter __end,
                                       _OutputIterator __result,
                                       _BinaryOperation __bin_op)

okay so bestie, this is the parallel partial sum — front to __end, and it's giving "prefix sums but make it multithreaded" ✨

Parameters

__begin — begin iterator of input sequence 💖
__end — end iterator of input sequence
__result — begin iterator of output sequence
__bin_op — associative binary function (yes it gotta be associative, no cap)

Returns End iterator of output sequence 🎀

References: __parallel_partial_sum_linear(), _GLIBCXX_CALL, and __gnu_parallel::_Settings::get().

🧚 `__parallel_partial_sum_basecase`

template<typename _IIter, typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
__gnu_parallel::__parallel_partial_sum_basecase(_IIter __begin, _IIter __end,
                                                _OutputIterator __result,
                                                _BinaryOperation __bin_op,
                                                typename std::iterator_traits<_IIter>::value_type __value)

the base case prefix sum routine, lowkey the little worker bee of the whole thing 🐝

Parameters

__begin — begin iterator of input sequence
__end — end iterator of input sequence
__result — begin iterator of output sequence
__bin_op — associative binary function
__value — start value. Must be passed since the neutral element is unknown in general 🙈 (like, we literally can't guess it for you)

Returns End iterator of output sequence 💫

Referenced by __parallel_partial_sum_linear().

🌸 `__parallel_partial_sum_linear`

template<typename _IIter, typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
__gnu_parallel::__parallel_partial_sum_linear(_IIter __begin, _IIter __end,
                                              _OutputIterator __result,
                                              _BinaryOperation __bin_op,
                                              typename std::iterator_traits<_IIter>::difference_type __n)

the parallel partial sum implementation — two-phase approach, no recursion 👑 it's giving "we do it in two passes and we don't call ourselves, periodt"

Parameters

__begin — begin iterator of input sequence
__end — end iterator of input sequence
__result — begin iterator of output sequence
__bin_op — associative binary function
__n — length of sequence 📏

Returns End iterator of output sequence ⭐

References: __equally_split(), __parallel_partial_sum_basecase(), __gnu_parallel::_Settings::get(), and __gnu_parallel::_Settings::partial_sum_dilation.

Referenced by __parallel_partial_sum().

🦋 `__parallel_partition`

template<typename _RAIter, typename _Predicate>
std::iterator_traits<_RAIter>::difference_type
__gnu_parallel::__parallel_partition(_RAIter __begin, _RAIter __end,
                                     _Predicate __pred,
                                     _ThreadIndex __num_threads)

the parallel implementation of std::partition — splitting the crowd into "yass" and "nah" 💅

Parameters

__begin — begin iterator of input sequence to split
__end — end iterator of input sequence to split
__pred — partition predicate, possibly including some kind of pivot 🎯
__num_threads — maximum number of threads to use for this task

Returns Number of elements not fulfilling the predicate (so like, count of the leftovers) 💀

References: __compare_and_swap(), __fetch_and_add(), _GLIBCXX_CALL, _GLIBCXX_VOLATILE, __gnu_parallel::_Settings::get(), __gnu_parallel::_Settings::partition_chunk_share, and __gnu_parallel::_Settings::partition_chunk_size.

Referenced by __parallel_nth_element(), __parallel_sort_qs_divide(), and __qsb_divide().

🎀 `__parallel_random_shuffle`

template<typename _RAIter, typename _RandomNumberGenerator>
void
__gnu_parallel::__parallel_random_shuffle(_RAIter __begin, _RAIter __end,
                                          _RandomNumberGenerator __rng = _RandomNumber())  // [inline]

the parallel random public call — this is the one you actually call, bestie, it's the front door 🚪✨

Parameters

__begin — begin iterator of sequence
__end — end iterator of sequence
__rng — random number generator to use (defaults to _RandomNumber())

References: __parallel_random_shuffle_drs().

🔥 `__parallel_random_shuffle_drs`

template<typename _RAIter, typename _RandomNumberGenerator>
void
__gnu_parallel::__parallel_random_shuffle_drs(_RAIter __begin, _RAIter __end,
                                              typename std::iterator_traits<_RAIter>::difference_type __n,
                                              _ThreadIndex __num_threads,
                                              _RandomNumberGenerator &__rng)

the main parallel random shuffle step — the real main-character energy of this shuffle situation 👑

Parameters

__begin — begin iterator of sequence
__end — end iterator of sequence
__n — length of sequence
__num_threads — number of threads to use
__rng — random number generator to use

References:

__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::__bins_end
__parallel_random_shuffle_drs_pu()
__rd_log2()
__round_up_to_pow2()
__sequential_random_shuffle()
_GLIBCXX_CALL
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_bin_proc
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_bins_begin
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_dist
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_num_bins
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_num_bits
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_num_threads
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_sd
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_seed
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_starts
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_temporaries
__gnu_parallel::_Settings::get()
__gnu_parallel::_Settings::L2_cache_size
std::min()
__gnu_parallel::_Settings::TLB_size

Referenced by __parallel_random_shuffle().

💜 `__parallel_random_shuffle_drs_pu`

template<typename _RAIter, typename _RandomNumberGenerator>
void
__gnu_parallel::__parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter, _RandomNumberGenerator> *__pus)

the random shuffle code executed by each thread — like, every thread grabs its own lil to-do list and vibes 🧚

Parameters

__pus — array of thread-local data records

References:

__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::__bins_end
__random_number_pow2()
__sequential_random_shuffle()
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_bin_proc
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_bins_begin
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_dist
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_num_bins
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_num_bits
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_num_threads
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_sd
__gnu_parallel::_DRSSorterPU<_RAIter, _RandomNumberGenerator>::_M_seed
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_source
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_starts
__gnu_parallel::_DRandomShufflingGlobalData<_RAIter>::_M_temporaries
std::partial_sum()

Referenced by __parallel_random_shuffle_drs().

🌈 `__parallel_sort` — the overload era

bestie, there are seven overloads of this and they're all just picking a different sorting algorithm based on the tag you hand them. same params, same template param, different vibe check on __parallelism 🫶

Every single one of them takes:

__begin — begin iterator of input sequence
__end — end iterator of input sequence
__comp — comparator

and has the template parameter:

__stable — sort stable

`__parallel_sort` with `balanced_quicksort_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                balanced_quicksort_tag __parallelism)  // [inline]

Choose balanced quicksort for parallel sorting. 🔥 balanced = the responsible quicksort, fr fr.

References: __gnu_parallel::parallel_tag::__get_num_threads(), __parallel_sort_qsb(), and _GLIBCXX_CALL.

`__parallel_sort` with `default_parallel_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                default_parallel_tag __parallelism)  // [inline]

Choose multiway mergesort with exact splitting, for parallel sorting. the default default, iconic ✨

References: __gnu_parallel::parallel_tag::__get_num_threads(), and _GLIBCXX_CALL.

`__parallel_sort` with `multiway_mergesort_exact_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                multiway_mergesort_exact_tag __parallelism)  // [inline]

Choose multiway mergesort with exact splitting, for parallel sorting. yes it's the same description as above, that's literally what the page says, don't come for me 💀

References: __gnu_parallel::parallel_tag::__get_num_threads(), and _GLIBCXX_CALL.

`__parallel_sort` with `multiway_mergesort_sampling_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                multiway_mergesort_sampling_tag __parallelism)  // [inline]

Choose multiway mergesort with splitting by sampling, for parallel sorting. sampling the data first, very "let me get a feel for the crowd" 🎀

References: __gnu_parallel::parallel_tag::__get_num_threads(), and _GLIBCXX_CALL.

`__parallel_sort` with `multiway_mergesort_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                multiway_mergesort_tag __parallelism)  // [inline]

Choose multiway mergesort, splitting variant at run-time, for parallel sorting. so it decides the splitting situation live — main character improvisation 💅

References: __gnu_parallel::parallel_tag::__get_num_threads(), _GLIBCXX_CALL, and __gnu_parallel::_Settings::get().

`__parallel_sort` with `parallel_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                parallel_tag __parallelism)  // [inline]

Choose a parallel sorting algorithm. just, like, one of them. the algorithm chooses its own destiny 🦋

References: __gnu_parallel::parallel_tag::__get_num_threads(), __parallel_sort_qs(), __parallel_sort_qsb(), _GLIBCXX_CALL, and __gnu_parallel::_Settings::get().

`__parallel_sort` with `quicksort_tag`

template<bool __stable, typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort(_RAIter __begin, _RAIter __end,
                                _Compare __comp,
                                quicksort_tag __parallelism)  // [inline]

Choose quicksort for parallel sorting. the classic, the legend, the one everybody knows ⭐

References: __gnu_parallel::parallel_tag::__get_num_threads(), __parallel_sort_qs(), and _GLIBCXX_CALL.

⚡ `__parallel_sort_qs`

template<typename _RAIter, typename _Compare>
void
__gnu_parallel::__parallel_sort_qs(_RAIter __begin, _RAIter __end,
                                   _Compare __comp,
                                   _ThreadIndex __num_threads)

the unbalanced quicksort main call — no balancing, all chaos, still slaps 🔥

Parameters

__begin — begin iterator of input sequence
__end — end iterator input sequence, ignored 🙈 (yes, literally ignored, that's what it says)
__comp — comparator
__num_threads — number of threads that are allowed to work on this part

References: __parallel_sort_qs_conquer(), and _GLIBCXX_CALL.

🌀 `__parallel_sort_qs_conquer`

template<typename _RAIter , typename _Compare > void
__gnu_parallel::__parallel_sort_qs_conquer (_RAIter __begin, _RAIter __end,
    _Compare __comp, _ThreadIndex __num_threads)

Unbalanced quicksort conquer step ✨ — literally the part where it goes and actually sorts the pieces.

Parameters

__begin — begin iterator of subsequence.
__end — end iterator of subsequence.
__comp — comparator.
__num_threads — number of threads that are allowed to work on this part.

References: __parallel_sort_qs_conquer(), __parallel_sort_qs_divide(), and __gnu_parallel::_Settings::get().

Referenced by: __parallel_sort_qs(), and __parallel_sort_qs_conquer().

🌀 `__parallel_sort_qs_divide`

template<typename _RAIter , typename _Compare > std::iterator_traits<
    _RAIter >::difference_type __gnu_parallel::__parallel_sort_qs_divide
    (_RAIter __begin, _RAIter __end, _Compare __comp,
     typename std::iterator_traits< _RAIter >::difference_type __pivot_rank,
     typename std::iterator_traits< _RAIter >::difference_type __num_samples,
     _ThreadIndex __num_threads)

Unbalanced quicksort divide step 💅 the part that picks the pivot and splits everything up.

Parameters

__begin — begin iterator of subsequence.
__end — end iterator of subsequence.
__comp — comparator.
__pivot_rank — desired __rank of the pivot.
__num_samples — choose pivot from that many samples.
__num_threads — number of threads that are allowed to work on this part.

References: __parallel_partition(), and std::min().

Referenced by: __parallel_sort_qs_conquer().

🌀 `__parallel_sort_qsb`

template<typename _RAIter , typename _Compare > void
__gnu_parallel::__parallel_sort_qsb (_RAIter __begin, _RAIter __end,
    _Compare __comp, _ThreadIndex __num_threads)

Top-level quicksort routine 👑 the main character of the quicksort situation, no cap.

Parameters

__begin — begin iterator of sequence.
__end — end iterator of sequence.
__comp — comparator.
__num_threads — number of threads that are allowed to work on this part.

References: __qsb_conquer(), __rd_log2(), _GLIBCXX_CALL, and __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_elements_leftover.

Referenced by: __parallel_sort(), and __parallel_sort().

🦋 `__parallel_unique_copy` (the no-predicate one)

template<typename _IIter , class _OutputIterator > _OutputIterator
__gnu_parallel::__parallel_unique_copy (_IIter __first, _IIter __last,
    _OutputIterator __result) [inline]

Parallel std::unique_copy(), without explicit equality predicate 🌸 — like, it just assumes == and vibes.

Parameters

__first — begin iterator of input sequence.
__last — end iterator of input sequence.
__result — begin iterator of result __sequence.

Returns: end iterator of result __sequence.

References: __parallel_unique_copy().

🦋 `__parallel_unique_copy` (the one with a predicate)

template<typename _IIter , class _OutputIterator , class _BinaryPredicate >
_OutputIterator __gnu_parallel::__parallel_unique_copy (_IIter __first,
    _IIter __last, _OutputIterator __result, _BinaryPredicate __binary_pred)

Parallel std::unique_copy(), w/__o explicit equality predicate 💖 — yes bestie, you get to bring your own "are these the same" rules. (That w/__o is exactly how the original spells it, iconic typo energy, we keep it fr.)

Parameters

__first — begin iterator of input sequence.
__last — end iterator of input sequence.
__result — begin iterator of result __sequence.
__binary_pred — equality predicate.

Returns: end iterator of result __sequence.

References: __equally_split(), and _GLIBCXX_CALL.

Referenced by: __parallel_unique_copy().

🎀 `__qsb_conquer`

template<typename _RAIter , typename _Compare > void
__gnu_parallel::__qsb_conquer (_QSBThreadLocal< _RAIter > ** __tls,
    _RAIter __begin, _RAIter __end, _Compare __comp, _ThreadIndex __iam,
    _ThreadIndex __num_threads, bool __parent_wait)

Quicksort conquer step ⭐ the balanced-quicksort version, doing its little recursion thing.

Parameters

__tls — array of thread-local storages.
__begin — begin iterator of subsequence.
__end — end iterator of subsequence.
__comp — comparator.
__iam — number of the thread processing this function.
__num_threads — number of threads that are allowed to work on this part.

References: __qsb_conquer(), __qsb_divide(), __qsb_local_sort_with_helping(), __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_elements_leftover, and __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_initial.

Referenced by: __parallel_sort_qsb(), and __qsb_conquer().

🎀 `__qsb_divide`

template<typename _RAIter , typename _Compare > std::iterator_traits<
    _RAIter >::difference_type __gnu_parallel::__qsb_divide (_RAIter __begin,
    _RAIter __end, _Compare __comp, _ThreadIndex __num_threads)

Balanced quicksort divide step 🧚 the split-up bit, but make it balanced.

Parameters

__begin — begin iterator of subsequence.
__end — end iterator of subsequence.
__comp — comparator.
__num_threads — number of threads that are allowed to work on this part.

Precondition: (__end-__begin)>=1 ⚠️ — like, there has to be at least one element in there, bestie, don't play.

References: __median_of_three_iterators(), and __parallel_partition().

Referenced by: __qsb_conquer().

🎀 `__qsb_local_sort_with_helping`

template<typename _RAIter , typename _Compare > void
__gnu_parallel::__qsb_local_sort_with_helping (_QSBThreadLocal< _RAIter >
    ** __tls, _Compare & __comp, _ThreadIndex __iam, bool __wait)

Quicksort step doing load-balanced local sort 🔥 — the name literally says "with helping", it's giving teamwork, it's giving community.

Parameters

__tls — array of thread-local storages.
__comp — comparator.
__iam — number of the thread processing this function.

References: __yield(), _GLIBCXX_PARALLEL_ASSERTIONS, __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_elements_leftover, __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_initial, __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_leftover_parts, __gnu_parallel::_QSBThreadLocal< _RAIter >::_M_num_threads, __gnu_parallel::_Settings::get(), and __gnu_parallel::_Settings::sort_qsb_base_case_maximal_n.

Referenced by: __qsb_conquer().

🌈 `__random_number_pow2`

template<typename _RandomNumberGenerator > int
__gnu_parallel::__random_number_pow2 (int __logp, _RandomNumberGenerator &
    __rng) [inline]

Generate a random number in [0,2^__logp) 🎲 — cute little power-of-two-bounded random, so tidy.

Parameters

__logp — logarithm (basis 2) of the upper range __bound.
__rng — random number generator to use.

Referenced by: __parallel_random_shuffle_drs_pu(), and __sequential_random_shuffle().

🌈 `__rd_log2`

template<typename _Size > _Size __gnu_parallel::__rd_log2 (_Size __n)
    [inline]

Calculates the rounded-down logarithm of __n for base 2 ✨ — floor energy only, we don't round up around here.

Parameters

__n — argument.

Returns: returns 0 for any argument <1 💀 yes, even then. Zero. That's the rule.

Referenced by: __gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_LoserTreeBase(), __parallel_random_shuffle_drs(), __parallel_sort_qsb(), __round_up_to_pow2(), __sequential_random_shuffle(), multiseq_partition(), and multiseq_selection().

🌈 `__round_up_to_pow2`

template<typename _Tp > _Tp __gnu_parallel::__round_up_to_pow2 (_Tp __x)

Round up to the next greater power of 2 💫 — glow-up your integer, basically.

Parameters

__x — _Integer to round up.

References: __rd_log2().

Referenced by: __parallel_random_shuffle_drs(), __sequential_random_shuffle(), and multiseq_selection().

🫶 `__search_template`

template<typename __RAIter1 , typename __RAIter2 , typename _Pred >
__RAIter1 __gnu_parallel::__search_template (__RAIter1 __begin1,
    __RAIter1 __end1, __RAIter2 __begin2, __RAIter2 __end2, _Pred __pred)

Parallel std::search 🔍 — the "where is this thing inside this other thing" situation, but make it threaded.

Parameters

__begin1 — begin iterator of first sequence.
__end1 — end iterator of first sequence.
__begin2 — begin iterator of second sequence.
__end2 — end iterator of second sequence.
__pred — find predicate.

Returns: place of finding in first sequences 🌸 (yes, "sequences" plural, that's the original wording, we keep it).

References: __calc_borders(), __equally_split(), _GLIBCXX_CALL, and std::min().

🍓 `__sequential_multiway_merge`

template<bool __stable, bool __sentinels, typename _RAIterIterator ,
    typename _RAIter3 , typename _DifferenceTp , typename _Compare >
_RAIter3 __gnu_parallel::__sequential_multiway_merge (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, const
    typename std::iterator_traits< typename std::iterator_traits<
    _RAIterIterator >::value_type::first_type >::value_type & __sentinel,
    _DifferenceTp __length, _Compare __comp)

Sequential multi-way merging switch 🎀 The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and runtime settings — so like, it decides stuff based on vibes (the branching factor) and the actual settings, iykyk.

Parameters

__seqs_begin — begin iterator of iterator pair input sequence.
__seqs_end — end iterator of iterator pair input sequence.
__target — begin iterator of output sequence.
__comp — comparator.
__length — maximum length to merge, possibly larger than the number of elements available.
__sentinel — the sequences have __a __sentinel element.

Returns: end iterator of output sequence.

References: __is_sorted(), __merge_advance(), _GLIBCXX_CALL, and _GLIBCXX_PARALLEL_LENGTH.

Referenced by: multiway_merge(), and multiway_merge_sentinels().

🍓 `__sequential_random_shuffle`

template<typename _RAIter , typename _RandomNumberGenerator > void
__gnu_parallel::__sequential_random_shuffle (_RAIter __begin, _RAIter __end,
    _RandomNumberGenerator & __rng)

Sequential cache-efficient random shuffle 🦋 — shuffling that's nice to your cache, we love a thoughtful icon.

Parameters

__begin — begin iterator of sequence.
__end — end iterator of sequence.
__rng — random number generator to use.

References: __random_number_pow2(), __rd_log2(), __round_up_to_pow2(), __sequential_random_shuffle(), __gnu_parallel::_Settings::get(), __gnu_parallel::_Settings::L2_cache_size, std::min(), std::partial_sum(), and __gnu_parallel::_Settings::TLB_size.

Referenced by: __parallel_random_shuffle_drs(), __parallel_random_shuffle_drs_pu(), and __sequential_random_shuffle().

💜 `__shrink`

template<typename _IIter > void __gnu_parallel::__shrink (std::vector<
    _IIter > & __os_starts, size_t & __count_to_two, size_t &
    __range_length)

Combines two ranges into one and thus halves the number of ranges 🔥 — like merging two group chats into one, except it's ranges.

Parameters

__os_starts — start positions worked on (oversampled).
__count_to_two — counts up to 2.
__range_length — current length of a chunk.

References: std::vector< _Tp, _Alloc >::size().

Referenced by: __shrink_and_double().

💜 `__shrink_and_double`

template<typename _IIter > void __gnu_parallel::__shrink_and_double
    (std::vector< _IIter > & __os_starts, size_t & __count_to_two, size_t &
    __range_length, const bool __make_twice)

Shrinks and doubles the ranges 😭 yes both, it shrinks and doubles, don't ask, it's a whole thing.

Parameters

__os_starts — start positions worked on (oversampled).
__count_to_two — counts up to 2.
__range_length — current length of a chunk.
__make_twice — whether the __os_starts is allowed to be grown or not.

References: __shrink(), std::vector< _Tp, _Alloc >::resize(), and std::vector< _Tp, _Alloc >::size().

Referenced by: list_partition().

💜 `__yield`

void __gnu_parallel::__yield () [inline]

Yield control to another thread, without waiting for the end of the time slice 🙈 — literally "here bestie, you go, I'm not gonna sit here hogging the whole slice."

Referenced by: __for_each_template_random_access_workstealing(), and __qsb_local_sort_with_helping().

🌟 `list_partition`

template<typename _IIter , typename _FunctorType > size_t
__gnu_parallel::list_partition (const _IIter __begin, const _IIter __end,
    _IIter * __starts, size_t * __lengths, const int __num_parts,
    _FunctorType & __f, int __oversampling = 0)

Splits a sequence given by input iterators into parts of almost equal size 💖 The function needs only one pass over the sequence — one pass! iconic efficiency, we stan.

Parameters

__begin — begin iterator of the input sequence, bestie. Like, where the vibe starts ✨
__end — end iterator of the input sequence. The finish line 🎀
__starts — the start iterators for the resulting parts, and it's dimension __num_parts+1. Convenience slay: __starts [__num_parts] literally contains the end iterator of the sequence for you 💅
__lengths — the length of each resulting part.
__num_parts — how many parts you want the sequence split into, no cap.
__f — functor to be applied to each element by traversing __it
__oversampling — the oversampling factor, and this one's got lore 🙈. If it's 0, then the partitions will differ in at most $t{thrm{end} - thrm{begin}}$ elements. Otherwise, the ratio between the longest and the shortest part is bounded by $1/(thrm{oversampling}

Returns

Length of the whole sequence. That's it, that's the return 💖

References

__shrink_and_double(), and std::vector< _Tp, _Alloc >::size().

template<typename _Tp > const _Tp & __gnu_parallel::max (const _Tp & __a,
    const _Tp & __b) [inline]

Equivalent to std::max. Same energy, different namespace, iykyk 🌸

template<typename _Tp > const _Tp & __gnu_parallel::min (const _Tp & __a,
    const _Tp & __b) [inline]

Equivalent to std::min. Iconic. No notes 👑

Referenced by __for_each_template_random_access_workstealing().

template<typename _RanSeqs , typename _RankType , typename _RankIterator ,
    typename _Compare > void __gnu_parallel::multiseq_partition (_RanSeqs
    __begin_seqs, _RanSeqs __end_seqs, _RankType __rank, _RankIterator
    __begin_offsets, _Compare __comp = std::less< typename
    std::iterator_traits<typename
    std::iterator_traits<_RanSeqs>::value_type:: first_type>::value_type>())

Okay so this one splits several sorted sequences at a certain global __rank, and the result is a splitting point for each sequence 🔥. The sequences get passed in via a sequence of random-access iterator pairs, and — important — none of the sequences may be empty. Empty sequences are not invited to this party 💀

If there are several equal elements across the split, the ones on the __left side will be chosen from sequences with smaller number. Periodt.

Parameters

__begin_seqs — begin of the sequence of iterator pairs.
__end_seqs — end of the sequence of iterator pairs.
__rank — the global rank to partition at.
__begin_offsets — a random-access __sequence __begin where the __result will be stored in. Each element of the sequence is an iterator that points to the first element on the greater part of the respective __sequence. Cute, right? 🦋
__comp — the ordering functor, defaults to std::less<_Tp>.

References

__rd_log2(), _GLIBCXX_CALL, std::distance(), std::priority_queue< _Tp, _Sequence, _Compare >::empty(), std::max(), std::min(), std::priority_queue< _Tp, _Sequence, _Compare >::pop(), std::priority_queue< _Tp, _Sequence, _Compare >::push(), and std::priority_queue< _Tp, _Sequence, _Compare >::top().

Referenced by multiway_merge_exact_splitting().

template<typename _Tp , typename _RanSeqs , typename _RankType , typename
    _Compare > _Tp __gnu_parallel::multiseq_selection (_RanSeqs
    __begin_seqs, _RanSeqs __end_seqs, _RankType __rank, _RankType &
    __offset, _Compare __comp = std::less<_Tp>())

This one selects the element at a certain global __rank from several sorted sequences 🎯. Same deal as before: the sequences get passed via a sequence of random-access iterator pairs, and none of the sequences may be empty. Non-negotiable 💅

Parameters

__begin_seqs — begin of the sequence of iterator pairs.
__end_seqs — end of the sequence of iterator pairs.
__rank — the global rank to partition at.
__offset — the rank of the selected element in the global subsequence of elements equal to the selected element. If the selected element is unique, this number is 0. Lowkey the most useful little detail here 🫶
__comp — the ordering functor, defaults to std::less.

References

__rd_log2(), __round_up_to_pow2(), _GLIBCXX_CALL, std::distance(), std::priority_queue< _Tp, _Sequence, _Compare >::empty(), std::max(), std::min(), std::priority_queue< _Tp, _Sequence, _Compare >::pop(), std::priority_queue< _Tp, _Sequence, _Compare >::push(), and std::priority_queue< _Tp, _Sequence, _Compare >::top().

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    __gnu_parallel::multiway_merge (_RAIterPairIterator __seqs_begin,
    _RAIterPairIterator __seqs_end, _RAIterOut __target, _DifferenceTp
    __length, _Compare __comp, __gnu_parallel::sequential_tag)

Multiway Merge Frontend ✨ — the main character of this whole section, honestly. Merge the sequences specified by seqs_begin and __seqs_end into __target.

__seqs_begin and __seqs_end must point to a sequence of pairs. These pairs must contain an iterator to the beginning of a sequence in their first entry and an iterator the _M_end of the same sequence in their second entry. That's the whole contract, bestie 🎀

Ties are broken arbitrarily. See stable_multiway_merge for a variant that breaks ties by sequence number but is slower. Trade-offs, always trade-offs 😭

The first entries of the pairs (i.e. the begin iterators) will be moved forward. Heads up 👀

The output sequence has to provide enough space for all elements that are written to it. No, like, seriously — give it space.

This function will merge the input sequences:

not stable
parallel, depending on the input size and Settings
using sampling for splitting
not using sentinels

Example

int sequences[10][10];
for (int __i = 0; __i < 10; ++__i)
  for (int __j = 0; __i < 10; ++__j)
    sequences[__i][__j] = __j;

int __out[33];
std::vector<std::pair<int*> > seqs;
for (int __i = 0; __i < 10; ++__i)
  { seqs.push(std::make_pair<int*>(sequences[__i],
                                   sequences[__i] + 10)) }

multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);

See also: stable_multiway_merge

Precondition

All input sequences must be sorted. Fr fr, do not skip this 💀
Target must provide enough space to merge out length elements or the number of elements in all sequences, whichever is smaller.

Postcondition

[__target, return __value) contains merged __elements from the input sequences.
return __value - __target = min(__length, number of elements in all sequences).

Template Parameters

_RAIterPairIterator — iterator over sequence of pairs of iterators
_RAIterOut — iterator over target sequence
_DifferenceTp — difference type for the sequence
_Compare — strict weak ordering type to compare elements in sequences

Parameters

__seqs_begin — __begin of sequence __sequence
__seqs_end — _M_end of sequence __sequence
__target — target sequence to merge to.
__comp — strict weak ordering to use for element comparison.
__length — maximum length to merge, possibly larger than the number of elements available. She's flexible like that 💅

Returns

_M_end iterator of output sequence 🦋

References

__sequential_multiway_merge(), and _GLIBCXX_CALL.

template<template< typename _RAI, typename _Cp > class iterator, typename
    _RAIterIterator , typename _RAIter3 , typename _DifferenceTp , typename
    _Compare > _RAIter3 __gnu_parallel::multiway_merge_3_variant
    (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3
    __target, _DifferenceTp __length, _Compare __comp)

Highly efficient 3-way merging procedure 🔥🔥🔥

Merging is done with the algorithm implementation described by Peter Sanders. Basically, the idea is to minimize the number of necessary comparison after merging an element. The implementation trick that makes this fast is that the order of the sequences is stored in the instruction pointer (translated into labels in C++). Like, that's genuinely unhinged and I'm obsessed 😭

This works well for merging up to 4 sequences.

Note that making the merging stable does not come at a performance hit. Free stability, we love to see it 👑

Whether the merging is done guarded or unguarded is selected by the used iterator class.

Parameters

__seqs_begin — begin iterator of iterator pair input sequence.
__seqs_end — end iterator of iterator pair input sequence.
__target — begin iterator of output sequence.
__comp — comparator.
__length — maximum length to merge, less equal than the total number of elements available.

Returns

End iterator of output sequence.

References

_GLIBCXX_CALL.

template<template< typename _RAI, typename _Cp > class iterator, typename
    _RAIterIterator , typename _RAIter3 , typename _DifferenceTp , typename
    _Compare > _RAIter3 __gnu_parallel::multiway_merge_4_variant
    (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3
    __target, _DifferenceTp __length, _Compare __comp)

Highly efficient 4-way merging procedure ✨ same icon behaviour, one more lane 🚗

Merging is done with the algorithm implementation described by Peter Sanders. Basically, the idea is to minimize the number of necessary comparison after merging an element. The implementation trick that makes this fast is that the order of the sequences is stored in the instruction pointer (translated into goto labels in C++). Yes goto. Yes it's still fast. Don't @ me 🙈

This works well for merging up to 4 sequences.

Note that making the merging stable does not come at a performance hit.

Whether the merging is done guarded or unguarded is selected by the used iterator class.

Parameters

__seqs_begin — begin iterator of iterator pair input sequence.
__seqs_end — end iterator of iterator pair input sequence.
__target — begin iterator of output sequence.
__comp — comparator.
__length — maximum length to merge, less equal than the total number of elements available.

Returns

End iterator of output sequence.

References

_GLIBCXX_CALL.

template<bool __stable, typename _RAIterIterator , typename _Compare ,
    typename _DifferenceType > void
    __gnu_parallel::multiway_merge_exact_splitting (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _DifferenceType __length,
    _DifferenceType __total_length, _Compare __comp, std::vector< std::pair<
    _DifferenceType, _DifferenceType > > * __pieces)

Exact splitting for parallel multiway-merge routine 🎯. None of the passed sequences may be empty — say it with me, none of them 🫶

References

__equally_split(), _GLIBCXX_PARALLEL_LENGTH, std::vector< _Tp, _Alloc >::begin(), std::vector< _Tp, _Alloc >::end(), multiseq_partition(), and std::vector< _Tp, _Alloc >::resize().

Referenced by __parallel_merge_advance().

template<typename _LT , typename _RAIterIterator , typename _RAIter3 ,
    typename _DifferenceTp , typename _Compare > _RAIter3
    __gnu_parallel::multiway_merge_loser_tree (_RAIterIterator __seqs_begin,
    _RAIterIterator __seqs_end, _RAIter3 __target, _DifferenceTp __length,
    _Compare __comp)

Multi-way merging procedure for a high branching factor, guarded case 💜. This merging variant uses a LoserTree class as selected by _LT.

Stability is selected through the used LoserTree class _LT.

At least one non-empty sequence is required. Just one! Low bar! Clear it! 🌈

Parameters

__seqs_begin — begin iterator of iterator pair input sequence.
__seqs_end — end iterator of iterator pair input sequence.
__target — begin iterator of output sequence.
__comp — comparator.
__length — maximum length to merge, less equal than the total number of elements available.

Returns: end iterator of the output sequence. 💫

References _GLIBCXX_CALL, and _GLIBCXX_PARALLEL_LENGTH.

template<typename _UnguardedLoserTree , typename _RAIterIterator , typename
    _RAIter3 , typename _DifferenceTp , typename _Compare > _RAIter3
    __gnu_parallel::multiway_merge_loser_tree_sentinel (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, const
    typename std::iterator_traits< typename std::iterator_traits<
    _RAIterIterator >::value_type::first_type >::value_type & __sentinel,
    _DifferenceTp __length, _Compare __comp)

Okay so this one is the multi-way merging procedure for a high branching factor — but like, the ✨sentinel edition✨. It requires sentinels to exist. No sentinel, no merge, that's the vibe check. 🫶

Template Parameters

_UnguardedLoserTree — the Loser Tree variant to use for the unguarded merging. (yes the name is iconic, we don't question it 💀)

Parameters

__seqs_begin — begin iterator of the iterator-pair input sequence.
__seqs_end — end iterator of the iterator-pair input sequence.
__target — begin iterator of the output sequence.
__comp — the comparator.
__length — maximum length to merge, less than or equal to the total number of elements available. Don't get greedy bestie.

Returns

End iterator of the output sequence. 💫

References

__is_sorted(), and _GLIBCXX_CALL.

template<typename _LT , typename _RAIterIterator , typename _RAIter3 ,
    typename _DifferenceTp , typename _Compare > _RAIter3
    __gnu_parallel::multiway_merge_loser_tree_unguarded (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _RAIter3 __target, const
    typename std::iterator_traits< typename std::iterator_traits<
    _RAIterIterator >::value_type::first_type >::value_type & __sentinel,
    _DifferenceTp __length, _Compare __comp)

Multi-way merging procedure for a high branching factor, unguarded case. The merging is done using the LoserTree class _LT. And the stability situation? It's selected by whichever LoserTree you used — so like, your tree, your rules. 🌈

Precondition: no input will run out of elements during the merge. fr fr, none of them. This is the unguarded life, no safety net. 😭

Parameters

__seqs_begin — begin iterator of the iterator-pair input sequence.
__seqs_end — end iterator of the iterator-pair input sequence.
__target — begin iterator of the output sequence.
__comp — the comparator.
__length — maximum length to merge, less than or equal to the total number of elements available.

Returns

End iterator of the output sequence. 💫

References

_GLIBCXX_CALL.

template<bool __stable, typename _RAIterIterator , typename _Compare ,
    typename _DifferenceType > void
    __gnu_parallel::multiway_merge_sampling_splitting (_RAIterIterator
    __seqs_begin, _RAIterIterator __seqs_end, _DifferenceType __length,
    _DifferenceType __total_length, _Compare __comp, std::vector< std::pair<
    _DifferenceType, _DifferenceType > > * __pieces)

Sampling-based splitting for the parallel multiway-merge routine. Like, it literally samples stuff to figure out where to slice the work. Very main character energy for a splitting heuristic. 🎀

References

_GLIBCXX_PARALLEL_LENGTH, __gnu_parallel::_Settings::get(), and __gnu_parallel::_Settings::merge_oversampling.

template<typename _RAIterPairIterator , typename _RAIterOut , typename
    _DifferenceTp , typename _Compare > _RAIterOut
    __gnu_parallel::multiway_merge_sentinels (_RAIterPairIterator
    __seqs_begin, _RAIterPairIterator __seqs_end, _RAIterOut __target,
    _DifferenceTp __length, _Compare __comp, __gnu_parallel::sequential_tag)

Multiway Merge Frontend. 💅 Merge the sequences specified by __seqs_begin and __seqs_end into __target. __seqs_begin and __seqs_end must point to a sequence of pairs. These pairs must contain an iterator to the beginning of a sequence in their first entry, and an iterator to the _M_end of the same sequence in their second entry.

Ties are broken arbitrarily — no cap, it just picks one. 👀 If you want a variant that breaks ties by sequence number but is slower, see stable_multiway_merge.

The first entries of the pairs (i.e. the begin iterators) will be moved forward accordingly.

The output sequence has to provide enough space for all the elements written to it. Not a suggestion, bestie. 🫶

This function will merge the input sequences:

not stable 💀
parallel, depending on the input size and Settings
using sampling for splitting
using sentinels

You have to take care that the element the _M_end iterator points to is readable and contains a value that is greater than any other non-sentinel value in all sequences. That's the whole sentinel deal — it's the final boss value. 👑

Example:

int sequences[10][11];
for (int __i = 0; __i < 10; ++__i)
  for (int __j = 0; __i < 11; ++__j)
    sequences[__i][__j] = __j; // __last one is sentinel!

int __out[33];
std::vector<std::pair<int*> > seqs;
for (int __i = 0; __i < 10; ++__i)
  { seqs.push(std::make_pair<int*>(sequences[__i],
                                   sequences[__i] + 10)) }

multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);

Precondition: all input sequences must be sorted. Target must provide enough space to merge out length elements or the number of elements in all sequences, whichever is smaller. For each __i, __seqs_begin[__i].second must be the end marker of the sequence, but also reference the one more __sentinel element. ✨

Postcondition: [__target, return __value) contains merged __elements from the input sequences. And return __value - __target = min(__length, number of elements in all sequences).

See also: stable_multiway_merge_sentinels

Template Parameters

_RAIterPairIterator — iterator over sequence of pairs of iterators
_RAIterOut — iterator over target sequence
_DifferenceTp — difference type for the sequence
_Compare — strict weak ordering type to compare elements in sequences

Parameters

__seqs_begin — __begin of sequence __sequence
__seqs_end — _M_end of sequence __sequence
__target — target sequence to merge to.
__comp — strict weak ordering to use for element comparison.
__length — maximum length to merge, possibly larger than the number of elements available.

Returns

_M_end iterator of the output sequence. 💫

References

__sequential_multiway_merge(), and _GLIBCXX_CALL.

template<bool __stable, bool __sentinels, typename _RAIterIterator ,
    typename _RAIter3 , typename _DifferenceTp , typename _Splitter ,
    typename _Compare > _RAIter3 __gnu_parallel::parallel_multiway_merge
    (_RAIterIterator __seqs_begin, _RAIterIterator __seqs_end, _RAIter3
    __target, _Splitter __splitter, _DifferenceTp __length, _Compare __comp,
    _ThreadIndex __num_threads)

Parallel multi-way merge routine. The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and the runtime settings. 🌀

Must not be called if the number of sequences is 1. That's not a merge, that's just... a sequence. Do not. 🚫

Template Parameters

_Splitter — functor to split input (either __exact or sampling based)
__stable — stable merging incurs a performance penalty. (worth it sometimes, ngl)
__sentinel — ignored. (it's giving "we kept the parameter for the aesthetic" 🙈)

Parameters

__seqs_begin — begin iterator of the iterator-pair input sequence.
__seqs_end — end iterator of the iterator-pair input sequence.
__target — begin iterator of the output sequence.
__comp — the comparator.
__length — maximum length to merge, possibly larger than the number of elements available.

Returns

End iterator of the output sequence. 💫

References

__is_sorted(), _GLIBCXX_CALL, _GLIBCXX_PARALLEL_LENGTH, __gnu_parallel::_Settings::get(), and __gnu_parallel::_Settings::merge_oversampling.

Referenced by __parallel_merge_advance().

template<bool __stable, bool __exact, typename _RAIter , typename _Compare >
    void __gnu_parallel::parallel_sort_mwms (_RAIter __begin, _RAIter __end,
    _Compare __comp, _ThreadIndex __num_threads)

PMWMS main call. The big one. The main character. 👑 (PMWMS = parallel multiway merge sort, iykyk)

Parameters

__begin — begin iterator of sequence.
__end — end iterator of sequence.
__comp — comparator.
__num_threads — number of threads to use. 🧵

References

_GLIBCXX_CALL, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_num_threads, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_offsets, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_pieces, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_samples, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_source, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_starts, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_temporary, __gnu_parallel::_Settings::get(), and __gnu_parallel::_Settings::sort_mwms_oversampling.

template<bool __stable, bool __exact, typename _RAIter , typename _Compare >
    void __gnu_parallel::parallel_sort_mwms_pu (_PMWMSSortingData< _RAIter >
    * __sd, _Compare & __comp)

PMWMS code executed by each thread. Like, every thread gets this little job and they all vibe together. 🦋

Parameters

__sd — pointer to algorithm data.
__comp — comparator.

References

__gnu_parallel::_PMWMSSortingData< _RAIter >::_M_num_threads, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_pieces, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_source, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_starts, __gnu_parallel::_PMWMSSortingData< _RAIter >::_M_temporary, __gnu_parallel::_Settings::get(), __gnu_parallel::_Settings::sort_mwms_oversampling, and std::uninitialized_copy().

🧮 VARIABLE DOCUMENTATION 🧮

const int __gnu_parallel::_CASable_bits [static] — number of bits of _CASable. That's it, that's the variable. 🎀

Referenced by __decode2(), and __encode2().

const _CASable __gnu_parallel::_CASable_mask [static] — a _CASable with the right half of bits set to 1. 💅

Referenced by __decode2().

✍️ AUTHOR ✍️

Generated automatically by Doxygen for libstdc++ from the source code. Not a human, bestie — a robot wrote this whole thing while we were out here reading it. 🤖💀

And that's a wrap on the whole page! 🎉 This was __gnu_parallel(3cxx) from libstdc++, auto-generated by Doxygen straight from the source — so like, if you spot something cursed in here, blame the source code, not me. No cap, you just read the entire manual page, and honestly? Iconic. Go take a nap. 💖🎀🦋🌸✨

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms

__gnu_parallel(3cxx)

✨ NAME ✨

🌸 SYNOPSIS 🌸

💅 Classes

✨ Typedefs

🎀 Enumerations

✨ Functions ✨

the __parallel_sort glow-up squad 👑

the quicksort internals 🌀

tiny math + random helpers 🎀

search, merge-ish, and shuffle-adjacent 🌈

range-shrinking era 🦋

odds and ends 🍓

multiway_merge frontends 👑

the variant algorithms ✨

🧮 Variables

🌸 Detailed Description

🎀 Typedef Documentation

typedef unsigned short __gnu_parallel::_BinIndex

typedef int64_t __gnu_parallel::_CASable

typedef uint64_t __gnu_parallel::_SequenceIndex

typedef uint16_t __gnu_parallel::_ThreadIndex

🌈 Enumeration Type Documentation

enum __gnu_parallel::_AlgorithmStrategy

enum __gnu_parallel::_FindAlgorithm

enum __gnu_parallel::_MultiwayMergeAlgorithm

enum __gnu_parallel::_Parallelism

Enumerator

enum __gnu_parallel::_PartialSumAlgorithm

enum __gnu_parallel::_SortAlgorithm

enum __gnu_parallel::_SplittingAlgorithm

⭐ Function Documentation

template<typename _RAIter , typename _DifferenceTp > void __gnu_parallel::__calc_borders (_RAIter __elements, _DifferenceTp __length, _DifferenceTp * __off)

template<typename _Tp > bool __gnu_parallel::__compare_and_swap (volatile _Tp * __ptr, _Tp __comparand, _Tp __replacement) [inline]

void __gnu_parallel::__decode2 (_CASable __x, int & __a, int & __b) [inline]

🎀 __determine_samples — picking the samples, lowkey iconic

🌈 __encode2 — squish two ints into one, [inline]

🦋 __equally_split — slice it into (almost) equal parts, periodt

⭐ __equally_split_point — the single split point you asked for

🔥 __fetch_and_add — atomic add, [inline]

🧚 __find_template — parallel std::find, the switchboard edition, [inline]

🍓 __find_template — constant size blocks variant

🌸 __find_template — equal splitting variant

🎀 __find_template — growing blocks variant

👑 __for_each_template_random_access — pick your algorithm by tag

💜 __for_each_template_random_access_ed — embarrassingly parallel, hand-crafted

🌈 __for_each_template_random_access_omp_loop

🦋 __for_each_template_random_access_omp_loop_static

🔥 __for_each_template_random_access_workstealing

⭐ __is_sorted

🧚 __median_of_three_iterators

💜 __merge_advance

🌸 __merge_advance_movc

🎀 __merge_advance_usual

🌈 __parallel_merge_advance (first overload)

🫶 __parallel_merge_advance (second overload)

👑 __parallel_nth_element

💖 __parallel_partial_sort

🌊 __parallel_partial_sum

🧚 __parallel_partial_sum_basecase

🌸 __parallel_partial_sum_linear

🦋 __parallel_partition

🎀 __parallel_random_shuffle

🔥 __parallel_random_shuffle_drs

💜 __parallel_random_shuffle_drs_pu

🌈 __parallel_sort — the overload era

__parallel_sort with balanced_quicksort_tag

__parallel_sort with default_parallel_tag

__parallel_sort with multiway_mergesort_exact_tag

__parallel_sort with multiway_mergesort_sampling_tag

__parallel_sort with multiway_mergesort_tag

__parallel_sort with parallel_tag

__parallel_sort with quicksort_tag

⚡ __parallel_sort_qs

🌀 __parallel_sort_qs_conquer

🌀 __parallel_sort_qs_divide

🌀 __parallel_sort_qsb

🦋 __parallel_unique_copy (the no-predicate one)

🦋 __parallel_unique_copy (the one with a predicate)

🎀 __qsb_conquer

the `__parallel_sort` glow-up squad 👑

`typedef unsigned short __gnu_parallel::_BinIndex`

`typedef int64_t __gnu_parallel::_CASable`

`typedef uint64_t __gnu_parallel::_SequenceIndex`

`typedef uint16_t __gnu_parallel::_ThreadIndex`

`enum __gnu_parallel::_AlgorithmStrategy`

`enum __gnu_parallel::_FindAlgorithm`

`enum __gnu_parallel::_MultiwayMergeAlgorithm`

`enum __gnu_parallel::_Parallelism`

`enum __gnu_parallel::_PartialSumAlgorithm`

`enum __gnu_parallel::_SortAlgorithm`

`enum __gnu_parallel::_SplittingAlgorithm`

`template<typename _RAIter , typename _DifferenceTp > void __gnu_parallel::__calc_borders (_RAIter __elements, _DifferenceTp __length, _DifferenceTp * __off)`

`template<typename _Tp > bool __gnu_parallel::__compare_and_swap (volatile _Tp * __ptr, _Tp __comparand, _Tp __replacement) [inline]`

`void __gnu_parallel::__decode2 (_CASable x, int & a, int & __b) [inline]`

🎀 `__determine_samples` — picking the samples, lowkey iconic

🌈 `__encode2` — squish two ints into one, [inline]

🦋 `__equally_split` — slice it into (almost) equal parts, periodt

⭐ `__equally_split_point` — the single split point you asked for

🔥 `__fetch_and_add` — atomic add, [inline]

🧚 `__find_template` — parallel `std::find`, the switchboard edition, [inline]

🍓 `__find_template` — constant size blocks variant

🌸 `__find_template` — equal splitting variant

🎀 `__find_template` — growing blocks variant

👑 `__for_each_template_random_access` — pick your algorithm by tag

💜 `__for_each_template_random_access_ed` — embarrassingly parallel, hand-crafted

🌈 `__for_each_template_random_access_omp_loop`

🦋 `__for_each_template_random_access_omp_loop_static`

🔥 `__for_each_template_random_access_workstealing`

⭐ `__is_sorted`

🧚 `__median_of_three_iterators`

💜 `__merge_advance`

🌸 `__merge_advance_movc`

🎀 `__merge_advance_usual`

🌈 `__parallel_merge_advance` (first overload)

🫶 `__parallel_merge_advance` (second overload)

👑 `__parallel_nth_element`

💖 `__parallel_partial_sort`

🌊 `__parallel_partial_sum`

🧚 `__parallel_partial_sum_basecase`

🌸 `__parallel_partial_sum_linear`

🦋 `__parallel_partition`

🎀 `__parallel_random_shuffle`

🔥 `__parallel_random_shuffle_drs`

💜 `__parallel_random_shuffle_drs_pu`

🌈 `__parallel_sort` — the overload era

`__parallel_sort` with `balanced_quicksort_tag`

`__parallel_sort` with `default_parallel_tag`

`__parallel_sort` with `multiway_mergesort_exact_tag`

`__parallel_sort` with `multiway_mergesort_sampling_tag`

`__parallel_sort` with `multiway_mergesort_tag`

`__parallel_sort` with `parallel_tag`

`__parallel_sort` with `quicksort_tag`

⚡ `__parallel_sort_qs`

🌀 `__parallel_sort_qs_conquer`

🌀 `__parallel_sort_qs_divide`

🌀 `__parallel_sort_qsb`

🦋 `__parallel_unique_copy` (the no-predicate one)

🦋 `__parallel_unique_copy` (the one with a predicate)

🎀 `__qsb_conquer`

🎀 `__qsb_divide`

🎀 `__qsb_local_sort_with_helping`

🌈 `__random_number_pow2`

🌈 `__rd_log2`

🌈 `__round_up_to_pow2`

🫶 `__search_template`

🍓 `__sequential_multiway_merge`

🍓 `__sequential_random_shuffle`

💜 `__shrink`

💜 `__shrink_and_double`

💜 `__yield`

🌟 `list_partition`