@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/sort/parallel_mergesort.hpp

@@ -0,0 +1,398 @@
+/*******************************************************************************
+ * tlx/sort/parallel_mergesort.hpp
+ *
+ * **EXPERIMENTAL** Parallel multiway mergesort **EXPERIMENTAL**
+ *
+ * Copied and modified from STXXL, see http://stxxl.org, which itself extracted
+ * it from MCSTL http://algo2.iti.uni-karlsruhe.de/singler/mcstl/. Both are
+ * distributed under the Boost Software License, Version 1.0.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2007 Johannes Singler <singler@ira.uka.de>
+ * Copyright (C) 2014-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_SORT_PARALLEL_MERGESORT_HEADER
+#define TLX_SORT_PARALLEL_MERGESORT_HEADER
+
+#include <tlx/algorithm/multiway_merge_splitting.hpp>
+#include <tlx/algorithm/parallel_multiway_merge.hpp>
+#include <tlx/container/simple_vector.hpp>
+#include <tlx/thread_barrier_mutex.hpp>
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <thread>
+#include <utility>
+
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+
+namespace tlx {
+
+//! \addtogroup tlx_sort
+//! \{
+
+namespace parallel_mergesort_detail {
+
+//! Subsequence description.
+template <typename DiffType>
+struct PMWMSPiece
+{
+    //! Begin of subsequence.
+    DiffType begin;
+    //! End of subsequence.
+    DiffType end;
+};
+
+/*!
+ * Data accessed by all threads.
+ *
+ * PMWMS = parallel multiway mergesort
+ */
+template <typename RandomAccessIterator>
+struct PMWMSSortingData
+{
+    using ValueType =
+        typename std::iterator_traits<RandomAccessIterator>::value_type;
+    using DiffType =
+        typename std::iterator_traits<RandomAccessIterator>::difference_type;
+
+    //! Input begin.
+    RandomAccessIterator source;
+    //! Start indices, per thread.
+    simple_vector<DiffType> starts;
+
+    /** Storage in which to sort. */
+    simple_vector<ValueType*> temporary;
+    /** Samples. */
+    simple_vector<ValueType> samples;
+    /** Offsets to add to the found positions. */
+    simple_vector<DiffType> offsets;
+    /** PMWMSPieces of data to merge \c [thread][sequence] */
+    simple_vector<simple_vector<PMWMSPiece<DiffType> > > pieces;
+
+    explicit PMWMSSortingData(size_t num_threads)
+        : starts(num_threads + 1),
+          temporary(num_threads),
+          offsets(num_threads - 1),
+          pieces(num_threads)
+    {
+    }
+};
+
+/*!
+ * Select samples from a sequence.
+ * \param sd Pointer to sorting data struct. Result will be placed in \c
+ * sd->samples. \param num_samples Number of samples to select. \param iam my
+ * thread number \param num_threads number of threads in group
+ */
+template <typename RandomAccessIterator, typename DiffType>
+void determine_samples(PMWMSSortingData<RandomAccessIterator>* sd,
+                       DiffType& num_samples, size_t iam, size_t num_threads)
+{
+    num_samples = parallel_multiway_merge_oversampling * num_threads - 1;
+
+    simple_vector<DiffType> es(num_samples + 2);
+    multiway_merge_detail::equally_split(sd->starts[iam + 1] - sd->starts[iam],
+                                         static_cast<size_t>(num_samples + 1),
+                                         es.begin());
+
+    for (DiffType i = 0; i < num_samples; i++)
+    {
+        sd->samples[iam * num_samples + i] =
+            sd->source[sd->starts[iam] + es[i + 1]];
+    }
+}
+
+/*!
+ * PMWMS code executed by each thread.
+ * \param sd Pointer to sorting data struct.
+ * \param iam my thread number
+ * \param num_threads number of threads in group
+ * \param barrier thread barrier from main function
+ * \param comp Comparator.
+ * \param mwmsa MultiwayMergeSplittingAlgorithm to use.
+ */
+template <bool Stable, typename RandomAccessIterator, typename Comparator>
+void parallel_sort_mwms_pu(PMWMSSortingData<RandomAccessIterator>* sd,
+                           size_t iam, size_t num_threads,
+                           ThreadBarrierMutex& barrier, Comparator& comp,
+                           MultiwayMergeSplittingAlgorithm mwmsa)
+{
+    using ValueType =
+        typename std::iterator_traits<RandomAccessIterator>::value_type;
+    using DiffType =
+        typename std::iterator_traits<RandomAccessIterator>::difference_type;
+
+    // length of this thread's chunk, before merging
+    DiffType length_local = sd->starts[iam + 1] - sd->starts[iam];
+
+    using SortingPlacesIterator = ValueType*;
+
+    // sort in temporary storage, leave space for sentinel
+    sd->temporary[iam] = static_cast<ValueType*>(
+        ::operator new(sizeof(ValueType) * (length_local + 1)));
+
+    // copy there
+    std::uninitialized_copy(sd->source + sd->starts[iam],
+                            sd->source + sd->starts[iam] + length_local,
+                            sd->temporary[iam]);
+
+    // sort locally
+    if (Stable)
+        std::stable_sort(sd->temporary[iam], sd->temporary[iam] + length_local,
+                         comp);
+    else
+        std::sort(sd->temporary[iam], sd->temporary[iam] + length_local, comp);
+
+    // invariant: locally sorted subsequence in sd->temporary[iam],
+    // sd->temporary[iam] + length_local
+
+    if (mwmsa == MWMSA_SAMPLING)
+    {
+        DiffType num_samples;
+        determine_samples(sd, num_samples, iam, num_threads);
+
+        barrier.wait(
+            [&]() { std::sort(sd->samples.begin(), sd->samples.end(), comp); });
+
+        for (size_t s = 0; s < num_threads; s++)
+        {
+            // for each sequence
+            if (num_samples * iam > 0)
+                sd->pieces[iam][s].begin =
+                    std::lower_bound(sd->temporary[s],
+                                     sd->temporary[s] + sd->starts[s + 1] -
+                                         sd->starts[s],
+                                     sd->samples[num_samples * iam], comp) -
+                    sd->temporary[s];
+            else
+                // absolute beginning
+                sd->pieces[iam][s].begin = 0;
+
+            if ((num_samples * (iam + 1)) < (num_samples * num_threads))
+                sd->pieces[iam][s].end =
+                    std::lower_bound(
+                        sd->temporary[s],
+                        sd->temporary[s] + sd->starts[s + 1] - sd->starts[s],
+                        sd->samples[num_samples * (iam + 1)], comp) -
+                    sd->temporary[s];
+            else
+                // absolute end
+                sd->pieces[iam][s].end = sd->starts[s + 1] - sd->starts[s];
+        }
+    }
+    else if (mwmsa == MWMSA_EXACT)
+    {
+        barrier.wait();
+
+        simple_vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
+            seqs(num_threads);
+
+        for (size_t s = 0; s < num_threads; s++)
+            seqs[s] = std::make_pair(sd->temporary[s], sd->temporary[s] +
+                                                           sd->starts[s + 1] -
+                                                           sd->starts[s]);
+
+        simple_vector<SortingPlacesIterator> offsets(num_threads);
+
+        // if not last thread
+        if (iam < num_threads - 1)
+            multisequence_partition(seqs.begin(), seqs.end(),
+                                    sd->starts[iam + 1], offsets.begin(), comp);
+
+        for (size_t seq = 0; seq < num_threads; seq++)
+        {
+            // for each sequence
+            if (iam < (num_threads - 1))
+                sd->pieces[iam][seq].end = offsets[seq] - seqs[seq].first;
+            else
+                // absolute end of this sequence
+                sd->pieces[iam][seq].end =
+                    sd->starts[seq + 1] - sd->starts[seq];
+        }
+
+        barrier.wait();
+
+        for (size_t seq = 0; seq < num_threads; seq++)
+        {
+            // for each sequence
+            if (iam > 0)
+                sd->pieces[iam][seq].begin = sd->pieces[iam - 1][seq].end;
+            else
+                // absolute beginning
+                sd->pieces[iam][seq].begin = 0;
+        }
+    }
+
+    // offset from target begin, length after merging
+    DiffType offset = 0, length_am = 0;
+    for (size_t s = 0; s < num_threads; s++)
+    {
+        length_am += sd->pieces[iam][s].end - sd->pieces[iam][s].begin;
+        offset += sd->pieces[iam][s].begin;
+    }
+
+    // merge directly to target
+
+    simple_vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
+        seqs(num_threads);
+
+    for (size_t s = 0; s < num_threads; s++)
+    {
+        seqs[s] = std::make_pair(sd->temporary[s] + sd->pieces[iam][s].begin,
+                                 sd->temporary[s] + sd->pieces[iam][s].end);
+    }
+
+    multiway_merge_base<Stable, /* Sentinels */ false>(
+        seqs.begin(), seqs.end(), sd->source + offset, length_am, comp);
+
+    barrier.wait();
+
+    operator delete(sd->temporary[iam]);
+}
+
+} // namespace parallel_mergesort_detail
+
+//! \name Parallel Sorting Algorithms
+//! \{
+
+/*!
+ * Parallel multiway mergesort main call.
+ *
+ * \param begin Begin iterator of sequence.
+ * \param end End iterator of sequence.
+ * \param comp Comparator.
+ * \param num_threads Number of threads to use.
+ * \param mwmsa MultiwayMergeSplittingAlgorithm to use.
+ * \tparam Stable Stable sorting.
+ */
+template <bool Stable, typename RandomAccessIterator, typename Comparator>
+void parallel_mergesort_base(
+    RandomAccessIterator begin, RandomAccessIterator end, Comparator comp,
+    size_t num_threads = std::thread::hardware_concurrency(),
+    MultiwayMergeSplittingAlgorithm mwmsa = MWMSA_DEFAULT)
+{
+    using namespace parallel_mergesort_detail;
+
+    using DiffType =
+        typename std::iterator_traits<RandomAccessIterator>::difference_type;
+
+    DiffType n = end - begin;
+
+    if (n <= 1)
+        return;
+
+    // at least one element per thread
+    if (num_threads > static_cast<size_t>(n))
+        num_threads = static_cast<size_t>(n);
+
+    PMWMSSortingData<RandomAccessIterator> sd(num_threads);
+    sd.source = begin;
+
+    if (mwmsa == MWMSA_SAMPLING)
+    {
+        sd.samples.resize(
+            num_threads *
+            (parallel_multiway_merge_oversampling * num_threads - 1));
+    }
+
+    for (size_t s = 0; s < num_threads; s++)
+        sd.pieces[s].resize(num_threads);
+
+    DiffType* starts = sd.starts.data();
+
+    DiffType chunk_length = n / num_threads, split = n % num_threads, start = 0;
+    for (size_t i = 0; i < num_threads; i++)
+    {
+        starts[i] = start;
+        start += (i < static_cast<size_t>(split)) ? (chunk_length + 1) :
+                                                    chunk_length;
+    }
+    starts[num_threads] = start;
+
+    // now sort in parallel
+
+    ThreadBarrierMutex barrier(num_threads);
+
+#if defined(_OPENMP)
+#pragma omp parallel num_threads(num_threads)
+    {
+        size_t iam = omp_get_thread_num();
+        parallel_sort_mwms_pu<Stable>(&sd, iam, num_threads, barrier, comp,
+                                      mwmsa);
+    }
+#else
+    simple_vector<std::thread> threads(num_threads);
+    for (size_t iam = 0; iam < num_threads; ++iam)
+    {
+        threads[iam] = std::thread([&, iam]() {
+            parallel_sort_mwms_pu<Stable>(&sd, iam, num_threads, barrier, comp,
+                                          mwmsa);
+        });
+    }
+    for (size_t i = 0; i < num_threads; i++)
+    {
+        threads[i].join();
+    }
+#endif // defined(_OPENMP)
+}
+
+/*!
+ * Parallel multiway mergesort.
+ *
+ * \param begin Begin iterator of sequence.
+ * \param end End iterator of sequence.
+ * \param comp Comparator.
+ * \param num_threads Number of threads to use.
+ * \param mwmsa MultiwayMergeSplittingAlgorithm to use.
+ */
+template <typename RandomAccessIterator,
+          typename Comparator = std::less<
+              typename std::iterator_traits<RandomAccessIterator>::value_type> >
+void parallel_mergesort(
+    RandomAccessIterator begin, RandomAccessIterator end,
+    Comparator comp = Comparator(),
+    size_t num_threads = std::thread::hardware_concurrency(),
+    MultiwayMergeSplittingAlgorithm mwmsa = MWMSA_DEFAULT)
+{
+    return parallel_mergesort_base</* Stable */ false>(begin, end, comp,
+                                                       num_threads, mwmsa);
+}
+
+/*!
+ * Stable parallel multiway mergesort.
+ *
+ * \param begin Begin iterator of sequence.
+ * \param end End iterator of sequence.
+ * \param comp Comparator.
+ * \param num_threads Number of threads to use.
+ * \param mwmsa MultiwayMergeSplittingAlgorithm to use.
+ */
+template <typename RandomAccessIterator,
+          typename Comparator = std::less<
+              typename std::iterator_traits<RandomAccessIterator>::value_type> >
+void stable_parallel_mergesort(
+    RandomAccessIterator begin, RandomAccessIterator end,
+    Comparator comp = Comparator(),
+    size_t num_threads = std::thread::hardware_concurrency(),
+    MultiwayMergeSplittingAlgorithm mwmsa = MWMSA_DEFAULT)
+{
+    return parallel_mergesort_base</* Stable */ true>(begin, end, comp,
+                                                      num_threads, mwmsa);
+}
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_SORT_PARALLEL_MERGESORT_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,232 @@
+/*******************************************************************************
+ * tlx/sort/strings/insertion_sort.hpp
+ *
+ * Base insertion string sort. This is an internal implementation header, see
+ * tlx/sort/strings.hpp for public front-end functions.
+ *
+ * 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_INSERTION_SORT_HEADER
+#define TLX_SORT_STRINGS_INSERTION_SORT_HEADER
+
+#include <tlx/define/likely.hpp>
+#include <tlx/meta/enable_if.hpp>
+#include <tlx/sort/strings/string_ptr.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_sort
+//! \{
+
+namespace sort_strings_detail {
+
+/******************************************************************************/
+
+//! Generic insertion sort for abstract string sets. This method only requires
+//! O(1) additional memory for sorting n strings, but runs in time O(nD).
+template <typename StringPtr>
+static inline typename enable_if<!StringPtr::with_lcp, void>::type
+insertion_sort(const StringPtr& strptr, size_t depth, size_t /* memory */)
+{
+    typedef typename StringPtr::StringSet StringSet;
+    typedef typename StringSet::Iterator Iterator;
+    typedef typename StringSet::String String;
+    typedef typename StringSet::CharIterator CharIterator;
+
+    // this stores the begin iterator and size n, making the loops faster
+    const typename StringPtr::StringSet& ss = strptr.active();
+    size_t n = ss.size();
+    if (n <= 1)
+        return;
+
+    const Iterator begin = ss.begin();
+    Iterator j;
+
+    for (Iterator i = begin + 1; TLX_UNLIKELY(--n != 0); ++i)
+    {
+        String tmp = std::move(ss[i]);
+        j = i;
+
+        while (TLX_LIKELY(j != begin))
+        {
+            CharIterator s = ss.get_chars(ss[j - 1], depth);
+            CharIterator t = ss.get_chars(tmp, depth);
+
+            while (TLX_LIKELY(ss.is_equal(ss[j - 1], s, tmp, t)))
+                ++s, ++t;
+
+            if (TLX_UNLIKELY(ss.is_leq(ss[j - 1], s, tmp, t)))
+                break;
+
+            ss[j] = std::move(ss[j - 1]);
+            --j;
+        }
+
+        ss[j] = std::move(tmp);
+    }
+}
+
+/******************************************************************************/
+
+//! LCP insertion sort for abstract string sets. Enabled via SFINAE if
+//! StringPtr::with_lcp is true. This method only requires O(1) additional
+//! memory for sorting n strings, and runs in time O(n^2 + D).
+template <typename StringPtr>
+static inline typename enable_if<StringPtr::with_lcp, void>::type
+insertion_sort(const StringPtr& strptr, size_t depth, size_t /* memory */)
+{
+    typedef typename StringPtr::StringSet StringSet;
+    typedef typename StringPtr::LcpType LcpType;
+    typedef typename StringSet::Iterator Iterator;
+    typedef typename StringSet::String String;
+    typedef typename StringSet::CharIterator CharIterator;
+
+    // this stores the begin iterator and size n, making the loops faster
+    const StringSet& ss = strptr.active();
+    size_t n = ss.size();
+    if (n <= 1)
+        return;
+
+    const Iterator begin = ss.begin();
+
+    for (size_t j = 0; j < n - 1; ++j)
+    {
+        // insert strings[j] into sorted strings[0..j-1]
+
+        String new_str = std::move(ss[begin + j]);
+        LcpType new_lcp = depth; // start with LCP depth
+
+        size_t i = j;
+        while (i > 0)
+        {
+            LcpType prev_lcp = new_lcp;
+
+            String cur_str = std::move(ss[begin + i - 1]);
+            LcpType cur_lcp = strptr.get_lcp(i);
+
+            if (cur_lcp < new_lcp)
+            {
+                // CASE 1: lcp goes down -> insert string
+
+                // move comparison string back
+                ss[begin + i - 1] = std::move(cur_str);
+                break;
+            }
+
+            if (cur_lcp == new_lcp)
+            {
+                // CASE 2: compare more characters
+
+                CharIterator c1 = ss.get_chars(new_str, new_lcp);
+                CharIterator c2 = ss.get_chars(cur_str, new_lcp);
+
+                while (ss.is_equal(new_str, c1, cur_str, c2))
+                    ++c1, ++c2, ++new_lcp;
+
+                // if (new_str >= curr_str) -> insert string
+                if (!ss.is_less(new_str, c1, cur_str, c2))
+                {
+                    // update lcp of prev (smaller string) with inserted string
+                    strptr.set_lcp(i, new_lcp);
+                    // lcp of inserted string with next string
+                    new_lcp = prev_lcp;
+
+                    // move comparison string back
+                    ss[begin + i - 1] = std::move(cur_str);
+                    break;
+                }
+            }
+            // else (cur_lcp > new_lcp), CASE 3: nothing to do
+
+            ss[begin + i] = std::move(cur_str);
+            strptr.set_lcp(i + 1, cur_lcp);
+
+            --i;
+        }
+
+        ss[begin + i] = std::move(new_str);
+        strptr.set_lcp(i + 1, new_lcp);
+    }
+
+    // last loop specialized with checks for out-of-bound access to lcp.
+    {
+        size_t j = n - 1;
+
+        // insert strings[j] into sorted strings[0..j-1]
+
+        String new_str = std::move(ss[begin + j]);
+        LcpType new_lcp = depth; // start with LCP depth
+
+        size_t i = j;
+        while (i > 0)
+        {
+            LcpType prev_lcp = new_lcp;
+
+            String cur_str = std::move(ss[begin + i - 1]);
+            LcpType cur_lcp = strptr.get_lcp(i);
+
+            if (cur_lcp < new_lcp)
+            {
+                // CASE 1: lcp goes down -> insert string
+
+                // move comparison string back
+                ss[begin + i - 1] = std::move(cur_str);
+                break;
+            }
+
+            if (cur_lcp == new_lcp)
+            {
+                // CASE 2: compare more characters
+
+                CharIterator c1 = ss.get_chars(new_str, new_lcp);
+                CharIterator c2 = ss.get_chars(cur_str, new_lcp);
+
+                while (ss.is_equal(new_str, c1, cur_str, c2))
+                    ++c1, ++c2, ++new_lcp;
+
+                // if (new_str >= curr_str) -> insert string
+                if (!ss.is_less(new_str, c1, cur_str, c2))
+                {
+                    // update lcp of prev (smaller string) with inserted string
+                    strptr.set_lcp(i, new_lcp);
+                    // lcp of inserted string with next string
+                    new_lcp = prev_lcp;
+
+                    // move comparison string back
+                    ss[begin + i - 1] = std::move(cur_str);
+                    break;
+                }
+            }
+            // else (cur_lcp > new_lcp), CASE 3: nothing to do
+
+            ss[begin + i] = std::move(cur_str);
+            if (i + 1 < n) // check out-of-bounds copy
+                strptr.set_lcp(i + 1, cur_lcp);
+
+            --i;
+        }
+
+        ss[begin + i] = std::move(new_str);
+        if (i + 1 < n)
+        { // check out-of-bounds save
+            strptr.set_lcp(i + 1, new_lcp);
+        }
+    }
+}
+
+/******************************************************************************/
+
+} // namespace sort_strings_detail
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_SORT_STRINGS_INSERTION_SORT_HEADER
+
+/******************************************************************************/