@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/tlx/sort/strings/parallel_sample_sort.hpp

@@ -1,1647 +0,0 @@
-/*******************************************************************************
- * tlx/sort/strings/parallel_sample_sort.hpp
- *
- * Parallel Super Scalar String Sample Sort (pS5)
- *
- * See also Timo Bingmann, Andreas Eberle, and Peter Sanders. "Engineering
- * parallel string sorting." Algorithmica 77.1 (2017): 235-286.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2013-2019 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_SORT_STRINGS_PARALLEL_SAMPLE_SORT_HEADER
-#define TLX_SORT_STRINGS_PARALLEL_SAMPLE_SORT_HEADER
-
-#include <tlx/logger/core.hpp>
-#include <tlx/math/clz.hpp>
-#include <tlx/math/ctz.hpp>
-#include <tlx/meta/enable_if.hpp>
-#include <tlx/multi_timer.hpp>
-#include <tlx/simple_vector.hpp>
-#include <tlx/sort/strings/insertion_sort.hpp>
-#include <tlx/sort/strings/sample_sort_tools.hpp>
-#include <tlx/sort/strings/string_ptr.hpp>
-#include <tlx/thread_pool.hpp>
-#include <tlx/unused.hpp>
-#include <algorithm>
-#include <atomic>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <random>
-#include <vector>
-
-namespace tlx { namespace sort_strings_detail {
-
-class PS5SortStep;
-
-/******************************************************************************/
-//! Parallel Super Scalar String Sample Sort Parameter Struct
-
-class PS5ParametersDefault
-{
-public:
-    static const bool debug_steps = false;
-    static const bool debug_jobs = false;
-
-    static const bool debug_bucket_size = false;
-    static const bool debug_recursion = false;
-    static const bool debug_lcp = false;
-
-    static const bool debug_result = false;
-
-    //! enable/disable various sorting levels
-    static const bool enable_parallel_sample_sort = true;
-    static const bool enable_sequential_sample_sort = true;
-    static const bool enable_sequential_mkqs = true;
-
-    //! terminate sort after first parallel sample sort step
-    static const bool use_only_first_sortstep = false;
-
-    //! enable work freeing
-    static const bool enable_work_sharing = true;
-
-    //! whether the base sequential_threshold() on the remaining unsorted string
-    //! set or on the whole string set.
-    static const bool enable_rest_size = false;
-
-    //! key type for sample sort: 32-bit or 64-bit
-    typedef size_t key_type;
-
-    //! depth of classification tree used in sample sorts
-    static const unsigned TreeBits = 10;
-
-    //! classification tree variant for sample sorts
-    using Classify = SSClassifyTreeCalcUnrollInterleave<key_type, TreeBits>;
-
-    //! threshold to run sequential small sorts
-    static const size_t smallsort_threshold = 1024 * 1024;
-    //! threshold to switch to insertion sort
-    static const size_t inssort_threshold = 32;
-};
-
-/******************************************************************************/
-//! Parallel Super Scalar String Sample Sort Context
-
-template <typename Parameters>
-class PS5Context : public Parameters
-{
-public:
-    //! total size of input
-    size_t total_size;
-
-    //! number of remaining strings to sort
-    std::atomic<size_t> rest_size;
-
-    //! counters
-    std::atomic<size_t> para_ss_steps, sequ_ss_steps, base_sort_steps;
-
-    //! timers for individual sorting steps
-    MultiTimer mtimer;
-
-    //! number of threads overall
-    size_t num_threads;
-
-    //! thread pool
-    ThreadPool threads_;
-
-    //! context constructor
-    PS5Context(size_t _thread_num)
-        : para_ss_steps(0),
-          sequ_ss_steps(0),
-          base_sort_steps(0),
-          num_threads(_thread_num),
-          threads_(_thread_num)
-    {
-    }
-
-    //! enqueue a new job in the thread pool
-    template <typename StringPtr>
-    void enqueue(PS5SortStep* pstep, const StringPtr& strptr, size_t depth);
-
-    //! return sequential sorting threshold
-    size_t sequential_threshold()
-    {
-        size_t threshold = this->smallsort_threshold;
-        if (this->enable_rest_size)
-            return std::max(threshold, rest_size / num_threads);
-        return std::max(threshold, total_size / num_threads);
-    }
-
-    //! decrement number of unordered strings
-    void donesize(size_t n)
-    {
-        if (this->enable_rest_size)
-            rest_size -= n;
-    }
-};
-
-/******************************************************************************/
-//! LCP calculation of Splitter Strings
-
-template <typename KeyType>
-static inline unsigned char lcpKeyType(const KeyType& a, const KeyType& b)
-{
-    // XOR both values and count the number of zero bytes
-    return clz(a ^ b) / 8;
-}
-
-template <typename KeyType>
-static inline unsigned char lcpKeyDepth(const KeyType& a)
-{
-    // count number of non-zero bytes
-    return sizeof(KeyType) - (ctz(a) / 8);
-}
-
-//! return the d-th character in the (swapped) key
-template <typename KeyType>
-static inline unsigned char getCharAtDepth(const KeyType& a, unsigned char d)
-{
-    return static_cast<unsigned char>(a >> (8 * (sizeof(KeyType) - 1 - d)));
-}
-
-/******************************************************************************/
-//! PS5SortStep Top-Level Class to Keep Track of Substeps
-
-class PS5SortStep
-{
-private:
-    //! Number of substeps still running
-    std::atomic<size_t> substep_working_;
-
-    //! Pure virtual function called by substep when all substeps are done.
-    virtual void substep_all_done() = 0;
-
-protected:
-    PS5SortStep() : substep_working_(0)
-    {
-    }
-
-    ~PS5SortStep()
-    {
-        assert(substep_working_ == 0);
-    }
-
-    //! Register new substep
-    void substep_add()
-    {
-        ++substep_working_;
-    }
-
-public:
-    //! Notify superstep that the currently substep is done.
-    void substep_notify_done()
-    {
-        assert(substep_working_ > 0);
-        if (--substep_working_ == 0)
-            substep_all_done();
-    }
-};
-
-/******************************************************************************/
-//! LCP Calculation for Finished Sample Sort Steps
-
-template <size_t bktnum, typename Context, typename Classify,
-          typename StringPtr, typename BktSizeType>
-void ps5_sample_sort_lcp(const Context& ctx, const Classify& classifier,
-                         const StringPtr& strptr, size_t depth,
-                         const BktSizeType* bkt)
-{
-    assert(!strptr.flipped());
-
-    const typename StringPtr::StringSet& strset = strptr.active();
-    typedef typename Context::key_type key_type;
-
-    size_t b = 0;         // current bucket number
-    key_type prevkey = 0; // previous key
-
-    // the following while loops only check b < bktnum when b is odd,
-    // because bktnum is always odd. We need a goto to jump into the loop,
-    // as b == 0 start even.
-    goto even_first;
-
-    // find first non-empty bucket
-    while (b < bktnum)
-    {
-        // odd bucket: = bkt
-        if (bkt[b] != bkt[b + 1])
-        {
-            prevkey = classifier.get_splitter(b / 2);
-            assert(prevkey ==
-                   get_key_at<key_type>(strset, bkt[b + 1] - 1, depth));
-            break;
-        }
-        ++b;
-    even_first:
-        // even bucket: <, << or > bkt
-        if (bkt[b] != bkt[b + 1])
-        {
-            prevkey = get_key_at<key_type>(strset, bkt[b + 1] - 1, depth);
-            break;
-        }
-        ++b;
-    }
-    ++b;
-
-    // goto depends on whether the first non-empty bucket was odd or
-    // even. the while loop below encodes this in the program counter.
-    if (b < bktnum && b % 2 == 0)
-        goto even_bucket;
-
-    // find next non-empty bucket
-    while (b < bktnum)
-    {
-        // odd bucket: = bkt
-        if (bkt[b] != bkt[b + 1])
-        {
-            key_type thiskey = classifier.get_splitter(b / 2);
-            assert(thiskey == get_key_at<key_type>(strset, bkt[b], depth));
-
-            int rlcp = lcpKeyType(prevkey, thiskey);
-            strptr.set_lcp(bkt[b], depth + rlcp);
-            // strptr.set_cache(bkt[b], getCharAtDepth(thiskey, rlcp));
-
-            TLX_LOGC(ctx.debug_lcp) << "LCP at odd-bucket " << b << " ["
-                                    << bkt[b] << "," << bkt[b + 1] << ")"
-                                    << " is " << depth + rlcp;
-
-            prevkey = thiskey;
-            assert(prevkey ==
-                   get_key_at<key_type>(strset, bkt[b + 1] - 1, depth));
-        }
-        ++b;
-    even_bucket:
-        // even bucket: <, << or > bkt
-        if (bkt[b] != bkt[b + 1])
-        {
-            key_type thiskey = get_key_at<key_type>(strset, bkt[b], depth);
-
-            int rlcp = lcpKeyType(prevkey, thiskey);
-            strptr.set_lcp(bkt[b], depth + rlcp);
-            // strptr.set_cache(bkt[b], getCharAtDepth(thiskey, rlcp));
-
-            TLX_LOGC(ctx.debug_lcp) << "LCP at even-bucket " << b << " ["
-                                    << bkt[b] << "," << bkt[b + 1] << ")"
-                                    << " is " << depth + rlcp;
-
-            prevkey = get_key_at<key_type>(strset, bkt[b + 1] - 1, depth);
-        }
-        ++b;
-    }
-}
-
-/******************************************************************************/
-//! SampleSort: Non-Recursive In-Place Sequential Sample Sort for Small Sorts
-
-template <typename Context, typename StringPtr, typename BktSizeType>
-class PS5SmallsortJob : public PS5SortStep
-{
-public:
-    Context& ctx_;
-
-    //! parent sort step
-    PS5SortStep* pstep_;
-
-    StringPtr strptr_;
-    size_t depth_;
-    MultiTimer mtimer_;
-
-    typedef typename Context::key_type key_type;
-    typedef typename StringPtr::StringSet StringSet;
-    typedef BktSizeType bktsize_type;
-
-    PS5SmallsortJob(Context& ctx, PS5SortStep* pstep, const StringPtr& strptr,
-                    size_t depth)
-        : ctx_(ctx), pstep_(pstep), strptr_(strptr), depth_(depth)
-    {
-        TLX_LOGC(ctx_.debug_steps)
-            << "enqueue depth=" << depth_ << " size=" << strptr_.size()
-            << " flip=" << strptr_.flipped();
-    }
-
-    virtual ~PS5SmallsortJob()
-    {
-        mtimer_.stop();
-        ctx_.mtimer.add(mtimer_);
-    }
-
-    simple_vector<std::uint8_t> bktcache_;
-    size_t bktcache_size_ = 0;
-
-    void run()
-    {
-        mtimer_.start("sequ_ss");
-
-        size_t n = strptr_.size();
-
-        TLX_LOGC(ctx_.debug_jobs)
-            << "Process PS5SmallsortJob " << this << " of size " << n;
-
-        // create anonymous wrapper job
-        this->substep_add();
-
-        if (ctx_.enable_sequential_sample_sort && n >= ctx_.smallsort_threshold)
-        {
-            bktcache_.resize(n * sizeof(std::uint16_t));
-            sort_sample_sort(strptr_, depth_);
-        }
-        else
-        {
-            mtimer_.start("mkqs");
-            sort_mkqs_cache(strptr_, depth_);
-        }
-
-        // finish wrapper job, handler delete's this
-        this->substep_notify_done();
-    }
-
-    /*------------------------------------------------------------------------*/
-    //! Stack of Recursive Sample Sort Steps
-
-    class SeqSampleSortStep
-    {
-    public:
-        StringPtr strptr_;
-        size_t idx_ = 0;
-        size_t depth_;
-
-        using StringSet = typename StringPtr::StringSet;
-        using bktsize_type = BktSizeType;
-
-        typename Context::Classify classifier;
-
-        static const size_t num_splitters = Context::Classify::num_splitters;
-        static const size_t bktnum = 2 * num_splitters + 1;
-
-        unsigned char splitter_lcp[num_splitters + 1];
-        bktsize_type bkt[bktnum + 1];
-
-        SeqSampleSortStep(Context& ctx, const StringPtr& strptr, size_t depth,
-                          std::uint16_t* bktcache)
-            : strptr_(strptr), depth_(depth)
-        {
-            size_t n = strptr_.size();
-
-            // step 1: select splitters with oversampling
-
-            const size_t oversample_factor = 2;
-            const size_t sample_size = oversample_factor * num_splitters;
-
-            simple_vector<key_type> samples(sample_size);
-
-            const StringSet& strset = strptr_.active();
-
-            std::minstd_rand rng(reinterpret_cast<uintptr_t>(samples.data()));
-
-            for (size_t i = 0; i < sample_size; ++i)
-                samples[i] = get_key_at<key_type>(strset, rng() % n, depth_);
-
-            std::sort(samples.begin(), samples.end());
-
-            classifier.build(samples.data(), sample_size, splitter_lcp);
-
-            // step 2: classify all strings
-
-            classifier.classify(strset, strset.begin(), strset.end(), bktcache,
-                                depth_);
-
-            // step 2.5: count bucket sizes
-
-            bktsize_type bktsize[bktnum];
-            memset(bktsize, 0, bktnum * sizeof(bktsize_type));
-
-            for (size_t si = 0; si < n; ++si)
-                ++bktsize[bktcache[si]];
-
-            // step 3: inclusive prefix sum
-
-            bkt[0] = bktsize[0];
-            for (unsigned int i = 1; i < bktnum; ++i)
-            {
-                bkt[i] = bkt[i - 1] + bktsize[i];
-            }
-            assert(bkt[bktnum - 1] == n);
-            bkt[bktnum] = n;
-
-            // step 4: premute out-of-place
-
-            const StringSet& strB = strptr_.active();
-            // get alternative shadow pointer array
-            const StringSet& sorted = strptr_.shadow();
-            typename StringSet::Iterator sbegin = sorted.begin();
-
-            for (typename StringSet::Iterator str = strB.begin();
-                 str != strB.end(); ++str, ++bktcache)
-                *(sbegin + --bkt[*bktcache]) = std::move(*str);
-
-            // bkt is afterwards the exclusive prefix sum of bktsize
-
-            // statistics
-
-            ++ctx.sequ_ss_steps;
-        }
-
-        void calculate_lcp(Context& ctx)
-        {
-            TLX_LOGC(ctx.debug_lcp) << "Calculate LCP after sample sort step";
-            if (strptr_.with_lcp)
-            {
-                ps5_sample_sort_lcp<bktnum>(ctx, classifier, strptr_, depth_,
-                                            bkt);
-            }
-        }
-    };
-
-    size_t ss_front_ = 0;
-    std::vector<SeqSampleSortStep> ss_stack_;
-
-    void sort_sample_sort(const StringPtr& strptr, size_t depth)
-    {
-        typedef SeqSampleSortStep Step;
-
-        assert(ss_front_ == 0);
-        assert(ss_stack_.empty());
-
-        std::uint16_t* bktcache =
-            reinterpret_cast<std::uint16_t*>(bktcache_.data());
-
-        // sort first level
-        ss_stack_.emplace_back(ctx_, strptr, depth, bktcache);
-
-        // step 5: "recursion"
-
-        while (ss_stack_.size() > ss_front_)
-        {
-            Step& s = ss_stack_.back();
-            size_t i = s.idx_++; // process the bucket s.idx_
-
-            if (i < Step::bktnum)
-            {
-                size_t bktsize = s.bkt[i + 1] - s.bkt[i];
-
-                StringPtr sp = s.strptr_.flip(s.bkt[i], bktsize);
-
-                // i is even -> bkt[i] is less-than bucket
-                if (i % 2 == 0)
-                {
-                    if (bktsize == 0)
-                    {
-                        // empty bucket
-                    }
-                    else if (bktsize < ctx_.smallsort_threshold)
-                    {
-                        assert(i / 2 <= Step::num_splitters);
-                        if (i == Step::bktnum - 1)
-                            TLX_LOGC(ctx_.debug_recursion)
-                                << "Recurse[" << s.depth_ << "]: > bkt " << i
-                                << " size " << bktsize << " no lcp";
-                        else
-                            TLX_LOGC(ctx_.debug_recursion)
-                                << "Recurse[" << s.depth_ << "]: < bkt " << i
-                                << " size " << bktsize << " lcp "
-                                << int(s.splitter_lcp[i / 2] & 0x7F);
-
-                        ScopedMultiTimerSwitch sts_inssort(mtimer_, "mkqs");
-                        sort_mkqs_cache(sp, s.depth_ +
-                                                (s.splitter_lcp[i / 2] & 0x7F));
-                    }
-                    else
-                    {
-                        if (i == Step::bktnum - 1)
-                            TLX_LOGC(ctx_.debug_recursion)
-                                << "Recurse[" << s.depth_ << "]: > bkt " << i
-                                << " size " << bktsize << " no lcp";
-                        else
-                            TLX_LOGC(ctx_.debug_recursion)
-                                << "Recurse[" << s.depth_ << "]: < bkt " << i
-                                << " size " << bktsize << " lcp "
-                                << int(s.splitter_lcp[i / 2] & 0x7F);
-
-                        ss_stack_.emplace_back(
-                            ctx_, sp, s.depth_ + (s.splitter_lcp[i / 2] & 0x7F),
-                            bktcache);
-                    }
-                }
-                // i is odd -> bkt[i] is equal bucket
-                else
-                {
-                    if (bktsize == 0)
-                    {
-                        // empty bucket
-                    }
-                    else if (s.splitter_lcp[i / 2] & 0x80)
-                    {
-                        // equal-bucket has nullptr-terminated key, done.
-                        TLX_LOGC(ctx_.debug_recursion)
-                            << "Recurse[" << s.depth_ << "]: = bkt " << i
-                            << " size " << bktsize << " is done!";
-                        StringPtr spb = sp.copy_back();
-
-                        if (sp.with_lcp)
-                        {
-                            spb.fill_lcp(
-                                s.depth_ +
-                                lcpKeyDepth(s.classifier.get_splitter(i / 2)));
-                        }
-                        ctx_.donesize(bktsize);
-                    }
-                    else if (bktsize < ctx_.smallsort_threshold)
-                    {
-                        TLX_LOGC(ctx_.debug_recursion)
-                            << "Recurse[" << s.depth_ << "]: = bkt " << i
-                            << " size " << bktsize << " lcp keydepth!";
-
-                        ScopedMultiTimerSwitch sts_inssort(mtimer_, "mkqs");
-                        sort_mkqs_cache(sp, s.depth_ + sizeof(key_type));
-                    }
-                    else
-                    {
-                        TLX_LOGC(ctx_.debug_recursion)
-                            << "Recurse[" << s.depth_ << "]: = bkt " << i
-                            << " size " << bktsize << " lcp keydepth!";
-
-                        ss_stack_.emplace_back(
-                            ctx_, sp, s.depth_ + sizeof(key_type), bktcache);
-                    }
-                }
-            }
-            else
-            {
-                // finished sort
-                assert(ss_stack_.size() > ss_front_);
-
-                // after full sort: calculate LCPs at this level
-                ss_stack_.back().calculate_lcp(ctx_);
-
-                ss_stack_.pop_back();
-            }
-
-            if (ctx_.enable_work_sharing && ctx_.threads_.has_idle())
-            {
-                sample_sort_free_work();
-            }
-        }
-    }
-
-    void sample_sort_free_work()
-    {
-        assert(ss_stack_.size() >= ss_front_);
-
-        if (ss_stack_.size() == ss_front_)
-        {
-            // ss_stack_ is empty, check other stack
-            return mkqs_free_work();
-        }
-
-        // convert top level of stack into independent jobs
-        TLX_LOGC(ctx_.debug_jobs)
-            << "Freeing top level of PS5SmallsortJob's sample_sort stack";
-
-        typedef SeqSampleSortStep Step;
-        Step& s = ss_stack_[ss_front_];
-
-        while (s.idx_ < Step::bktnum)
-        {
-            size_t i = s.idx_++; // process the bucket s.idx_
-
-            size_t bktsize = s.bkt[i + 1] - s.bkt[i];
-
-            StringPtr sp = s.strptr_.flip(s.bkt[i], bktsize);
-
-            // i is even -> bkt[i] is less-than bucket
-            if (i % 2 == 0)
-            {
-                if (bktsize == 0)
-                {
-                    // empty bucket
-                }
-                else
-                {
-                    if (i == Step::bktnum - 1)
-                        TLX_LOGC(ctx_.debug_recursion)
-                            << "Recurse[" << s.depth_ << "]: > bkt " << i
-                            << " size " << bktsize << " no lcp";
-                    else
-                        TLX_LOGC(ctx_.debug_recursion)
-                            << "Recurse[" << s.depth_ << "]: < bkt " << i
-                            << " size " << bktsize << " lcp "
-                            << int(s.splitter_lcp[i / 2] & 0x7F);
-
-                    this->substep_add();
-                    ctx_.enqueue(this, sp,
-                                 s.depth_ + (s.splitter_lcp[i / 2] & 0x7F));
-                }
-            }
-            // i is odd -> bkt[i] is equal bucket
-            else
-            {
-                if (bktsize == 0)
-                {
-                    // empty bucket
-                }
-                else if (s.splitter_lcp[i / 2] & 0x80)
-                {
-                    // equal-bucket has nullptr-terminated key, done.
-                    TLX_LOGC(ctx_.debug_recursion)
-                        << "Recurse[" << s.depth_ << "]: = bkt " << i
-                        << " size " << bktsize << " is done!";
-                    StringPtr spb = sp.copy_back();
-
-                    if (sp.with_lcp)
-                    {
-                        spb.fill_lcp(
-                            s.depth_ +
-                            lcpKeyDepth(s.classifier.get_splitter(i / 2)));
-                    }
-                    ctx_.donesize(bktsize);
-                }
-                else
-                {
-                    TLX_LOGC(ctx_.debug_recursion)
-                        << "Recurse[" << s.depth_ << "]: = bkt " << i
-                        << " size " << bktsize << " lcp keydepth!";
-
-                    this->substep_add();
-                    ctx_.enqueue(this, sp, s.depth_ + sizeof(key_type));
-                }
-            }
-        }
-
-        // shorten the current stack
-        ++ss_front_;
-    }
-
-    /*------------------------------------------------------------------------*/
-    //! Stack of Recursive MKQS Steps
-
-    static int cmp(const key_type& a, const key_type& b)
-    {
-        return (a > b) ? 1 : (a < b) ? -1 : 0;
-    }
-
-    template <typename Type>
-    static size_t med3(Type* A, size_t i, size_t j, size_t k)
-    {
-        if (A[i] == A[j])
-            return i;
-        if (A[k] == A[i] || A[k] == A[j])
-            return k;
-        if (A[i] < A[j])
-        {
-            if (A[j] < A[k])
-                return j;
-            if (A[i] < A[k])
-                return k;
-            return i;
-        }
-
-        if (A[j] > A[k])
-            return j;
-        if (A[i] < A[k])
-            return i;
-        return k;
-    }
-
-    //! Insertion sort the strings only based on the cached characters.
-    static void insertion_sort_cache_block(const StringPtr& strptr,
-                                           key_type* cache)
-    {
-        const StringSet& strings = strptr.active();
-        size_t n = strptr.size();
-        size_t pi, pj;
-        for (pi = 1; --n > 0; ++pi)
-        {
-            typename StringSet::String tmps = std::move(strings.at(pi));
-            key_type tmpc = cache[pi];
-            for (pj = pi; pj > 0; --pj)
-            {
-                if (cache[pj - 1] <= tmpc)
-                    break;
-                strings.at(pj) = std::move(strings.at(pj - 1));
-                cache[pj] = cache[pj - 1];
-            }
-            strings.at(pj) = std::move(tmps);
-            cache[pj] = tmpc;
-        }
-    }
-
-    //! Insertion sort, but use cached characters if possible.
-    template <bool CacheDirty>
-    static void insertion_sort_cache(const StringPtr& _strptr, key_type* cache,
-                                     size_t depth)
-    {
-        StringPtr strptr = _strptr.copy_back();
-
-        if (strptr.size() <= 1)
-            return;
-        if (CacheDirty)
-            return insertion_sort(strptr, depth, /* memory */ 0);
-
-        insertion_sort_cache_block(strptr, cache);
-
-        size_t start = 0, bktsize = 1;
-        for (size_t i = 0; i < strptr.size() - 1; ++i)
-        {
-            // group areas with equal cache values
-            if (cache[i] == cache[i + 1])
-            {
-                ++bktsize;
-                continue;
-            }
-            // calculate LCP between group areas
-            if (start != 0 && strptr.with_lcp)
-            {
-                int rlcp = lcpKeyType(cache[start - 1], cache[start]);
-                strptr.set_lcp(start, depth + rlcp);
-                // strptr.set_cache(start, getCharAtDepth(cache[start], rlcp));
-            }
-            // sort group areas deeper if needed
-            if (bktsize > 1)
-            {
-                if (cache[start] & 0xFF)
-                {
-                    // need deeper sort
-                    insertion_sort(strptr.sub(start, bktsize),
-                                   depth + sizeof(key_type),
-                                   /* memory */ 0);
-                }
-                else
-                {
-                    // cache contains nullptr-termination
-                    strptr.sub(start, bktsize)
-                        .fill_lcp(depth + lcpKeyDepth(cache[start]));
-                }
-            }
-            bktsize = 1;
-            start = i + 1;
-        }
-        // tail of loop for last item
-        if (start != 0 && strptr.with_lcp)
-        {
-            int rlcp = lcpKeyType(cache[start - 1], cache[start]);
-            strptr.set_lcp(start, depth + rlcp);
-            // strptr.set_cache(start, getCharAtDepth(cache[start], rlcp));
-        }
-        if (bktsize > 1)
-        {
-            if (cache[start] & 0xFF)
-            {
-                // need deeper sort
-                insertion_sort(strptr.sub(start, bktsize),
-                               depth + sizeof(key_type),
-                               /* memory */ 0);
-            }
-            else
-            {
-                // cache contains nullptr-termination
-                strptr.sub(start, bktsize)
-                    .fill_lcp(depth + lcpKeyDepth(cache[start]));
-            }
-        }
-    }
-
-    class MKQSStep
-    {
-    public:
-        StringPtr strptr_;
-        key_type* cache_;
-        size_t num_lt_, num_eq_, num_gt_, depth_;
-        size_t idx_ = 0;
-        unsigned char eq_recurse_;
-        // typename StringPtr::StringSet::Char dchar_eq_, dchar_gt_;
-        std::uint8_t lcp_lt_, lcp_eq_, lcp_gt_;
-
-        MKQSStep(Context& ctx, const StringPtr& strptr, key_type* cache,
-                 size_t depth, bool CacheDirty)
-            : strptr_(strptr), cache_(cache), depth_(depth)
-        {
-            size_t n = strptr_.size();
-
-            const StringSet& strset = strptr_.active();
-
-            if (CacheDirty)
-            {
-                typename StringSet::Iterator it = strset.begin();
-                for (size_t i = 0; i < n; ++i, ++it)
-                {
-                    cache_[i] = get_key<key_type>(strset, *it, depth);
-                }
-            }
-            // select median of 9
-            size_t p = med3(cache_, med3(cache_, 0, n / 8, n / 4),
-                            med3(cache_, n / 2 - n / 8, n / 2, n / 2 + n / 8),
-                            med3(cache_, n - 1 - n / 4, n - 1 - n / 8, n - 3));
-            // swap pivot to first position
-            std::swap(strset.at(0), strset.at(p));
-            std::swap(cache_[0], cache_[p]);
-            // save the pivot value
-            key_type pivot = cache_[0];
-            // for immediate LCP calculation
-            key_type max_lt = 0, min_gt = std::numeric_limits<key_type>::max();
-
-            // indexes into array:
-            // 0 [pivot] 1 [===] leq [<<<] llt [???] rgt [>>>] req [===] n-1
-            size_t leq = 1, llt = 1, rgt = n - 1, req = n - 1;
-            while (true)
-            {
-                while (llt <= rgt)
-                {
-                    int r = cmp(cache[llt], pivot);
-                    if (r > 0)
-                    {
-                        min_gt = std::min(min_gt, cache[llt]);
-                        break;
-                    }
-                    if (r == 0)
-                    {
-                        std::swap(strset.at(leq), strset.at(llt));
-                        std::swap(cache[leq], cache[llt]);
-                        leq++;
-                    }
-                    else
-                    {
-                        max_lt = std::max(max_lt, cache[llt]);
-                    }
-                    ++llt;
-                }
-                while (llt <= rgt)
-                {
-                    int r = cmp(cache[rgt], pivot);
-                    if (r < 0)
-                    {
-                        max_lt = std::max(max_lt, cache[rgt]);
-                        break;
-                    }
-                    if (r == 0)
-                    {
-                        std::swap(strset.at(req), strset.at(rgt));
-                        std::swap(cache[req], cache[rgt]);
-                        req--;
-                    }
-                    else
-                    {
-                        min_gt = std::min(min_gt, cache[rgt]);
-                    }
-                    --rgt;
-                }
-                if (llt > rgt)
-                    break;
-                std::swap(strset.at(llt), strset.at(rgt));
-                std::swap(cache[llt], cache[rgt]);
-                ++llt;
-                --rgt;
-            }
-            // calculate size of areas = < and >, save into struct
-            size_t num_leq = leq, num_req = n - 1 - req;
-            num_eq_ = num_leq + num_req;
-            num_lt_ = llt - leq;
-            num_gt_ = req - rgt;
-            assert(num_eq_ > 0);
-            assert(num_lt_ + num_eq_ + num_gt_ == n);
-
-            // swap equal values from left to center
-            const size_t size1 = std::min(num_leq, num_lt_);
-            std::swap_ranges(strset.begin(), strset.begin() + size1,
-                             strset.begin() + llt - size1);
-            std::swap_ranges(cache, cache + size1, cache + llt - size1);
-
-            // swap equal values from right to center
-            const size_t size2 = std::min(num_req, num_gt_);
-            std::swap_ranges(strset.begin() + llt, strset.begin() + llt + size2,
-                             strset.begin() + n - size2);
-            std::swap_ranges(cache + llt, cache + llt + size2,
-                             cache + n - size2);
-
-            // No recursive sorting if pivot has a zero byte
-            eq_recurse_ = (pivot & 0xFF);
-
-            // save LCP values for writing into LCP array after sorting further
-            if (strptr_.with_lcp && num_lt_ > 0)
-            {
-                assert(max_lt ==
-                       *std::max_element(cache_ + 0, cache + num_lt_));
-
-                lcp_lt_ = lcpKeyType(max_lt, pivot);
-                // dchar_eq_ = getCharAtDepth(pivot, lcp_lt_);
-                TLX_LOGC(ctx.debug_lcp)
-                    << "LCP lt with pivot: " << depth_ + lcp_lt_;
-            }
-
-            // calculate equal area lcp: +1 for the equal zero termination byte
-            lcp_eq_ = lcpKeyDepth(pivot);
-
-            if (strptr_.with_lcp && num_gt_ > 0)
-            {
-                assert(min_gt == *std::min_element(cache_ + num_lt_ + num_eq_,
-                                                   cache_ + n));
-
-                lcp_gt_ = lcpKeyType(pivot, min_gt);
-                // dchar_gt_ = getCharAtDepth(min_gt, lcp_gt_);
-                TLX_LOGC(ctx.debug_lcp)
-                    << "LCP pivot with gt: " << depth_ + lcp_gt_;
-            }
-
-            ++ctx.base_sort_steps;
-        }
-
-        void calculate_lcp()
-        {
-            if (strptr_.with_lcp && num_lt_ > 0)
-            {
-                strptr_.set_lcp(num_lt_, depth_ + lcp_lt_);
-                // strptr_.set_cache(num_lt_, dchar_eq_);
-            }
-
-            if (strptr_.with_lcp && num_gt_ > 0)
-            {
-                strptr_.set_lcp(num_lt_ + num_eq_, depth_ + lcp_gt_);
-                // strptr_.set_cache(num_lt_ + num_eq_, dchar_gt_);
-            }
-        }
-    };
-
-    size_t ms_front_ = 0;
-    std::vector<MKQSStep> ms_stack_;
-
-    void sort_mkqs_cache(const StringPtr& strptr, size_t depth)
-    {
-        assert(strcmp(mtimer_.running(), "mkqs") == 0);
-
-        if (!ctx_.enable_sequential_mkqs ||
-            strptr.size() < ctx_.inssort_threshold)
-        {
-            TLX_LOGC(ctx_.debug_jobs) << "insertion_sort() size "
-                                      << strptr.size() << " depth " << depth;
-
-            ScopedMultiTimerSwitch sts_inssort(mtimer_, "inssort");
-            insertion_sort(strptr.copy_back(), depth, /* memory */ 0);
-            ctx_.donesize(strptr.size());
-            return;
-        }
-
-        TLX_LOGC(ctx_.debug_jobs)
-            << "sort_mkqs_cache() size " << strptr.size() << " depth " << depth;
-
-        if (bktcache_.size() < strptr.size() * sizeof(key_type))
-        {
-            bktcache_.destroy();
-            bktcache_.resize(strptr.size() * sizeof(key_type));
-        }
-
-        // reuse bktcache as keycache
-        key_type* cache = reinterpret_cast<key_type*>(bktcache_.data());
-
-        assert(ms_front_ == 0);
-        assert(ms_stack_.empty());
-
-        // std::deque is much slower than std::vector, so we use an artificial
-        // pop_front variable.
-        ms_stack_.emplace_back(ctx_, strptr, cache, depth, true);
-
-        while (ms_stack_.size() > ms_front_)
-        {
-            MKQSStep& ms = ms_stack_.back();
-            ++ms.idx_; // increment here, because stack may change
-
-            // process the lt-subsequence
-            if (ms.idx_ == 1)
-            {
-                if (ms.num_lt_ == 0)
-                {
-                    // empty subsequence
-                }
-                else if (ms.num_lt_ < ctx_.inssort_threshold)
-                {
-                    ScopedMultiTimerSwitch sts_inssort(mtimer_, "inssort");
-                    insertion_sort_cache<false>(ms.strptr_.sub(0, ms.num_lt_),
-                                                ms.cache_, ms.depth_);
-                    ctx_.donesize(ms.num_lt_);
-                }
-                else
-                {
-                    ms_stack_.emplace_back(ctx_, ms.strptr_.sub(0, ms.num_lt_),
-                                           ms.cache_, ms.depth_, false);
-                }
-            }
-            // process the eq-subsequence
-            else if (ms.idx_ == 2)
-            {
-                StringPtr sp = ms.strptr_.sub(ms.num_lt_, ms.num_eq_);
-
-                assert(ms.num_eq_ > 0);
-
-                if (!ms.eq_recurse_)
-                {
-                    StringPtr spb = sp.copy_back();
-                    spb.fill_lcp(ms.depth_ + ms.lcp_eq_);
-                    ctx_.donesize(spb.size());
-                }
-                else if (ms.num_eq_ < ctx_.inssort_threshold)
-                {
-                    ScopedMultiTimerSwitch sts_inssort(mtimer_, "inssort");
-                    insertion_sort_cache<true>(sp, ms.cache_ + ms.num_lt_,
-                                               ms.depth_ + sizeof(key_type));
-                    ctx_.donesize(ms.num_eq_);
-                }
-                else
-                {
-                    ms_stack_.emplace_back(ctx_, sp, ms.cache_ + ms.num_lt_,
-                                           ms.depth_ + sizeof(key_type), true);
-                }
-            }
-            // process the gt-subsequence
-            else if (ms.idx_ == 3)
-            {
-                StringPtr sp =
-                    ms.strptr_.sub(ms.num_lt_ + ms.num_eq_, ms.num_gt_);
-
-                if (ms.num_gt_ == 0)
-                {
-                    // empty subsequence
-                }
-                else if (ms.num_gt_ < ctx_.inssort_threshold)
-                {
-                    ScopedMultiTimerSwitch sts_inssort(mtimer_, "inssort");
-                    insertion_sort_cache<false>(
-                        sp, ms.cache_ + ms.num_lt_ + ms.num_eq_, ms.depth_);
-                    ctx_.donesize(ms.num_gt_);
-                }
-                else
-                {
-                    ms_stack_.emplace_back(ctx_, sp,
-                                           ms.cache_ + ms.num_lt_ + ms.num_eq_,
-                                           ms.depth_, false);
-                }
-            }
-            // calculate lcps
-            else
-            {
-                // finished sort
-                assert(ms_stack_.size() > ms_front_);
-
-                // calculate LCP after the three parts are sorted
-                ms_stack_.back().calculate_lcp();
-
-                ms_stack_.pop_back();
-            }
-
-            if (ctx_.enable_work_sharing && ctx_.threads_.has_idle())
-            {
-                sample_sort_free_work();
-            }
-        }
-    }
-
-    void mkqs_free_work()
-    {
-        assert(ms_stack_.size() >= ms_front_);
-
-        for (unsigned int fl = 0; fl < 8; ++fl)
-        {
-            if (ms_stack_.size() == ms_front_)
-            {
-                return;
-            }
-
-            TLX_LOGC(ctx_.debug_jobs)
-                << "Freeing top level of PS5SmallsortJob's mkqs stack - size "
-                << ms_stack_.size();
-
-            // convert top level of stack into independent jobs
-
-            MKQSStep& ms = ms_stack_[ms_front_];
-
-            if (ms.idx_ == 0 && ms.num_lt_ != 0)
-            {
-                this->substep_add();
-                ctx_.enqueue(this, ms.strptr_.sub(0, ms.num_lt_), ms.depth_);
-            }
-            if (ms.idx_ <= 1) // st.num_eq > 0 always
-            {
-                assert(ms.num_eq_ > 0);
-
-                StringPtr sp = ms.strptr_.sub(ms.num_lt_, ms.num_eq_);
-
-                if (ms.eq_recurse_)
-                {
-                    this->substep_add();
-                    ctx_.enqueue(this, sp, ms.depth_ + sizeof(key_type));
-                }
-                else
-                {
-                    StringPtr spb = sp.copy_back();
-                    spb.fill_lcp(ms.depth_ + ms.lcp_eq_);
-                    ctx_.donesize(ms.num_eq_);
-                }
-            }
-            if (ms.idx_ <= 2 && ms.num_gt_ != 0)
-            {
-                this->substep_add();
-                ctx_.enqueue(
-                    this, ms.strptr_.sub(ms.num_lt_ + ms.num_eq_, ms.num_gt_),
-                    ms.depth_);
-            }
-
-            // shorten the current stack
-            ++ms_front_;
-        }
-    }
-
-    /*------------------------------------------------------------------------*/
-    // Called When PS5SmallsortJob is Finished
-
-    void substep_all_done() final
-    {
-        TLX_LOGC(ctx_.debug_recursion)
-            << "SmallSort[" << depth_ << "] "
-            << "all substeps done -> LCP calculation";
-
-        while (ms_front_ > 0)
-        {
-            TLX_LOGC(ctx_.debug_lcp)
-                << "SmallSort[" << depth_ << "] ms_front_: " << ms_front_;
-            ms_stack_[--ms_front_].calculate_lcp();
-        }
-
-        while (ss_front_ > 0)
-        {
-            TLX_LOGC(ctx_.debug_lcp)
-                << "SmallSort[" << depth_ << "] ss_front_: " << ss_front_;
-            ss_stack_[--ss_front_].calculate_lcp(ctx_);
-        }
-
-        if (pstep_ != nullptr)
-            pstep_->substep_notify_done();
-        delete this;
-    }
-};
-
-/******************************************************************************/
-//! PS5BigSortStep Out-of-Place Parallel Sample Sort with Separate Jobs
-
-template <typename Context, typename StringPtr>
-class PS5BigSortStep : public PS5SortStep
-{
-public:
-    typedef typename StringPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator StrIterator;
-    typedef typename Context::key_type key_type;
-
-    //! context
-    Context& ctx_;
-    //! parent sort step for notification
-    PS5SortStep* pstep_;
-
-    //! string pointers, size, and current sorting depth
-    StringPtr strptr_;
-    size_t depth_;
-
-    //! number of parts into which the strings were split
-    size_t parts_;
-    //! size of all parts except the last
-    size_t psize_;
-    //! number of threads still working
-    std::atomic<size_t> pwork_;
-
-    //! classifier instance and variables (contains splitter tree
-    typename Context::Classify classifier_;
-
-    static const size_t treebits_ = Context::Classify::treebits;
-    static const size_t num_splitters_ = Context::Classify::num_splitters;
-    static const size_t bktnum_ = 2 * num_splitters_ + 1;
-
-    //! LCPs of splitters, needed for recursive calls
-    unsigned char splitter_lcp_[num_splitters_ + 1];
-
-    //! individual bucket array of threads, keep bkt[0] for DistributeJob
-    simple_vector<simple_vector<size_t> > bkt_;
-    //! bucket ids cache, created by classifier and later counted
-    simple_vector<simple_vector<std::uint16_t> > bktcache_;
-
-    /*------------------------------------------------------------------------*/
-    // Constructor
-
-    PS5BigSortStep(Context& ctx, PS5SortStep* pstep, const StringPtr& strptr,
-                   size_t depth)
-        : ctx_(ctx), pstep_(pstep), strptr_(strptr), depth_(depth)
-    {
-        // calculate number of parts
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        parts_ = strptr_.size() / ctx.sequential_threshold() * 2;
-        if (parts_ == 0)
-            parts_ = 1;
-
-        bkt_.resize(parts_);
-        bktcache_.resize(parts_);
-
-        psize_ = (strptr.size() + parts_ - 1) / parts_;
-
-        TLX_LOGC(ctx_.debug_steps)
-            << "enqueue depth=" << depth_ << " size=" << strptr_.size()
-            << " parts=" << parts_ << " psize=" << psize_
-            << " flip=" << strptr_.flipped();
-
-        ctx.threads_.enqueue([this]() { sample(); });
-        ++ctx.para_ss_steps;
-    }
-
-    virtual ~PS5BigSortStep()
-    {
-    }
-
-    /*------------------------------------------------------------------------*/
-    // Sample Step
-
-    void sample()
-    {
-        ScopedMultiTimer smt(ctx_.mtimer, "para_ss");
-        TLX_LOGC(ctx_.debug_jobs) << "Process SampleJob @ " << this;
-
-        const size_t oversample_factor = 2;
-        size_t sample_size = oversample_factor * num_splitters_;
-
-        const StringSet& strset = strptr_.active();
-        size_t n = strset.size();
-
-        simple_vector<key_type> samples(sample_size);
-
-        std::minstd_rand rng(reinterpret_cast<uintptr_t>(samples.data()));
-
-        for (size_t i = 0; i < sample_size; ++i)
-            samples[i] = get_key_at<key_type>(strset, rng() % n, depth_);
-
-        std::sort(samples.begin(), samples.end());
-
-        classifier_.build(samples.data(), sample_size, splitter_lcp_);
-
-        // create new jobs
-        pwork_ = parts_;
-        for (unsigned int p = 0; p < parts_; ++p)
-        {
-            ctx_.threads_.enqueue([this, p]() { count(p); });
-        }
-    }
-
-    /*------------------------------------------------------------------------*/
-    // Counting Step
-
-    void count(unsigned int p)
-    {
-        ScopedMultiTimer smt(ctx_.mtimer, "para_ss");
-        TLX_LOGC(ctx_.debug_jobs) << "Process CountJob " << p << " @ " << this;
-
-        const StringSet& strset = strptr_.active();
-
-        StrIterator strB = strset.begin() + p * psize_;
-        StrIterator strE =
-            strset.begin() + std::min((p + 1) * psize_, strptr_.size());
-        if (strE < strB)
-            strE = strB;
-
-        bktcache_[p].resize(strE - strB);
-        std::uint16_t* bktcache = bktcache_[p].data();
-        classifier_.classify(strset, strB, strE, bktcache, depth_);
-
-        bkt_[p].resize(bktnum_ + (p == 0 ? 1 : 0));
-        size_t* bkt = bkt_[p].data();
-        memset(bkt, 0, bktnum_ * sizeof(size_t));
-
-        for (std::uint16_t* bc = bktcache; bc != bktcache + (strE - strB); ++bc)
-            ++bkt[*bc];
-
-        if (--pwork_ == 0)
-            count_finished();
-    }
-
-    void count_finished()
-    {
-        ScopedMultiTimer smt(ctx_.mtimer, "para_ss");
-        TLX_LOGC(ctx_.debug_jobs)
-            << "Finishing CountJob " << this << " with prefixsum";
-
-        // abort sorting if we're measuring only the top level
-        if (ctx_.use_only_first_sortstep)
-            return;
-
-        // inclusive prefix sum over bkt
-        size_t sum = 0;
-        for (unsigned int i = 0; i < bktnum_; ++i)
-        {
-            for (unsigned int p = 0; p < parts_; ++p)
-            {
-                bkt_[p][i] = (sum += bkt_[p][i]);
-            }
-        }
-        assert(sum == strptr_.size());
-
-        // create new jobs
-        pwork_ = parts_;
-        for (unsigned int p = 0; p < parts_; ++p)
-        {
-            ctx_.threads_.enqueue([this, p]() { distribute(p); });
-        }
-    }
-
-    /*------------------------------------------------------------------------*/
-    // Distribute Step
-
-    void distribute(unsigned int p)
-    {
-        ScopedMultiTimer smt(ctx_.mtimer, "para_ss");
-        TLX_LOGC(ctx_.debug_jobs)
-            << "Process DistributeJob " << p << " @ " << this;
-
-        const StringSet& strset = strptr_.active();
-
-        StrIterator strB = strset.begin() + p * psize_;
-        StrIterator strE =
-            strset.begin() + std::min((p + 1) * psize_, strptr_.size());
-        if (strE < strB)
-            strE = strB;
-
-        // get alternative shadow pointer array
-        const StringSet& sorted = strptr_.shadow();
-        typename StringSet::Iterator sbegin = sorted.begin();
-
-        std::uint16_t* bktcache = bktcache_[p].data();
-        size_t* bkt = bkt_[p].data();
-
-        for (StrIterator str = strB; str != strE; ++str, ++bktcache)
-            *(sbegin + --bkt[*bktcache]) = std::move(*str);
-
-        if (p != 0) // p = 0 is needed for recursion into bkts
-            bkt_[p].destroy();
-
-        bktcache_[p].destroy();
-
-        if (--pwork_ == 0)
-            distribute_finished();
-    }
-
-    void distribute_finished()
-    {
-        TLX_LOGC(ctx_.debug_jobs)
-            << "Finishing DistributeJob " << this << " with enqueuing subjobs";
-
-        size_t* bkt = bkt_[0].data();
-        assert(bkt);
-
-        // first processor's bkt pointers are boundaries between bkts, just add
-        // sentinel:
-        assert(bkt[0] == 0);
-        bkt[bktnum_] = strptr_.size();
-
-        // keep anonymous subjob handle while creating subjobs
-        this->substep_add();
-
-        size_t i = 0;
-        while (i < bktnum_ - 1)
-        {
-            // i is even -> bkt[i] is less-than bucket
-            size_t bktsize = bkt[i + 1] - bkt[i];
-            if (bktsize == 0)
-            {
-                // empty bucket
-            }
-            else if (bktsize == 1)
-            { // just one string pointer, copyback
-                strptr_.flip(bkt[i], 1).copy_back();
-                ctx_.donesize(1);
-            }
-            else
-            {
-                TLX_LOGC(ctx_.debug_recursion)
-                    << "Recurse[" << depth_ << "]: < bkt " << bkt[i] << " size "
-                    << bktsize << " lcp " << int(splitter_lcp_[i / 2] & 0x7F);
-                this->substep_add();
-                ctx_.enqueue(this, strptr_.flip(bkt[i], bktsize),
-                             depth_ + (splitter_lcp_[i / 2] & 0x7F));
-            }
-            ++i;
-            // i is odd -> bkt[i] is equal bucket
-            bktsize = bkt[i + 1] - bkt[i];
-            if (bktsize == 0)
-            {
-                // empty bucket
-            }
-            else if (bktsize == 1)
-            { // just one string pointer, copyback
-                strptr_.flip(bkt[i], 1).copy_back();
-                ctx_.donesize(1);
-            }
-            else
-            {
-                if (splitter_lcp_[i / 2] & 0x80)
-                {
-                    // equal-bucket has nullptr-terminated key, done.
-                    TLX_LOGC(ctx_.debug_recursion)
-                        << "Recurse[" << depth_ << "]: = bkt " << bkt[i]
-                        << " size " << bktsize << " is done!";
-                    StringPtr sp = strptr_.flip(bkt[i], bktsize).copy_back();
-                    sp.fill_lcp(depth_ +
-                                lcpKeyDepth(classifier_.get_splitter(i / 2)));
-                    ctx_.donesize(bktsize);
-                }
-                else
-                {
-                    TLX_LOGC(ctx_.debug_recursion)
-                        << "Recurse[" << depth_ << "]: = bkt " << bkt[i]
-                        << " size " << bktsize << " lcp keydepth!";
-                    this->substep_add();
-                    ctx_.enqueue(this, strptr_.flip(bkt[i], bktsize),
-                                 depth_ + sizeof(key_type));
-                }
-            }
-            ++i;
-        }
-
-        size_t bktsize = bkt[i + 1] - bkt[i];
-
-        if (bktsize == 0)
-        {
-            // empty bucket
-        }
-        else if (bktsize == 1)
-        { // just one string pointer, copyback
-            strptr_.flip(bkt[i], 1).copy_back();
-            ctx_.donesize(1);
-        }
-        else
-        {
-            TLX_LOGC(ctx_.debug_recursion)
-                << "Recurse[" << depth_ << "]: > bkt " << bkt[i] << " size "
-                << bktsize << " no lcp";
-            this->substep_add();
-            ctx_.enqueue(this, strptr_.flip(bkt[i], bktsize), depth_);
-        }
-
-        this->substep_notify_done(); // release anonymous subjob handle
-
-        if (!strptr_.with_lcp)
-            bkt_[0].destroy();
-    }
-
-    /*------------------------------------------------------------------------*/
-    // After Recursive Sorting
-
-    void substep_all_done() final
-    {
-        ScopedMultiTimer smt(ctx_.mtimer, "para_ss");
-        if (strptr_.with_lcp)
-        {
-            TLX_LOGC(ctx_.debug_steps)
-                << "pSampleSortStep[" << depth_ << "]: all substeps done.";
-
-            ps5_sample_sort_lcp<bktnum_>(ctx_, classifier_, strptr_, depth_,
-                                         bkt_[0].data());
-            bkt_[0].destroy();
-        }
-
-        if (pstep_ != nullptr)
-            pstep_->substep_notify_done();
-        delete this;
-    }
-};
-
-/******************************************************************************/
-// PS5Context::enqueue()
-
-template <typename Parameters>
-template <typename StringPtr>
-void PS5Context<Parameters>::enqueue(PS5SortStep* pstep,
-                                     const StringPtr& strptr, size_t depth)
-{
-    if (this->enable_parallel_sample_sort &&
-        (strptr.size() > sequential_threshold() ||
-         this->use_only_first_sortstep))
-    {
-        new PS5BigSortStep<PS5Context, StringPtr>(*this, pstep, strptr, depth);
-    }
-    else
-    {
-        if (strptr.size() < (1LLU << 32))
-        {
-            auto j = new PS5SmallsortJob<PS5Context, StringPtr, std::uint32_t>(
-                *this, pstep, strptr, depth);
-            threads_.enqueue([j]() { j->run(); });
-        }
-        else
-        {
-            auto j = new PS5SmallsortJob<PS5Context, StringPtr, std::uint64_t>(
-                *this, pstep, strptr, depth);
-            threads_.enqueue([j]() { j->run(); });
-        }
-    }
-}
-
-/******************************************************************************/
-// Externally Callable Sorting Methods
-
-//! Main Parallel Sample Sort Function. See below for more convenient wrappers.
-template <typename PS5Parameters, typename StringPtr>
-void parallel_sample_sort_base(const StringPtr& strptr, size_t depth)
-{
-    using Context = PS5Context<PS5Parameters>;
-    Context ctx(std::thread::hardware_concurrency());
-    ctx.total_size = strptr.size();
-    ctx.rest_size = strptr.size();
-    ctx.num_threads = ctx.threads_.size();
-
-    MultiTimer timer;
-    timer.start("sort");
-
-    ctx.enqueue(/* pstep */ nullptr, strptr, depth);
-    ctx.threads_.loop_until_empty();
-
-    timer.stop();
-
-    assert(!ctx.enable_rest_size || ctx.rest_size == 0);
-
-    using BigSortStep = PS5BigSortStep<Context, StringPtr>;
-
-    TLX_LOGC(ctx.debug_result)
-        << "RESULT"
-        << " sizeof(key_type)=" << sizeof(typename PS5Parameters::key_type)
-        << " splitter_treebits=" << size_t(BigSortStep::treebits_)
-        << " num_splitters=" << size_t(BigSortStep::num_splitters_)
-        << " num_threads=" << ctx.num_threads
-        << " enable_work_sharing=" << size_t(ctx.enable_work_sharing)
-        << " use_restsize=" << size_t(ctx.enable_rest_size)
-        << " tm_para_ss=" << ctx.mtimer.get("para_ss")
-        << " tm_seq_ss=" << ctx.mtimer.get("sequ_ss")
-        << " tm_mkqs=" << ctx.mtimer.get("mkqs")
-        << " tm_inssort=" << ctx.mtimer.get("inssort")
-        << " tm_total=" << ctx.mtimer.total()
-        << " tm_idle=" << (ctx.num_threads * timer.total()) - ctx.mtimer.total()
-        << " steps_para_sample_sort=" << ctx.para_ss_steps
-        << " steps_seq_sample_sort=" << ctx.sequ_ss_steps
-        << " steps_base_sort=" << ctx.base_sort_steps;
-}
-
-//! Parallel Sample Sort Function for a generic StringSet, this allocates the
-//! shadow array for flipping.
-template <typename PS5Parameters, typename StringPtr>
-typename enable_if<!StringPtr::with_lcp, void>::type
-parallel_sample_sort_params(const StringPtr& strptr, size_t depth,
-                            size_t memory = 0)
-{
-    tlx::unused(memory);
-
-    typedef typename StringPtr::StringSet StringSet;
-    const StringSet& strset = strptr.active();
-
-    typedef StringShadowPtr<StringSet> StringShadowPtr;
-    typedef typename StringSet::Container Container;
-
-    // allocate shadow pointer array
-    Container shadow = strset.allocate(strset.size());
-    StringShadowPtr new_strptr(strset, StringSet(shadow));
-
-    parallel_sample_sort_base<PS5Parameters>(new_strptr, depth);
-
-    StringSet::deallocate(shadow);
-}
-
-//! Parallel Sample Sort Function for a generic StringSet with LCPs, this
-//! allocates the shadow array for flipping.
-template <typename PS5Parameters, typename StringPtr>
-typename enable_if<StringPtr::with_lcp, void>::type parallel_sample_sort_params(
-    const StringPtr& strptr, size_t depth, size_t memory = 0)
-{
-    tlx::unused(memory);
-
-    typedef typename StringPtr::StringSet StringSet;
-    typedef typename StringPtr::LcpType LcpType;
-    const StringSet& strset = strptr.active();
-
-    typedef StringShadowLcpPtr<StringSet, LcpType> StringShadowLcpPtr;
-    typedef typename StringSet::Container Container;
-
-    // allocate shadow pointer array
-    Container shadow = strset.allocate(strset.size());
-    StringShadowLcpPtr new_strptr(strset, StringSet(shadow), strptr.lcp());
-
-    parallel_sample_sort_base<PS5Parameters>(new_strptr, depth);
-
-    StringSet::deallocate(shadow);
-}
-
-//! Parallel Sample Sort Function with default parameter size for a generic
-//! StringSet.
-template <typename StringPtr>
-void parallel_sample_sort(const StringPtr& strptr, size_t depth, size_t memory)
-{
-    return parallel_sample_sort_params<PS5ParametersDefault>(strptr, depth,
-                                                             memory);
-}
-
-}} // namespace tlx::sort_strings_detail
-
-#endif // !TLX_SORT_STRINGS_PARALLEL_SAMPLE_SORT_HEADER
-
-/******************************************************************************/