@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,934 +0,0 @@
-/*******************************************************************************
- * tlx/sort/strings/radix_sort.hpp
- *
- * Out-of-place and in-place radix sort for strings. This is an internal
- * implementation header, see tlx/sort/strings.hpp for public front-end
- * functions.
- *
- * These are explicit stack-based most-significant-digit radix sort
- * implementations. All implementations were written by Timo Bingmann and are
- * based on work by Juha Kärkkäinen and Tommi Rantala. "Engineering Radix Sort
- * for Strings."  International Symposium on String Processing and Information
- * Retrieval (SPIRE). Springer, 2008.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2015-2019 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_SORT_STRINGS_RADIX_SORT_HEADER
-#define TLX_SORT_STRINGS_RADIX_SORT_HEADER
-
-#include <tlx/container/simple_vector.hpp>
-#include <tlx/define/likely.hpp>
-#include <tlx/sort/strings/multikey_quicksort.hpp>
-#include <tlx/sort/strings/string_ptr.hpp>
-#include <cstdint>
-#include <stack>
-#include <utility>
-#include <vector>
-
-namespace tlx {
-
-//! \addtogroup tlx_sort
-//! \{
-
-namespace sort_strings_detail {
-
-/******************************************************************************/
-
-static const size_t g_inssort_threshold = 32;
-
-/******************************************************************************/
-// Out-of-place 8-bit radix-sort WITHOUT character caching.
-
-template <typename StringShadowPtr>
-struct RadixStep_CE0
-{
-    StringShadowPtr strptr;
-    size_t idx, pos, bkt_size[256];
-
-    typedef typename StringShadowPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator Iterator;
-
-    RadixStep_CE0(const StringShadowPtr& in_strptr, size_t depth)
-        : strptr(in_strptr)
-    {
-        const StringSet& ss = strptr.active();
-
-        // count character occurrences
-        std::fill(bkt_size, bkt_size + 256, 0);
-        for (Iterator i = ss.begin(); i != ss.end(); ++i)
-            ++bkt_size[ss.get_uint8(ss[i], depth)];
-
-        // prefix sum
-        Iterator bkt_index[256];
-        bkt_index[0] = strptr.shadow().begin();
-        for (size_t i = 1; i < 256; ++i)
-            bkt_index[i] = bkt_index[i - 1] + bkt_size[i - 1];
-
-        // distribute
-        for (Iterator i = ss.begin(); i != ss.end(); ++i)
-            *(bkt_index[ss.get_uint8(ss[i], depth)]++) = std::move(ss[i]);
-
-        // will increment to 1 on first process
-        idx = 0;
-        pos = bkt_size[0];
-
-        // copy back finished strings in zeroth bucket
-        strptr.flip(0, pos).copy_back();
-
-        // store lcps
-        if (strptr.with_lcp)
-        {
-            size_t size = ss.size();
-
-            // set lcps of zero-terminated strings
-            for (size_t i = 1; i < pos; ++i)
-                strptr.set_lcp(i, depth);
-
-            // set lcps between non-empty bucket boundaries
-            size_t bkt = bkt_size[0], i = 1;
-            if (bkt > 0 && bkt < size)
-                strptr.set_lcp(bkt, depth);
-            while (i < 256)
-            {
-                while (i < 256 && bkt_size[i] == 0)
-                    ++i;
-                bkt += bkt_size[i];
-                if (bkt >= size)
-                    break;
-                strptr.set_lcp(bkt, depth);
-                ++i;
-            }
-        }
-    }
-};
-
-/*
- * Out-of-place 8-bit radix-sort WITHOUT character caching.
- */
-template <typename StringShadowPtr>
-static inline void radixsort_CE0_loop(const StringShadowPtr& strptr,
-                                      size_t depth, size_t memory)
-{
-    typedef RadixStep_CE0<StringShadowPtr> RadixStep;
-
-    std::stack<RadixStep, std::vector<RadixStep> > radixstack;
-    radixstack.emplace(strptr, depth);
-
-    while (!radixstack.empty())
-    {
-        while (radixstack.top().idx < 255)
-        {
-            RadixStep& rs = radixstack.top();
-
-            // process the bucket rs.idx
-            size_t bkt_size = rs.bkt_size[++rs.idx];
-
-            if (bkt_size == 0)
-            {
-                // done
-            }
-            else if (bkt_size < g_inssort_threshold)
-            {
-                insertion_sort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                               depth + radixstack.size(),
-                               memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(memory != 0 &&
-                                  memory < sizeof(RadixStep) *
-                                               (radixstack.size() + 1)))
-            {
-                multikey_quicksort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                                   depth + radixstack.size(),
-                                   memory -
-                                       sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else
-            {
-                rs.pos += bkt_size;
-                radixstack.emplace(rs.strptr.flip(rs.pos - bkt_size, bkt_size),
-                                   depth + radixstack.size());
-                // cannot add here, because rs may have invalidated
-            }
-        }
-        radixstack.pop();
-    }
-}
-
-/*!
- * Adapter method to allocate shadow array if needed.
- */
-template <typename StringPtr>
-static inline void radixsort_CE0(const StringPtr& strptr, size_t depth,
-                                 size_t memory)
-{
-    typedef typename StringPtr::StringSet StringSet;
-    const StringSet& ss = strptr.active();
-    if (ss.size() < g_inssort_threshold)
-        return insertion_sort(strptr, depth, memory);
-
-    typedef RadixStep_CE0<typename StringPtr::WithShadow> RadixStep;
-
-    // try to estimate the amount of memory used
-    size_t memory_use = 2 * sizeof(size_t) + sizeof(StringSet) +
-                        ss.size() * sizeof(typename StringSet::String);
-    size_t memory_slack = 3 * sizeof(RadixStep);
-
-    if (memory != 0 && memory < memory_use + memory_slack + 1)
-        return multikey_quicksort(strptr, depth, memory);
-
-    typename StringSet::Container shadow = ss.allocate(ss.size());
-    radixsort_CE0_loop(strptr.add_shadow(StringSet(shadow)), depth,
-                       memory - memory_use);
-    StringSet::deallocate(shadow);
-}
-
-/******************************************************************************/
-// Out-of-place 8-bit radix-sort with character caching.
-
-template <typename StringShadowPtr>
-struct RadixStep_CE2
-{
-    StringShadowPtr strptr;
-    size_t idx, pos, bkt_size[256];
-
-    typedef typename StringShadowPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator Iterator;
-
-    RadixStep_CE2(const StringShadowPtr& in_strptr, size_t depth,
-                  std::uint8_t* charcache)
-        : strptr(in_strptr)
-    {
-        const StringSet& ss = strptr.active();
-        const size_t n = ss.size();
-
-        // read characters and count character occurrences
-        std::fill(bkt_size, bkt_size + 256, 0);
-        std::uint8_t* cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *cc = ss.get_uint8(ss[i], depth);
-        for (cc = charcache; cc != charcache + n; ++cc)
-            ++bkt_size[static_cast<std::uint8_t>(*cc)];
-
-        // prefix sum
-        Iterator bkt_index[256];
-        bkt_index[0] = strptr.shadow().begin();
-        for (size_t i = 1; i < 256; ++i)
-            bkt_index[i] = bkt_index[i - 1] + bkt_size[i - 1];
-
-        // distribute
-        cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *(bkt_index[static_cast<std::uint8_t>(*cc)]++) = std::move(ss[i]);
-
-        idx = 0; // will increment to 1 on first process
-        pos = bkt_size[0];
-
-        // copy back finished strings in zeroth bucket
-        strptr.flip(0, pos).copy_back();
-
-        // store lcps
-        if (strptr.with_lcp)
-        {
-            size_t size = ss.size();
-
-            // set lcps of zero-terminated strings
-            for (size_t i = 1; i < pos; ++i)
-                strptr.set_lcp(i, depth);
-
-            // set lcps between non-empty bucket boundaries
-            size_t bkt = bkt_size[0], i = 1;
-            if (bkt > 0 && bkt < size)
-                strptr.set_lcp(bkt, depth);
-            while (i < 256)
-            {
-                while (i < 256 && bkt_size[i] == 0)
-                    ++i;
-                bkt += bkt_size[i];
-                if (bkt >= size)
-                    break;
-                strptr.set_lcp(bkt, depth);
-                ++i;
-            }
-        }
-    }
-};
-
-template <typename StringPtr>
-static inline void radixsort_CI3(const StringPtr& strptr,
-                                 std::uint16_t* charcache, size_t depth,
-                                 size_t memory);
-
-/*
- * Out-of-place 8-bit radix-sort with character caching.
- */
-template <typename StringShadowPtr>
-static inline void radixsort_CE2_loop(const StringShadowPtr& strptr,
-                                      std::uint8_t* charcache, size_t depth,
-                                      size_t memory)
-{
-    typedef RadixStep_CE2<StringShadowPtr> RadixStep;
-
-    std::stack<RadixStep, std::vector<RadixStep> > radixstack;
-    radixstack.emplace(strptr, depth, charcache);
-
-    while (TLX_LIKELY(!radixstack.empty()))
-    {
-        while (TLX_LIKELY(radixstack.top().idx < 255))
-        {
-            RadixStep& rs = radixstack.top();
-
-            // process the bucket rs.idx
-            size_t bkt_size = rs.bkt_size[++rs.idx];
-
-            if (TLX_UNLIKELY(bkt_size == 0))
-            {
-                // done
-            }
-            else if (bkt_size < g_inssort_threshold)
-            {
-                insertion_sort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                               depth + radixstack.size(),
-                               memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(memory != 0 &&
-                                  memory < sizeof(RadixStep) *
-                                               (radixstack.size() + 1)))
-            {
-                multikey_quicksort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                                   depth + radixstack.size(),
-                                   memory -
-                                       sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else
-            {
-                // have to increment first, as rs may be invalidated
-                rs.pos += bkt_size;
-                radixstack.emplace(rs.strptr.flip(rs.pos - bkt_size, bkt_size),
-                                   depth + radixstack.size(), charcache);
-            }
-        }
-        radixstack.pop();
-    }
-}
-
-template <typename StringPtr>
-static inline void radixsort_CE2(const StringPtr& strptr, size_t depth,
-                                 size_t memory)
-{
-    typedef typename StringPtr::StringSet StringSet;
-    const StringSet& ss = strptr.active();
-    if (ss.size() < g_inssort_threshold)
-        return insertion_sort(strptr, depth, memory);
-
-    typedef RadixStep_CE2<typename StringPtr::WithShadow> RadixStep;
-
-    // try to estimate the amount of memory used
-    size_t memory_use = 2 * sizeof(size_t) + sizeof(StringSet) +
-                        ss.size() * sizeof(std::uint8_t) +
-                        ss.size() * sizeof(typename StringSet::String);
-    size_t memory_slack = 3 * sizeof(RadixStep);
-
-    if (memory != 0 && memory < memory_use + memory_slack + 1)
-        return radixsort_CI3(strptr, depth, memory);
-
-    typename StringSet::Container shadow = ss.allocate(ss.size());
-    std::uint8_t* charcache = new std::uint8_t[ss.size()];
-
-    radixsort_CE2_loop(strptr.add_shadow(StringSet(shadow)), charcache, depth,
-                       memory - memory_use);
-
-    delete[] charcache;
-    StringSet::deallocate(shadow);
-}
-
-/******************************************************************************/
-// Out-of-place adaptive radix-sort with character caching
-
-template <typename StringShadowPtr>
-struct RadixStep_CE3
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    StringShadowPtr strptr;
-    size_t idx, pos, bkt_size[RADIX];
-
-    typedef typename StringShadowPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator Iterator;
-
-    RadixStep_CE3(const StringShadowPtr& in_strptr, size_t depth,
-                  std::uint16_t* charcache)
-        : strptr(in_strptr)
-    {
-        const StringSet& ss = strptr.active();
-        const size_t n = ss.size();
-
-        // read characters and count character occurrences
-        std::fill(bkt_size, bkt_size + RADIX, 0);
-        std::uint16_t* cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *cc = ss.get_uint16(ss[i], depth);
-        for (cc = charcache; cc != charcache + n; ++cc)
-            ++bkt_size[static_cast<std::uint16_t>(*cc)];
-
-        // prefix sum
-        simple_vector<Iterator> bkt_index(RADIX);
-        bkt_index[0] = strptr.shadow().begin();
-        for (size_t i = 1; i < RADIX; ++i)
-            bkt_index[i] = bkt_index[i - 1] + bkt_size[i - 1];
-
-        // store lcps
-        if (strptr.with_lcp)
-        {
-            // set lcps of zero-terminated strings
-            for (size_t i = 1; i < bkt_size[0]; ++i)
-                strptr.set_lcp(i, depth);
-
-            // set lcps between non-empty bucket boundaries
-            size_t first = get_next_non_empty_bkt_index(0);
-            size_t bkt = bkt_index[first] + bkt_size[first] - bkt_index[0];
-
-            size_t second = get_next_non_empty_bkt_index(first + 1);
-            while (second < RADIX)
-            {
-                size_t partial_equal =
-                    static_cast<size_t>((first >> 8) == (second >> 8));
-                strptr.set_lcp(bkt, depth + partial_equal);
-                bkt += bkt_size[second];
-                first = second;
-                second = get_next_non_empty_bkt_index(second + 1);
-            }
-        }
-
-        // distribute
-        cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *(bkt_index[static_cast<std::uint16_t>(*cc)]++) = std::move(ss[i]);
-
-        // will increment to 1 on first process
-        idx = 0;
-        pos = bkt_size[0];
-
-        // copy back finished strings in zeroth bucket
-        strptr.flip(0, pos).copy_back();
-    }
-
-    size_t get_next_non_empty_bkt_index(size_t start)
-    {
-        if (start >= RADIX)
-            return RADIX;
-        while (start < RADIX && bkt_size[start] == 0)
-            ++start;
-        return start;
-    }
-};
-
-/*
- * Out-of-place adaptive radix-sort with character caching which starts with
- * 16-bit radix sort and then switching to 8-bit for smaller string sets.
- */
-template <typename StringShadowPtr>
-static inline void radixsort_CE3_loop(const StringShadowPtr& strptr,
-                                      std::uint16_t* charcache, size_t depth,
-                                      size_t memory)
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    typedef RadixStep_CE3<StringShadowPtr> RadixStep;
-
-    std::stack<RadixStep, std::vector<RadixStep> > radixstack;
-    radixstack.emplace(strptr, depth, charcache);
-
-    while (TLX_LIKELY(!radixstack.empty()))
-    {
-        while (TLX_LIKELY(radixstack.top().idx < RADIX - 1))
-        {
-            RadixStep& rs = radixstack.top();
-
-            // process the bucket rs.idx
-            size_t bkt_size = rs.bkt_size[++rs.idx];
-
-            if (TLX_UNLIKELY(bkt_size == 0))
-            {
-                // done
-            }
-            else if (TLX_UNLIKELY((rs.idx & 0xFF) == 0))
-            {
-                // zero-termination
-                rs.strptr.flip(rs.pos, bkt_size).copy_back();
-                for (size_t i = rs.pos + 1; i < rs.pos + bkt_size; ++i)
-                    rs.strptr.set_lcp(i, depth + 2 * radixstack.size() - 1);
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(bkt_size < g_inssort_threshold))
-            {
-                insertion_sort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                               depth + 2 * radixstack.size(),
-                               memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (bkt_size < RADIX)
-            {
-                radixsort_CE2_loop(rs.strptr.flip(rs.pos, bkt_size),
-                                   reinterpret_cast<std::uint8_t*>(charcache),
-                                   depth + 2 * radixstack.size(),
-                                   memory -
-                                       sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(memory != 0 &&
-                                  memory < sizeof(RadixStep) *
-                                               (radixstack.size() + 1)))
-            {
-                multikey_quicksort(rs.strptr.flip(rs.pos, bkt_size).copy_back(),
-                                   depth + 2 * radixstack.size(),
-                                   memory -
-                                       sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else
-            {
-                // have to increment first, as rs may be invalidated
-                rs.pos += bkt_size;
-                radixstack.emplace(rs.strptr.flip(rs.pos - bkt_size, bkt_size),
-                                   depth + 2 * radixstack.size(), charcache);
-            }
-        }
-        radixstack.pop();
-    }
-}
-
-template <typename StringPtr>
-static inline void radixsort_CE3(const StringPtr& strptr, size_t depth,
-                                 size_t memory)
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    typedef typename StringPtr::StringSet StringSet;
-
-    const StringSet& ss = strptr.active();
-    if (ss.size() < g_inssort_threshold)
-        return insertion_sort(strptr, depth, memory);
-
-    if (ss.size() < RADIX)
-        return radixsort_CE2(strptr, depth, memory);
-
-    typedef RadixStep_CE3<typename StringPtr::WithShadow> RadixStep;
-
-    // try to estimate the amount of memory used
-    size_t memory_use = 2 * sizeof(size_t) + sizeof(StringSet) +
-                        ss.size() * sizeof(std::uint16_t) +
-                        ss.size() * sizeof(typename StringSet::String);
-    size_t memory_slack = 3 * sizeof(RadixStep);
-
-    if (memory != 0 && memory < memory_use + memory_slack + 1)
-        return radixsort_CE2(strptr, depth, memory);
-
-    typename StringSet::Container shadow = ss.allocate(ss.size());
-    std::uint16_t* charcache = new std::uint16_t[ss.size()];
-
-    radixsort_CE3_loop(strptr.add_shadow(StringSet(shadow)), charcache, depth,
-                       memory - memory_use);
-
-    delete[] charcache;
-    StringSet::deallocate(shadow);
-}
-
-/******************************************************************************/
-// In-place 8-bit radix-sort with character caching.
-
-template <typename StringPtr>
-struct RadixStep_CI2
-{
-    typedef typename StringPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator Iterator;
-    typedef typename StringSet::String String;
-
-    size_t idx, pos;
-    size_t bkt_size[256];
-
-    RadixStep_CI2(const StringPtr& strptr, size_t base, size_t depth,
-                  std::uint8_t* charcache)
-    {
-        const StringSet& ss = strptr.active();
-        size_t size = ss.size();
-
-        // read characters and count character occurrences
-        std::fill(bkt_size, bkt_size + 256, 0);
-        std::uint8_t* cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *cc = ss.get_uint8(ss[i], depth);
-        for (cc = charcache; cc != charcache + size; ++cc)
-            ++bkt_size[static_cast<std::uint8_t>(*cc)];
-
-        // inclusive prefix sum
-        size_t bkt[256];
-        bkt[0] = bkt_size[0];
-        size_t last_bkt_size = bkt_size[0];
-        for (size_t i = 1; i < 256; ++i)
-        {
-            bkt[i] = bkt[i - 1] + bkt_size[i];
-            if (bkt_size[i] != 0)
-                last_bkt_size = bkt_size[i];
-        }
-
-        // premute in-place
-        for (size_t i = 0, j; i < size - last_bkt_size;)
-        {
-            String perm = std::move(ss[ss.begin() + i]);
-            std::uint8_t permch = charcache[i];
-            while ((j = --bkt[permch]) > i)
-            {
-                std::swap(perm, ss[ss.begin() + j]);
-                std::swap(permch, charcache[j]);
-            }
-            ss[ss.begin() + i] = std::move(perm);
-            i += bkt_size[permch];
-        }
-
-        // will increment idx to 1 in first step, bkt 0 is not sorted further
-        idx = 0;
-        pos = base + bkt_size[0];
-
-        // store lcps
-        if (strptr.with_lcp)
-        {
-            // set lcps of zero-terminated strings
-            for (size_t i = 1; i < bkt_size[0]; ++i)
-                strptr.set_lcp(i, depth);
-
-            // set lcps between non-empty bucket boundaries
-            size_t lbkt = bkt_size[0], i = 1;
-            if (lbkt > 0 && lbkt < size)
-                strptr.set_lcp(lbkt, depth);
-            while (i < 256)
-            {
-                while (i < 256 && bkt_size[i] == 0)
-                    ++i;
-                lbkt += bkt_size[i];
-                if (lbkt >= size)
-                    break;
-                strptr.set_lcp(lbkt, depth);
-                ++i;
-            }
-        }
-    }
-};
-
-/*
- * In-place 8-bit radix-sort with character caching.
- */
-template <typename StringPtr>
-static inline void radixsort_CI2(const StringPtr& strptr,
-                                 std::uint8_t* charcache, size_t depth,
-                                 size_t memory)
-{
-    typedef RadixStep_CI2<StringPtr> RadixStep;
-
-    std::stack<RadixStep, std::vector<RadixStep> > radixstack;
-    radixstack.emplace(strptr, /* base */ 0, depth, charcache);
-
-    while (TLX_LIKELY(!radixstack.empty()))
-    {
-        while (TLX_LIKELY(radixstack.top().idx < 255))
-        {
-            RadixStep& rs = radixstack.top();
-
-            // process the bucket rs.idx
-            size_t bkt_size = rs.bkt_size[++rs.idx];
-
-            if (TLX_UNLIKELY(bkt_size <= 1))
-            {
-                // done
-                rs.pos += bkt_size;
-            }
-            else if (bkt_size < g_inssort_threshold)
-            {
-                insertion_sort(strptr.sub(rs.pos, bkt_size),
-                               depth + radixstack.size(),
-                               memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(memory != 0 &&
-                                  memory < sizeof(RadixStep) *
-                                               (radixstack.size() + 1)))
-            {
-                multikey_quicksort(
-                    strptr.sub(rs.pos, bkt_size), depth + radixstack.size(),
-                    memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else
-            {
-                // have to increment first, as rs may be invalidated
-                rs.pos += bkt_size;
-                radixstack.emplace(strptr.sub(rs.pos - bkt_size, bkt_size),
-                                   rs.pos - bkt_size, depth + radixstack.size(),
-                                   charcache);
-            }
-        }
-        radixstack.pop();
-    }
-}
-
-/*
- * In-place 8-bit radix-sort with character caching.
- */
-template <typename StringPtr>
-static inline void radixsort_CI2(const StringPtr& strptr, size_t depth,
-                                 size_t memory)
-{
-    typedef typename StringPtr::StringSet StringSet;
-
-    if (strptr.size() < g_inssort_threshold)
-        return insertion_sort(strptr, depth, memory);
-
-    typedef RadixStep_CI2<StringPtr> RadixStep;
-
-    // try to estimate the amount of memory used
-    size_t memory_use = 2 * sizeof(size_t) + sizeof(StringSet) +
-                        strptr.size() * sizeof(std::uint8_t);
-    size_t memory_slack = 3 * sizeof(RadixStep);
-
-    if (memory != 0 && memory < memory_use + memory_slack + 1)
-        return multikey_quicksort(strptr, depth, memory);
-
-    std::uint8_t* charcache = new std::uint8_t[strptr.size()];
-
-    radixsort_CI2(strptr, charcache, depth, memory - memory_use);
-
-    delete[] charcache;
-}
-
-/******************************************************************************/
-// In-place adaptive radix-sort with character caching
-
-template <typename StringPtr>
-struct RadixStep_CI3
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    typedef typename StringPtr::StringSet StringSet;
-    typedef typename StringSet::Iterator Iterator;
-    typedef typename StringSet::String String;
-
-    size_t idx, pos;
-    size_t bkt_size[RADIX];
-
-    RadixStep_CI3(const StringPtr& strptr, size_t base, size_t depth,
-                  std::uint16_t* charcache)
-    {
-        const StringSet& ss = strptr.active();
-        const size_t n = ss.size();
-        // read characters and count character occurrences
-        std::fill(bkt_size, bkt_size + RADIX, 0);
-        std::uint16_t* cc = charcache;
-        for (Iterator i = ss.begin(); i != ss.end(); ++i, ++cc)
-            *cc = ss.get_uint16(ss[i], depth);
-        for (cc = charcache; cc != charcache + n; ++cc)
-            ++bkt_size[static_cast<std::uint16_t>(*cc)];
-
-        // inclusive prefix sum
-        simple_vector<size_t> bkt_index(RADIX);
-        bkt_index[0] = bkt_size[0];
-        size_t last_bkt_size = bkt_size[0];
-        for (size_t i = 1; i < RADIX; ++i)
-        {
-            bkt_index[i] = bkt_index[i - 1] + bkt_size[i];
-            if (bkt_size[i])
-                last_bkt_size = bkt_size[i];
-        }
-
-        // store lcps
-        if (strptr.with_lcp)
-        {
-            // set lcps of zero-terminated strings
-            for (size_t i = 1; i < bkt_size[0]; ++i)
-                strptr.set_lcp(i, depth);
-
-            // set lcps between non-empty bucket boundaries
-            size_t first = get_next_non_empty_bkt_index(0);
-            size_t bkt = bkt_index[first];
-
-            size_t second = get_next_non_empty_bkt_index(first + 1);
-            while (second < RADIX)
-            {
-                size_t partial_equal =
-                    static_cast<size_t>((first >> 8) == (second >> 8));
-                strptr.set_lcp(bkt, depth + partial_equal);
-                bkt += bkt_size[second];
-                first = second;
-                second = get_next_non_empty_bkt_index(second + 1);
-            }
-        }
-
-        // premute in-place
-        for (size_t i = 0, j; i < n - last_bkt_size;)
-        {
-            String perm = std::move(ss[ss.begin() + i]);
-            std::uint16_t permch = charcache[i];
-            while ((j = --bkt_index[permch]) > i)
-            {
-                std::swap(perm, ss[ss.begin() + j]);
-                std::swap(permch, charcache[j]);
-            }
-            ss[ss.begin() + i] = std::move(perm);
-            i += bkt_size[permch];
-        }
-
-        // will increment to 1 on first process, bkt 0 is not sorted further
-        idx = 0;
-        pos = base + bkt_size[0];
-    }
-
-    size_t get_next_non_empty_bkt_index(size_t start)
-    {
-        if (start >= RADIX)
-            return RADIX;
-        while (start < RADIX && bkt_size[start] == 0)
-            ++start;
-        return start;
-    }
-};
-
-/*
- * In-place adaptive radix-sort with character caching which starts with 16-bit
- * radix sort and then switching to 8-bit for smaller string sets.
- */
-template <typename StringPtr>
-static inline void radixsort_CI3(const StringPtr& strptr,
-                                 std::uint16_t* charcache, size_t depth,
-                                 size_t memory)
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    typedef RadixStep_CI3<StringPtr> RadixStep;
-
-    std::stack<RadixStep, std::vector<RadixStep> > radixstack;
-    radixstack.emplace(strptr, /* base */ 0, depth, charcache);
-
-    while (TLX_LIKELY(!radixstack.empty()))
-    {
-        while (TLX_LIKELY(radixstack.top().idx < RADIX - 1))
-        {
-            RadixStep& rs = radixstack.top();
-
-            // process the bucket rs.idx
-            size_t bkt_size = rs.bkt_size[++rs.idx];
-
-            if (TLX_UNLIKELY(bkt_size <= 1))
-            {
-                // done
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY((rs.idx & 0xFF) == 0))
-            {
-                // zero-termination
-                for (size_t i = rs.pos + 1; i < rs.pos + bkt_size; ++i)
-                    strptr.set_lcp(i, depth + 2 * radixstack.size() - 1);
-
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(bkt_size < g_inssort_threshold))
-            {
-                insertion_sort(strptr.sub(rs.pos, bkt_size),
-                               depth + 2 * radixstack.size(),
-                               memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (bkt_size < RADIX)
-            {
-                radixsort_CI2(strptr.sub(rs.pos, bkt_size),
-                              reinterpret_cast<std::uint8_t*>(charcache),
-                              depth + 2 * radixstack.size(),
-                              memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else if (TLX_UNLIKELY(memory != 0 &&
-                                  memory < sizeof(RadixStep) *
-                                               (radixstack.size() + 1)))
-            {
-                multikey_quicksort(
-                    strptr.sub(rs.pos, bkt_size), depth + 2 * radixstack.size(),
-                    memory - sizeof(RadixStep) * radixstack.size());
-                rs.pos += bkt_size;
-            }
-            else
-            {
-                // have to increment first, as rs may be invalidated
-                rs.pos += bkt_size;
-                radixstack.emplace(strptr.sub(rs.pos - bkt_size, bkt_size),
-                                   /* base */ rs.pos - bkt_size,
-                                   depth + 2 * radixstack.size(), charcache);
-            }
-        }
-        radixstack.pop();
-    }
-}
-
-template <typename StringPtr>
-static inline void radixsort_CI3(const StringPtr& strptr, size_t depth,
-                                 size_t memory)
-{
-    enum
-    {
-        RADIX = 0x10000
-    };
-
-    typedef typename StringPtr::StringSet StringSet;
-
-    if (strptr.size() < g_inssort_threshold)
-        return insertion_sort(strptr, depth, memory);
-
-    if (strptr.size() < RADIX)
-        return radixsort_CI2(strptr, depth, memory);
-
-    typedef RadixStep_CI3<StringPtr> RadixStep;
-
-    // try to estimate the amount of memory used
-    size_t memory_use = 2 * sizeof(size_t) + sizeof(StringSet) +
-                        strptr.size() * sizeof(std::uint16_t);
-    size_t memory_slack = 3 * sizeof(RadixStep);
-
-    if (memory != 0 && memory < memory_use + memory_slack + 1)
-        return radixsort_CI2(strptr, depth, memory);
-
-    std::uint16_t* charcache = new std::uint16_t[strptr.size()];
-    radixsort_CI3(strptr, charcache, depth, memory - memory_use);
-    delete[] charcache;
-}
-
-/******************************************************************************/
-
-} // namespace sort_strings_detail
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_SORT_STRINGS_RADIX_SORT_HEADER
-
-/******************************************************************************/