Parallel.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_PARALLEL_HPP
#define CUBBYFLOW_PARALLEL_HPP
 
#include <iterator>
 
namespace CubbyFlow
{
enum class ExecutionPolicy
{
    Serial,
    Parallel
};
 
template <typename RandomIterator, typename T>
void ParallelFill(const RandomIterator& begin, const RandomIterator& end,
                  const T& value,
                  ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelFor(IndexType beginIndex, IndexType endIndex,
                 const Function& function,
                 ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelRangeFor(IndexType beginIndex, IndexType endIndex,
                      const Function& function,
                      ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelFor(IndexType beginIndexX, IndexType endIndexX,
                 IndexType beginIndexY, IndexType endIndexY,
                 const Function& function,
                 ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelRangeFor(IndexType beginIndexX, IndexType endIndexX,
                      IndexType beginIndexY, IndexType endIndexY,
                      const Function& function,
                      ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelFor(IndexType beginIndexX, IndexType endIndexX,
                 IndexType beginIndexY, IndexType endIndexY,
                 IndexType beginIndexZ, IndexType endIndexZ,
                 const Function& function,
                 ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Function>
void ParallelRangeFor(IndexType beginIndexX, IndexType endIndexX,
                      IndexType beginIndexY, IndexType endIndexY,
                      IndexType beginIndexZ, IndexType endIndexZ,
                      const Function& function,
                      ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
template <typename IndexType, typename Value, typename Function,
          typename Reduce>
Value ParallelReduce(IndexType beginIndex, IndexType endIndex,
                     const Value& identity, const Function& function,
                     const Reduce& reduce,
                     ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
#ifdef __CUDACC__
template <typename RandomIterator>
#else
template <std::random_access_iterator RandomIterator>
#endif
void ParallelSort(RandomIterator begin, RandomIterator end,
                  ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
#ifdef __CUDACC__
template <typename RandomIterator, typename CompareFunction>
#else
template <std::random_access_iterator RandomIterator, typename CompareFunction>
#endif
void ParallelSort(RandomIterator begin, RandomIterator end,
                  CompareFunction compare,
                  ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
void SetMaxNumberOfThreads(unsigned int numThreads);
 
unsigned int GetMaxNumberOfThreads();
}  // namespace CubbyFlow
 
#include <Core/Utils/Parallel-Impl.hpp>
 
#endif