BaseThread.h

Go to the documentation of this file.

 
#ifndef BaseThread_H
#define BaseThread_H
 
#include <memory>
#include <atomic>
#include "OsAbstraction.h"
#include "OsUtility.h"
#include "SignalSemaphore.h"
 
class BaseThread
{
public:
    BaseThread(const char *threadName);
 
    BaseThread(const BaseThread&) = delete;
 
    BaseThread& operator =(const BaseThread&) = delete;
 
    virtual ~BaseThread() noexcept;
 
    OS_Thread* GetThreadId() noexcept
    {
        return initialized ? &osThread : nullptr;
    }
 
    inline bool IsInitialized() const noexcept
    {
        return initialized;
    }
 
    bool EnsureInitialized() noexcept
    {
        if (!initialized)
        {
            initialized = Initialize();
        }
        return initialized;
    }
 
    bool Suspend() noexcept;
 
    bool Resume() noexcept;
 
    bool IsSuspended() noexcept;
 
    bool IsThreadCreated() noexcept { return osThreadCreated; }
    bool IsThreadStopRequested() noexcept { return stopThreadRequested; }
    bool IsSetupComplete() const noexcept { return setupComplete; }
    bool IsThreadRunning() const noexcept {
        return threadRunning.load(std::memory_order_acquire);
    }
    bool IsThreadStopped() const noexcept {
        return !threadRunning.load(std::memory_order_acquire);
    }
    bool IsCleanupComplete() const noexcept {return cleanupComplete; }
    bool IsThreadInStepDelay() const noexcept {return threadStepInDelay; }
 
 
    bool Start() noexcept;
 
    virtual bool StartAction() noexcept;
 
    bool Stop() noexcept;
 
    virtual bool Setup() noexcept = 0;
 
    virtual uint32_t Step() noexcept = 0;
 
    virtual bool Cleanup() noexcept = 0;
 
    const char* GetThreadName() noexcept;
 
    bool StartThreadAndWaitToVerify(uint32_t startTimeoutMsec = 1000);
 
    bool StopThreadAndWaitToVerify(uint32_t stopTimeoutMsec);
 
    uint32_t GetStackHighWaterMark() const noexcept;
 
    bool ChangePriority(uint32_t newPriority) noexcept;
 
 
protected:
 
    void WaitForStart() noexcept;
 
    virtual bool Initialize() noexcept = 0;
 
    virtual bool ResetVariables() noexcept = 0;
 
    static void ThreadEntry(OS_Ulong instanceAddress);
 
    bool CreateBaseThread(uint8_t *stack, OS_Ulong stackSizeBytes, OS_Uint priority,
            OS_Uint preempt_threshold, OS_Ulong timeSliceAllowed, OS_Uint auto_start) noexcept;
 
    bool CreateBaseThread(uint8_t *stack, OS_Ulong stackSizeBytes, OS_Uint priority,
            OS_Uint preempt_threshold, OS_Ulong timeSliceAllowed, OS_Uint auto_start,
            int core_id) noexcept;
 
    void MarkSetupComplete() noexcept { setupComplete = true; }
 
    void ClearSetupComplete() noexcept { setupComplete = false; }
 
    void MarkCleanupComplete() noexcept { cleanupComplete = true; }
 
    void ClearCleanupComplete() noexcept { cleanupComplete = false; }
 
    void MarkThreadRunning() noexcept { threadRunning.store(true, std::memory_order_release); }
 
    void ClearThreadRunning() noexcept { threadRunning.store(false, std::memory_order_release); }
 
    void MarkThreadStopRequested() noexcept { stopThreadRequested = true; }
 
    void ClearThreadStopRequested() noexcept { stopThreadRequested = false; }
 
    void MarkThreadStepInDelay() noexcept { threadStepInDelay = true; }
 
    void ClearThreadStepInDelay() noexcept { threadStepInDelay = false; }
 
    bool initialized;
    OS_Thread osThread;
    const char *osThreadName;
    bool osThreadCreated;
    SignalSemaphore signalSemaphore;
    static constexpr char baseThreadStartSemaphoreBaseName[] = "BaseThreadStartSem-";
 
private:
 
    uint32_t waitBeforeStep;
    uint32_t minTimestampBeforeNextStep;
 
    std::atomic<bool> threadRunning;
    std::atomic<bool> threadStepInDelay;
    std::atomic<bool> setupComplete;
    std::atomic<bool> cleanupComplete;
    std::atomic<bool> stopThreadRequested;
 
};
 
#endif /* BaseThread */