virtualx-engine/thirdparty/embree/common/algorithms/parallel_for.h

187 lines
5.3 KiB
C++
Raw Normal View History

// Copyright 2009-2021 Intel Corporation
2020-12-19 14:50:20 +01:00
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../tasking/taskscheduler.h"
#include "../sys/array.h"
#include "../math/math.h"
#include "../math/range.h"
namespace embree
{
/* parallel_for without range */
template<typename Index, typename Func>
__forceinline void parallel_for( const Index N, const Func& func)
{
#if defined(TASKING_INTERNAL)
if (N) {
TaskScheduler::spawn(Index(0),N,Index(1),[&] (const range<Index>& r) {
assert(r.size() == 1);
func(r.begin());
});
if (!TaskScheduler::wait())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
}
2020-12-19 14:50:20 +01:00
#elif defined(TASKING_TBB)
#if TBB_INTERFACE_VERSION >= 12002
tbb::task_group_context context;
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
},context);
if (context.is_group_execution_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#else
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
});
if (tbb::task::self().is_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#endif
#elif defined(TASKING_PPL)
concurrency::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
});
#else
# error "no tasking system enabled"
#endif
}
/* parallel for with range and granulatity */
template<typename Index, typename Func>
__forceinline void parallel_for( const Index first, const Index last, const Index minStepSize, const Func& func)
{
assert(first <= last);
#if defined(TASKING_INTERNAL)
TaskScheduler::spawn(first,last,minStepSize,func);
if (!TaskScheduler::wait())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#elif defined(TASKING_TBB)
#if TBB_INTERFACE_VERSION >= 12002
tbb::task_group_context context;
tbb::parallel_for(tbb::blocked_range<Index>(first,last,minStepSize),[&](const tbb::blocked_range<Index>& r) {
func(range<Index>(r.begin(),r.end()));
},context);
if (context.is_group_execution_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#else
tbb::parallel_for(tbb::blocked_range<Index>(first,last,minStepSize),[&](const tbb::blocked_range<Index>& r) {
func(range<Index>(r.begin(),r.end()));
});
if (tbb::task::self().is_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#endif
#elif defined(TASKING_PPL)
concurrency::parallel_for(first, last, Index(1) /*minStepSize*/, [&](Index i) {
func(range<Index>(i,i+1));
});
#else
# error "no tasking system enabled"
#endif
}
/* parallel for with range */
template<typename Index, typename Func>
__forceinline void parallel_for( const Index first, const Index last, const Func& func)
{
assert(first <= last);
parallel_for(first,last,(Index)1,func);
}
#if defined(TASKING_TBB) && (TBB_INTERFACE_VERSION > 4001)
template<typename Index, typename Func>
__forceinline void parallel_for_static( const Index N, const Func& func)
{
#if TBB_INTERFACE_VERSION >= 12002
tbb::task_group_context context;
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
},tbb::simple_partitioner(),context);
if (context.is_group_execution_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#else
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
},tbb::simple_partitioner());
if (tbb::task::self().is_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#endif
}
typedef tbb::affinity_partitioner affinity_partitioner;
template<typename Index, typename Func>
__forceinline void parallel_for_affinity( const Index N, const Func& func, tbb::affinity_partitioner& ap)
{
#if TBB_INTERFACE_VERSION >= 12002
tbb::task_group_context context;
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
},ap,context);
if (context.is_group_execution_cancelled())
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#else
tbb::parallel_for(Index(0),N,Index(1),[&](Index i) {
func(i);
},ap);
if (tbb::task::self().is_cancelled())
2021-05-04 11:07:12 +02:00
// -- GODOT start --
// throw std::runtime_error("task cancelled");
abort();
2021-05-04 11:07:12 +02:00
// -- GODOT end --
2020-12-19 14:50:20 +01:00
#endif
}
#else
template<typename Index, typename Func>
__forceinline void parallel_for_static( const Index N, const Func& func)
{
parallel_for(N,func);
}
struct affinity_partitioner {
};
template<typename Index, typename Func>
__forceinline void parallel_for_affinity( const Index N, const Func& func, affinity_partitioner& ap)
{
parallel_for(N,func);
}
#endif
}