libstdc++-v3/include/parallel/types.h

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2007-2019 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/types.h
  26  *  @brief Basic types and typedefs.
  27  *  This file is a GNU parallel extension to the Standard C++ Library.
  28  */
  29
  30 // Written by Johannes Singler and Felix Putze.
  31
  32 #ifndef _GLIBCXX_PARALLEL_TYPES_H
  33 #define _GLIBCXX_PARALLEL_TYPES_H 1
  34
  35 #include <cstdlib>
  36 #include <limits>
  37 #include <tr1/cstdint>
  38
  39 namespace __gnu_parallel
  40 {
  41   // Enumerated types.
  42
  43   /// Run-time equivalents for the compile-time tags.
  44   enum _Parallelism
  45     {
  46       /// Not parallel.
  47       sequential,
  48
  49       /// Parallel unbalanced (equal-sized chunks).
  50       parallel_unbalanced,
  51
  52       /// Parallel balanced (work-stealing).
  53       parallel_balanced,
  54
  55       /// Parallel with OpenMP dynamic load-balancing.
  56       parallel_omp_loop,
  57
  58       /// Parallel with OpenMP static load-balancing.
  59       parallel_omp_loop_static,
  60
  61       /// Parallel with OpenMP taskqueue construct.
  62       parallel_taskqueue
  63     };
  64
  65   /// Strategies for run-time algorithm selection:
  66   // force_sequential, force_parallel, heuristic.
  67   enum _AlgorithmStrategy
  68     {
  69       heuristic,
  70       force_sequential,
  71       force_parallel
  72     };
  73
  74   /// Sorting algorithms:
  75   // multi-way mergesort, quicksort, load-balanced quicksort.
  76   enum _SortAlgorithm
  77     {
  78       MWMS,
  79       QS,
  80       QS_BALANCED
  81     };
  82
  83   /// Merging algorithms:
  84   // bubblesort-alike, loser-tree variants, enum __sentinel.
  85   enum _MultiwayMergeAlgorithm
  86     {
  87       LOSER_TREE
  88     };
  89
  90   /// Partial sum algorithms: recursive, linear.
  91   enum _PartialSumAlgorithm
  92     {
  93       RECURSIVE,
  94       LINEAR
  95     };
  96
  97   /// Sorting/merging algorithms: sampling, __exact.
  98   enum _SplittingAlgorithm
  99     {
 100       SAMPLING,
 101       EXACT
 102     };
 103
 104   /// Find algorithms:
 105   // growing blocks, equal-sized blocks, equal splitting.
 106   enum _FindAlgorithm
 107     {
 108       GROWING_BLOCKS,
 109       CONSTANT_SIZE_BLOCKS,
 110       EQUAL_SPLIT
 111     };
 112
 113   /**
 114    * @brief Unsigned integer to index __elements.
 115    * The total number of elements for each algorithm must fit into this type.
 116    */
 117   typedef uint64_t _SequenceIndex;
 118
 119   /**
 120    * @brief Unsigned integer to index a thread number.
 121    * The maximum thread number (for each processor) must fit into this type.
 122    */
 123   typedef uint16_t _ThreadIndex;
 124
 125   // XXX atomics interface?
 126   /// Longest compare-and-swappable integer type on this platform.
 127   typedef int64_t _CASable;
 128
 129   /// Number of bits of _CASable.
 130   static const int _CASable_bits = std::numeric_limits<_CASable>::digits;
 131
 132   /// ::_CASable with the right half of bits set to 1.
 133   static const _CASable _CASable_mask =
 134                             ((_CASable(1) << (_CASable_bits / 2)) - 1);
 135 }
 136
 137 #endif /* _GLIBCXX_PARALLEL_TYPES_H */