ACIL FM

Nama	Ukuran	Aksi
algorithm_fwd.h	66.74 MB	View DL Edit
algorithm_impl.h	170.41 MB	View DL Edit
execution_defs.h	3.61 MB	View DL Edit
execution_impl.h	4.72 MB	View DL Edit
glue_algorithm_defs.h	31.52 MB	View DL Edit
glue_algorithm_impl.h	62.84 MB	View DL Edit
glue_execution_defs.h	1.51 MB	View DL Edit
glue_memory_defs.h	3.77 MB	View DL Edit
glue_memory_impl.h	18.96 MB	View DL Edit
glue_numeric_defs.h	6.46 MB	View DL Edit
glue_numeric_impl.h	12.01 MB	View DL Edit
memory_impl.h	3.95 MB	View DL Edit
numeric_fwd.h	7.74 MB	View DL Edit
numeric_impl.h	18.26 MB	View DL Edit
parallel_backend.h	845 B	View DL Edit
parallel_backend_serial.h	3.91 MB	View DL Edit
parallel_backend_tbb.h	42.74 MB	View DL Edit
parallel_backend_utils.h	8.9 MB	View DL Edit
parallel_impl.h	4.01 MB	View DL Edit
pstl_config.h	7.16 MB	View DL Edit
unseq_backend_simd.h	28.5 MB	View DL Edit
utils.h	4.5 MB	View DL Edit

Edit file: /usr/include/c++/11/pstl/parallel_impl.h

// -*- C++ -*-
//===-- parallel_impl.h ---------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _PSTL_PARALLEL_IMPL_H
#define _PSTL_PARALLEL_IMPL_H

#include <atomic>
// This header defines the minimum set of parallel routines required to support Parallel STL,
// implemented on top of Intel(R) Threading Building Blocks (Intel(R) TBB) library

namespace __pstl
{
namespace __internal
{

//------------------------------------------------------------------------
// parallel_find
//-----------------------------------------------------------------------
/** Return extremum value returned by brick f[i,j) for subranges [i,j) of [first,last)
Each f[i,j) must return a value in [i,j). */
template <class _ExecutionPolicy, class _Index, class _Brick, class _Compare>
_Index
__parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first)
{
    typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
    const _DifferenceType __n = __last - __first;
    _DifferenceType __initial_dist = __b_first ? __n : -1;
    std::atomic<_DifferenceType> __extremum(__initial_dist);
    // TODO: find out what is better here: parallel_for or parallel_reduce
    __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                  [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
                                      // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
                                      // why using a shared variable scales fairly well in this situation.
                                      if (__comp(__i - __first, __extremum))
                                      {
                                          _Index __res = __f(__i, __j);
                                          // If not '__last' returned then we found what we want so put this to extremum
                                          if (__res != __j)
                                          {
                                              const _DifferenceType __k = __res - __first;
                                              for (_DifferenceType __old = __extremum; __comp(__k, __old);
                                                   __old = __extremum)
                                              {
                                                  __extremum.compare_exchange_weak(__old, __k);
                                              }
                                          }
                                      }
                                  });
    return __extremum != __initial_dist ? __first + __extremum : __last;
}

//------------------------------------------------------------------------
// parallel_or
//------------------------------------------------------------------------
//! Return true if brick f[i,j) returns true for some subrange [i,j) of [first,last)
template <class _ExecutionPolicy, class _Index, class _Brick>
bool
__parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f)
{
    std::atomic<bool> __found(false);
    __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                  [__f, &__found](_Index __i, _Index __j) {
                                      if (!__found.load(std::memory_order_relaxed) && __f(__i, __j))
                                      {
                                          __found.store(true, std::memory_order_relaxed);
                                          __par_backend::__cancel_execution();
                                      }
                                  });
    return __found;
}

} // namespace __internal
} // namespace __pstl

#endif /* _PSTL_PARALLEL_IMPL_H */

Batal