# list_partition.h

Go to the documentation of this file.

    00001 // -*- C++ -*-
    00002
    00003 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the terms
    00007 // of the GNU General Public License as published by the Free Software
    00008 // Foundation; either version 3, or (at your option) any later
    00009 // version.
    00010
    00011 // This library is distributed in the hope that it will be useful, but
    00012 // WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00014 // General Public License for more details.
    00015
    00016 // Under Section 7 of GPL version 3, you are granted additional
    00017 // permissions described in the GCC Runtime Library Exception, version
    00018 // 3.1, as published by the Free Software Foundation.
    00019
    00020 // You should have received a copy of the GNU General Public License and
    00021 // a copy of the GCC Runtime Library Exception along with this program;
    00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    00023 // <http://www.gnu.org/licenses/>.
    00024
    00025 /** @file parallel/list_partition.h
    00026  *  @brief Functionality to split sequence referenced by only input
    00027  *  iterators.
    00028  *  This file is a GNU parallel extension to the Standard C++ Library.
    00029  */
    00030
    00031 // Written by Leonor Frias Moya and Johannes Singler.
    00032
    00033 #ifndef _GLIBCXX_PARALLEL_LIST_PARTITION_H
    00034 #define _GLIBCXX_PARALLEL_LIST_PARTITION_H 1
    00035
    00036 #include <parallel/parallel.h>
    00037 #include <vector>
    00038
    00039 namespace __gnu_parallel
    00040 {
    00041   /** @brief Shrinks and doubles the ranges.
    00042    *  @param os_starts Start positions worked on (oversampled).
    00043    *  @param count_to_two Counts up to 2.
    00044    *  @param range_length Current length of a chunk.
    00045    *  @param make_twice Whether the @c os_starts is allowed to be
    00046    *  grown or not
    00047    */
    00048   template<typename InputIterator>
    00049     void
    00050     shrink_and_double(std::vector<InputIterator>& os_starts,
    00051               size_t& count_to_two, size_t& range_length,
    00052               const bool make_twice)
    00053     {
    00054       ++count_to_two;
    00055       if (not make_twice or count_to_two < 2)
    00056     shrink(os_starts, count_to_two, range_length);
    00057       else
    00058     {
    00059       os_starts.resize((os_starts.size() - 1) * 2 + 1);
    00060       count_to_two = 0;
    00061     }
    00062     }
    00063
    00064   /** @brief Combines two ranges into one and thus halves the number of ranges.
    00065    *  @param os_starts Start positions worked on (oversampled).
    00066    *  @param count_to_two Counts up to 2.
    00067    *  @param range_length Current length of a chunk. */
    00068   template<typename InputIterator>
    00069     void
    00070     shrink(std::vector<InputIterator>& os_starts, size_t& count_to_two,
    00071        size_t& range_length)
    00072     {
    00073       for (typename std::vector<InputIterator>::size_type i = 0;
    00074        i <= (os_starts.size() / 2); ++i)
    00075     os_starts[i] = os_starts[i * 2];
    00076       range_length *= 2;
    00077     }
    00078
    00079   /** @brief Splits a sequence given by input iterators into parts of
    00080    * almost equal size
    00081    *
    00082    *  The function needs only one pass over the sequence.
    00083    *  @param begin Begin iterator of input sequence.
    00084    *  @param end End iterator of input sequence.
    00085    *  @param starts Start iterators for the resulting parts, dimension
    00086    *  @c num_parts+1. For convenience, @c starts @c [num_parts]
    00087    *  contains the end iterator of the sequence.
    00088    *  @param lengths Length of the resulting parts.
    00089    *  @param num_parts Number of parts to split the sequence into.
    00090    *  @param f Functor to be applied to each element by traversing it
    00091    *  @param oversampling Oversampling factor. If 0, then the
    00092    *  partitions will differ in at most @f$ \sqrt{\mathrm{end} -
    00093    *  \mathrm{begin}} @f$ elements. Otherwise, the ratio between the
    00094    *  longest and the shortest part is bounded by @f$
    00095    *  1/(\mathrm{oversampling} \cdot \mathrm{num\_parts}) @f$.
    00096    *  @return Length of the whole sequence.
    00097    */
    00098   template<typename InputIterator, typename FunctorType>
    00099     size_t
    00100     list_partition(const InputIterator begin, const InputIterator end,
    00101            InputIterator* starts, size_t* lengths, const int num_parts,
    00102            FunctorType& f, int oversampling = 0)
    00103     {
    00104       bool make_twice = false;
    00105
    00106       // The resizing algorithm is chosen according to the oversampling factor.
    00107       if (oversampling == 0)
    00108     {
    00109       make_twice = true;
    00110       oversampling = 1;
    00111     }
    00112
    00113       std::vector<InputIterator> os_starts(2 * oversampling * num_parts + 1);
    00114
    00115       os_starts[0]= begin;
    00116       InputIterator prev = begin, it = begin;
    00117       size_t dist_limit = 0, dist = 0;
    00118       size_t cur = 1, next = 1;
    00119       size_t range_length = 1;
    00120       size_t count_to_two = 0;
    00121       while (it != end)
    00122     {
    00123       cur = next;
    00124       for (; cur < os_starts.size() and it != end; ++cur)
    00125         {
    00126           for (dist_limit += range_length;
    00127            dist < dist_limit and it != end; ++dist)
    00128         {
    00129           f(it);
    00130           ++it;
    00131         }
    00132           os_starts[cur] = it;
    00133         }
    00134
    00135       // Must compare for end and not cur < os_starts.size() , because
    00136       // cur could be == os_starts.size() as well
    00137       if (it == end)
    00138         break;
    00139
    00140       shrink_and_double(os_starts, count_to_two, range_length, make_twice);
    00141       next = os_starts.size() / 2 + 1;
    00142     }
    00143
    00144       // Calculation of the parts (one must be extracted from current
    00145       // because the partition beginning at end, consists only of
    00146       // itself).
    00147       size_t size_part = (cur - 1) / num_parts;
    00148       int size_greater = static_cast<int>((cur - 1) % num_parts);
    00149       starts[0] = os_starts[0];
    00150
    00151       size_t index = 0;
    00152
    00153       // Smallest partitions.
    00154       for (int i = 1; i < (num_parts + 1 - size_greater); ++i)
    00155     {
    00156       lengths[i - 1] =  size_part * range_length;
    00157       index += size_part;
    00158       starts[i] = os_starts[index];
    00159     }
    00160
    00161       // Biggest partitions.
    00162       for (int i = num_parts + 1 - size_greater; i <= num_parts; ++i)
    00163     {
    00164       lengths[i - 1] =  (size_part+1) * range_length;
    00165       index += (size_part+1);
    00166       starts[i] = os_starts[index];
    00167     }
    00168
    00169       // Correction of the end size (the end iteration has not finished).
    00170       lengths[num_parts - 1] -= (dist_limit - dist);
    00171
    00172       return dist;
    00173     }
    00174 }
    00175
    00176 #endif /* _GLIBCXX_PARALLEL_LIST_PARTITION_H */