<h2>Editing File: /usr/include/c++/8/parallel/random_shuffle.h</h2><form method='post'><textarea name='content' class='file-edit'>// -*- C++ -*-

// Copyright (C) 2007-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.

// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file parallel/random_shuffle.h
 *  @brief Parallel implementation of std::random_shuffle().
 *  This file is a GNU parallel extension to the Standard C++ Library.
 */

// Written by Johannes Singler.

#ifndef _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H
#define _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H 1

#include &lt;limits&gt;
#include &lt;bits/stl_numeric.h&gt;
#include &lt;parallel/parallel.h&gt;
#include &lt;parallel/random_number.h&gt;

namespace __gnu_parallel
{
  /** @brief Type to hold the index of a bin.
    *
    *  Since many variables of this type are allocated, it should be
    *  chosen as small as possible.
    */
  typedef unsigned short _BinIndex;

  /** @brief Data known to every thread participating in
      __gnu_parallel::__parallel_random_shuffle(). */
  template&lt;typename _RAIter&gt;
    struct _DRandomShufflingGlobalData
    {
      typedef std::iterator_traits&lt;_RAIter&gt; _TraitsType;
      typedef typename _TraitsType::value_type _ValueType;
      typedef typename _TraitsType::difference_type _DifferenceType;

      /** @brief Begin iterator of the __source. */
      _RAIter&amp; _M_source;

      /** @brief Temporary arrays for each thread. */
      _ValueType** _M_temporaries;

      /** @brief Two-dimensional array to hold the thread-bin distribution.
       *
       *  Dimensions (_M_num_threads + 1) __x (_M_num_bins + 1). */
      _DifferenceType** _M_dist;

      /** @brief Start indexes of the threads' __chunks. */
      _DifferenceType* _M_starts;

      /** @brief Number of the thread that will further process the
          corresponding bin. */
      _ThreadIndex* _M_bin_proc;

      /** @brief Number of bins to distribute to. */
      int _M_num_bins;

      /** @brief Number of bits needed to address the bins. */
      int _M_num_bits;

      /** @brief Constructor. */
      _DRandomShufflingGlobalData(_RAIter&amp; __source)
      : _M_source(__source) { }
    };

  /** @brief Local data for a thread participating in
      __gnu_parallel::__parallel_random_shuffle().
    */
  template&lt;typename _RAIter, typename _RandomNumberGenerator&gt;
    struct _DRSSorterPU
    {
      /** @brief Number of threads participating in total. */
      int _M_num_threads;

      /** @brief Begin index for bins taken care of by this thread. */
      _BinIndex _M_bins_begin;

      /** @brief End index for bins taken care of by this thread. */
      _BinIndex __bins_end;

      /** @brief Random _M_seed for this thread. */
      uint32_t _M_seed;

      /** @brief Pointer to global data. */
      _DRandomShufflingGlobalData&lt;_RAIter&gt;* _M_sd;
    };

  /** @brief Generate a random number in @c [0,2^__logp).
    *  @param __logp Logarithm (basis 2) of the upper range __bound.
    *  @param __rng Random number generator to use.
    */
  template&lt;typename _RandomNumberGenerator&gt;
    inline int
    __random_number_pow2(int __logp, _RandomNumberGenerator&amp; __rng)
    { return __rng.__genrand_bits(__logp); }

  /** @brief Random shuffle code executed by each thread.
    *  @param __pus Array of thread-local data records. */
  template&lt;typename _RAIter, typename _RandomNumberGenerator&gt;
    void 
    __parallel_random_shuffle_drs_pu(_DRSSorterPU&lt;_RAIter,
				     _RandomNumberGenerator&gt;* __pus)
    {
      typedef std::iterator_traits&lt;_RAIter&gt; _TraitsType;
      typedef typename _TraitsType::value_type _ValueType;
      typedef typename _TraitsType::difference_type _DifferenceType;

      _ThreadIndex __iam = omp_get_thread_num();
      _DRSSorterPU&lt;_RAIter, _RandomNumberGenerator&gt;* __d = &amp;__pus[__iam];
      _DRandomShufflingGlobalData&lt;_RAIter&gt;* __sd = __d-&gt;_M_sd;

      // Indexing: _M_dist[bin][processor]
      _DifferenceType __length = (__sd-&gt;_M_starts[__iam + 1]
				  - __sd-&gt;_M_starts[__iam]);
      _BinIndex* __oracles = new _BinIndex[__length];
      _DifferenceType* __dist = new _DifferenceType[__sd-&gt;_M_num_bins + 1];
      _BinIndex* __bin_proc = new _BinIndex[__sd-&gt;_M_num_bins];
      _ValueType** __temporaries = new _ValueType*[__d-&gt;_M_num_threads];

      // Compute oracles and count appearances.
      for (_BinIndex __b = 0; __b &lt; __sd-&gt;_M_num_bins + 1; ++__b)
	__dist[__b] = 0;
      int __num_bits = __sd-&gt;_M_num_bits;

      _RandomNumber __rng(__d-&gt;_M_seed);

      // First main loop.
      for (_DifferenceType __i = 0; __i &lt; __length; ++__i)
	{
          _BinIndex __oracle = __random_number_pow2(__num_bits, __rng);
          __oracles[__i] = __oracle;

          // To allow prefix (partial) sum.
          ++(__dist[__oracle + 1]);
	}

      for (_BinIndex __b = 0; __b &lt; __sd-&gt;_M_num_bins + 1; ++__b)
	__sd-&gt;_M_dist[__b][__iam + 1] = __dist[__b];

#     pragma omp barrier

#     pragma omp single
      {
	// Sum up bins, __sd-&gt;_M_dist[__s + 1][__d-&gt;_M_num_threads] now
	// contains the total number of items in bin __s
	for (_BinIndex __s = 0; __s &lt; __sd-&gt;_M_num_bins; ++__s)
          __gnu_sequential::partial_sum(__sd-&gt;_M_dist[__s + 1],
					__sd-&gt;_M_dist[__s + 1]
					+ __d-&gt;_M_num_threads + 1,
					__sd-&gt;_M_dist[__s + 1]);
      }

#     pragma omp barrier

      _SequenceIndex __offset = 0, __global_offset = 0;
      for (_BinIndex __s = 0; __s &lt; __d-&gt;_M_bins_begin; ++__s)
	__global_offset += __sd-&gt;_M_dist[__s + 1][__d-&gt;_M_num_threads];

#     pragma omp barrier

      for (_BinIndex __s = __d-&gt;_M_bins_begin; __s &lt; __d-&gt;__bins_end; ++__s)
	{
          for (int __t = 0; __t &lt; __d-&gt;_M_num_threads + 1; ++__t)
            __sd-&gt;_M_dist[__s + 1][__t] += __offset;
          __offset = __sd-&gt;_M_dist[__s + 1][__d-&gt;_M_num_threads];
	}

      __sd-&gt;_M_temporaries[__iam] = static_cast&lt;_ValueType*&gt;
	(::operator new(sizeof(_ValueType) * __offset));

#     pragma omp barrier

      // Draw local copies to avoid false sharing.
      for (_BinIndex __b = 0; __b &lt; __sd-&gt;_M_num_bins + 1; ++__b)
	__dist[__b] = __sd-&gt;_M_dist[__b][__iam];
      for (_BinIndex __b = 0; __b &lt; __sd-&gt;_M_num_bins; ++__b)
	__bin_proc[__b] = __sd-&gt;_M_bin_proc[__b];
      for (_ThreadIndex __t = 0; __t &lt; __d-&gt;_M_num_threads; ++__t)
	__temporaries[__t] = __sd-&gt;_M_temporaries[__t];

      _RAIter __source = __sd-&gt;_M_source;
      _DifferenceType __start = __sd-&gt;_M_starts[__iam];

      // Distribute according to oracles, second main loop.
      for (_DifferenceType __i = 0; __i &lt; __length; ++__i)
	{
          _BinIndex __target_bin = __oracles[__i];
          _ThreadIndex __target_p = __bin_proc[__target_bin];

          // Last column [__d-&gt;_M_num_threads] stays unchanged.
	  ::new(&amp;(__temporaries[__target_p][__dist[__target_bin + 1]++]))
              _ValueType(*(__source + __i + __start));
	}

      delete[] __oracles;
      delete[] __dist;
      delete[] __bin_proc;
      delete[] __temporaries;

#     pragma omp barrier

      // Shuffle bins internally.
      for (_BinIndex __b = __d-&gt;_M_bins_begin; __b &lt; __d-&gt;__bins_end; ++__b)
	{
          _ValueType* __begin =
	    (__sd-&gt;_M_temporaries[__iam]
	     + (__b == __d-&gt;_M_bins_begin
		? 0 : __sd-&gt;_M_dist[__b][__d-&gt;_M_num_threads])),
	    *__end = (__sd-&gt;_M_temporaries[__iam]
		      + __sd-&gt;_M_dist[__b + 1][__d-&gt;_M_num_threads]);

          __sequential_random_shuffle(__begin, __end, __rng);
          std::copy(__begin, __end, __sd-&gt;_M_source + __global_offset
		    + (__b == __d-&gt;_M_bins_begin
		       ? 0 : __sd-&gt;_M_dist[__b][__d-&gt;_M_num_threads]));
	}

      for (_SequenceIndex __i = 0; __i &lt; __offset; ++__i)
	__sd-&gt;_M_temporaries[__iam][__i].~_ValueType();
      ::operator delete(__sd-&gt;_M_temporaries[__iam]);
    }

  /** @brief Round up to the next greater power of 2.
    *  @param __x _Integer to round up */
  template&lt;typename _Tp&gt;
    _Tp 
    __round_up_to_pow2(_Tp __x)
    {
      if (__x &lt;= 1)
	return 1;
      else
	return (_Tp)1 &lt;&lt; (__rd_log2(__x - 1) + 1);
    }

  /** @brief Main parallel random shuffle step.
    *  @param __begin Begin iterator of sequence.
    *  @param __end End iterator of sequence.
    *  @param __n Length of sequence.
    *  @param __num_threads Number of threads to use.
    *  @param __rng Random number generator to use.
    */
  template&lt;typename _RAIter, typename _RandomNumberGenerator&gt;
    void
    __parallel_random_shuffle_drs(_RAIter __begin, _RAIter __end,
				  typename std::iterator_traits
				  &lt;_RAIter&gt;::difference_type __n,
				  _ThreadIndex __num_threads,
				  _RandomNumberGenerator&amp; __rng)
    {
      typedef std::iterator_traits&lt;_RAIter&gt; _TraitsType;
      typedef typename _TraitsType::value_type _ValueType;
      typedef typename _TraitsType::difference_type _DifferenceType;

      _GLIBCXX_CALL(__n)

      const _Settings&amp; __s = _Settings::get();

      if (__num_threads &gt; __n)
	__num_threads = static_cast&lt;_ThreadIndex&gt;(__n);

      _BinIndex __num_bins, __num_bins_cache;

#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
      // Try the L1 cache first.

      // Must fit into L1.
      __num_bins_cache =
	std::max&lt;_DifferenceType&gt;(1, __n / (__s.L1_cache_size_lb
					    / sizeof(_ValueType)));
      __num_bins_cache = __round_up_to_pow2(__num_bins_cache);

      // No more buckets than TLB entries, power of 2
      // Power of 2 and at least one element per bin, at most the TLB size.
      __num_bins = std::min&lt;_DifferenceType&gt;(__n, __num_bins_cache);

#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
      // 2 TLB entries needed per bin.
      __num_bins = std::min&lt;_DifferenceType&gt;(__s.TLB_size / 2, __num_bins);
#endif
      __num_bins = __round_up_to_pow2(__num_bins);

      if (__num_bins &lt; __num_bins_cache)
	{
#endif
          // Now try the L2 cache
          // Must fit into L2
          __num_bins_cache = static_cast&lt;_BinIndex&gt;
	    (std::max&lt;_DifferenceType&gt;(1, __n / (__s.L2_cache_size
						 / sizeof(_ValueType))));
          __num_bins_cache = __round_up_to_pow2(__num_bins_cache);

          // No more buckets than TLB entries, power of 2.
          __num_bins = static_cast&lt;_BinIndex&gt;
	    (std::min(__n, static_cast&lt;_DifferenceType&gt;(__num_bins_cache)));
          // Power of 2 and at least one element per bin, at most the TLB size.
#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
          // 2 TLB entries needed per bin.
          __num_bins = std::min(static_cast&lt;_DifferenceType&gt;(__s.TLB_size / 2),
				__num_bins);
#endif
            __num_bins = __round_up_to_pow2(__num_bins);
#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
	}
#endif

      __num_bins = __round_up_to_pow2(
                        std::max&lt;_BinIndex&gt;(__num_threads, __num_bins));

      if (__num_threads &lt;= 1)
      {
        _RandomNumber __derived_rng(
                            __rng(std::numeric_limits&lt;uint32_t&gt;::max()));
	__sequential_random_shuffle(__begin, __end, __derived_rng);
        return;
      }

      _DRandomShufflingGlobalData&lt;_RAIter&gt; __sd(__begin);
      _DRSSorterPU&lt;_RAIter, _RandomNumber &gt;* __pus;
      _DifferenceType* __starts;

#     pragma omp parallel num_threads(__num_threads)
      {
	_ThreadIndex __num_threads = omp_get_num_threads();
#       pragma omp single
	{
	  __pus = new _DRSSorterPU&lt;_RAIter, _RandomNumber&gt;[__num_threads];
	  
	  __sd._M_temporaries = new _ValueType*[__num_threads];
	  __sd._M_dist = new _DifferenceType*[__num_bins + 1];
	  __sd._M_bin_proc = new _ThreadIndex[__num_bins];
	  for (_BinIndex __b = 0; __b &lt; __num_bins + 1; ++__b)
	    __sd._M_dist[__b] = new _DifferenceType[__num_threads + 1];
	  for (_BinIndex __b = 0; __b &lt; (__num_bins + 1); ++__b)
	    {
	      __sd._M_dist[0][0] = 0;
	      __sd._M_dist[__b][0] = 0;
	    }
	  __starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
	  int __bin_cursor = 0;
	  __sd._M_num_bins = __num_bins;
	  __sd._M_num_bits = __rd_log2(__num_bins);

	  _DifferenceType __chunk_length = __n / __num_threads,
	                         __split = __n % __num_threads,
	                         __start = 0;
	  _DifferenceType __bin_chunk_length = __num_bins / __num_threads,
	                         __bin_split = __num_bins % __num_threads;
	  for (_ThreadIndex __i = 0; __i &lt; __num_threads; ++__i)
	    {
	      __starts[__i] = __start;
	      __start += (__i &lt; __split
			  ? (__chunk_length + 1) : __chunk_length);
	      int __j = __pus[__i]._M_bins_begin = __bin_cursor;

	      // Range of bins for this processor.
	      __bin_cursor += (__i &lt; __bin_split
			       ? (__bin_chunk_length + 1)
			       : __bin_chunk_length);
	      __pus[__i].__bins_end = __bin_cursor;
	      for (; __j &lt; __bin_cursor; ++__j)
		__sd._M_bin_proc[__j] = __i;
	      __pus[__i]._M_num_threads = __num_threads;
	      __pus[__i]._M_seed = __rng(std::numeric_limits&lt;uint32_t&gt;::max());
	      __pus[__i]._M_sd = &amp;__sd;
	    }
	  __starts[__num_threads] = __start;
	} //single
          // Now shuffle in parallel.
	__parallel_random_shuffle_drs_pu(__pus);
      }  // parallel

      delete[] __starts;
      delete[] __sd._M_bin_proc;
      for (int __s = 0; __s &lt; (__num_bins + 1); ++__s)
	delete[] __sd._M_dist[__s];
      delete[] __sd._M_dist;
      delete[] __sd._M_temporaries;

      delete[] __pus;
    }

  /** @brief Sequential cache-efficient random shuffle.
   *  @param __begin Begin iterator of sequence.
   *  @param __end End iterator of sequence.
   *  @param __rng Random number generator to use.
   */
  template&lt;typename _RAIter, typename _RandomNumberGenerator&gt;
    void
    __sequential_random_shuffle(_RAIter __begin, _RAIter __end,
				_RandomNumberGenerator&amp; __rng)
    {
      typedef std::iterator_traits&lt;_RAIter&gt; _TraitsType;
      typedef typename _TraitsType::value_type _ValueType;
      typedef typename _TraitsType::difference_type _DifferenceType;

      _DifferenceType __n = __end - __begin;
      const _Settings&amp; __s = _Settings::get();

      _BinIndex __num_bins, __num_bins_cache;

#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
      // Try the L1 cache first, must fit into L1.
      __num_bins_cache = std::max&lt;_DifferenceType&gt;
	(1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType)));
      __num_bins_cache = __round_up_to_pow2(__num_bins_cache);

      // No more buckets than TLB entries, power of 2
      // Power of 2 and at least one element per bin, at most the TLB size
      __num_bins = std::min(__n, (_DifferenceType)__num_bins_cache);
#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
      // 2 TLB entries needed per bin
      __num_bins = std::min((_DifferenceType)__s.TLB_size / 2, __num_bins);
#endif
      __num_bins = __round_up_to_pow2(__num_bins);

      if (__num_bins &lt; __num_bins_cache)
	{
#endif
          // Now try the L2 cache, must fit into L2.
          __num_bins_cache = static_cast&lt;_BinIndex&gt;
	    (std::max&lt;_DifferenceType&gt;(1, __n / (__s.L2_cache_size
						 / sizeof(_ValueType))));
          __num_bins_cache = __round_up_to_pow2(__num_bins_cache);

          // No more buckets than TLB entries, power of 2
          // Power of 2 and at least one element per bin, at most the TLB size.
          __num_bins = static_cast&lt;_BinIndex&gt;
	    (std::min(__n, static_cast&lt;_DifferenceType&gt;(__num_bins_cache)));

#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
          // 2 TLB entries needed per bin
          __num_bins = std::min&lt;_DifferenceType&gt;(__s.TLB_size / 2, __num_bins);
#endif
          __num_bins = __round_up_to_pow2(__num_bins);
#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
	}
#endif

      int __num_bits = __rd_log2(__num_bins);

      if (__num_bins &gt; 1)
	{
          _ValueType* __target =
	    static_cast&lt;_ValueType*&gt;(::operator new(sizeof(_ValueType) * __n));
          _BinIndex* __oracles = new _BinIndex[__n];
          _DifferenceType* __dist0 = new _DifferenceType[__num_bins + 1],
                	 * __dist1 = new _DifferenceType[__num_bins + 1];

          for (int __b = 0; __b &lt; __num_bins + 1; ++__b)
            __dist0[__b] = 0;

          _RandomNumber __bitrng(__rng(0xFFFFFFFF));

          for (_DifferenceType __i = 0; __i &lt; __n; ++__i)
            {
              _BinIndex __oracle = __random_number_pow2(__num_bits, __bitrng);
              __oracles[__i] = __oracle;

              // To allow prefix (partial) sum.
              ++(__dist0[__oracle + 1]);
            }

          // Sum up bins.
          __gnu_sequential::partial_sum(__dist0, __dist0 + __num_bins + 1,
					__dist0);

          for (int __b = 0; __b &lt; __num_bins + 1; ++__b)
            __dist1[__b] = __dist0[__b];

          // Distribute according to oracles.
          for (_DifferenceType __i = 0; __i &lt; __n; ++__i)
            ::new(&amp;(__target[(__dist0[__oracles[__i]])++])) 
		_ValueType(*(__begin + __i));

          for (int __b = 0; __b &lt; __num_bins; ++__b)
	    __sequential_random_shuffle(__target + __dist1[__b],
					__target + __dist1[__b + 1], __rng);

          // Copy elements back.
          std::copy(__target, __target + __n, __begin);

          delete[] __dist0;
          delete[] __dist1;
          delete[] __oracles;
	  
	  for (_DifferenceType __i = 0; __i &lt; __n; ++__i)
	    __target[__i].~_ValueType();
          ::operator delete(__target);
	}
      else
	__gnu_sequential::random_shuffle(__begin, __end, __rng);
    }

  /** @brief Parallel random public call.
   *  @param __begin Begin iterator of sequence.
   *  @param __end End iterator of sequence.
   *  @param __rng Random number generator to use.
   */
  template&lt;typename _RAIter, typename _RandomNumberGenerator&gt;
    inline void
    __parallel_random_shuffle(_RAIter __begin, _RAIter __end,
			      _RandomNumberGenerator __rng = _RandomNumber())
    {
      typedef std::iterator_traits&lt;_RAIter&gt; _TraitsType;
      typedef typename _TraitsType::difference_type _DifferenceType;
      _DifferenceType __n = __end - __begin;
      __parallel_random_shuffle_drs(__begin, __end, __n,
				    __get_max_threads(), __rng);
    }
}

#endif /* _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fparallel'>Back to Directory</a>