ThreadLocal.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Array.h"
#include "objects/utility/Iterator.h"
#include "objects/wrappers/Optional.h"
#include "thread/Scheduler.h"
 
NAMESPACE_SPH_BEGIN
 
namespace Detail {
 
struct ValueInitTag {};
struct FunctorInitTag {};
 
template <typename... TArgs>
struct ParamTraits {
    using Tag = ValueInitTag;
};
template <typename TArg>
struct ParamTraits<TArg> {
    using Tag = std::conditional_t<IsCallable<TArg>::value, FunctorInitTag, ValueInitTag>;
};
 
} // namespace Detail
 
template <typename Type>
class ThreadLocal {
    // befriend other ThreadLocal classes
    template <typename>
    friend class ThreadLocal;
 
private:
    struct Local {
        uint8_t padd1[64];
        Type value;
        uint8_t padd2[64];
 
        template <typename... TArgs>
        Local(TArgs&&... args)
            : value(std::forward<TArgs>(args)...) {}
    };
 
    Array<Local> locals;
 
    IScheduler& scheduler;
 
    struct Sum {
        INLINE constexpr Type operator()(const Type& t1, const Type& t2) const {
            return t1 + t2;
        }
    };
 
public:
    template <typename... TArgs>
    ThreadLocal(IScheduler& scheduler, TArgs&&... args)
        : scheduler(scheduler) {
        initialize(typename Detail::ParamTraits<TArgs...>::Tag{}, std::forward<TArgs>(args)...);
    }
 
    template <typename TFunctor>
    ThreadLocal(IScheduler& scheduler, TFunctor&& functor)
        : scheduler(scheduler) {
        initialize(typename Detail::ParamTraits<TFunctor>::Tag{}, std::forward<TFunctor>(functor));
    }
 
    INLINE Type& local() {
        const Optional<Size> idx = scheduler.getThreadIdx();
        SPH_ASSERT(idx && idx.value() < locals.size());
        return locals[idx.value()].value;
    }
 
    INLINE const Type& local() const {
        const Optional<Size> idx = scheduler.getThreadIdx();
        SPH_ASSERT(idx && idx.value() < locals.size());
        return locals[idx.value()].value;
    }
 
    INLINE Type& value(const Size threadId) {
        return locals[threadId].value;
    }
 
    Type accumulate(const Type& initial = Type(0._f)) const {
        return this->accumulate(initial, Sum{});
    }
 
    template <typename TPredicate>
    Type accumulate(const Type& initial, const TPredicate& predicate) const {
        Type sum = initial;
        for (const Type& value : *this) {
            sum = predicate(sum, value);
        }
        return sum;
    }
 
    template <typename T>
    class LocalIterator : public Iterator<T> {
    public:
        LocalIterator(Iterator<T> iter)
            : Iterator<T>(iter) {}
 
        using Return = std::conditional_t<std::is_const<T>::value, const Type&, Type&>;
 
        INLINE Return operator*() const {
            return this->data->value;
        }
    };
 
    LocalIterator<Local> begin() {
        return locals.begin();
    }
 
    LocalIterator<const Local> begin() const {
        return locals.begin();
    }
 
    LocalIterator<Local> end() {
        return locals.end();
    }
 
    LocalIterator<const Local> end() const {
        return locals.end();
    }
 
private:
    template <typename... TArgs>
    void initialize(Detail::ValueInitTag, TArgs&&... args) {
        const Size threadCnt = scheduler.getThreadCnt();
        locals.reserve(threadCnt);
        for (Size i = 0; i < threadCnt; ++i) {
            // intentionally not forwarded, we cannot move parameters if we have more than one object
            locals.emplaceBack(args...);
        }
    }
 
    template <typename TFunctor>
    void initialize(Detail::FunctorInitTag, TFunctor&& functor) {
        const Size threadCnt = scheduler.getThreadCnt();
        locals.reserve(threadCnt);
        for (Size i = 0; i < threadCnt; ++i) {
            locals.emplaceBack(functor());
        }
    }
};
 
template <typename Type, typename TFunctor>
INLINE void parallelFor(IScheduler& scheduler,
    ThreadLocal<Type>& storage,
    const Size from,
    const Size to,
    TFunctor&& functor) {
    const Size granularity = scheduler.getRecommendedGranularity();
    parallelFor(scheduler, storage, from, to, granularity, std::forward<TFunctor>(functor));
}
 
template <typename Type, typename TFunctor>
INLINE void parallelFor(IScheduler& scheduler,
    ThreadLocal<Type>& storage,
    const Size from,
    const Size to,
    const Size granularity,
    TFunctor&& functor) {
    SPH_ASSERT(from <= to);
 
    scheduler.parallelFor(from, to, granularity, [&storage, &functor](Size n1, Size n2) {
        SPH_ASSERT(n1 < n2);
        Type& value = storage.local();
        for (Size i = n1; i < n2; ++i) {
            functor(i, value);
        }
    });
}
 
NAMESPACE_SPH_END