@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,756 +0,0 @@
-/*******************************************************************************
- * tlx/sort/strings/sample_sort_tools.hpp
- *
- * Helpers for (Parallel) Super Scalar String Sample Sort
- *
- * 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_SAMPLE_SORT_TOOLS_HEADER
-#define TLX_SORT_STRINGS_SAMPLE_SORT_TOOLS_HEADER
-
-#include <tlx/define/attribute_fallthrough.hpp>
-#include <tlx/die/core.hpp>
-#include <tlx/logger/core.hpp>
-#include <tlx/math/clz.hpp>
-#include <tlx/math/ctz.hpp>
-#include <tlx/sort/strings/string_set.hpp>
-#include <tlx/string/hexdump.hpp>
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-
-namespace tlx { namespace sort_strings_detail {
-
-/******************************************************************************/
-
-//! represent binary digits of large integer datatypes
-template <typename Type>
-static inline std::string to_binary(Type v,
-                                    const size_t width = (8 * sizeof(Type)))
-{
-    std::string str(width, ' ');
-    for (size_t i = 0; i < width; i++)
-    {
-        str[width - i - 1] = (v & 1) ? '1' : '0';
-        v /= 2;
-    }
-    return str;
-}
-
-//! Class to transform in-order to level-order indexes in a perfect binary tree
-template <size_t TreeBits>
-struct PerfectTreeCalculations
-{
-    static const bool debug = false;
-
-    static const size_t treebits = TreeBits;
-    static const size_t num_nodes = (1 << treebits) - 1;
-
-    static unsigned int level_to_preorder(unsigned int id)
-    {
-        assert(id > 0);
-        TLX_LOG << "index: " << id << " = " << to_binary(id);
-
-        static const int bitmask = num_nodes;
-
-        int hi = treebits - 32 + clz<std::uint32_t>(id);
-        TLX_LOG << "high zero: " << hi;
-
-        unsigned int bkt = ((id << (hi + 1)) & bitmask) | (1 << hi);
-
-        TLX_LOG << "bkt: " << bkt << " = " << to_binary(bkt);
-        return bkt;
-    }
-
-    static unsigned int pre_to_levelorder(unsigned int id)
-    {
-        assert(id > 0);
-        TLX_LOG << "index: " << id << " = " << to_binary(id);
-
-        static const int bitmask = num_nodes;
-
-        int lo = ctz<std::uint32_t>(id) + 1;
-        TLX_LOG << "low zero: " << lo;
-
-        unsigned int bkt = ((id >> lo) & bitmask) | (1 << (treebits - lo));
-
-        TLX_LOG << "bkt: " << bkt << " = " << to_binary(bkt);
-        return bkt;
-    }
-
-    static void self_verify()
-    {
-        for (size_t i = 1; i <= num_nodes; ++i)
-        {
-            TLX_LOG << to_binary(i, treebits) << " -> ";
-
-            size_t id = level_to_preorder(i);
-            TLX_LOG << to_binary(id, treebits) << " -> ";
-
-            id = pre_to_levelorder(id);
-            TLX_LOG << to_binary(id, treebits);
-
-            TLX_LOG << "";
-            tlx_die_unequal(id, i);
-        }
-    }
-};
-
-static inline void perfect_tree_calculations_self_verify()
-{
-    PerfectTreeCalculations<4>::self_verify();
-    PerfectTreeCalculations<5>::self_verify();
-    PerfectTreeCalculations<6>::self_verify();
-    PerfectTreeCalculations<10>::self_verify();
-    PerfectTreeCalculations<11>::self_verify();
-    PerfectTreeCalculations<12>::self_verify();
-    PerfectTreeCalculations<13>::self_verify();
-    PerfectTreeCalculations<14>::self_verify();
-    PerfectTreeCalculations<15>::self_verify();
-    PerfectTreeCalculations<16>::self_verify();
-}
-
-/******************************************************************************/
-
-//! Recursive TreeBuilder for full-descent and unrolled variants, constructs a
-//! both a pre-order and level-order array of splitters and the corresponding
-//! LCPs.
-template <typename key_type, size_t num_splitters>
-class SSTreeBuilderPreAndLevelOrder
-{
-    static const bool debug_splitter = false;
-
-public:
-    // build tree: splitter[num_splitters], splitter_tree[num_splitters + 1],
-    // and splitter_lcp[num_splitters + 1].
-    SSTreeBuilderPreAndLevelOrder(key_type splitter[num_splitters],
-                                  key_type tree[num_splitters + 1],
-                                  unsigned char splitter_lcp[num_splitters + 1],
-                                  const key_type* samples, size_t samplesize)
-        : splitter_(splitter),
-          tree_(tree),
-          lcp_iter_(splitter_lcp),
-          samples_(samples)
-    {
-        key_type sentinel = 0;
-        recurse(samples, samples + samplesize, 1, sentinel);
-
-        assert(splitter_ == splitter + num_splitters);
-        assert(lcp_iter_ == splitter_lcp + num_splitters);
-        // overwrite sentinel lcp for first < everything bucket
-        splitter_lcp[0] &= 0x80;
-        // sentinel for > everything bucket
-        splitter_lcp[num_splitters] = 0;
-    }
-
-    ptrdiff_t snum(const key_type* s) const
-    {
-        return static_cast<ptrdiff_t>(s - samples_);
-    }
-
-    key_type recurse(const key_type* lo, const key_type* hi,
-                     unsigned int treeidx, key_type& rec_prevkey)
-    {
-        TLX_LOGC(debug_splitter) << "rec_buildtree(" << snum(lo) << ","
-                                 << snum(hi) << ", treeidx=" << treeidx << ")";
-
-        // pick middle element as splitter
-        const key_type* mid = lo + static_cast<ptrdiff_t>(hi - lo) / 2;
-
-        TLX_LOGC(debug_splitter) << "tree[" << treeidx << "] = samples["
-                                 << snum(mid) << "] = " << hexdump_type(*mid);
-
-        key_type mykey = tree_[treeidx] = *mid;
-#if 1
-        const key_type* midlo = mid;
-        while (lo < midlo && *(midlo - 1) == mykey)
-            midlo--;
-
-        const key_type* midhi = mid;
-        while (midhi + 1 < hi && *midhi == mykey)
-            midhi++;
-
-        if (midhi - midlo > 1)
-            TLX_LOG0 << "key range = [" << snum(midlo) << "," << snum(midhi)
-                     << ")";
-#else
-        const key_type *midlo = mid, *midhi = mid + 1;
-#endif
-        if (2 * treeidx < num_splitters)
-        {
-            key_type prevkey = recurse(lo, midlo, 2 * treeidx + 0, rec_prevkey);
-
-            key_type xorSplit = prevkey ^ mykey;
-
-            TLX_LOGC(debug_splitter)                    //
-                << "    lcp: " << hexdump_type(prevkey) //
-                << " XOR " << hexdump_type(mykey)       //
-                << " = " << hexdump_type(xorSplit)      //
-                << " - " << clz(xorSplit)               //
-                << " bits = " << clz(xorSplit) / 8      //
-                << " chars lcp";
-
-            *splitter_++ = mykey;
-
-            *lcp_iter_++ = (clz(xorSplit) / 8) |
-                           // marker for done splitters
-                           ((mykey & 0xFF) ? 0 : 0x80);
-
-            return recurse(midhi, hi, 2 * treeidx + 1, mykey);
-        }
-
-        key_type xorSplit = rec_prevkey ^ mykey;
-
-        TLX_LOGC(debug_splitter)                        //
-            << "    lcp: " << hexdump_type(rec_prevkey) //
-            << " XOR " << hexdump_type(mykey)           //
-            << " = " << hexdump_type(xorSplit)          //
-            << " - " << clz(xorSplit)                   //
-            << " bits = " << clz(xorSplit) / 8          //
-            << " chars lcp";
-
-        *splitter_++ = mykey;
-
-        *lcp_iter_++ = (clz(xorSplit) / 8) |
-                       // marker for done splitters
-                       ((mykey & 0xFF) ? 0 : 0x80);
-
-        return mykey;
-    }
-
-private:
-    key_type* splitter_;
-    key_type* tree_;
-    unsigned char* lcp_iter_;
-    const key_type* samples_;
-};
-
-//! Recursive TreeBuilder for full-descent and unrolled variants, constructs
-//! only a level-order binary tree of splitters
-template <typename key_type, size_t num_splitters>
-class SSTreeBuilderLevelOrder
-{
-    static const bool debug_splitter = false;
-
-public:
-    //! build tree, sizes: splitter_tree[num_splitters + 1] and
-    SSTreeBuilderLevelOrder(key_type tree[num_splitters],
-                            unsigned char splitter_lcp[num_splitters + 1],
-                            const key_type* samples, size_t samplesize)
-        : tree_(tree), lcp_iter_(splitter_lcp), samples_(samples)
-    {
-        key_type sentinel = 0;
-        recurse(samples, samples + samplesize, 1, sentinel);
-
-        assert(lcp_iter_ == splitter_lcp + num_splitters);
-        // overwrite sentinel lcp for first < everything bucket
-        splitter_lcp[0] &= 0x80;
-        // sentinel for > everything bucket
-        splitter_lcp[num_splitters] = 0;
-    }
-
-    ptrdiff_t snum(const key_type* s) const
-    {
-        return static_cast<ptrdiff_t>(s - samples_);
-    }
-
-    key_type recurse(const key_type* lo, const key_type* hi,
-                     unsigned int treeidx, key_type& rec_prevkey)
-    {
-        TLX_LOGC(debug_splitter) << "rec_buildtree(" << snum(lo) << ","
-                                 << snum(hi) << ", treeidx=" << treeidx << ")";
-
-        // pick middle element as splitter
-        const key_type* mid = lo + static_cast<ptrdiff_t>(hi - lo) / 2;
-
-        TLX_LOGC(debug_splitter) << "tree[" << treeidx << "] = samples["
-                                 << snum(mid) << "] = " << hexdump_type(*mid);
-
-        key_type mykey = tree_[treeidx] = *mid;
-#if 1
-        const key_type* midlo = mid;
-        while (lo < midlo && *(midlo - 1) == mykey)
-            midlo--;
-
-        const key_type* midhi = mid;
-        while (midhi + 1 < hi && *midhi == mykey)
-            midhi++;
-
-        if (midhi - midlo > 1)
-            TLX_LOG0 << "key range = [" << snum(midlo) << "," << snum(midhi)
-                     << ")";
-#else
-        const key_type *midlo = mid, *midhi = mid + 1;
-#endif
-        if (2 * treeidx < num_splitters)
-        {
-            key_type prevkey = recurse(lo, midlo, 2 * treeidx + 0, rec_prevkey);
-
-            key_type xorSplit = prevkey ^ mykey;
-
-            TLX_LOGC(debug_splitter)                    //
-                << "    lcp: " << hexdump_type(prevkey) //
-                << " XOR " << hexdump_type(mykey)       //
-                << " = " << hexdump_type(xorSplit)      //
-                << " - " << clz(xorSplit)               //
-                << " bits = " << clz(xorSplit) / 8      //
-                << " chars lcp";
-
-            *lcp_iter_++ = (clz(xorSplit) / 8) |
-                           // marker for done splitters
-                           ((mykey & 0xFF) ? 0 : 0x80);
-
-            return recurse(midhi, hi, 2 * treeidx + 1, mykey);
-        }
-
-        key_type xorSplit = rec_prevkey ^ mykey;
-
-        TLX_LOGC(debug_splitter)                        //
-            << "    lcp: " << hexdump_type(rec_prevkey) //
-            << " XOR " << hexdump_type(mykey)           //
-            << " = " << hexdump_type(xorSplit)          //
-            << " - " << clz(xorSplit)                   //
-            << " bits = " << clz(xorSplit) / 8          //
-            << " chars lcp";
-
-        *lcp_iter_++ = (clz(xorSplit) / 8) |
-                       // marker for done splitters
-                       ((mykey & 0xFF) ? 0 : 0x80);
-
-        return mykey;
-    }
-
-private:
-    key_type* tree_;
-    unsigned char* lcp_iter_;
-    const key_type* samples_;
-};
-
-/******************************************************************************/
-
-//! Sample Sort Classification Tree Unrolled and Interleaved
-template <typename key_type, size_t TreeBits, size_t Rollout = 4>
-class SSClassifyTreeUnrollInterleave
-{
-public:
-    static const size_t treebits = TreeBits;
-    static const size_t num_splitters = (1 << treebits) - 1;
-
-    //! build tree and splitter array from sample
-    void build(key_type* samples, size_t samplesize,
-               unsigned char* splitter_lcp)
-    {
-        SSTreeBuilderPreAndLevelOrder<key_type, num_splitters>(
-            splitter_, splitter_tree_, splitter_lcp, samples, samplesize);
-    }
-
-    //! binary search on splitter array for bucket number
-    unsigned int find_bkt(const key_type& key) const
-    {
-        // binary tree traversal without left branch
-
-        unsigned int i = 1;
-        while (i <= num_splitters)
-        {
-            // in gcc-4.6.3 this produces a SETA, LEA sequence
-            i = 2 * i + (key <= splitter_tree_[i] ? 0 : 1);
-        }
-        i -= num_splitters + 1;
-
-        size_t b = i * 2; // < bucket
-        if (i < num_splitters && splitter_[i] == key)
-            b += 1; // equal bucket
-
-        return b;
-    }
-
-    // in gcc-4.6.3 this produces a SETA, LEA sequence
-#define TLX_CLASSIFY_TREE_STEP                                                 \
-    for (size_t u = 0; u < Rollout; ++u)                                       \
-    {                                                                          \
-        i[u] = 2 * i[u] + (key[u] <= splitter_tree_[i[u]] ? 0 : 1);            \
-    }                                                                          \
-    TLX_ATTRIBUTE_FALLTHROUGH;
-
-    //! search in splitter tree for bucket number, unrolled for Rollout keys at
-    //! once.
-    void find_bkt_unroll(const key_type key[Rollout],
-                         std::uint16_t obkt[Rollout]) const
-    {
-        // binary tree traversal without left branch
-
-        unsigned int i[Rollout];
-        std::fill(i, i + Rollout, 1U);
-
-        switch (treebits)
-        {
-        default:
-            abort();
-        case 15:
-            TLX_CLASSIFY_TREE_STEP;
-        case 14:
-            TLX_CLASSIFY_TREE_STEP;
-        case 13:
-            TLX_CLASSIFY_TREE_STEP;
-        case 12:
-            TLX_CLASSIFY_TREE_STEP;
-        case 11:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 10:
-            TLX_CLASSIFY_TREE_STEP;
-        case 9:
-            TLX_CLASSIFY_TREE_STEP;
-        case 8:
-            TLX_CLASSIFY_TREE_STEP;
-        case 7:
-            TLX_CLASSIFY_TREE_STEP;
-        case 6:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 5:
-            TLX_CLASSIFY_TREE_STEP;
-        case 4:
-            TLX_CLASSIFY_TREE_STEP;
-        case 3:
-            TLX_CLASSIFY_TREE_STEP;
-        case 2:
-            TLX_CLASSIFY_TREE_STEP;
-        case 1:
-            TLX_CLASSIFY_TREE_STEP;
-        }
-
-        for (size_t u = 0; u < Rollout; ++u)
-            i[u] -= num_splitters + 1;
-
-        for (size_t u = 0; u < Rollout; ++u)
-        {
-            // < bucket
-            obkt[u] = i[u] * 2;
-        }
-
-        for (size_t u = 0; u < Rollout; ++u)
-        {
-            // equal bucket
-            if (i[u] < num_splitters && splitter_[i[u]] == key[u])
-                obkt[u] += 1;
-        }
-    }
-
-#undef TLX_CLASSIFY_TREE_STEP
-
-    //! classify all strings in area by walking tree and saving bucket id
-    template <typename StringSet>
-    // __attribute__ ((optimize("unroll-all-loops")))
-    void classify(const StringSet& strset, typename StringSet::Iterator begin,
-                  typename StringSet::Iterator end, std::uint16_t* bktout,
-                  size_t depth) const
-    {
-        while (begin != end)
-        {
-            if (begin + Rollout <= end)
-            {
-                key_type key[Rollout];
-                for (size_t u = 0; u < Rollout; ++u)
-                    key[u] = get_key<key_type>(strset, begin[u], depth);
-
-                find_bkt_unroll(key, bktout);
-
-                begin += Rollout, bktout += Rollout;
-            }
-            else
-            {
-                key_type key = get_key<key_type>(strset, *begin++, depth);
-                *bktout++ = this->find_bkt(key);
-            }
-        }
-    }
-
-    //! return a splitter
-    key_type get_splitter(unsigned int i) const
-    {
-        return splitter_[i];
-    }
-
-private:
-    key_type splitter_[num_splitters];
-    key_type splitter_tree_[num_splitters + 1];
-};
-
-/******************************************************************************/
-
-//! Sample Sort Classification Tree Unrolled with Equal Comparisons
-template <typename key_type, size_t TreeBits>
-class SSClassifyEqualUnroll
-{
-public:
-    static const size_t treebits = TreeBits;
-    static const size_t num_splitters = (1 << treebits) - 1;
-
-    //! build tree and splitter array from sample
-    void build(key_type* samples, size_t samplesize,
-               unsigned char* splitter_lcp)
-    {
-        SSTreeBuilderLevelOrder<key_type, num_splitters>(
-            splitter_tree_, splitter_lcp, samples, samplesize);
-    }
-
-#define TLX_CLASSIFY_TREE_STEP                                                 \
-    if (TLX_UNLIKELY(key == splitter_tree_[i]))                                \
-    {                                                                          \
-        return 2 * PerfectTreeCalculations<treebits>::level_to_preorder(i) -   \
-               1;                                                              \
-    }                                                                          \
-    i = 2 * i + (key < splitter_tree_[i] ? 0 : 1);                             \
-    TLX_ATTRIBUTE_FALLTHROUGH;
-
-    //! binary search on splitter array for bucket number
-    unsigned int find_bkt(const key_type& key) const
-    {
-        // binary tree traversal without left branch
-
-        unsigned int i = 1;
-
-        switch (treebits)
-        {
-        default:
-            abort();
-        case 15:
-            TLX_CLASSIFY_TREE_STEP;
-        case 14:
-            TLX_CLASSIFY_TREE_STEP;
-        case 13:
-            TLX_CLASSIFY_TREE_STEP;
-        case 12:
-            TLX_CLASSIFY_TREE_STEP;
-        case 11:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 10:
-            TLX_CLASSIFY_TREE_STEP;
-        case 9:
-            TLX_CLASSIFY_TREE_STEP;
-        case 8:
-            TLX_CLASSIFY_TREE_STEP;
-        case 7:
-            TLX_CLASSIFY_TREE_STEP;
-        case 6:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 5:
-            TLX_CLASSIFY_TREE_STEP;
-        case 4:
-            TLX_CLASSIFY_TREE_STEP;
-        case 3:
-            TLX_CLASSIFY_TREE_STEP;
-        case 2:
-            TLX_CLASSIFY_TREE_STEP;
-        case 1:
-            TLX_CLASSIFY_TREE_STEP;
-        }
-
-        i -= num_splitters + 1;
-        return 2 * i; // < or > bucket
-    }
-
-#undef TLX_CLASSIFY_TREE_STEP
-
-    //! classify all strings in area by walking tree and saving bucket id
-    template <typename StringSet>
-    void classify(const StringSet& strset, typename StringSet::Iterator begin,
-                  typename StringSet::Iterator end, std::uint16_t* bktout,
-                  size_t depth) const
-    {
-        while (begin != end)
-        {
-            key_type key = get_key<key_type>(strset, *begin++, depth);
-            *bktout++ = find_bkt(key);
-        }
-    }
-
-    //! return a splitter
-    key_type get_splitter(unsigned int i) const
-    {
-        return splitter_tree_
-            [PerfectTreeCalculations<treebits>::pre_to_levelorder(i)];
-    }
-
-private:
-    key_type splitter_tree_[num_splitters + 1];
-};
-
-/******************************************************************************/
-
-//! Sample Sort Classification Tree Unrolled, Interleaved, and with Perfect Tree
-//! Index Calculations
-template <typename key_type, size_t TreeBits, unsigned Rollout = 4>
-class SSClassifyTreeCalcUnrollInterleave
-{
-public:
-    static const size_t treebits = TreeBits;
-    static const size_t num_splitters = (1 << treebits) - 1;
-
-    //! build tree and splitter array from sample
-    void build(key_type* samples, size_t samplesize,
-               unsigned char* splitter_lcp)
-    {
-        SSTreeBuilderLevelOrder<key_type, num_splitters>(
-            splitter_tree_, splitter_lcp, samples, samplesize);
-    }
-
-    //! binary search on splitter array for bucket number
-    unsigned int find_bkt(const key_type& key) const
-    {
-        // binary tree traversal without left branch
-
-        unsigned int i = 1;
-
-        while (i <= num_splitters)
-        {
-            // in gcc-4.6.3 this produces a SETA, LEA sequence
-            i = 2 * i + (key <= splitter_tree_[i] ? 0 : 1);
-        }
-
-        i -= num_splitters + 1;
-
-        // < bucket
-        size_t b = i * 2;
-        if (i < num_splitters && get_splitter(i) == key)
-        {
-            // equal bucket
-            b += 1;
-        }
-
-        return b;
-    }
-
-    // in gcc-4.6.3 this produces a SETA, LEA sequence
-#define TLX_CLASSIFY_TREE_STEP                                                 \
-    for (size_t u = 0; u < Rollout; ++u)                                       \
-    {                                                                          \
-        i[u] = 2 * i[u] + (key[u] <= splitter_tree_[i[u]] ? 0 : 1);            \
-    }                                                                          \
-    TLX_ATTRIBUTE_FALLTHROUGH;
-
-    //! search in splitter tree for bucket number, unrolled for Rollout keys at
-    //! once.
-    void find_bkt_unroll(const key_type key[Rollout],
-                         std::uint16_t obkt[Rollout]) const
-    {
-        // binary tree traversal without left branch
-
-        unsigned int i[Rollout];
-        std::fill(i + 0, i + Rollout, 1);
-
-        switch (treebits)
-        {
-        default:
-            abort();
-
-        case 15:
-            TLX_CLASSIFY_TREE_STEP;
-        case 14:
-            TLX_CLASSIFY_TREE_STEP;
-        case 13:
-            TLX_CLASSIFY_TREE_STEP;
-        case 12:
-            TLX_CLASSIFY_TREE_STEP;
-        case 11:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 10:
-            TLX_CLASSIFY_TREE_STEP;
-        case 9:
-            TLX_CLASSIFY_TREE_STEP;
-        case 8:
-            TLX_CLASSIFY_TREE_STEP;
-        case 7:
-            TLX_CLASSIFY_TREE_STEP;
-        case 6:
-            TLX_CLASSIFY_TREE_STEP;
-
-        case 5:
-            TLX_CLASSIFY_TREE_STEP;
-        case 4:
-            TLX_CLASSIFY_TREE_STEP;
-        case 3:
-            TLX_CLASSIFY_TREE_STEP;
-        case 2:
-            TLX_CLASSIFY_TREE_STEP;
-        case 1:
-            TLX_CLASSIFY_TREE_STEP;
-        }
-
-        for (unsigned u = 0; u < Rollout; ++u)
-            i[u] -= num_splitters + 1;
-
-        for (unsigned u = 0; u < Rollout; ++u)
-        {
-            // < bucket
-            obkt[u] = i[u] * 2;
-        }
-
-        for (unsigned u = 0; u < Rollout; ++u)
-        {
-            // equal bucket
-            if (i[u] < num_splitters && get_splitter(i[u]) == key[u])
-                obkt[u] += 1;
-        }
-    }
-
-#undef TLX_CLASSIFY_TREE_STEP
-
-    //! classify all strings in area by walking tree and saving bucket id
-    template <typename StringSet>
-    // __attribute__ ((optimize("unroll-all-loops")))
-    void classify(const StringSet& strset, typename StringSet::Iterator begin,
-                  typename StringSet::Iterator end, std::uint16_t* bktout,
-                  size_t depth) const
-    {
-        while (begin != end)
-        {
-            if (begin + Rollout <= end)
-            {
-                key_type key[Rollout];
-                for (size_t u = 0; u < Rollout; ++u)
-                    key[u] = get_key<key_type>(strset, begin[u], depth);
-
-                find_bkt_unroll(key, bktout);
-
-                begin += Rollout, bktout += Rollout;
-            }
-            else
-            {
-                key_type key = get_key<key_type>(strset, *begin++, depth);
-                *bktout++ = this->find_bkt(key);
-            }
-        }
-    }
-
-    //! return a splitter
-    key_type get_splitter(unsigned int i) const
-    {
-        return splitter_tree_
-            [PerfectTreeCalculations<treebits>::pre_to_levelorder(i + 1)];
-    }
-
-private:
-    key_type splitter_tree_[num_splitters + 1];
-};
-
-/******************************************************************************/
-
-}} // namespace tlx::sort_strings_detail
-
-#endif // !TLX_SORT_STRINGS_SAMPLE_SORT_TOOLS_HEADER
-
-/******************************************************************************/