The libstdc++ parallel mode

The latest version of this document is always available at http://gcc.gnu.org/onlinedocs/libstdc++/parallel_mode.html.

To the libstdc++-v3 homepage.

The libstdc++ parallel mode is an experimental parallel implementation of many algorithms the C++ Standard Library.

Several of the standard algorithms, for instance std::sort, are made parallel using OpenMP annotations. These parallel mode constructs and can be invoked by explicit source declaration or by compiling existing sources with a specific compiler flag.

The libstdc++ parallel mode

The libstdc++ parallel mode performs parallelization of algorithms, function objects, classes, and functions in the C++ Standard.

Using the libstdc++ parallel mode

To use the libstdc++ parallel mode, compile your application with the compiler flag -D_GLIBCXX_PARALLEL -fopenmp. This will link in libgomp, the GNU OpenMP implementation, whose presence is mandatory. In addition, hardware capable of atomic operations is mandatory. Actually activating these atomic operations may require explicit compiler flags on some targets (like sparc and x86), such as -march=i686, -march=native or -mcpu=v9.

Note that the _GLIBCXX_PARALLEL define may change the sizes and behavior of standard class templates such as std::search, and therefore one can only link code compiled with parallel mode and code compiled without parallel mode if no instantiation of a container is passed between the two translation units. Parallel mode functionality has distinct linkage, and cannot be confused with normal mode symbols.

The following library components in the include <numeric> are included in the parallel mode:

• std::accumulate
• std::adjacent_difference
• std::inner_product
• std::partial_sum

The following library components in the include <algorithm> are included in the parallel mode:

• std::adjacent_find
• std::count
• std::count_if
• std::equal
• std::find
• std::find_if
• std::find_first_of
• std::for_each
• std::generate
• std::generate_n
• std::lexicographical_compare
• std::mismatch
• std::search
• std::search_n
• std::transform
• std::replace
• std::replace_if
• std::max_element
• std::merge
• std::min_element
• std::nth_element
• std::partial_sort
• std::partition
• std::random_shuffle
• std::set_union
• std::set_intersection
• std::set_symmetric_difference
• std::set_difference
• std::sort
• std::stable_sort
• std::unique_copy

The following library components in the includes <set> and <map> are included in the parallel mode:

• std::(multi_)map/set<T>::(multi_)map/set(Iterator begin, Iterator end) (bulk construction)
• std::(multi_)map/set<T>::insert(Iterator begin, Iterator end) (bulk insertion)

Using the parallel algorithms without parallel mode

When it is not feasible to recompile your entire application, or only specific algorithms need to be parallel-aware, individual parallel algorithms can be made available explicitly. These parallel algorithms are functionally equivalent to the standard drop-in algorithms used in parallel mode, but they are available in a separate namespace as GNU extensions and may be used in programs compiled with either release mode or with parallel mode. The following table provides the names and headers of the parallel algorithms:

Parallel mode semantics

The parallel mode STL algorithms are currently not exception-safe, i. e. user-defined functors must not throw exceptions.

Since the current GCC OpenMP implementation does not support OpenMP parallel regions in concurrent threads, it is not possible to call parallel STL algorithm in concurrent threads, either. It might work with other compilers, though.

Configuration and Tuning

Some algorithm variants can be enabled/disabled/selected at compile-time. See <compiletime_settings.h> and See <features.h> for details.

To specify the number of threads to be used for an algorithm, use omp_set_num_threads. To force a function to execute sequentially, even though parallelism is switched on in general, add __gnu_parallel::sequential_tag() to the end of the argument list.

Parallelism always incurs some overhead. Thus, it is not helpful to parallelize operations on very small sets of data. There are measures to avoid parallelizing stuff that is not worth it. For each algorithm, a minimum problem size can be stated, usually using the variable __gnu_parallel::Settings::[algorithm]_minimal_n. Please see <settings.h> for details.

namespace std
{
  template<typename _FIter>
    _FIter
    adjacent_find(_FIter, _FIter);
}

namespace std
{
  namespace __parallel
  {
    template<typename _FIter>
      _FIter
      adjacent_find(_FIter, _FIter);

    ...
  }
}

Return to the top of the page or to the libstdc++ homepage.

References / Further Reading

Johannes Singler, Peter Sanders, Felix Putze. The Multi-Core Standard Template Library. Euro-Par 2007: Parallel Processing. (LNCS 4641)

Leonor Frias, Johannes Singler: Parallelization of Bulk Operations for STL Dictionaries. Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS)

See license.html for copying conditions. Comments and suggestions are welcome, and may be sent to the libstdc++ mailing list.