@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,398 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,232 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/