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

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);

template <typename RandomIterator>
void ParallelSort(RandomIterator begin, RandomIterator end,
                  ExecutionPolicy policy = ExecutionPolicy::Parallel);

template <typename RandomIterator, typename CompareFunction>
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