StaticThread.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_STATICTHREAD_HPP_
#define INCLUDE_DISTORTOS_STATICTHREAD_HPP_

#include "distortos/internal/memory/dummyDeleter.hpp"

#include "distortos/assert.h"
#include "distortos/StaticSignalsReceiver.hpp"
#include "distortos/UndetachableThread.hpp"

#include <functional>

namespace distortos
{

namespace internal
{

template<size_t StackSize, typename Function, typename... Args>
class StaticThreadBase : public UndetachableThread
{
public:

    using Base = UndetachableThread;

    StaticThreadBase(const uint8_t priority, const SchedulingPolicy schedulingPolicy,
            SignalsReceiver* const signalsReceiver, Function&& function, Args&&... args) :
                    Base{{{&stack_, internal::dummyDeleter<decltype(stack_)>}, sizeof(stack_)}, priority,
                            schedulingPolicy, nullptr, signalsReceiver},
                    boundFunction_{std::bind(std::forward<Function>(function), std::forward<Args>(args)...)}
    {

    }

    StaticThreadBase(const StaticThreadBase&) = delete;
    StaticThreadBase(StaticThreadBase&&) = default;
    const StaticThreadBase& operator=(const StaticThreadBase&) = delete;
    StaticThreadBase& operator=(StaticThreadBase&&) = delete;

    int start()
    {
        return UndetachableThread::startInternal();
    }

protected:

    void run() override
    {
        boundFunction_();
    }

private:

    constexpr static size_t adjustedStackSize {(StackSize + DISTORTOS_ARCHITECTURE_STACK_ALIGNMENT - 1) /
            DISTORTOS_ARCHITECTURE_STACK_ALIGNMENT * DISTORTOS_ARCHITECTURE_STACK_ALIGNMENT};

    alignas(DISTORTOS_ARCHITECTURE_STACK_ALIGNMENT)
    typename std::aligned_storage<adjustedStackSize + internal::stackGuardSize>::type stack_;

    static_assert(sizeof(stack_) % DISTORTOS_ARCHITECTURE_STACK_ALIGNMENT == 0, "Stack size is not aligned!");

    decltype(std::bind(std::declval<Function>(), std::declval<Args>()...)) boundFunction_;
};

}   // namespace internal


template<size_t StackSize, bool CanReceiveSignals, size_t QueuedSignals, size_t SignalActions, typename Function,
        typename... Args>
class StaticThread : public internal::StaticThreadBase<StackSize, Function, Args...>
{
public:

    using Base = internal::StaticThreadBase<StackSize, Function, Args...>;

    StaticThread(uint8_t priority, SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args);

    StaticThread(const uint8_t priority, Function&& function, Args&&... args) :
            StaticThread{priority, SchedulingPolicy::roundRobin, std::forward<Function>(function),
                    std::forward<Args>(args)...}
    {

    }

    StaticThread(const StaticThread&) = delete;
    StaticThread(StaticThread&&) = default;
    const StaticThread& operator=(const StaticThread&) = delete;
    StaticThread& operator=(StaticThread&&) = delete;
};

#if DISTORTOS_SIGNALS_ENABLE == 1

template<size_t StackSize, size_t QueuedSignals, size_t SignalActions, typename Function, typename... Args>
class StaticThread<StackSize, true, QueuedSignals, SignalActions, Function, Args...> :
        public internal::StaticThreadBase<StackSize, Function, Args...>
{
public:

    using Base = internal::StaticThreadBase<StackSize, Function, Args...>;

    StaticThread(uint8_t priority, SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args);

    StaticThread(const uint8_t priority, Function&& function, Args&&... args) :
            StaticThread{priority, SchedulingPolicy::roundRobin, std::forward<Function>(function),
                    std::forward<Args>(args)...}
    {

    }

    StaticThread(const StaticThread&) = delete;
    StaticThread(StaticThread&&) = default;
    const StaticThread& operator=(const StaticThread&) = delete;
    StaticThread& operator=(StaticThread&&) = delete;

private:

    StaticSignalsReceiver<QueuedSignals, SignalActions> staticSignalsReceiver_;
};

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

template<size_t StackSize, bool CanReceiveSignals = {}, size_t QueuedSignals = {}, size_t SignalActions = {},
        typename Function, typename... Args>
StaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions, Function, Args...>
makeStaticThread(const uint8_t priority, const SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args)
{
    return {priority, schedulingPolicy, std::forward<Function>(function), std::forward<Args>(args)...};
}

template<size_t StackSize, bool CanReceiveSignals = {}, size_t QueuedSignals = {}, size_t SignalActions = {},
        typename Function, typename... Args>
StaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions, Function, Args...>
makeStaticThread(const uint8_t priority, Function&& function, Args&&... args)
{
    return {priority, std::forward<Function>(function), std::forward<Args>(args)...};
}

template<size_t StackSize, bool CanReceiveSignals = {}, size_t QueuedSignals = {}, size_t SignalActions = {},
        typename Function, typename... Args>
StaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions, Function, Args...>
makeAndStartStaticThread(const uint8_t priority, const SchedulingPolicy schedulingPolicy, Function&& function,
        Args&&... args)
{
    auto thread = makeStaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions>(priority,
            schedulingPolicy, std::forward<Function>(function), std::forward<Args>(args)...);
    {
        const auto ret = thread.start();
        assert(ret == 0 && "Could not start thread!");
    }
    return thread;
}

template<size_t StackSize, bool CanReceiveSignals = {}, size_t QueuedSignals = {}, size_t SignalActions = {},
        typename Function, typename... Args>
StaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions, Function, Args...>
makeAndStartStaticThread(const uint8_t priority, Function&& function, Args&&... args)
{
    auto thread = makeStaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions>(priority,
            std::forward<Function>(function), std::forward<Args>(args)...);
    {
        const auto ret = thread.start();
        assert(ret == 0 && "Could not start thread!");
    }
    return thread;
}


template<size_t StackSize, bool CanReceiveSignals, size_t QueuedSignals, size_t SignalActions, typename Function,
        typename... Args>
StaticThread<StackSize, CanReceiveSignals, QueuedSignals, SignalActions, Function, Args...>::
StaticThread(const uint8_t priority, const SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args) :
        Base{priority, schedulingPolicy, nullptr, std::forward<Function>(function), std::forward<Args>(args)...}
{

}

#if DISTORTOS_SIGNALS_ENABLE == 1

template<size_t StackSize, size_t QueuedSignals, size_t SignalActions, typename Function, typename... Args>
StaticThread<StackSize, true, QueuedSignals, SignalActions, Function, Args...>::StaticThread(const uint8_t priority,
        const SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args) :
        Base{priority, schedulingPolicy, &static_cast<SignalsReceiver&>(staticSignalsReceiver_),
                std::forward<Function>(function), std::forward<Args>(args)...},
        staticSignalsReceiver_{}
{

}

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_STATICTHREAD_HPP_