OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [parallel/] [multiway_merge.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe 
// -*- C++ -*-
2 
 
3 
// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 
//
5 
// This file is part of the GNU ISO C++ Library.  This library is free
6 
// software; you can redistribute it and/or modify it under the terms
7 
// of the GNU General Public License as published by the Free Software
8 
// Foundation; either version 3, or (at your option) any later
9 
// version.
10 
 
11 
// This library is distributed in the hope that it will be useful, but
12 
// WITHOUT ANY WARRANTY; without even the implied warranty of
13 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
// General Public License for more details.
15 
 
16 
// Under Section 7 of GPL version 3, you are granted additional
17 
// permissions described in the GCC Runtime Library Exception, version
18 
// 3.1, as published by the Free Software Foundation.
19 
 
20 
// You should have received a copy of the GNU General Public License and
21 
// a copy of the GCC Runtime Library Exception along with this program;
22 
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 
// <http://www.gnu.org/licenses/>.
24 
 
25 
/** @file parallel/multiway_merge.h
26 
*  @brief Implementation of sequential and parallel multiway merge.
27 
*
28 
*  Explanations on the high-speed merging routines in the appendix of
29 
*
30 
*  P. Sanders.
31 
*  Fast priority queues for cached memory.
32 
*  ACM Journal of Experimental Algorithmics, 5, 2000.
33 
*
34 
*  This file is a GNU parallel extension to the Standard C++ Library.
35 
*/
36 
 
37 
// Written by Johannes Singler and Manuel Holtgrewe.
38 
 
39 
#ifndef _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H
40 
#define _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H
41 
 
42 
#include <vector>
43 
 
44 
#include <bits/stl_algo.h>
45 
#include <parallel/features.h>
46 
#include <parallel/parallel.h>
47 
#include <parallel/losertree.h>
48 
#include <parallel/multiseq_selection.h>
49 
#if _GLIBCXX_ASSERTIONS
50 
#include <parallel/checkers.h>
51 
#endif
52 
 
53 
/** @brief Length of a sequence described by a pair of iterators. */
54 
#define _GLIBCXX_PARALLEL_LENGTH(__s) ((__s).second - (__s).first)
55 
 
56 
namespace __gnu_parallel
57 
{
58 
  template<typename _RAIter1, typename _RAIter2, typename _OutputIterator,
59 
           typename _DifferenceTp, typename _Compare>
60 
    _OutputIterator
61 
    __merge_advance(_RAIter1&, _RAIter1, _RAIter2&, _RAIter2,
62 
                    _OutputIterator, _DifferenceTp, _Compare);
63 
 
64 
  /** @brief _Iterator wrapper supporting an implicit supremum at the end
65 
   *         of the sequence, dominating all comparisons.
66 
   *
67 
   * The implicit supremum comes with a performance cost.
68 
   *
69 
   * Deriving from _RAIter is not possible since
70 
   * _RAIter need not be a class.
71 
   */
72 
  template<typename _RAIter, typename _Compare>
73 
    class _GuardedIterator
74 
    {
75 
    private:
76 
      /** @brief Current iterator __position. */
77 
      _RAIter _M_current;
78 
 
79 
      /** @brief End iterator of the sequence. */
80 
      _RAIter _M_end;
81 
 
82 
      /** @brief _Compare. */
83 
      _Compare& __comp;
84 
 
85 
    public:
86 
      /** @brief Constructor. Sets iterator to beginning of sequence.
87 
      *  @param __begin Begin iterator of sequence.
88 
      *  @param __end End iterator of sequence.
89 
      *  @param __comp Comparator provided for associated overloaded
90 
      *  compare operators. */
91 
      _GuardedIterator(_RAIter __begin, _RAIter __end, _Compare& __comp)
92 
      : _M_current(__begin), _M_end(__end), __comp(__comp)
93 
      { }
94 
 
95 
      /** @brief Pre-increment operator.
96 
      *  @return This. */
97 
      _GuardedIterator<_RAIter, _Compare>&
98 
      operator++()
99 
      {
100 
        ++_M_current;
101 
        return *this;
102 
      }
103 
 
104 
      /** @brief Dereference operator.
105 
      *  @return Referenced element. */
106 
      typename std::iterator_traits<_RAIter>::value_type&
107 
      operator*()
108 
      { return *_M_current; }
109 
 
110 
      /** @brief Convert to wrapped iterator.
111 
      *  @return Wrapped iterator. */
112 
      operator _RAIter()
113 
      { return _M_current; }
114 
 
115 
      /** @brief Compare two elements referenced by guarded iterators.
116 
       *  @param __bi1 First iterator.
117 
       *  @param __bi2 Second iterator.
118 
       *  @return @c true if less. */
119 
      friend bool
120 
      operator<(_GuardedIterator<_RAIter, _Compare>& __bi1,
121 
                _GuardedIterator<_RAIter, _Compare>& __bi2)
122 
      {
123 
        if (__bi1._M_current == __bi1._M_end)       // __bi1 is sup
124 
          return __bi2._M_current == __bi2._M_end;  // __bi2 is not sup
125 
        if (__bi2._M_current == __bi2._M_end)       // __bi2 is sup
126 
          return true;
127 
        return (__bi1.__comp)(*__bi1, *__bi2);      // normal compare
128 
      }
129 
 
130 
      /** @brief Compare two elements referenced by guarded iterators.
131 
       *  @param __bi1 First iterator.
132 
       *  @param __bi2 Second iterator.
133 
       *  @return @c True if less equal. */
134 
      friend bool
135 
      operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1,
136 
                 _GuardedIterator<_RAIter, _Compare>& __bi2)
137 
      {
138 
        if (__bi2._M_current == __bi2._M_end)       // __bi1 is sup
139 
          return __bi1._M_current != __bi1._M_end;  // __bi2 is not sup
140 
        if (__bi1._M_current == __bi1._M_end)       // __bi2 is sup
141 
          return false;
142 
        return !(__bi1.__comp)(*__bi2, *__bi1);     // normal compare
143 
      }
144 
    };
145 
 
146 
  template<typename _RAIter, typename _Compare>
147 
    class _UnguardedIterator
148 
    {
149 
    private:
150 
      /** @brief Current iterator __position. */
151 
      _RAIter _M_current;
152 
      /** @brief _Compare. */
153 
      _Compare& __comp;
154 
 
155 
    public:
156 
      /** @brief Constructor. Sets iterator to beginning of sequence.
157 
      *  @param __begin Begin iterator of sequence.
158 
      *  @param __end Unused, only for compatibility.
159 
      *  @param __comp Unused, only for compatibility. */
160 
      _UnguardedIterator(_RAIter __begin,
161 
                         _RAIter /* __end */, _Compare& __comp)
162 
      : _M_current(__begin), __comp(__comp)
163 
      { }
164 
 
165 
      /** @brief Pre-increment operator.
166 
      *  @return This. */
167 
      _UnguardedIterator<_RAIter, _Compare>&
168 
      operator++()
169 
      {
170 
        ++_M_current;
171 
        return *this;
172 
      }
173 
 
174 
      /** @brief Dereference operator.
175 
      *  @return Referenced element. */
176 
      typename std::iterator_traits<_RAIter>::value_type&
177 
      operator*()
178 
      { return *_M_current; }
179 
 
180 
      /** @brief Convert to wrapped iterator.
181 
      *  @return Wrapped iterator. */
182 
      operator _RAIter()
183 
      { return _M_current; }
184 
 
185 
      /** @brief Compare two elements referenced by unguarded iterators.
186 
       *  @param __bi1 First iterator.
187 
       *  @param __bi2 Second iterator.
188 
       *  @return @c true if less. */
189 
      friend bool
190 
      operator<(_UnguardedIterator<_RAIter, _Compare>& __bi1,
191 
                _UnguardedIterator<_RAIter, _Compare>& __bi2)
192 
      {
193 
        // Normal compare.
194 
        return (__bi1.__comp)(*__bi1, *__bi2);
195 
      }
196 
 
197 
      /** @brief Compare two elements referenced by unguarded iterators.
198 
       *  @param __bi1 First iterator.
199 
       *  @param __bi2 Second iterator.
200 
       *  @return @c True if less equal. */
201 
      friend bool
202 
      operator<=(_UnguardedIterator<_RAIter, _Compare>& __bi1,
203 
                 _UnguardedIterator<_RAIter, _Compare>& __bi2)
204 
      {
205 
        // Normal compare.
206 
        return !(__bi1.__comp)(*__bi2, *__bi1);
207 
      }
208 
    };
209 
 
210 
  /** @brief Highly efficient 3-way merging procedure.
211 
   *
212 
   * Merging is done with the algorithm implementation described by Peter
213 
   * Sanders.  Basically, the idea is to minimize the number of necessary
214 
   * comparison after merging an element.  The implementation trick
215 
   * that makes this fast is that the order of the sequences is stored
216 
   * in the instruction pointer (translated into labels in C++).
217 
   *
218 
   * This works well for merging up to 4 sequences.
219 
   *
220 
   * Note that making the merging stable does @a not come at a
221 
   * performance hit.
222 
   *
223 
   * Whether the merging is done guarded or unguarded is selected by the
224 
   * used iterator class.
225 
   *
226 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
227 
   * @param __seqs_end End iterator of iterator pair input sequence.
228 
   * @param __target Begin iterator of output sequence.
229 
   * @param __comp Comparator.
230 
   * @param __length Maximum length to merge, less equal than the
231 
   * total number of elements available.
232 
   *
233 
   * @return End iterator of output sequence.
234 
   */
235 
  template<template<typename RAI, typename C> class iterator,
236 
           typename _RAIterIterator,
237 
           typename _RAIter3,
238 
           typename _DifferenceTp,
239 
           typename _Compare>
240 
    _RAIter3
241 
    multiway_merge_3_variant(_RAIterIterator __seqs_begin,
242 
                             _RAIterIterator __seqs_end,
243 
                             _RAIter3 __target,
244 
                             _DifferenceTp __length, _Compare __comp)
245 
    {
246 
      _GLIBCXX_CALL(__length);
247 
 
248 
      typedef _DifferenceTp _DifferenceType;
249 
 
250 
      typedef typename std::iterator_traits<_RAIterIterator>
251 
        ::value_type::first_type
252 
        _RAIter1;
253 
      typedef typename std::iterator_traits<_RAIter1>::value_type
254 
        _ValueType;
255 
 
256 
      if (__length == 0)
257 
        return __target;
258 
 
259 
#if _GLIBCXX_ASSERTIONS
260 
      _DifferenceTp __orig_length = __length;
261 
#endif
262 
 
263 
      iterator<_RAIter1, _Compare>
264 
        __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
265 
        __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
266 
        __seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp);
267 
 
268 
      if (__seq0 <= __seq1)
269 
        {
270 
          if (__seq1 <= __seq2)
271 
            goto __s012;
272 
          else
273 
            if (__seq2 <  __seq0)
274 
              goto __s201;
275 
            else
276 
              goto __s021;
277 
        }
278 
      else
279 
        {
280 
          if (__seq1 <= __seq2)
281 
            {
282 
              if (__seq0 <= __seq2)
283 
                goto __s102;
284 
              else
285 
                goto __s120;
286 
            }
287 
          else
288 
            goto __s210;
289 
        }
290 
#define _GLIBCXX_PARALLEL_MERGE_3_CASE(__a, __b, __c, __c0, __c1) \
291 
      __s ## __a ## __b ## __c :                            \
292 
        *__target = *__seq ## __a;                          \
293 
        ++__target;                                         \
294 
        --__length;                                         \
295 
        ++__seq ## __a;                                     \
296 
        if (__length == 0) goto __finish;                   \
297 
        if (__seq ## __a __c0 __seq ## __b) goto __s ## __a ## __b ## __c; \
298 
        if (__seq ## __a __c1 __seq ## __c) goto __s ## __b ## __a ## __c; \
299 
        goto __s ## __b ## __c ## __a;
300 
 
301 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 1, 2, <=, <=);
302 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 2, 0, <=, < );
303 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(2, 0, 1, < , < );
304 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 0, 2, < , <=);
305 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 2, 1, <=, <=);
306 
      _GLIBCXX_PARALLEL_MERGE_3_CASE(2, 1, 0, < , < );
307 
 
308 
#undef _GLIBCXX_PARALLEL_MERGE_3_CASE
309 
 
310 
    __finish:
311 
      ;
312 
 
313 
#if _GLIBCXX_ASSERTIONS
314 
    _GLIBCXX_PARALLEL_ASSERT(
315 
        ((_RAIter1)__seq0 - __seqs_begin[0].first) +
316 
        ((_RAIter1)__seq1 - __seqs_begin[1].first) +
317 
        ((_RAIter1)__seq2 - __seqs_begin[2].first)
318 
        == __orig_length);
319 
#endif
320 
 
321 
      __seqs_begin[0].first = __seq0;
322 
      __seqs_begin[1].first = __seq1;
323 
      __seqs_begin[2].first = __seq2;
324 
 
325 
      return __target;
326 
    }
327 
 
328 
  /**
329 
   * @brief Highly efficient 4-way merging procedure.
330 
   *
331 
   * Merging is done with the algorithm implementation described by Peter
332 
   * Sanders. Basically, the idea is to minimize the number of necessary
333 
   * comparison after merging an element.  The implementation trick
334 
   * that makes this fast is that the order of the sequences is stored
335 
   * in the instruction pointer (translated into goto labels in C++).
336 
   *
337 
   * This works well for merging up to 4 sequences.
338 
   *
339 
   * Note that making the merging stable does @a not come at a
340 
   * performance hit.
341 
   *
342 
   * Whether the merging is done guarded or unguarded is selected by the
343 
   * used iterator class.
344 
   *
345 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
346 
   * @param __seqs_end End iterator of iterator pair input sequence.
347 
   * @param __target Begin iterator of output sequence.
348 
   * @param __comp Comparator.
349 
   * @param __length Maximum length to merge, less equal than the
350 
   * total number of elements available.
351 
   *
352 
   * @return End iterator of output sequence.
353 
   */
354 
  template<template<typename RAI, typename C> class iterator,
355 
           typename _RAIterIterator,
356 
           typename _RAIter3,
357 
           typename _DifferenceTp,
358 
           typename _Compare>
359 
    _RAIter3
360 
    multiway_merge_4_variant(_RAIterIterator __seqs_begin,
361 
                             _RAIterIterator __seqs_end,
362 
                             _RAIter3 __target,
363 
                             _DifferenceTp __length, _Compare __comp)
364 
    {
365 
      _GLIBCXX_CALL(__length);
366 
      typedef _DifferenceTp _DifferenceType;
367 
 
368 
      typedef typename std::iterator_traits<_RAIterIterator>
369 
        ::value_type::first_type
370 
        _RAIter1;
371 
      typedef typename std::iterator_traits<_RAIter1>::value_type
372 
        _ValueType;
373 
 
374 
      iterator<_RAIter1, _Compare>
375 
        __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
376 
        __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
377 
        __seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp),
378 
        __seq3(__seqs_begin[3].first, __seqs_begin[3].second, __comp);
379 
 
380 
#define _GLIBCXX_PARALLEL_DECISION(__a, __b, __c, __d) {  \
381 
        if (__seq ## __d < __seq ## __a)                  \
382 
          goto __s ## __d ## __a ## __b ## __c;           \
383 
        if (__seq ## __d < __seq ## __b)                  \
384 
          goto __s ## __a ## __d ## __b ## __c;           \
385 
        if (__seq ## __d < __seq ## __c)                  \
386 
          goto __s ## __a ## __b ## __d ## __c;           \
387 
        goto __s ## __a ## __b ## __c ## __d;  }
388 
 
389 
      if (__seq0 <= __seq1)
390 
        {
391 
          if (__seq1 <= __seq2)
392 
            _GLIBCXX_PARALLEL_DECISION(0,1,2,3)
393 
            else
394 
              if (__seq2 < __seq0)
395 
                _GLIBCXX_PARALLEL_DECISION(2,0,1,3)
396 
                else
397 
                  _GLIBCXX_PARALLEL_DECISION(0,2,1,3)
398 
                    }
399 
      else
400 
        {
401 
          if (__seq1 <= __seq2)
402 
            {
403 
              if (__seq0 <= __seq2)
404 
                _GLIBCXX_PARALLEL_DECISION(1,0,2,3)
405 
                else
406 
                  _GLIBCXX_PARALLEL_DECISION(1,2,0,3)
407 
                    }
408 
          else
409 
            _GLIBCXX_PARALLEL_DECISION(2,1,0,3)
410 
              }
411 
 
412 
#define _GLIBCXX_PARALLEL_MERGE_4_CASE(__a, __b, __c, __d,  \
413 
                                       __c0, __c1, __c2)    \
414 
      __s ## __a ## __b ## __c ## __d:                      \
415 
      if (__length == 0) goto __finish;                     \
416 
      *__target = *__seq ## __a;                            \
417 
      ++__target;                                           \
418 
      --__length;                                           \
419 
      ++__seq ## __a;                                       \
420 
      if (__seq ## __a __c0 __seq ## __b)      \
421 
        goto __s ## __a ## __b ## __c ## __d;  \
422 
      if (__seq ## __a __c1 __seq ## __c)      \
423 
        goto __s ## __b ## __a ## __c ## __d;  \
424 
      if (__seq ## __a __c2 __seq ## __d)      \
425 
        goto __s ## __b ## __c ## __a ## __d;  \
426 
      goto __s ## __b ## __c ## __d ## __a;
427 
 
428 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 2, 3, <=, <=, <=);
429 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 3, 2, <=, <=, <=);
430 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 2, 1, 3, <=, <=, <=);
431 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 2, 3, 1, <=, <=, <=);
432 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 3, 1, 2, <=, <=, <=);
433 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 3, 2, 1, <=, <=, <=);
434 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 0, 2, 3, < , <=, <=);
435 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 0, 3, 2, < , <=, <=);
436 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 2, 0, 3, <=, < , <=);
437 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 2, 3, 0, <=, <=, < );
438 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 3, 0, 2, <=, < , <=);
439 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 3, 2, 0, <=, <=, < );
440 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 0, 1, 3, < , < , <=);
441 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 0, 3, 1, < , <=, < );
442 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 1, 0, 3, < , < , <=);
443 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 1, 3, 0, < , <=, < );
444 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 3, 0, 1, <=, < , < );
445 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 3, 1, 0, <=, < , < );
446 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 0, 1, 2, < , < , < );
447 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 0, 2, 1, < , < , < );
448 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 1, 0, 2, < , < , < );
449 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 1, 2, 0, < , < , < );
450 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 2, 0, 1, < , < , < );
451 
      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 2, 1, 0, < , < , < );
452 
 
453 
#undef _GLIBCXX_PARALLEL_MERGE_4_CASE
454 
#undef _GLIBCXX_PARALLEL_DECISION
455 
 
456 
    __finish:
457 
      ;
458 
 
459 
      __seqs_begin[0].first = __seq0;
460 
      __seqs_begin[1].first = __seq1;
461 
      __seqs_begin[2].first = __seq2;
462 
      __seqs_begin[3].first = __seq3;
463 
 
464 
      return __target;
465 
    }
466 
 
467 
  /** @brief Multi-way merging procedure for a high branching factor,
468 
   *         guarded case.
469 
   *
470 
   * This merging variant uses a LoserTree class as selected by <tt>_LT</tt>.
471 
   *
472 
   * Stability is selected through the used LoserTree class <tt>_LT</tt>.
473 
   *
474 
   * At least one non-empty sequence is required.
475 
   *
476 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
477 
   * @param __seqs_end End iterator of iterator pair input sequence.
478 
   * @param __target Begin iterator of output sequence.
479 
   * @param __comp Comparator.
480 
   * @param __length Maximum length to merge, less equal than the
481 
   * total number of elements available.
482 
   *
483 
   * @return End iterator of output sequence.
484 
   */
485 
  template<typename _LT,
486 
           typename _RAIterIterator,
487 
           typename _RAIter3,
488 
           typename _DifferenceTp,
489 
           typename _Compare>
490 
    _RAIter3
491 
    multiway_merge_loser_tree(_RAIterIterator __seqs_begin,
492 
                              _RAIterIterator __seqs_end,
493 
                              _RAIter3 __target,
494 
                              _DifferenceTp __length, _Compare __comp)
495 
    {
496 
      _GLIBCXX_CALL(__length)
497 
 
498 
      typedef _DifferenceTp _DifferenceType;
499 
      typedef typename std::iterator_traits<_RAIterIterator>
500 
        ::difference_type _SeqNumber;
501 
      typedef typename std::iterator_traits<_RAIterIterator>
502 
        ::value_type::first_type
503 
        _RAIter1;
504 
      typedef typename std::iterator_traits<_RAIter1>::value_type
505 
        _ValueType;
506 
 
507 
      _SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
508 
 
509 
      _LT __lt(__k, __comp);
510 
 
511 
      // Default value for potentially non-default-constructible types.
512 
      _ValueType* __arbitrary_element = 0;
513 
 
514 
      for (_SeqNumber __t = 0; __t < __k; ++__t)
515 
        {
516 
          if(!__arbitrary_element
517 
             && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
518 
            __arbitrary_element = &(*__seqs_begin[__t].first);
519 
        }
520 
 
521 
      for (_SeqNumber __t = 0; __t < __k; ++__t)
522 
        {
523 
          if (__seqs_begin[__t].first == __seqs_begin[__t].second)
524 
            __lt.__insert_start(*__arbitrary_element, __t, true);
525 
          else
526 
            __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
527 
        }
528 
 
529 
      __lt.__init();
530 
 
531 
      _SeqNumber __source;
532 
 
533 
      for (_DifferenceType __i = 0; __i < __length; ++__i)
534 
        {
535 
          //take out
536 
          __source = __lt.__get_min_source();
537 
 
538 
          *(__target++) = *(__seqs_begin[__source].first++);
539 
 
540 
          // Feed.
541 
          if (__seqs_begin[__source].first == __seqs_begin[__source].second)
542 
            __lt.__delete_min_insert(*__arbitrary_element, true);
543 
          else
544 
            // Replace from same __source.
545 
            __lt.__delete_min_insert(*__seqs_begin[__source].first, false);
546 
        }
547 
 
548 
      return __target;
549 
    }
550 
 
551 
  /** @brief Multi-way merging procedure for a high branching factor,
552 
   *         unguarded case.
553 
   *
554 
   * Merging is done using the LoserTree class <tt>_LT</tt>.
555 
   *
556 
   * Stability is selected by the used LoserTrees.
557 
   *
558 
   * @pre No input will run out of elements during the merge.
559 
   *
560 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
561 
   * @param __seqs_end End iterator of iterator pair input sequence.
562 
   * @param __target Begin iterator of output sequence.
563 
   * @param __comp Comparator.
564 
   * @param __length Maximum length to merge, less equal than the
565 
   * total number of elements available.
566 
   *
567 
   * @return End iterator of output sequence.
568 
   */
569 
  template<typename _LT,
570 
           typename _RAIterIterator,
571 
           typename _RAIter3,
572 
           typename _DifferenceTp, typename _Compare>
573 
    _RAIter3
574 
    multiway_merge_loser_tree_unguarded(_RAIterIterator __seqs_begin,
575 
                                        _RAIterIterator __seqs_end,
576 
                                        _RAIter3 __target,
577 
       const typename std::iterator_traits<typename std::iterator_traits<
578 
          _RAIterIterator>::value_type::first_type>::value_type&
579 
                                        __sentinel,
580 
                                        _DifferenceTp __length,
581 
                                        _Compare __comp)
582 
    {
583 
      _GLIBCXX_CALL(__length)
584 
      typedef _DifferenceTp _DifferenceType;
585 
 
586 
      typedef typename std::iterator_traits<_RAIterIterator>
587 
        ::difference_type _SeqNumber;
588 
      typedef typename std::iterator_traits<_RAIterIterator>
589 
        ::value_type::first_type
590 
        _RAIter1;
591 
      typedef typename std::iterator_traits<_RAIter1>::value_type
592 
        _ValueType;
593 
 
594 
      _SeqNumber __k = __seqs_end - __seqs_begin;
595 
 
596 
      _LT __lt(__k, __sentinel, __comp);
597 
 
598 
      for (_SeqNumber __t = 0; __t < __k; ++__t)
599 
        {
600 
#if _GLIBCXX_ASSERTIONS
601 
          _GLIBCXX_PARALLEL_ASSERT(__seqs_begin[__t].first
602 
                                   != __seqs_begin[__t].second);
603 
#endif
604 
          __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
605 
        }
606 
 
607 
      __lt.__init();
608 
 
609 
      _SeqNumber __source;
610 
 
611 
#if _GLIBCXX_ASSERTIONS
612 
      _DifferenceType __i = 0;
613 
#endif
614 
 
615 
      _RAIter3 __target_end = __target + __length;
616 
      while (__target < __target_end)
617 
        {
618 
          // Take out.
619 
          __source = __lt.__get_min_source();
620 
 
621 
#if _GLIBCXX_ASSERTIONS
622 
          _GLIBCXX_PARALLEL_ASSERT(0 <= __source && __source < __k);
623 
          _GLIBCXX_PARALLEL_ASSERT(__i == 0
624 
              || !__comp(*(__seqs_begin[__source].first), *(__target - 1)));
625 
#endif
626 
 
627 
          // Feed.
628 
          *(__target++) = *(__seqs_begin[__source].first++);
629 
 
630 
#if _GLIBCXX_ASSERTIONS
631 
          ++__i;
632 
#endif
633 
          // Replace from same __source.
634 
          __lt.__delete_min_insert(*__seqs_begin[__source].first, false);
635 
        }
636 
 
637 
      return __target;
638 
    }
639 
 
640 
 
641 
  /** @brief Multi-way merging procedure for a high branching factor,
642 
   *         requiring sentinels to exist.
643 
   *
644 
   * @tparam UnguardedLoserTree _Loser Tree variant to use for the unguarded
645 
   *   merging.
646 
   *
647 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
648 
   * @param __seqs_end End iterator of iterator pair input sequence.
649 
   * @param __target Begin iterator of output sequence.
650 
   * @param __comp Comparator.
651 
   * @param __length Maximum length to merge, less equal than the
652 
   * total number of elements available.
653 
   *
654 
   * @return End iterator of output sequence.
655 
   */
656 
  template<typename UnguardedLoserTree,
657 
           typename _RAIterIterator,
658 
           typename _RAIter3,
659 
           typename _DifferenceTp,
660 
           typename _Compare>
661 
    _RAIter3
662 
    multiway_merge_loser_tree_sentinel(_RAIterIterator __seqs_begin,
663 
                                       _RAIterIterator __seqs_end,
664 
                                       _RAIter3 __target,
665 
      const typename std::iterator_traits<typename std::iterator_traits<
666 
        _RAIterIterator>::value_type::first_type>::value_type&
667 
                                       __sentinel,
668 
                                       _DifferenceTp __length,
669 
                                       _Compare __comp)
670 
    {
671 
      _GLIBCXX_CALL(__length)
672 
 
673 
      typedef _DifferenceTp _DifferenceType;
674 
      typedef std::iterator_traits<_RAIterIterator> _TraitsType;
675 
      typedef typename std::iterator_traits<_RAIterIterator>
676 
        ::value_type::first_type
677 
        _RAIter1;
678 
      typedef typename std::iterator_traits<_RAIter1>::value_type
679 
        _ValueType;
680 
 
681 
      _RAIter3 __target_end;
682 
 
683 
      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
684 
        // Move the sequence ends to the sentinel.  This has the
685 
        // effect that the sentinel appears to be within the sequence. Then,
686 
        // we can use the unguarded variant if we merge out as many
687 
        // non-sentinel elements as we have.
688 
        ++((*__s).second);
689 
 
690 
      __target_end = multiway_merge_loser_tree_unguarded<UnguardedLoserTree>
691 
        (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
692 
 
693 
#if _GLIBCXX_ASSERTIONS
694 
      _GLIBCXX_PARALLEL_ASSERT(__target_end == __target + __length);
695 
      _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target_end, __comp));
696 
#endif
697 
 
698 
      // Restore the sequence ends so the sentinels are not contained in the
699 
      // sequence any more (see comment in loop above).
700 
      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
701 
        --((*__s).second);
702 
 
703 
      return __target_end;
704 
    }
705 
 
706 
  /**
707 
   * @brief Traits for determining whether the loser tree should
708 
   *   use pointers or copies.
709 
   *
710 
   * The field "_M_use_pointer" is used to determine whether to use pointers
711 
   * in he loser trees or whether to copy the values into the loser tree.
712 
   *
713 
   * The default behavior is to use pointers if the data type is 4 times as
714 
   * big as the pointer to it.
715 
   *
716 
   * Specialize for your data type to customize the behavior.
717 
   *
718 
   * Example:
719 
   *
720 
   *   template<>
721 
   *   struct _LoserTreeTraits<int>
722 
   *   { static const bool _M_use_pointer = false; };
723 
   *
724 
   *   template<>
725 
   *   struct _LoserTreeTraits<heavyweight_type>
726 
   *   { static const bool _M_use_pointer = true; };
727 
   *
728 
   * @param _Tp type to give the loser tree traits for.
729 
   */
730 
  template <typename _Tp>
731 
    struct _LoserTreeTraits
732 
    {
733 
      /**
734 
       * @brief True iff to use pointers instead of values in loser trees.
735 
       *
736 
       * The default behavior is to use pointers if the data type is four
737 
       * times as big as the pointer to it.
738 
       */
739 
      static const bool _M_use_pointer = (sizeof(_Tp) > 4 * sizeof(_Tp*));
740 
    };
741 
 
742 
  /**
743 
   * @brief Switch for 3-way merging with __sentinels turned off.
744 
   *
745 
   * Note that 3-way merging is always stable!
746 
   */
747 
  template<bool __sentinels /*default == false*/,
748 
           typename _RAIterIterator,
749 
           typename _RAIter3,
750 
           typename _DifferenceTp,
751 
           typename _Compare>
752 
    struct __multiway_merge_3_variant_sentinel_switch
753 
    {
754 
      _RAIter3
755 
      operator()(_RAIterIterator __seqs_begin,
756 
                 _RAIterIterator __seqs_end,
757 
                 _RAIter3 __target,
758 
                 _DifferenceTp __length, _Compare __comp)
759 
      { return multiway_merge_3_variant<_GuardedIterator>
760 
          (__seqs_begin, __seqs_end, __target, __length, __comp); }
761 
    };
762 
 
763 
  /**
764 
   * @brief Switch for 3-way merging with __sentinels turned on.
765 
   *
766 
   * Note that 3-way merging is always stable!
767 
   */
768 
  template<typename _RAIterIterator,
769 
           typename _RAIter3,
770 
           typename _DifferenceTp,
771 
           typename _Compare>
772 
    struct __multiway_merge_3_variant_sentinel_switch<true, _RAIterIterator,
773 
                                                      _RAIter3, _DifferenceTp,
774 
                                                      _Compare>
775 
    {
776 
      _RAIter3
777 
      operator()(_RAIterIterator __seqs_begin,
778 
                 _RAIterIterator __seqs_end,
779 
                 _RAIter3 __target,
780 
                 _DifferenceTp __length, _Compare __comp)
781 
      { return multiway_merge_3_variant<_UnguardedIterator>
782 
          (__seqs_begin, __seqs_end, __target, __length, __comp); }
783 
    };
784 
 
785 
  /**
786 
   * @brief Switch for 4-way merging with __sentinels turned off.
787 
   *
788 
   * Note that 4-way merging is always stable!
789 
   */
790 
  template<bool __sentinels /*default == false*/,
791 
           typename _RAIterIterator,
792 
           typename _RAIter3,
793 
           typename _DifferenceTp,
794 
           typename _Compare>
795 
    struct __multiway_merge_4_variant_sentinel_switch
796 
    {
797 
      _RAIter3
798 
      operator()(_RAIterIterator __seqs_begin,
799 
                 _RAIterIterator __seqs_end,
800 
                 _RAIter3 __target,
801 
                 _DifferenceTp __length, _Compare __comp)
802 
      { return multiway_merge_4_variant<_GuardedIterator>
803 
          (__seqs_begin, __seqs_end, __target, __length, __comp); }
804 
    };
805 
 
806 
  /**
807 
   * @brief Switch for 4-way merging with __sentinels turned on.
808 
   *
809 
   * Note that 4-way merging is always stable!
810 
   */
811 
  template<typename _RAIterIterator,
812 
           typename _RAIter3,
813 
           typename _DifferenceTp,
814 
           typename _Compare>
815 
    struct __multiway_merge_4_variant_sentinel_switch<true, _RAIterIterator,
816 
                                                      _RAIter3, _DifferenceTp,
817 
                                                      _Compare>
818 
    {
819 
      _RAIter3
820 
      operator()(_RAIterIterator __seqs_begin,
821 
                 _RAIterIterator __seqs_end,
822 
                 _RAIter3 __target,
823 
                 _DifferenceTp __length, _Compare __comp)
824 
      { return multiway_merge_4_variant<_UnguardedIterator>
825 
          (__seqs_begin, __seqs_end, __target, __length, __comp); }
826 
    };
827 
 
828 
  /**
829 
   * @brief Switch for k-way merging with __sentinels turned on.
830 
   */
831 
  template<bool __sentinels,
832 
           bool __stable,
833 
           typename _RAIterIterator,
834 
           typename _RAIter3,
835 
           typename _DifferenceTp,
836 
           typename _Compare>
837 
    struct __multiway_merge_k_variant_sentinel_switch
838 
    {
839 
      _RAIter3
840 
      operator()(_RAIterIterator __seqs_begin,
841 
                 _RAIterIterator __seqs_end,
842 
                 _RAIter3 __target,
843 
      const typename std::iterator_traits<typename std::iterator_traits<
844 
      _RAIterIterator>::value_type::first_type>::value_type&
845 
                 __sentinel,
846 
                 _DifferenceTp __length, _Compare __comp)
847 
      {
848 
        typedef typename std::iterator_traits<_RAIterIterator>
849 
          ::value_type::first_type
850 
          _RAIter1;
851 
        typedef typename std::iterator_traits<_RAIter1>::value_type
852 
          _ValueType;
853 
 
854 
        return multiway_merge_loser_tree_sentinel<
855 
        typename __gnu_cxx::__conditional_type<
856 
        _LoserTreeTraits<_ValueType>::_M_use_pointer,
857 
          _LoserTreePointerUnguarded<__stable, _ValueType, _Compare>,
858 
          _LoserTreeUnguarded<__stable, _ValueType, _Compare>
859 
          >::__type>
860 
          (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
861 
      }
862 
    };
863 
 
864 
  /**
865 
   * @brief Switch for k-way merging with __sentinels turned off.
866 
   */
867 
  template<bool __stable,
868 
           typename _RAIterIterator,
869 
           typename _RAIter3,
870 
           typename _DifferenceTp,
871 
           typename _Compare>
872 
    struct __multiway_merge_k_variant_sentinel_switch<false, __stable,
873 
                                                      _RAIterIterator,
874 
                                                      _RAIter3, _DifferenceTp,
875 
                                                      _Compare>
876 
    {
877 
      _RAIter3
878 
      operator()(_RAIterIterator __seqs_begin,
879 
                 _RAIterIterator __seqs_end,
880 
                 _RAIter3 __target,
881 
       const typename std::iterator_traits<typename std::iterator_traits<
882 
       _RAIterIterator>::value_type::first_type>::value_type&
883 
                 __sentinel,
884 
                 _DifferenceTp __length, _Compare __comp)
885 
      {
886 
        typedef typename std::iterator_traits<_RAIterIterator>
887 
          ::value_type::first_type
888 
          _RAIter1;
889 
        typedef typename std::iterator_traits<_RAIter1>::value_type
890 
          _ValueType;
891 
 
892 
        return multiway_merge_loser_tree<
893 
        typename __gnu_cxx::__conditional_type<
894 
        _LoserTreeTraits<_ValueType>::_M_use_pointer,
895 
          _LoserTreePointer<__stable, _ValueType, _Compare>,
896 
          _LoserTree<__stable, _ValueType, _Compare>
897 
          >::__type >(__seqs_begin, __seqs_end, __target, __length, __comp);
898 
      }
899 
    };
900 
 
901 
  /** @brief Sequential multi-way merging switch.
902 
   *
903 
   *  The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and
904 
   *  runtime settings.
905 
   *  @param __seqs_begin Begin iterator of iterator pair input sequence.
906 
   *  @param __seqs_end End iterator of iterator pair input sequence.
907 
   *  @param __target Begin iterator of output sequence.
908 
   *  @param __comp Comparator.
909 
   *  @param __length Maximum length to merge, possibly larger than the
910 
   *  number of elements available.
911 
   *  @param __sentinel The sequences have __a __sentinel element.
912 
   *  @return End iterator of output sequence. */
913 
  template<bool __stable,
914 
           bool __sentinels,
915 
           typename _RAIterIterator,
916 
           typename _RAIter3,
917 
           typename _DifferenceTp,
918 
           typename _Compare>
919 
    _RAIter3
920 
    __sequential_multiway_merge(_RAIterIterator __seqs_begin,
921 
                                _RAIterIterator __seqs_end,
922 
                                _RAIter3 __target,
923 
      const typename std::iterator_traits<typename std::iterator_traits<
924 
        _RAIterIterator>::value_type::first_type>::value_type&
925 
                                __sentinel,
926 
                                _DifferenceTp __length, _Compare __comp)
927 
    {
928 
      _GLIBCXX_CALL(__length)
929 
 
930 
      typedef _DifferenceTp _DifferenceType;
931 
      typedef typename std::iterator_traits<_RAIterIterator>
932 
        ::difference_type _SeqNumber;
933 
      typedef typename std::iterator_traits<_RAIterIterator>
934 
        ::value_type::first_type
935 
        _RAIter1;
936 
      typedef typename std::iterator_traits<_RAIter1>::value_type
937 
        _ValueType;
938 
 
939 
#if _GLIBCXX_ASSERTIONS
940 
      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
941 
        {
942 
          _GLIBCXX_PARALLEL_ASSERT(__is_sorted((*__s).first,
943 
                                               (*__s).second, __comp));
944 
        }
945 
#endif
946 
 
947 
      _DifferenceTp __total_length = 0;
948 
      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
949 
        __total_length += _GLIBCXX_PARALLEL_LENGTH(*__s);
950 
 
951 
      __length = std::min<_DifferenceTp>(__length, __total_length);
952 
 
953 
      if(__length == 0)
954 
        return __target;
955 
 
956 
      _RAIter3 __return_target = __target;
957 
      _SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
958 
 
959 
      switch (__k)
960 
        {
961 
        case 0:
962 
          break;
963 
        case 1:
964 
          __return_target = std::copy(__seqs_begin[0].first,
965 
                                      __seqs_begin[0].first + __length,
966 
                                      __target);
967 
          __seqs_begin[0].first += __length;
968 
          break;
969 
        case 2:
970 
          __return_target = __merge_advance(__seqs_begin[0].first,
971 
                                            __seqs_begin[0].second,
972 
                                            __seqs_begin[1].first,
973 
                                            __seqs_begin[1].second,
974 
                                            __target, __length, __comp);
975 
          break;
976 
        case 3:
977 
          __return_target = __multiway_merge_3_variant_sentinel_switch
978 
            <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
979 
            (__seqs_begin, __seqs_end, __target, __length, __comp);
980 
          break;
981 
        case 4:
982 
          __return_target = __multiway_merge_4_variant_sentinel_switch
983 
            <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
984 
            (__seqs_begin, __seqs_end, __target, __length, __comp);
985 
          break;
986 
        default:
987 
          __return_target = __multiway_merge_k_variant_sentinel_switch
988 
            <__sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp,
989 
             _Compare>()
990 
            (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
991 
          break;
992 
        }
993 
#if _GLIBCXX_ASSERTIONS
994 
      _GLIBCXX_PARALLEL_ASSERT(
995 
        __is_sorted(__target, __target + __length, __comp));
996 
#endif
997 
 
998 
      return __return_target;
999 
    }
1000 
 
1001 
  /**
1002 
   * @brief Stable sorting functor.
1003 
   *
1004 
   * Used to reduce code instanciation in multiway_merge_sampling_splitting.
1005 
   */
1006 
  template<bool __stable, class _RAIter, class _StrictWeakOrdering>
1007 
    struct _SamplingSorter
1008 
    {
1009 
      void
1010 
      operator()(_RAIter __first, _RAIter __last, _StrictWeakOrdering __comp)
1011 
      { __gnu_sequential::stable_sort(__first, __last, __comp); }
1012 
    };
1013 
 
1014 
  /**
1015 
   * @brief Non-__stable sorting functor.
1016 
   *
1017 
   * Used to reduce code instantiation in multiway_merge_sampling_splitting.
1018 
   */
1019 
  template<class _RAIter, class _StrictWeakOrdering>
1020 
    struct _SamplingSorter<false, _RAIter, _StrictWeakOrdering>
1021 
    {
1022 
      void
1023 
      operator()(_RAIter __first, _RAIter __last, _StrictWeakOrdering __comp)
1024 
      { __gnu_sequential::sort(__first, __last, __comp); }
1025 
    };
1026 
 
1027 
  /**
1028 
   * @brief Sampling based splitting for parallel multiway-merge routine.
1029 
   */
1030 
  template<bool __stable,
1031 
           typename _RAIterIterator,
1032 
           typename _Compare,
1033 
           typename _DifferenceType>
1034 
    void
1035 
    multiway_merge_sampling_splitting(_RAIterIterator __seqs_begin,
1036 
                                      _RAIterIterator __seqs_end,
1037 
                                      _DifferenceType __length,
1038 
                                      _DifferenceType __total_length,
1039 
                                      _Compare __comp,
1040 
     std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
1041 
    {
1042 
      typedef typename std::iterator_traits<_RAIterIterator>
1043 
        ::difference_type _SeqNumber;
1044 
      typedef typename std::iterator_traits<_RAIterIterator>
1045 
        ::value_type::first_type
1046 
        _RAIter1;
1047 
      typedef typename std::iterator_traits<_RAIter1>::value_type
1048 
        _ValueType;
1049 
 
1050 
      // __k sequences.
1051 
      const _SeqNumber __k
1052 
        = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
1053 
 
1054 
      const _ThreadIndex __num_threads = omp_get_num_threads();
1055 
 
1056 
      const _DifferenceType __num_samples =
1057 
        __gnu_parallel::_Settings::get().merge_oversampling * __num_threads;
1058 
 
1059 
      _ValueType* __samples = static_cast<_ValueType*>
1060 
        (::operator new(sizeof(_ValueType) * __k * __num_samples));
1061 
      // Sample.
1062 
      for (_SeqNumber __s = 0; __s < __k; ++__s)
1063 
        for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
1064 
          {
1065 
            _DifferenceType sample_index = static_cast<_DifferenceType>
1066 
              (_GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__s])
1067 
               * (double(__i + 1) / (__num_samples + 1))
1068 
               * (double(__length) / __total_length));
1069 
            new(&(__samples[__s * __num_samples + __i]))
1070 
              _ValueType(__seqs_begin[__s].first[sample_index]);
1071 
          }
1072 
 
1073 
      // Sort stable or non-stable, depending on value of template parameter
1074 
      // "__stable".
1075 
      _SamplingSorter<__stable, _ValueType*, _Compare>()
1076 
        (__samples, __samples + (__num_samples * __k), __comp);
1077 
 
1078 
      for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
1079 
        // For each slab / processor.
1080 
        for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
1081 
          {
1082 
            // For each sequence.
1083 
            if (__slab > 0)
1084 
              __pieces[__slab][__seq].first = std::upper_bound
1085 
                (__seqs_begin[__seq].first, __seqs_begin[__seq].second,
1086 
                 __samples[__num_samples * __k * __slab / __num_threads],
1087 
                 __comp)
1088 
                - __seqs_begin[__seq].first;
1089 
            else
1090 
              // Absolute beginning.
1091 
              __pieces[__slab][__seq].first = 0;
1092 
            if ((__slab + 1) < __num_threads)
1093 
              __pieces[__slab][__seq].second = std::upper_bound
1094 
                (__seqs_begin[__seq].first, __seqs_begin[__seq].second,
1095 
                 __samples[__num_samples * __k * (__slab + 1) / __num_threads],
1096 
                 __comp)
1097 
                - __seqs_begin[__seq].first;
1098 
            else
1099 
              // Absolute end.
1100 
              __pieces[__slab][__seq].second =
1101 
                _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
1102 
          }
1103 
 
1104 
      for (_SeqNumber __s = 0; __s < __k; ++__s)
1105 
        for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
1106 
          __samples[__s * __num_samples + __i].~_ValueType();
1107 
      ::operator delete(__samples);
1108 
    }
1109 
 
1110 
  /**
1111 
   * @brief Exact splitting for parallel multiway-merge routine.
1112 
   *
1113 
   * None of the passed sequences may be empty.
1114 
   */
1115 
  template<bool __stable,
1116 
           typename _RAIterIterator,
1117 
           typename _Compare,
1118 
           typename _DifferenceType>
1119 
    void
1120 
    multiway_merge_exact_splitting(_RAIterIterator __seqs_begin,
1121 
                                   _RAIterIterator __seqs_end,
1122 
                                   _DifferenceType __length,
1123 
                                   _DifferenceType __total_length,
1124 
                                   _Compare __comp,
1125 
       std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
1126 
    {
1127 
      typedef typename std::iterator_traits<_RAIterIterator>
1128 
        ::difference_type _SeqNumber;
1129 
      typedef typename std::iterator_traits<_RAIterIterator>
1130 
        ::value_type::first_type
1131 
        _RAIter1;
1132 
 
1133 
      const bool __tight = (__total_length == __length);
1134 
 
1135 
      // __k sequences.
1136 
      const _SeqNumber __k = __seqs_end - __seqs_begin;
1137 
 
1138 
      const _ThreadIndex __num_threads = omp_get_num_threads();
1139 
 
1140 
      // (Settings::multiway_merge_splitting
1141 
      //  == __gnu_parallel::_Settings::EXACT).
1142 
      std::vector<_RAIter1>* __offsets =
1143 
        new std::vector<_RAIter1>[__num_threads];
1144 
      std::vector<std::pair<_RAIter1, _RAIter1> > __se(__k);
1145 
 
1146 
      copy(__seqs_begin, __seqs_end, __se.begin());
1147 
 
1148 
      _DifferenceType* __borders =
1149 
        new _DifferenceType[__num_threads + 1];
1150 
      __equally_split(__length, __num_threads, __borders);
1151 
 
1152 
      for (_ThreadIndex __s = 0; __s < (__num_threads - 1); ++__s)
1153 
        {
1154 
          __offsets[__s].resize(__k);
1155 
          multiseq_partition(__se.begin(), __se.end(), __borders[__s + 1],
1156 
                             __offsets[__s].begin(), __comp);
1157 
 
1158 
          // Last one also needed and available.
1159 
          if (!__tight)
1160 
            {
1161 
              __offsets[__num_threads - 1].resize(__k);
1162 
              multiseq_partition(__se.begin(), __se.end(),
1163 
                                 _DifferenceType(__length),
1164 
                                 __offsets[__num_threads - 1].begin(),
1165 
                                 __comp);
1166 
            }
1167 
        }
1168 
      delete[] __borders;
1169 
 
1170 
      for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
1171 
        {
1172 
          // For each slab / processor.
1173 
          for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
1174 
            {
1175 
              // For each sequence.
1176 
              if (__slab == 0)
1177 
                {
1178 
                  // Absolute beginning.
1179 
                  __pieces[__slab][__seq].first = 0;
1180 
                }
1181 
              else
1182 
                __pieces[__slab][__seq].first =
1183 
                  __pieces[__slab - 1][__seq].second;
1184 
              if (!__tight || __slab < (__num_threads - 1))
1185 
                __pieces[__slab][__seq].second =
1186 
                  __offsets[__slab][__seq] - __seqs_begin[__seq].first;
1187 
              else
1188 
                {
1189 
                  // __slab == __num_threads - 1
1190 
                  __pieces[__slab][__seq].second =
1191 
                    _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
1192 
                }
1193 
            }
1194 
        }
1195 
      delete[] __offsets;
1196 
    }
1197 
 
1198 
  /** @brief Parallel multi-way merge routine.
1199 
   *
1200 
   * The _GLIBCXX_PARALLEL_DECISION is based on the branching factor
1201 
   * and runtime settings.
1202 
   *
1203 
   * Must not be called if the number of sequences is 1.
1204 
   *
1205 
   * @tparam _Splitter functor to split input (either __exact or sampling based)
1206 
   * @tparam __stable Stable merging incurs a performance penalty.
1207 
   * @tparam __sentinel Ignored.
1208 
   *
1209 
   * @param __seqs_begin Begin iterator of iterator pair input sequence.
1210 
   * @param __seqs_end End iterator of iterator pair input sequence.
1211 
   * @param __target Begin iterator of output sequence.
1212 
   * @param __comp Comparator.
1213 
   * @param __length Maximum length to merge, possibly larger than the
1214 
   * number of elements available.
1215 
   * @return End iterator of output sequence.
1216 
   */
1217 
  template<bool __stable,
1218 
           bool __sentinels,
1219 
           typename _RAIterIterator,
1220 
           typename _RAIter3,
1221 
           typename _DifferenceTp,
1222 
           typename _Splitter,
1223 
           typename _Compare>
1224 
    _RAIter3
1225 
    parallel_multiway_merge(_RAIterIterator __seqs_begin,
1226 
                            _RAIterIterator __seqs_end,
1227 
                            _RAIter3 __target,
1228 
                            _Splitter __splitter,
1229 
                            _DifferenceTp __length,
1230 
                            _Compare __comp,
1231 
                            _ThreadIndex __num_threads)
1232 
      {
1233 
#if _GLIBCXX_ASSERTIONS
1234 
        _GLIBCXX_PARALLEL_ASSERT(__seqs_end - __seqs_begin > 1);
1235 
#endif
1236 
 
1237 
        _GLIBCXX_CALL(__length)
1238 
 
1239 
        typedef _DifferenceTp _DifferenceType;
1240 
        typedef typename std::iterator_traits<_RAIterIterator>
1241 
          ::difference_type _SeqNumber;
1242 
        typedef typename std::iterator_traits<_RAIterIterator>
1243 
          ::value_type::first_type
1244 
          _RAIter1;
1245 
        typedef typename
1246 
          std::iterator_traits<_RAIter1>::value_type _ValueType;
1247 
 
1248 
        // Leave only non-empty sequences.
1249 
        typedef std::pair<_RAIter1, _RAIter1> seq_type;
1250 
        seq_type* __ne_seqs = new seq_type[__seqs_end - __seqs_begin];
1251 
        _SeqNumber __k = 0;
1252 
        _DifferenceType __total_length = 0;
1253 
        for (_RAIterIterator __raii = __seqs_begin;
1254 
             __raii != __seqs_end; ++__raii)
1255 
          {
1256 
            _DifferenceTp __seq_length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
1257 
            if(__seq_length > 0)
1258 
              {
1259 
                __total_length += __seq_length;
1260 
                __ne_seqs[__k++] = *__raii;
1261 
              }
1262 
          }
1263 
 
1264 
        _GLIBCXX_CALL(__total_length)
1265 
 
1266 
        __length = std::min<_DifferenceTp>(__length, __total_length);
1267 
 
1268 
        if (__total_length == 0 || __k == 0)
1269 
          {
1270 
            delete[] __ne_seqs;
1271 
            return __target;
1272 
          }
1273 
 
1274 
        std::vector<std::pair<_DifferenceType, _DifferenceType> >* __pieces;
1275 
 
1276 
        __num_threads = static_cast<_ThreadIndex>
1277 
          (std::min<_DifferenceType>(__num_threads, __total_length));
1278 
 
1279 
#       pragma omp parallel num_threads (__num_threads)
1280 
        {
1281 
#         pragma omp single
1282 
          {
1283 
            __num_threads = omp_get_num_threads();
1284 
            // Thread __t will have to merge pieces[__iam][0..__k - 1]
1285 
            __pieces = new std::vector<
1286 
            std::pair<_DifferenceType, _DifferenceType> >[__num_threads];
1287 
            for (_ThreadIndex __s = 0; __s < __num_threads; ++__s)
1288 
              __pieces[__s].resize(__k);
1289 
 
1290 
            _DifferenceType __num_samples =
1291 
              __gnu_parallel::_Settings::get().merge_oversampling
1292 
              * __num_threads;
1293 
 
1294 
            __splitter(__ne_seqs, __ne_seqs + __k, __length, __total_length,
1295 
                       __comp, __pieces);
1296 
          } //single
1297 
 
1298 
          _ThreadIndex __iam = omp_get_thread_num();
1299 
 
1300 
          _DifferenceType __target_position = 0;
1301 
 
1302 
          for (_SeqNumber __c = 0; __c < __k; ++__c)
1303 
            __target_position += __pieces[__iam][__c].first;
1304 
 
1305 
          seq_type* __chunks = new seq_type[__k];
1306 
 
1307 
          for (_SeqNumber __s = 0; __s < __k; ++__s)
1308 
            __chunks[__s] = std::make_pair(__ne_seqs[__s].first
1309 
                                           + __pieces[__iam][__s].first,
1310 
                                           __ne_seqs[__s].first
1311 
                                           + __pieces[__iam][__s].second);
1312 
 
1313 
          if(__length > __target_position)
1314 
            __sequential_multiway_merge<__stable, __sentinels>
1315 
              (__chunks, __chunks + __k, __target + __target_position,
1316 
               *(__seqs_begin->second), __length - __target_position, __comp);
1317 
 
1318 
          delete[] __chunks;
1319 
        } // parallel
1320 
 
1321 
#if _GLIBCXX_ASSERTIONS
1322 
        _GLIBCXX_PARALLEL_ASSERT(
1323 
          __is_sorted(__target, __target + __length, __comp));
1324 
#endif
1325 
 
1326 
        __k = 0;
1327 
        // Update ends of sequences.
1328 
        for (_RAIterIterator __raii = __seqs_begin;
1329 
             __raii != __seqs_end; ++__raii)
1330 
          {
1331 
            _DifferenceTp __length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
1332 
            if(__length > 0)
1333 
              (*__raii).first += __pieces[__num_threads - 1][__k++].second;
1334 
          }
1335 
 
1336 
        delete[] __pieces;
1337 
        delete[] __ne_seqs;
1338 
 
1339 
        return __target + __length;
1340 
      }
1341 
 
1342 
  /**
1343 
   * @brief Multiway Merge Frontend.
1344 
   *
1345 
   * Merge the sequences specified by seqs_begin and __seqs_end into
1346 
   * __target.  __seqs_begin and __seqs_end must point to a sequence of
1347 
   * pairs.  These pairs must contain an iterator to the beginning
1348 
   * of a sequence in their first entry and an iterator the _M_end of
1349 
   * the same sequence in their second entry.
1350 
   *
1351 
   * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
1352 
   * that breaks ties by sequence number but is slower.
1353 
   *
1354 
   * The first entries of the pairs (i.e. the begin iterators) will be moved
1355 
   * forward.
1356 
   *
1357 
   * The output sequence has to provide enough space for all elements
1358 
   * that are written to it.
1359 
   *
1360 
   * This function will merge the input sequences:
1361 
   *
1362 
   * - not stable
1363 
   * - parallel, depending on the input size and Settings
1364 
   * - using sampling for splitting
1365 
   * - not using sentinels
1366 
   *
1367 
   * Example:
1368 
   *
1369 
   * <pre>
1370 
   *   int sequences[10][10];
1371 
   *   for (int __i = 0; __i < 10; ++__i)
1372 
   *     for (int __j = 0; __i < 10; ++__j)
1373 
   *       sequences[__i][__j] = __j;
1374 
   *
1375 
   *   int __out[33];
1376 
   *   std::vector<std::pair<int*> > seqs;
1377 
   *   for (int __i = 0; __i < 10; ++__i)
1378 
   *     { seqs.push(std::make_pair<int*>(sequences[__i],
1379 
   *                                      sequences[__i] + 10)) }
1380 
   *
1381 
   *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
1382 
   * </pre>
1383 
   *
1384 
   * @see stable_multiway_merge
1385 
   *
1386 
   * @pre All input sequences must be sorted.
1387 
   * @pre Target must provide enough space to merge out length elements or
1388 
   *    the number of elements in all sequences, whichever is smaller.
1389 
   *
1390 
   * @post [__target, return __value) contains merged __elements from the
1391 
   *    input sequences.
1392 
   * @post return __value - __target = min(__length, number of elements in all
1393 
   *    sequences).
1394 
   *
1395 
   * @tparam _RAIterPairIterator iterator over sequence
1396 
   *    of pairs of iterators
1397 
   * @tparam _RAIterOut iterator over target sequence
1398 
   * @tparam _DifferenceTp difference type for the sequence
1399 
   * @tparam _Compare strict weak ordering type to compare elements
1400 
   *    in sequences
1401 
   *
1402 
   * @param __seqs_begin  __begin of sequence __sequence
1403 
   * @param __seqs_end    _M_end of sequence __sequence
1404 
   * @param __target      target sequence to merge to.
1405 
   * @param __comp        strict weak ordering to use for element comparison.
1406 
   * @param __length Maximum length to merge, possibly larger than the
1407 
   * number of elements available.
1408 
   *
1409 
   * @return _M_end iterator of output sequence
1410 
   */
1411 
  // multiway_merge
1412 
  // public interface
1413 
  template<typename _RAIterPairIterator,
1414 
           typename _RAIterOut,
1415 
           typename _DifferenceTp,
1416 
           typename _Compare>
1417 
    _RAIterOut
1418 
    multiway_merge(_RAIterPairIterator __seqs_begin,
1419 
                   _RAIterPairIterator __seqs_end,
1420 
                   _RAIterOut __target,
1421 
                   _DifferenceTp __length, _Compare __comp,
1422 
                   __gnu_parallel::sequential_tag)
1423 
    {
1424 
      typedef _DifferenceTp _DifferenceType;
1425 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1426 
 
1427 
      // catch special case: no sequences
1428 
      if (__seqs_begin == __seqs_end)
1429 
        return __target;
1430 
 
1431 
      // Execute multiway merge *sequentially*.
1432 
      return __sequential_multiway_merge
1433 
        </* __stable = */ false, /* __sentinels = */ false>
1434 
        (__seqs_begin, __seqs_end, __target,
1435 
         *(__seqs_begin->second), __length, __comp);
1436 
    }
1437 
 
1438 
  // public interface
1439 
  template<typename _RAIterPairIterator,
1440 
           typename _RAIterOut,
1441 
           typename _DifferenceTp,
1442 
           typename _Compare>
1443 
    _RAIterOut
1444 
    multiway_merge(_RAIterPairIterator __seqs_begin,
1445 
                   _RAIterPairIterator __seqs_end,
1446 
                   _RAIterOut __target,
1447 
                   _DifferenceTp __length, _Compare __comp,
1448 
                   __gnu_parallel::exact_tag __tag)
1449 
    {
1450 
      typedef _DifferenceTp _DifferenceType;
1451 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1452 
 
1453 
      // catch special case: no sequences
1454 
      if (__seqs_begin == __seqs_end)
1455 
        return __target;
1456 
 
1457 
      // Execute merge; maybe parallel, depending on the number of merged
1458 
      // elements and the number of sequences and global thresholds in
1459 
      // Settings.
1460 
      if ((__seqs_end - __seqs_begin > 1)
1461 
          && _GLIBCXX_PARALLEL_CONDITION(
1462 
            ((__seqs_end - __seqs_begin) >=
1463 
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1464 
            && ((_SequenceIndex)__length >=
1465 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1466 
        return parallel_multiway_merge
1467 
          </* __stable = */ false, /* __sentinels = */ false>
1468 
          (__seqs_begin, __seqs_end, __target,
1469 
           multiway_merge_exact_splitting</* __stable = */ false,
1470 
           typename std::iterator_traits<_RAIterPairIterator>
1471 
           ::value_type*, _Compare, _DifferenceTp>,
1472 
           static_cast<_DifferenceType>(__length), __comp,
1473 
           __tag.__get_num_threads());
1474 
      else
1475 
        return __sequential_multiway_merge
1476 
          </* __stable = */ false, /* __sentinels = */ false>
1477 
          (__seqs_begin, __seqs_end, __target,
1478 
           *(__seqs_begin->second), __length, __comp);
1479 
    }
1480 
 
1481 
  // public interface
1482 
  template<typename _RAIterPairIterator,
1483 
           typename _RAIterOut,
1484 
           typename _DifferenceTp,
1485 
           typename _Compare>
1486 
    _RAIterOut
1487 
    multiway_merge(_RAIterPairIterator __seqs_begin,
1488 
                   _RAIterPairIterator __seqs_end,
1489 
                   _RAIterOut __target,
1490 
                   _DifferenceTp __length, _Compare __comp,
1491 
                   __gnu_parallel::sampling_tag __tag)
1492 
    {
1493 
      typedef _DifferenceTp _DifferenceType;
1494 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1495 
 
1496 
      // catch special case: no sequences
1497 
      if (__seqs_begin == __seqs_end)
1498 
        return __target;
1499 
 
1500 
      // Execute merge; maybe parallel, depending on the number of merged
1501 
      // elements and the number of sequences and global thresholds in
1502 
      // Settings.
1503 
      if ((__seqs_end - __seqs_begin > 1)
1504 
          && _GLIBCXX_PARALLEL_CONDITION(
1505 
            ((__seqs_end - __seqs_begin) >=
1506 
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1507 
            && ((_SequenceIndex)__length >=
1508 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1509 
        return parallel_multiway_merge
1510 
          </* __stable = */ false, /* __sentinels = */ false>
1511 
          (__seqs_begin, __seqs_end, __target,
1512 
           multiway_merge_exact_splitting</* __stable = */ false,
1513 
           typename std::iterator_traits<_RAIterPairIterator>
1514 
           ::value_type*, _Compare, _DifferenceTp>,
1515 
           static_cast<_DifferenceType>(__length), __comp,
1516 
           __tag.__get_num_threads());
1517 
      else
1518 
        return __sequential_multiway_merge
1519 
          </* __stable = */ false, /* __sentinels = */ false>
1520 
          (__seqs_begin, __seqs_end, __target,
1521 
           *(__seqs_begin->second), __length, __comp);
1522 
    }
1523 
 
1524 
  // public interface
1525 
  template<typename _RAIterPairIterator,
1526 
           typename _RAIterOut,
1527 
           typename _DifferenceTp,
1528 
           typename _Compare>
1529 
    _RAIterOut
1530 
    multiway_merge(_RAIterPairIterator __seqs_begin,
1531 
                   _RAIterPairIterator __seqs_end,
1532 
                   _RAIterOut __target,
1533 
                   _DifferenceTp __length, _Compare __comp,
1534 
                   parallel_tag __tag = parallel_tag(0))
1535 
    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
1536 
                            __comp, exact_tag(__tag.__get_num_threads())); }
1537 
 
1538 
  // public interface
1539 
  template<typename _RAIterPairIterator,
1540 
           typename _RAIterOut,
1541 
           typename _DifferenceTp,
1542 
           typename _Compare>
1543 
    _RAIterOut
1544 
    multiway_merge(_RAIterPairIterator __seqs_begin,
1545 
                   _RAIterPairIterator __seqs_end,
1546 
                   _RAIterOut __target,
1547 
                   _DifferenceTp __length, _Compare __comp,
1548 
                   default_parallel_tag __tag)
1549 
    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
1550 
                            __comp, exact_tag(__tag.__get_num_threads())); }
1551 
 
1552 
  // stable_multiway_merge
1553 
  // public interface
1554 
  template<typename _RAIterPairIterator,
1555 
           typename _RAIterOut,
1556 
           typename _DifferenceTp,
1557 
           typename _Compare>
1558 
    _RAIterOut
1559 
    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
1560 
                          _RAIterPairIterator __seqs_end,
1561 
                          _RAIterOut __target,
1562 
                          _DifferenceTp __length, _Compare __comp,
1563 
                          __gnu_parallel::sequential_tag)
1564 
    {
1565 
      typedef _DifferenceTp _DifferenceType;
1566 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1567 
 
1568 
      // catch special case: no sequences
1569 
      if (__seqs_begin == __seqs_end)
1570 
        return __target;
1571 
 
1572 
      // Execute multiway merge *sequentially*.
1573 
      return __sequential_multiway_merge
1574 
        </* __stable = */ true, /* __sentinels = */ false>
1575 
          (__seqs_begin, __seqs_end, __target,
1576 
           *(__seqs_begin->second), __length, __comp);
1577 
    }
1578 
 
1579 
  // public interface
1580 
  template<typename _RAIterPairIterator,
1581 
           typename _RAIterOut,
1582 
           typename _DifferenceTp,
1583 
           typename _Compare>
1584 
    _RAIterOut
1585 
    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
1586 
                          _RAIterPairIterator __seqs_end,
1587 
                          _RAIterOut __target,
1588 
                          _DifferenceTp __length, _Compare __comp,
1589 
                          __gnu_parallel::exact_tag __tag)
1590 
    {
1591 
      typedef _DifferenceTp _DifferenceType;
1592 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1593 
 
1594 
      // catch special case: no sequences
1595 
      if (__seqs_begin == __seqs_end)
1596 
        return __target;
1597 
 
1598 
      // Execute merge; maybe parallel, depending on the number of merged
1599 
      // elements and the number of sequences and global thresholds in
1600 
      // Settings.
1601 
      if ((__seqs_end - __seqs_begin > 1)
1602 
          && _GLIBCXX_PARALLEL_CONDITION(
1603 
            ((__seqs_end - __seqs_begin) >=
1604 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1605 
            && ((_SequenceIndex)__length >=
1606 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1607 
        return parallel_multiway_merge
1608 
          </* __stable = */ true, /* __sentinels = */ false>
1609 
          (__seqs_begin, __seqs_end, __target,
1610 
           multiway_merge_exact_splitting</* __stable = */ true,
1611 
           typename std::iterator_traits<_RAIterPairIterator>
1612 
           ::value_type*, _Compare, _DifferenceTp>,
1613 
           static_cast<_DifferenceType>(__length), __comp,
1614 
           __tag.__get_num_threads());
1615 
      else
1616 
        return __sequential_multiway_merge
1617 
          </* __stable = */ true, /* __sentinels = */ false>
1618 
          (__seqs_begin, __seqs_end, __target,
1619 
           *(__seqs_begin->second), __length, __comp);
1620 
    }
1621 
 
1622 
  // public interface
1623 
  template<typename _RAIterPairIterator,
1624 
           typename _RAIterOut,
1625 
           typename _DifferenceTp,
1626 
           typename _Compare>
1627 
    _RAIterOut
1628 
    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
1629 
                          _RAIterPairIterator __seqs_end,
1630 
                          _RAIterOut __target,
1631 
                          _DifferenceTp __length, _Compare __comp,
1632 
                          sampling_tag __tag)
1633 
    {
1634 
      typedef _DifferenceTp _DifferenceType;
1635 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1636 
 
1637 
      // catch special case: no sequences
1638 
      if (__seqs_begin == __seqs_end)
1639 
        return __target;
1640 
 
1641 
      // Execute merge; maybe parallel, depending on the number of merged
1642 
      // elements and the number of sequences and global thresholds in
1643 
      // Settings.
1644 
      if ((__seqs_end - __seqs_begin > 1)
1645 
          && _GLIBCXX_PARALLEL_CONDITION(
1646 
            ((__seqs_end - __seqs_begin) >=
1647 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1648 
            && ((_SequenceIndex)__length >=
1649 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1650 
        return parallel_multiway_merge
1651 
          </* __stable = */ true, /* __sentinels = */ false>
1652 
          (__seqs_begin, __seqs_end, __target,
1653 
           multiway_merge_sampling_splitting</* __stable = */ true,
1654 
           typename std::iterator_traits<_RAIterPairIterator>
1655 
           ::value_type*, _Compare, _DifferenceTp>,
1656 
           static_cast<_DifferenceType>(__length), __comp,
1657 
           __tag.__get_num_threads());
1658 
      else
1659 
        return __sequential_multiway_merge
1660 
          </* __stable = */ true, /* __sentinels = */ false>
1661 
          (__seqs_begin, __seqs_end, __target,
1662 
           *(__seqs_begin->second), __length, __comp);
1663 
    }
1664 
 
1665 
  // public interface
1666 
  template<typename _RAIterPairIterator,
1667 
           typename _RAIterOut,
1668 
           typename _DifferenceTp,
1669 
           typename _Compare>
1670 
    _RAIterOut
1671 
    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
1672 
                          _RAIterPairIterator __seqs_end,
1673 
                          _RAIterOut __target,
1674 
                          _DifferenceTp __length, _Compare __comp,
1675 
                          parallel_tag __tag = parallel_tag(0))
1676 
    {
1677 
      return stable_multiway_merge
1678 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
1679 
         exact_tag(__tag.__get_num_threads()));
1680 
    }
1681 
 
1682 
  // public interface
1683 
  template<typename _RAIterPairIterator,
1684 
           typename _RAIterOut,
1685 
           typename _DifferenceTp,
1686 
           typename _Compare>
1687 
    _RAIterOut
1688 
    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
1689 
                          _RAIterPairIterator __seqs_end,
1690 
                          _RAIterOut __target,
1691 
                          _DifferenceTp __length, _Compare __comp,
1692 
                          default_parallel_tag __tag)
1693 
    {
1694 
      return stable_multiway_merge
1695 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
1696 
         exact_tag(__tag.__get_num_threads()));
1697 
    }
1698 
 
1699 
  /**
1700 
   * @brief Multiway Merge Frontend.
1701 
   *
1702 
   * Merge the sequences specified by seqs_begin and __seqs_end into
1703 
   * __target.  __seqs_begin and __seqs_end must point to a sequence of
1704 
   * pairs.  These pairs must contain an iterator to the beginning
1705 
   * of a sequence in their first entry and an iterator the _M_end of
1706 
   * the same sequence in their second entry.
1707 
   *
1708 
   * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
1709 
   * that breaks ties by sequence number but is slower.
1710 
   *
1711 
   * The first entries of the pairs (i.e. the begin iterators) will be moved
1712 
   * forward accordingly.
1713 
   *
1714 
   * The output sequence has to provide enough space for all elements
1715 
   * that are written to it.
1716 
   *
1717 
   * This function will merge the input sequences:
1718 
   *
1719 
   * - not stable
1720 
   * - parallel, depending on the input size and Settings
1721 
   * - using sampling for splitting
1722 
   * - using sentinels
1723 
   *
1724 
   * You have to take care that the element the _M_end iterator points to is
1725 
   * readable and contains a value that is greater than any other non-sentinel
1726 
   * value in all sequences.
1727 
   *
1728 
   * Example:
1729 
   *
1730 
   * <pre>
1731 
   *   int sequences[10][11];
1732 
   *   for (int __i = 0; __i < 10; ++__i)
1733 
   *     for (int __j = 0; __i < 11; ++__j)
1734 
   *       sequences[__i][__j] = __j; // __last one is sentinel!
1735 
   *
1736 
   *   int __out[33];
1737 
   *   std::vector<std::pair<int*> > seqs;
1738 
   *   for (int __i = 0; __i < 10; ++__i)
1739 
   *     { seqs.push(std::make_pair<int*>(sequences[__i],
1740 
   *                                      sequences[__i] + 10)) }
1741 
   *
1742 
   *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
1743 
   * </pre>
1744 
   *
1745 
   * @pre All input sequences must be sorted.
1746 
   * @pre Target must provide enough space to merge out length elements or
1747 
   *    the number of elements in all sequences, whichever is smaller.
1748 
   * @pre For each @c __i, @c __seqs_begin[__i].second must be the end
1749 
   *    marker of the sequence, but also reference the one more __sentinel
1750 
   *    element.
1751 
   *
1752 
   * @post [__target, return __value) contains merged __elements from the
1753 
   *    input sequences.
1754 
   * @post return __value - __target = min(__length, number of elements in all
1755 
   *    sequences).
1756 
   *
1757 
   * @see stable_multiway_merge_sentinels
1758 
   *
1759 
   * @tparam _RAIterPairIterator iterator over sequence
1760 
   *    of pairs of iterators
1761 
   * @tparam _RAIterOut iterator over target sequence
1762 
   * @tparam _DifferenceTp difference type for the sequence
1763 
   * @tparam _Compare strict weak ordering type to compare elements
1764 
   *    in sequences
1765 
   *
1766 
   * @param __seqs_begin  __begin of sequence __sequence
1767 
   * @param __seqs_end    _M_end of sequence __sequence
1768 
   * @param __target      target sequence to merge to.
1769 
   * @param __comp        strict weak ordering to use for element comparison.
1770 
   * @param __length Maximum length to merge, possibly larger than the
1771 
   * number of elements available.
1772 
   *
1773 
   * @return _M_end iterator of output sequence
1774 
   */
1775 
  // multiway_merge_sentinels
1776 
  // public interface
1777 
  template<typename _RAIterPairIterator,
1778 
           typename _RAIterOut,
1779 
           typename _DifferenceTp,
1780 
           typename _Compare>
1781 
    _RAIterOut
1782 
    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1783 
                             _RAIterPairIterator __seqs_end,
1784 
                             _RAIterOut __target,
1785 
                             _DifferenceTp __length, _Compare __comp,
1786 
                             __gnu_parallel::sequential_tag)
1787 
    {
1788 
      typedef _DifferenceTp _DifferenceType;
1789 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1790 
 
1791 
      // catch special case: no sequences
1792 
      if (__seqs_begin == __seqs_end)
1793 
        return __target;
1794 
 
1795 
      // Execute multiway merge *sequentially*.
1796 
      return __sequential_multiway_merge
1797 
        </* __stable = */ false, /* __sentinels = */ true>
1798 
          (__seqs_begin, __seqs_end,
1799 
           __target, *(__seqs_begin->second), __length, __comp);
1800 
    }
1801 
 
1802 
  // public interface
1803 
  template<typename _RAIterPairIterator,
1804 
           typename _RAIterOut,
1805 
           typename _DifferenceTp,
1806 
           typename _Compare>
1807 
    _RAIterOut
1808 
    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1809 
                             _RAIterPairIterator __seqs_end,
1810 
                             _RAIterOut __target,
1811 
                             _DifferenceTp __length, _Compare __comp,
1812 
                             __gnu_parallel::exact_tag __tag)
1813 
    {
1814 
      typedef _DifferenceTp _DifferenceType;
1815 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1816 
 
1817 
      // catch special case: no sequences
1818 
      if (__seqs_begin == __seqs_end)
1819 
        return __target;
1820 
 
1821 
      // Execute merge; maybe parallel, depending on the number of merged
1822 
      // elements and the number of sequences and global thresholds in
1823 
      // Settings.
1824 
      if ((__seqs_end - __seqs_begin > 1)
1825 
          && _GLIBCXX_PARALLEL_CONDITION(
1826 
            ((__seqs_end - __seqs_begin) >=
1827 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1828 
            && ((_SequenceIndex)__length >=
1829 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1830 
        return parallel_multiway_merge
1831 
          </* __stable = */ false, /* __sentinels = */ true>
1832 
          (__seqs_begin, __seqs_end, __target,
1833 
           multiway_merge_exact_splitting</* __stable = */ false,
1834 
           typename std::iterator_traits<_RAIterPairIterator>
1835 
           ::value_type*, _Compare, _DifferenceTp>,
1836 
           static_cast<_DifferenceType>(__length), __comp,
1837 
           __tag.__get_num_threads());
1838 
      else
1839 
        return __sequential_multiway_merge
1840 
          </* __stable = */ false, /* __sentinels = */ true>
1841 
          (__seqs_begin, __seqs_end, __target,
1842 
           *(__seqs_begin->second), __length, __comp);
1843 
    }
1844 
 
1845 
  // public interface
1846 
  template<typename _RAIterPairIterator,
1847 
           typename _RAIterOut,
1848 
           typename _DifferenceTp,
1849 
           typename _Compare>
1850 
    _RAIterOut
1851 
    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1852 
                             _RAIterPairIterator __seqs_end,
1853 
                             _RAIterOut __target,
1854 
                             _DifferenceTp __length, _Compare __comp,
1855 
                             sampling_tag __tag)
1856 
    {
1857 
      typedef _DifferenceTp _DifferenceType;
1858 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1859 
 
1860 
      // catch special case: no sequences
1861 
      if (__seqs_begin == __seqs_end)
1862 
        return __target;
1863 
 
1864 
      // Execute merge; maybe parallel, depending on the number of merged
1865 
      // elements and the number of sequences and global thresholds in
1866 
      // Settings.
1867 
      if ((__seqs_end - __seqs_begin > 1)
1868 
          && _GLIBCXX_PARALLEL_CONDITION(
1869 
            ((__seqs_end - __seqs_begin) >=
1870 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1871 
            && ((_SequenceIndex)__length >=
1872 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1873 
        return parallel_multiway_merge
1874 
          </* __stable = */ false, /* __sentinels = */ true>
1875 
          (__seqs_begin, __seqs_end, __target,
1876 
           multiway_merge_sampling_splitting</* __stable = */ false,
1877 
           typename std::iterator_traits<_RAIterPairIterator>
1878 
           ::value_type*, _Compare, _DifferenceTp>,
1879 
           static_cast<_DifferenceType>(__length), __comp,
1880 
           __tag.__get_num_threads());
1881 
      else
1882 
        return __sequential_multiway_merge
1883 
          </* __stable = */false, /* __sentinels = */ true>(
1884 
            __seqs_begin, __seqs_end, __target,
1885 
            *(__seqs_begin->second), __length, __comp);
1886 
    }
1887 
 
1888 
  // public interface
1889 
  template<typename _RAIterPairIterator,
1890 
           typename _RAIterOut,
1891 
           typename _DifferenceTp,
1892 
           typename _Compare>
1893 
    _RAIterOut
1894 
    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1895 
                             _RAIterPairIterator __seqs_end,
1896 
                             _RAIterOut __target,
1897 
                             _DifferenceTp __length, _Compare __comp,
1898 
                             parallel_tag __tag = parallel_tag(0))
1899 
    {
1900 
      return multiway_merge_sentinels
1901 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
1902 
         exact_tag(__tag.__get_num_threads()));
1903 
    }
1904 
 
1905 
  // public interface
1906 
  template<typename _RAIterPairIterator,
1907 
           typename _RAIterOut,
1908 
           typename _DifferenceTp,
1909 
           typename _Compare>
1910 
    _RAIterOut
1911 
    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1912 
                             _RAIterPairIterator __seqs_end,
1913 
                             _RAIterOut __target,
1914 
                             _DifferenceTp __length, _Compare __comp,
1915 
                             default_parallel_tag __tag)
1916 
    {
1917 
      return multiway_merge_sentinels
1918 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
1919 
         exact_tag(__tag.__get_num_threads()));
1920 
    }
1921 
 
1922 
  // stable_multiway_merge_sentinels
1923 
  // public interface
1924 
  template<typename _RAIterPairIterator,
1925 
           typename _RAIterOut,
1926 
           typename _DifferenceTp,
1927 
           typename _Compare>
1928 
    _RAIterOut
1929 
    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1930 
                                    _RAIterPairIterator __seqs_end,
1931 
                                    _RAIterOut __target,
1932 
                                    _DifferenceTp __length, _Compare __comp,
1933 
                                    __gnu_parallel::sequential_tag)
1934 
    {
1935 
      typedef _DifferenceTp _DifferenceType;
1936 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1937 
 
1938 
      // catch special case: no sequences
1939 
      if (__seqs_begin == __seqs_end)
1940 
        return __target;
1941 
 
1942 
      // Execute multiway merge *sequentially*.
1943 
      return __sequential_multiway_merge
1944 
        </* __stable = */ true, /* __sentinels = */ true>
1945 
        (__seqs_begin, __seqs_end, __target,
1946 
         *(__seqs_begin->second), __length, __comp);
1947 
    }
1948 
 
1949 
  // public interface
1950 
  template<typename _RAIterPairIterator,
1951 
           typename _RAIterOut,
1952 
           typename _DifferenceTp,
1953 
           typename _Compare>
1954 
    _RAIterOut
1955 
    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1956 
                                    _RAIterPairIterator __seqs_end,
1957 
                                    _RAIterOut __target,
1958 
                                    _DifferenceTp __length, _Compare __comp,
1959 
                                    __gnu_parallel::exact_tag __tag)
1960 
    {
1961 
      typedef _DifferenceTp _DifferenceType;
1962 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
1963 
 
1964 
      // catch special case: no sequences
1965 
      if (__seqs_begin == __seqs_end)
1966 
        return __target;
1967 
 
1968 
      // Execute merge; maybe parallel, depending on the number of merged
1969 
      // elements and the number of sequences and global thresholds in
1970 
      // Settings.
1971 
      if ((__seqs_end - __seqs_begin > 1)
1972 
          && _GLIBCXX_PARALLEL_CONDITION(
1973 
            ((__seqs_end - __seqs_begin) >=
1974 
            __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
1975 
            && ((_SequenceIndex)__length >=
1976 
            __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
1977 
        return parallel_multiway_merge
1978 
          </* __stable = */ true, /* __sentinels = */ true>
1979 
          (__seqs_begin, __seqs_end, __target,
1980 
           multiway_merge_exact_splitting</* __stable = */ true,
1981 
           typename std::iterator_traits<_RAIterPairIterator>
1982 
           ::value_type*, _Compare, _DifferenceTp>,
1983 
           static_cast<_DifferenceType>(__length), __comp,
1984 
           __tag.__get_num_threads());
1985 
      else
1986 
        return __sequential_multiway_merge
1987 
          </* __stable = */ true, /* __sentinels = */ true>
1988 
          (__seqs_begin, __seqs_end, __target,
1989 
           *(__seqs_begin->second), __length, __comp);
1990 
    }
1991 
 
1992 
  // public interface
1993 
  template<typename _RAIterPairIterator,
1994 
           typename _RAIterOut,
1995 
           typename _DifferenceTp,
1996 
           typename _Compare>
1997 
    _RAIterOut
1998 
    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
1999 
                                    _RAIterPairIterator __seqs_end,
2000 
                                    _RAIterOut __target,
2001 
                                    _DifferenceTp __length,
2002 
                                    _Compare __comp,
2003 
                                    sampling_tag __tag)
2004 
    {
2005 
      typedef _DifferenceTp _DifferenceType;
2006 
      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
2007 
 
2008 
      // catch special case: no sequences
2009 
      if (__seqs_begin == __seqs_end)
2010 
        return __target;
2011 
 
2012 
      // Execute merge; maybe parallel, depending on the number of merged
2013 
      // elements and the number of sequences and global thresholds in
2014 
      // Settings.
2015 
      if ((__seqs_end - __seqs_begin > 1)
2016 
          && _GLIBCXX_PARALLEL_CONDITION(
2017 
            ((__seqs_end - __seqs_begin) >=
2018 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
2019 
            && ((_SequenceIndex)__length >=
2020 
              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
2021 
        return parallel_multiway_merge
2022 
          </* __stable = */ true, /* __sentinels = */ true>
2023 
          (__seqs_begin, __seqs_end, __target,
2024 
           multiway_merge_sampling_splitting</* __stable = */ true,
2025 
           typename std::iterator_traits<_RAIterPairIterator>
2026 
           ::value_type*, _Compare, _DifferenceTp>,
2027 
           static_cast<_DifferenceType>(__length), __comp,
2028 
           __tag.__get_num_threads());
2029 
      else
2030 
        return __sequential_multiway_merge
2031 
          </* __stable = */ true, /* __sentinels = */ true>
2032 
          (__seqs_begin, __seqs_end, __target,
2033 
           *(__seqs_begin->second), __length, __comp);
2034 
    }
2035 
 
2036 
  // public interface
2037 
  template<typename _RAIterPairIterator,
2038 
           typename _RAIterOut,
2039 
           typename _DifferenceTp,
2040 
           typename _Compare>
2041 
    _RAIterOut
2042 
    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
2043 
                                    _RAIterPairIterator __seqs_end,
2044 
                                    _RAIterOut __target,
2045 
                                    _DifferenceTp __length,
2046 
                                    _Compare __comp,
2047 
                                    parallel_tag __tag = parallel_tag(0))
2048 
    {
2049 
      return stable_multiway_merge_sentinels
2050 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
2051 
         exact_tag(__tag.__get_num_threads()));
2052 
    }
2053 
 
2054 
  // public interface
2055 
  template<typename _RAIterPairIterator,
2056 
           typename _RAIterOut,
2057 
           typename _DifferenceTp,
2058 
           typename _Compare>
2059 
    _RAIterOut
2060 
    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
2061 
                                    _RAIterPairIterator __seqs_end,
2062 
                                    _RAIterOut __target,
2063 
                                    _DifferenceTp __length, _Compare __comp,
2064 
                                    default_parallel_tag __tag)
2065 
    {
2066 
      return stable_multiway_merge_sentinels
2067 
        (__seqs_begin, __seqs_end, __target, __length, __comp,
2068 
         exact_tag(__tag.__get_num_threads()));
2069 
    }
2070 
}; // namespace __gnu_parallel
2071 
 
2072 
#endif /* _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.