1 <chapter xmlns="http://docbook.org/ns/docbook" version="5.0"
2 xml:id="manual.ext.parallel_mode" xreflabel="Parallel Mode">
3 <?dbhtml filename="parallel_mode.html"?>
5 <info><title>Parallel Mode</title>
21 <para> The libstdc++ parallel mode is an experimental parallel
22 implementation of many algorithms the C++ Standard Library.
26 Several of the standard algorithms, for instance
27 <function>std::sort</function>, are made parallel using OpenMP
28 annotations. These parallel mode constructs and can be invoked by
29 explicit source declaration or by compiling existing sources with a
30 specific compiler flag.
34 <section xml:id="manual.ext.parallel_mode.intro" xreflabel="Intro"><info><title>Intro</title></info>
37 <para>The following library components in the include
38 <filename class="headerfile">numeric</filename> are included in the parallel mode:</para>
40 <listitem><para><function>std::accumulate</function></para></listitem>
41 <listitem><para><function>std::adjacent_difference</function></para></listitem>
42 <listitem><para><function>std::inner_product</function></para></listitem>
43 <listitem><para><function>std::partial_sum</function></para></listitem>
46 <para>The following library components in the include
47 <filename class="headerfile">algorithm</filename> are included in the parallel mode:</para>
49 <listitem><para><function>std::adjacent_find</function></para></listitem>
50 <listitem><para><function>std::count</function></para></listitem>
51 <listitem><para><function>std::count_if</function></para></listitem>
52 <listitem><para><function>std::equal</function></para></listitem>
53 <listitem><para><function>std::find</function></para></listitem>
54 <listitem><para><function>std::find_if</function></para></listitem>
55 <listitem><para><function>std::find_first_of</function></para></listitem>
56 <listitem><para><function>std::for_each</function></para></listitem>
57 <listitem><para><function>std::generate</function></para></listitem>
58 <listitem><para><function>std::generate_n</function></para></listitem>
59 <listitem><para><function>std::lexicographical_compare</function></para></listitem>
60 <listitem><para><function>std::mismatch</function></para></listitem>
61 <listitem><para><function>std::search</function></para></listitem>
62 <listitem><para><function>std::search_n</function></para></listitem>
63 <listitem><para><function>std::transform</function></para></listitem>
64 <listitem><para><function>std::replace</function></para></listitem>
65 <listitem><para><function>std::replace_if</function></para></listitem>
66 <listitem><para><function>std::max_element</function></para></listitem>
67 <listitem><para><function>std::merge</function></para></listitem>
68 <listitem><para><function>std::min_element</function></para></listitem>
69 <listitem><para><function>std::nth_element</function></para></listitem>
70 <listitem><para><function>std::partial_sort</function></para></listitem>
71 <listitem><para><function>std::partition</function></para></listitem>
72 <listitem><para><function>std::random_shuffle</function></para></listitem>
73 <listitem><para><function>std::set_union</function></para></listitem>
74 <listitem><para><function>std::set_intersection</function></para></listitem>
75 <listitem><para><function>std::set_symmetric_difference</function></para></listitem>
76 <listitem><para><function>std::set_difference</function></para></listitem>
77 <listitem><para><function>std::sort</function></para></listitem>
78 <listitem><para><function>std::stable_sort</function></para></listitem>
79 <listitem><para><function>std::unique_copy</function></para></listitem>
84 <section xml:id="manual.ext.parallel_mode.semantics" xreflabel="Semantics"><info><title>Semantics</title></info>
87 <para> The parallel mode STL algorithms are currently not exception-safe,
88 i.e. user-defined functors must not throw exceptions.
89 Also, the order of execution is not guaranteed for some functions, of course.
90 Therefore, user-defined functors should not have any concurrent side effects.
93 <para> Since the current GCC OpenMP implementation does not support
94 OpenMP parallel regions in concurrent threads,
95 it is not possible to call parallel STL algorithm in
96 concurrent threads, either.
97 It might work with other compilers, though.</para>
101 <section xml:id="manual.ext.parallel_mode.using" xreflabel="Using"><info><title>Using</title></info>
104 <section xml:id="parallel_mode.using.prereq_flags"><info><title>Prerequisite Compiler Flags</title></info>
108 Any use of parallel functionality requires additional compiler
109 and runtime support, in particular support for OpenMP. Adding this support is
110 not difficult: just compile your application with the compiler
111 flag <literal>-fopenmp</literal>. This will link
112 in <code>libgomp</code>, the GNU
113 OpenMP <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libgomp">implementation</link>,
114 whose presence is mandatory.
118 In addition, hardware that supports atomic operations and a compiler
119 capable of producing atomic operations is mandatory: GCC defaults to no
120 support for atomic operations on some common hardware
121 architectures. Activating atomic operations may require explicit
122 compiler flags on some targets (like sparc and x86), such
123 as <literal>-march=i686</literal>,
124 <literal>-march=native</literal> or <literal>-mcpu=v9</literal>. See
125 the GCC manual for more information.
130 <section xml:id="parallel_mode.using.parallel_mode"><info><title>Using Parallel Mode</title></info>
134 To use the libstdc++ parallel mode, compile your application with
135 the prerequisite flags as detailed above, and in addition
136 add <constant>-D_GLIBCXX_PARALLEL</constant>. This will convert all
137 use of the standard (sequential) algorithms to the appropriate parallel
138 equivalents. Please note that this doesn't necessarily mean that
139 everything will end up being executed in a parallel manner, but
140 rather that the heuristics and settings coded into the parallel
141 versions will be used to determine if all, some, or no algorithms
142 will be executed using parallel variants.
145 <para>Note that the <constant>_GLIBCXX_PARALLEL</constant> define may change the
146 sizes and behavior of standard class templates such as
147 <function>std::search</function>, and therefore one can only link code
148 compiled with parallel mode and code compiled without parallel mode
149 if no instantiation of a container is passed between the two
150 translation units. Parallel mode functionality has distinct linkage,
151 and cannot be confused with normal mode symbols.
155 <section xml:id="parallel_mode.using.specific"><info><title>Using Specific Parallel Components</title></info>
158 <para>When it is not feasible to recompile your entire application, or
159 only specific algorithms need to be parallel-aware, individual
160 parallel algorithms can be made available explicitly. These
161 parallel algorithms are functionally equivalent to the standard
162 drop-in algorithms used in parallel mode, but they are available in
163 a separate namespace as GNU extensions and may be used in programs
164 compiled with either release mode or with parallel mode.
168 <para>An example of using a parallel version
169 of <function>std::sort</function>, but no other parallel algorithms, is:
173 #include <vector>
174 #include <parallel/algorithm>
178 std::vector<int> v(100);
182 // Explicitly force a call to parallel sort.
183 __gnu_parallel::sort(v.begin(), v.end());
189 Then compile this code with the prerequisite compiler flags
190 (<literal>-fopenmp</literal> and any necessary architecture-specific
191 flags for atomic operations.)
194 <para> The following table provides the names and headers of all the
195 parallel algorithms that can be used in a similar manner:
199 <title>Parallel Algorithms</title>
201 <tgroup cols="4" align="left" colsep="1" rowsep="1">
202 <colspec colname="c1"/>
203 <colspec colname="c2"/>
204 <colspec colname="c3"/>
205 <colspec colname="c4"/>
209 <entry>Algorithm</entry>
210 <entry>Header</entry>
211 <entry>Parallel algorithm</entry>
212 <entry>Parallel header</entry>
218 <entry><function>std::accumulate</function></entry>
219 <entry><filename class="headerfile">numeric</filename></entry>
220 <entry><function>__gnu_parallel::accumulate</function></entry>
221 <entry><filename class="headerfile">parallel/numeric</filename></entry>
224 <entry><function>std::adjacent_difference</function></entry>
225 <entry><filename class="headerfile">numeric</filename></entry>
226 <entry><function>__gnu_parallel::adjacent_difference</function></entry>
227 <entry><filename class="headerfile">parallel/numeric</filename></entry>
230 <entry><function>std::inner_product</function></entry>
231 <entry><filename class="headerfile">numeric</filename></entry>
232 <entry><function>__gnu_parallel::inner_product</function></entry>
233 <entry><filename class="headerfile">parallel/numeric</filename></entry>
236 <entry><function>std::partial_sum</function></entry>
237 <entry><filename class="headerfile">numeric</filename></entry>
238 <entry><function>__gnu_parallel::partial_sum</function></entry>
239 <entry><filename class="headerfile">parallel/numeric</filename></entry>
242 <entry><function>std::adjacent_find</function></entry>
243 <entry><filename class="headerfile">algorithm</filename></entry>
244 <entry><function>__gnu_parallel::adjacent_find</function></entry>
245 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
249 <entry><function>std::count</function></entry>
250 <entry><filename class="headerfile">algorithm</filename></entry>
251 <entry><function>__gnu_parallel::count</function></entry>
252 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
256 <entry><function>std::count_if</function></entry>
257 <entry><filename class="headerfile">algorithm</filename></entry>
258 <entry><function>__gnu_parallel::count_if</function></entry>
259 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
263 <entry><function>std::equal</function></entry>
264 <entry><filename class="headerfile">algorithm</filename></entry>
265 <entry><function>__gnu_parallel::equal</function></entry>
266 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
270 <entry><function>std::find</function></entry>
271 <entry><filename class="headerfile">algorithm</filename></entry>
272 <entry><function>__gnu_parallel::find</function></entry>
273 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
277 <entry><function>std::find_if</function></entry>
278 <entry><filename class="headerfile">algorithm</filename></entry>
279 <entry><function>__gnu_parallel::find_if</function></entry>
280 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
284 <entry><function>std::find_first_of</function></entry>
285 <entry><filename class="headerfile">algorithm</filename></entry>
286 <entry><function>__gnu_parallel::find_first_of</function></entry>
287 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
291 <entry><function>std::for_each</function></entry>
292 <entry><filename class="headerfile">algorithm</filename></entry>
293 <entry><function>__gnu_parallel::for_each</function></entry>
294 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
298 <entry><function>std::generate</function></entry>
299 <entry><filename class="headerfile">algorithm</filename></entry>
300 <entry><function>__gnu_parallel::generate</function></entry>
301 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
305 <entry><function>std::generate_n</function></entry>
306 <entry><filename class="headerfile">algorithm</filename></entry>
307 <entry><function>__gnu_parallel::generate_n</function></entry>
308 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
312 <entry><function>std::lexicographical_compare</function></entry>
313 <entry><filename class="headerfile">algorithm</filename></entry>
314 <entry><function>__gnu_parallel::lexicographical_compare</function></entry>
315 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
319 <entry><function>std::mismatch</function></entry>
320 <entry><filename class="headerfile">algorithm</filename></entry>
321 <entry><function>__gnu_parallel::mismatch</function></entry>
322 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
326 <entry><function>std::search</function></entry>
327 <entry><filename class="headerfile">algorithm</filename></entry>
328 <entry><function>__gnu_parallel::search</function></entry>
329 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
333 <entry><function>std::search_n</function></entry>
334 <entry><filename class="headerfile">algorithm</filename></entry>
335 <entry><function>__gnu_parallel::search_n</function></entry>
336 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
340 <entry><function>std::transform</function></entry>
341 <entry><filename class="headerfile">algorithm</filename></entry>
342 <entry><function>__gnu_parallel::transform</function></entry>
343 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
347 <entry><function>std::replace</function></entry>
348 <entry><filename class="headerfile">algorithm</filename></entry>
349 <entry><function>__gnu_parallel::replace</function></entry>
350 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
354 <entry><function>std::replace_if</function></entry>
355 <entry><filename class="headerfile">algorithm</filename></entry>
356 <entry><function>__gnu_parallel::replace_if</function></entry>
357 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
361 <entry><function>std::max_element</function></entry>
362 <entry><filename class="headerfile">algorithm</filename></entry>
363 <entry><function>__gnu_parallel::max_element</function></entry>
364 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
368 <entry><function>std::merge</function></entry>
369 <entry><filename class="headerfile">algorithm</filename></entry>
370 <entry><function>__gnu_parallel::merge</function></entry>
371 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
375 <entry><function>std::min_element</function></entry>
376 <entry><filename class="headerfile">algorithm</filename></entry>
377 <entry><function>__gnu_parallel::min_element</function></entry>
378 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
382 <entry><function>std::nth_element</function></entry>
383 <entry><filename class="headerfile">algorithm</filename></entry>
384 <entry><function>__gnu_parallel::nth_element</function></entry>
385 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
389 <entry><function>std::partial_sort</function></entry>
390 <entry><filename class="headerfile">algorithm</filename></entry>
391 <entry><function>__gnu_parallel::partial_sort</function></entry>
392 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
396 <entry><function>std::partition</function></entry>
397 <entry><filename class="headerfile">algorithm</filename></entry>
398 <entry><function>__gnu_parallel::partition</function></entry>
399 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
403 <entry><function>std::random_shuffle</function></entry>
404 <entry><filename class="headerfile">algorithm</filename></entry>
405 <entry><function>__gnu_parallel::random_shuffle</function></entry>
406 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
410 <entry><function>std::set_union</function></entry>
411 <entry><filename class="headerfile">algorithm</filename></entry>
412 <entry><function>__gnu_parallel::set_union</function></entry>
413 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
417 <entry><function>std::set_intersection</function></entry>
418 <entry><filename class="headerfile">algorithm</filename></entry>
419 <entry><function>__gnu_parallel::set_intersection</function></entry>
420 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
424 <entry><function>std::set_symmetric_difference</function></entry>
425 <entry><filename class="headerfile">algorithm</filename></entry>
426 <entry><function>__gnu_parallel::set_symmetric_difference</function></entry>
427 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
431 <entry><function>std::set_difference</function></entry>
432 <entry><filename class="headerfile">algorithm</filename></entry>
433 <entry><function>__gnu_parallel::set_difference</function></entry>
434 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
438 <entry><function>std::sort</function></entry>
439 <entry><filename class="headerfile">algorithm</filename></entry>
440 <entry><function>__gnu_parallel::sort</function></entry>
441 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
445 <entry><function>std::stable_sort</function></entry>
446 <entry><filename class="headerfile">algorithm</filename></entry>
447 <entry><function>__gnu_parallel::stable_sort</function></entry>
448 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
452 <entry><function>std::unique_copy</function></entry>
453 <entry><filename class="headerfile">algorithm</filename></entry>
454 <entry><function>__gnu_parallel::unique_copy</function></entry>
455 <entry><filename class="headerfile">parallel/algorithm</filename></entry>
465 <section xml:id="manual.ext.parallel_mode.design" xreflabel="Design"><info><title>Design</title></info>
469 <section xml:id="parallel_mode.design.intro" xreflabel="Intro"><info><title>Interface Basics</title></info>
473 All parallel algorithms are intended to have signatures that are
474 equivalent to the ISO C++ algorithms replaced. For instance, the
475 <function>std::adjacent_find</function> function is declared as:
480 template<typename _FIter>
482 adjacent_find(_FIter, _FIter);
487 Which means that there should be something equivalent for the parallel
488 version. Indeed, this is the case:
496 template<typename _FIter>
498 adjacent_find(_FIter, _FIter);
505 <para>But.... why the ellipses?
508 <para> The ellipses in the example above represent additional overloads
509 required for the parallel version of the function. These additional
510 overloads are used to dispatch calls from the ISO C++ function
511 signature to the appropriate parallel function (or sequential
512 function, if no parallel functions are deemed worthy), based on either
513 compile-time or run-time conditions.
516 <para> The available signature options are specific for the different
517 algorithms/algorithm classes.</para>
519 <para> The general view of overloads for the parallel algorithms look like this:
522 <listitem><para>ISO C++ signature</para></listitem>
523 <listitem><para>ISO C++ signature + sequential_tag argument</para></listitem>
524 <listitem><para>ISO C++ signature + algorithm-specific tag type
525 (several signatures)</para></listitem>
528 <para> Please note that the implementation may use additional functions
529 (designated with the <code>_switch</code> suffix) to dispatch from the
530 ISO C++ signature to the correct parallel version. Also, some of the
531 algorithms do not have support for run-time conditions, so the last
532 overload is therefore missing.
538 <section xml:id="parallel_mode.design.tuning" xreflabel="Tuning"><info><title>Configuration and Tuning</title></info>
542 <section xml:id="parallel_mode.design.tuning.omp" xreflabel="OpenMP Environment"><info><title>Setting up the OpenMP Environment</title></info>
546 Several aspects of the overall runtime environment can be manipulated
547 by standard OpenMP function calls.
551 To specify the number of threads to be used for the algorithms globally,
552 use the function <function>omp_set_num_threads</function>. An example:
556 #include <stdlib.h>
557 #include <omp.h>
561 // Explicitly set number of threads.
562 const int threads_wanted = 20;
563 omp_set_dynamic(false);
564 omp_set_num_threads(threads_wanted);
566 // Call parallel mode algorithms.
573 Some algorithms allow the number of threads being set for a particular call,
574 by augmenting the algorithm variant.
575 See the next section for further information.
579 Other parts of the runtime environment able to be manipulated include
580 nested parallelism (<function>omp_set_nested</function>), schedule kind
581 (<function>omp_set_schedule</function>), and others. See the OpenMP
582 documentation for more information.
587 <section xml:id="parallel_mode.design.tuning.compile" xreflabel="Compile Switches"><info><title>Compile Time Switches</title></info>
591 To force an algorithm to execute sequentially, even though parallelism
592 is switched on in general via the macro <constant>_GLIBCXX_PARALLEL</constant>,
593 add <classname>__gnu_parallel::sequential_tag()</classname> to the end
594 of the algorithm's argument list.
602 std::sort(v.begin(), v.end(), __gnu_parallel::sequential_tag());
606 Some parallel algorithm variants can be excluded from compilation by
607 preprocessor defines. See the doxygen documentation on
608 <code>compiletime_settings.h</code> and <code>features.h</code> for details.
612 For some algorithms, the desired variant can be chosen at compile-time by
613 appending a tag object. The available options are specific to the particular
618 For the "embarrassingly parallel" algorithms, there is only one "tag object
619 type", the enum _Parallelism.
620 It takes one of the following values,
621 <code>__gnu_parallel::parallel_tag</code>,
622 <code>__gnu_parallel::balanced_tag</code>,
623 <code>__gnu_parallel::unbalanced_tag</code>,
624 <code>__gnu_parallel::omp_loop_tag</code>,
625 <code>__gnu_parallel::omp_loop_static_tag</code>.
626 This means that the actual parallelization strategy is chosen at run-time.
627 (Choosing the variants at compile-time will come soon.)
631 For the following algorithms in general, we have
632 <code>__gnu_parallel::parallel_tag</code> and
633 <code>__gnu_parallel::default_parallel_tag</code>, in addition to
634 <code>__gnu_parallel::sequential_tag</code>.
635 <code>__gnu_parallel::default_parallel_tag</code> chooses the default
636 algorithm at compiletime, as does omitting the tag.
637 <code>__gnu_parallel::parallel_tag</code> postpones the decision to runtime
639 For all tags, the number of threads desired for this call can optionally be
640 passed to the respective tag's constructor.
644 The <code>multiway_merge</code> algorithm comes with the additional choices,
645 <code>__gnu_parallel::exact_tag</code> and
646 <code>__gnu_parallel::sampling_tag</code>.
647 Exact and sampling are the two available splitting strategies.
651 For the <code>sort</code> and <code>stable_sort</code> algorithms, there are
652 several additional choices, namely
653 <code>__gnu_parallel::multiway_mergesort_tag</code>,
654 <code>__gnu_parallel::multiway_mergesort_exact_tag</code>,
655 <code>__gnu_parallel::multiway_mergesort_sampling_tag</code>,
656 <code>__gnu_parallel::quicksort_tag</code>, and
657 <code>__gnu_parallel::balanced_quicksort_tag</code>.
658 Multiway mergesort comes with the two splitting strategies for multi-way
659 merging. The quicksort options cannot be used for <code>stable_sort</code>.
664 <section xml:id="parallel_mode.design.tuning.settings" xreflabel="_Settings"><info><title>Run Time Settings and Defaults</title></info>
668 The default parallelization strategy, the choice of specific algorithm
669 strategy, the minimum threshold limits for individual parallel
670 algorithms, and aspects of the underlying hardware can be specified as
671 desired via manipulation
672 of <classname>__gnu_parallel::_Settings</classname> member data.
676 First off, the choice of parallelization strategy: serial, parallel,
677 or heuristically deduced. This corresponds
678 to <code>__gnu_parallel::_Settings::algorithm_strategy</code> and is a
679 value of enum <type>__gnu_parallel::_AlgorithmStrategy</type>
681 include: <type>heuristic</type>, <type>force_sequential</type>,
682 and <type>force_parallel</type>. The default is <type>heuristic</type>.
687 Next, the sub-choices for algorithm variant, if not fixed at compile-time.
688 Specific algorithms like <function>find</function> or <function>sort</function>
689 can be implemented in multiple ways: when this is the case,
690 a <classname>__gnu_parallel::_Settings</classname> member exists to
691 pick the default strategy. For
692 example, <code>__gnu_parallel::_Settings::sort_algorithm</code> can
694 enum <type>__gnu_parallel::_SortAlgorithm</type>: <type>MWMS</type>, <type>QS</type>,
695 or <type>QS_BALANCED</type>.
699 Likewise for setting the minimal threshold for algorithm
700 parallelization. Parallelism always incurs some overhead. Thus, it is
701 not helpful to parallelize operations on very small sets of
702 data. Because of this, measures are taken to avoid parallelizing below
703 a certain, pre-determined threshold. For each algorithm, a minimum
704 problem size is encoded as a variable in the
705 active <classname>__gnu_parallel::_Settings</classname> object. This
706 threshold variable follows the following naming scheme:
707 <code>__gnu_parallel::_Settings::[algorithm]_minimal_n</code>. So,
708 for <function>fill</function>, the threshold variable
709 is <code>__gnu_parallel::_Settings::fill_minimal_n</code>,
713 Finally, hardware details like L1/L2 cache size can be hardwired
714 via <code>__gnu_parallel::_Settings::L1_cache_size</code> and friends.
721 All these configuration variables can be changed by the user, if
723 There exists one global instance of the class <classname>_Settings</classname>,
724 i. e. it is a singleton. It can be read and written by calling
725 <code>__gnu_parallel::_Settings::get</code> and
726 <code>__gnu_parallel::_Settings::set</code>, respectively.
727 Please note that the first call return a const object, so direct manipulation
729 See <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01005.html">
730 <filename class="headerfile">settings.h</filename></link>
731 for complete details.
735 A small example of tuning the default:
739 #include <parallel/algorithm>
740 #include <parallel/settings.h>
744 __gnu_parallel::_Settings s;
745 s.algorithm_strategy = __gnu_parallel::force_parallel;
746 __gnu_parallel::_Settings::set(s);
748 // Do work... all algorithms will be parallelized, always.
758 <section xml:id="parallel_mode.design.impl" xreflabel="Impl"><info><title>Implementation Namespaces</title></info>
761 <para> One namespace contain versions of code that are always
762 explicitly sequential:
763 <code>__gnu_serial</code>.
766 <para> Two namespaces contain the parallel mode:
767 <code>std::__parallel</code> and <code>__gnu_parallel</code>.
770 <para> Parallel implementations of standard components, including
771 template helpers to select parallelism, are defined in <code>namespace
772 std::__parallel</code>. For instance, <function>std::transform</function> from <filename class="headerfile">algorithm</filename> has a parallel counterpart in
773 <function>std::__parallel::transform</function> from <filename class="headerfile">parallel/algorithm</filename>. In addition, these parallel
774 implementations are injected into <code>namespace
775 __gnu_parallel</code> with using declarations.
778 <para> Support and general infrastructure is in <code>namespace
779 __gnu_parallel</code>.
782 <para> More information, and an organized index of types and functions
783 related to the parallel mode on a per-namespace basis, can be found in
784 the generated source documentation.
791 <section xml:id="manual.ext.parallel_mode.test" xreflabel="Testing"><info><title>Testing</title></info>
795 Both the normal conformance and regression tests and the
796 supplemental performance tests work.
800 To run the conformance and regression tests with the parallel mode
805 <userinput>make check-parallel</userinput>
809 The log and summary files for conformance testing are in the
810 <filename class="directory">testsuite/parallel</filename> directory.
814 To run the performance tests with the parallel mode active,
818 <userinput>make check-performance-parallel</userinput>
822 The result file for performance testing are in the
823 <filename class="directory">testsuite</filename> directory, in the file
824 <filename>libstdc++_performance.sum</filename>. In addition, the
825 policy-based containers have their own visualizations, which have
826 additional software dependencies than the usual bare-boned text
827 file, and can be generated by using the <code>make
828 doc-performance</code> rule in the testsuite's Makefile.
832 <bibliography xml:id="parallel_mode.biblio"><info><title>Bibliography</title></info>
837 Parallelization of Bulk Operations for STL Dictionaries
840 <author><personname><firstname>Johannes</firstname><surname>Singler</surname></personname></author>
841 <author><personname><firstname>Leonor</firstname><surname>Frias</surname></personname></author>
850 Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS)
857 The Multi-Core Standard Template Library
860 <author><personname><firstname>Johannes</firstname><surname>Singler</surname></personname></author>
861 <author><personname><firstname>Peter</firstname><surname>Sanders</surname></personname></author>
862 <author><personname><firstname>Felix</firstname><surname>Putze</surname></personname></author>
871 Euro-Par 2007: Parallel Processing. (LNCS 4641)