10 #ifndef LLVM_SUPPORT_PARALLEL_H 11 #define LLVM_SUPPORT_PARALLEL_H 14 #include "llvm/Config/llvm-config.h" 18 #include <condition_variable> 22 #if defined(_MSC_VER) && LLVM_ENABLE_THREADS 24 #pragma warning(disable : 4530) 38 :
public std::integral_constant<
39 bool, llvm::is_one_of<T, sequential_execution_policy,
40 parallel_execution_policy>::value> {};
47 #if LLVM_ENABLE_THREADS 51 mutable std::mutex
Mutex;
52 mutable std::condition_variable Cond;
59 std::lock_guard<std::mutex> lock(Mutex);
64 std::lock_guard<std::mutex> lock(Mutex);
70 std::unique_lock<std::mutex> lock(Mutex);
71 Cond.wait(lock, [&] {
return Count == 0; });
85 template <
class RandomAccessIterator,
class Comparator>
86 void parallel_sort(RandomAccessIterator Start, RandomAccessIterator End,
87 const Comparator &Comp) {
90 template <
class IterTy,
class FuncTy>
95 template <
class IndexTy,
class FuncTy>
97 concurrency::parallel_for(Begin, End, Fn);
104 template <
class RandomAccessIterator,
class Comparator>
105 RandomAccessIterator
medianOf3(RandomAccessIterator Start,
106 RandomAccessIterator End,
107 const Comparator &Comp) {
108 RandomAccessIterator Mid = Start + (std::distance(Start, End) / 2);
109 return Comp(*Start, *(End - 1))
110 ? (Comp(*Mid, *(End - 1)) ? (Comp(*Start, *Mid) ? Mid : Start)
112 : (Comp(*Mid, *Start) ? (Comp(*(End - 1), *Mid) ? Mid : End - 1)
116 template <
class RandomAccessIterator,
class Comparator>
126 auto Pivot =
medianOf3(Start, End, Comp);
129 Pivot =
std::partition(Start, End - 1, [&Comp, End](decltype(*Start) V) {
130 return Comp(V, *(End - 1));
136 TG.
spawn([=, &Comp, &TG] {
142 template <
class RandomAccessIterator,
class Comparator>
144 const Comparator &Comp) {
150 template <
class IterTy,
class FuncTy>
156 ptrdiff_t TaskSize = std::distance(Begin, End) / 1024;
161 while (TaskSize < std::distance(Begin, End)) {
168 template <
class IndexTy,
class FuncTy>
170 ptrdiff_t TaskSize = (End - Begin) / 1024;
176 for (; I + TaskSize < End; I += TaskSize) {
178 for (IndexTy J = I,
E = I + TaskSize; J !=
E; ++J)
182 for (IndexTy J = I; J < End; ++J)
190 template <
typename Iter>
192 std::less<typename std::iterator_traits<Iter>::value_type>;
197 template <
class Policy,
class RandomAccessIterator,
199 void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End,
200 const Comparator &Comp = Comparator()) {
202 "Invalid execution policy!");
206 template <
class Policy,
class IterTy,
class FuncTy>
207 void for_each(Policy policy, IterTy Begin, IterTy End, FuncTy Fn) {
209 "Invalid execution policy!");
213 template <
class Policy,
class IndexTy,
class FuncTy>
214 void for_each_n(Policy policy, IndexTy Begin, IndexTy End, FuncTy Fn) {
216 "Invalid execution policy!");
217 for (IndexTy
I = Begin;
I != End; ++
I)
223 #if LLVM_ENABLE_THREADS 224 template <
class RandomAccessIterator,
227 RandomAccessIterator End,
const Comparator &Comp = Comparator()) {
231 template <
class IterTy,
class FuncTy>
237 template <
class IndexTy,
class FuncTy>
247 #endif // LLVM_SUPPORT_PARALLEL_H const ptrdiff_t MinParallelSize
void for_each_n(Policy policy, IndexTy Begin, IndexTy End, FuncTy Fn)
This class represents lattice values for constants.
void parallel_for_each_n(IndexTy Begin, IndexTy End, FuncTy Fn)
constexpr sequential_execution_policy seq
SmartMutex< false > Mutex
Mutex - A standard, always enforced mutex.
auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::partition which take ranges instead of having to pass begin/end explicitly...
void spawn(std::function< void()> f)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void sort(IteratorTy Start, IteratorTy End)
constexpr parallel_execution_policy par
void for_each(Policy policy, IterTy Begin, IterTy End, FuncTy Fn)
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
std::less< typename std::iterator_traits< Iter >::value_type > DefComparator
void parallel_for_each(IterTy Begin, IterTy End, FuncTy Fn)
void parallel_sort(RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp)
RandomAccessIterator medianOf3(RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp)
Inclusive median.
void for_each(parallel_execution_policy policy, IterTy Begin, IterTy End, FuncTy Fn)
void parallel_quick_sort(RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp, TaskGroup &TG, size_t Depth)
print Print MemDeps of function
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.