Scheduler.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/ForwardDecl.h"
#include "objects/utility/IteratorAdapters.h"
#include "objects/wrappers/Function.h"
 
NAMESPACE_SPH_BEGIN
 
class ITask : public Polymorphic {
public:
    virtual void wait() = 0;
 
    virtual bool completed() const = 0;
};
 
class IScheduler : public Polymorphic {
public:
    virtual SharedPtr<ITask> submit(const Function<void()>& task) = 0;
 
    virtual Optional<Size> getThreadIdx() const = 0;
 
    virtual Size getThreadCnt() const = 0;
 
    virtual Size getRecommendedGranularity() const = 0;
 
    virtual void parallelFor(const Size from,
        const Size to,
        const Size granularity,
        const Function<void(Size n1, Size n2)>& functor);
};
 
class SequentialScheduler : public IScheduler {
public:
    virtual SharedPtr<ITask> submit(const Function<void()>& task) override;
 
    virtual Optional<Size> getThreadIdx() const override;
 
    virtual Size getThreadCnt() const override;
 
    virtual Size getRecommendedGranularity() const override;
 
    static SharedPtr<SequentialScheduler> getGlobalInstance();
};
 
extern SequentialScheduler SEQUENTIAL;
 
 
template <typename TFunctor>
INLINE void parallelFor(IScheduler& scheduler, const Size from, const Size to, TFunctor&& functor) {
    const Size granularity = scheduler.getRecommendedGranularity();
    parallelFor(scheduler, from, to, granularity, std::forward<TFunctor>(functor));
}
 
template <typename TFunctor>
INLINE void parallelFor(IScheduler& scheduler,
    const Size from,
    const Size to,
    const Size granularity,
    TFunctor&& functor) {
    scheduler.parallelFor(from, to, granularity, [&functor](Size n1, Size n2) {
        SPH_ASSERT(n1 < n2);
        for (Size i = n1; i < n2; ++i) {
            functor(i);
        }
    });
}
 
template <typename TFunctor>
INLINE void parallelFor(IScheduler& scheduler, const IndexSequence& sequence, TFunctor&& functor) {
    parallelFor(scheduler, *sequence.begin(), *sequence.end(), std::forward<TFunctor>(functor));
}
 
 
NAMESPACE_SPH_END