AuroraRuntime/Source/Threading/Threads/AuOSThread.hpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: AuOSThread.hpp
    Date: 2021-6-12
    Author: Reece
***/
#pragma once

#if defined(AURORA_IS_POSIX_DERIVED)
    #include <setjmp.h>
#endif

namespace Aurora::Threading::Threads
{
    struct OSThread : IAuroraThread
    {
        OSThread();
        OSThread(const ThreadInfo &info);
        OSThread(AuUInt64);
        ~OSThread();

        bool              Run()                         override;
        void              Exit()                        override;
        bool              Exiting()                     override;
        void              SendExitSignal()              override;

        void              UnsafeForceTerminateSignal()  override;

        void              SetPriority(EThreadPriority prio) override;
        void              SetThrottle(EThreadThrottle prio) override;
        void              SetAffinity(const HWInfo::CpuBitId &mask)    override;
        void              SetName(const AuString &name) override;

        EThreadPriority   GetPriority()                 override;
        EThreadThrottle   GetThrottle()                 override;
        HWInfo::CpuBitId  GetMask()                     override;
        AuString          GetName()                     override;
        
        void              ExecuteInDeadThread(AuFunction<void()> callback) override;
        AuSPtr<IWaitable> AsWaitable()                  override;

        void              AddLastHopeTlsHook(const AuSPtr<Threading::Threads::IThreadFeature> &feature) override;
        AuUInt64          SetNoUnwindTerminateExitWatchDogTimeoutInMS(AuUInt64 uMS) override;

        void              Detach()                      override;

        AuUInt64          GetThreadCreationTime(Time::EClock eClock) override;

        void InitThreadCreateTime();

        void _ThreadEP();
        AuSPtr<AuLoop::ILoopSource> AsLoopSource() override;
        AuSPtr<IWaitable> GetShutdownSignalWaitable() override;
        AuSPtr<AuLoop::ILoopSource> GetShutdownSignalLS() override;

        bool InternalKillForceNtfy();
        void SignalDeath();
        bool InternalKill(bool locked);

        void AffinityPrioThrottleTickAmendECores();

    // !protected!
        void MakeMain();
    protected:
    
        bool Exit(bool willReturnToOS, bool isEOL = false);
        bool ExecuteNewOSContext(AuFunction<void()> task);
        void UpdatePrio(EThreadThrottle throttle, EThreadPriority prio);
        void UpdateAffinity(const HWInfo::CpuBitId &mask);
        void UpdateName();
        void OSAttach();
        void OSDeatach();
        void TeminateOSContext(bool calledFromThis);
        void FreeOSContext();

        void HookReleaseThreadResources();
        void HookOnExit();

    private:
    #if defined(AURORA_IS_POSIX_DERIVED)
        jmp_buf env;
    #endif
        Primitives::Mutex         tlsLock_;
        AuUInt32                  tls_ {};
        OSThread *                tlsReferenceThread_ {};
        AuString                  name_;
        ThreadInfo                info_;
        HWInfo::CpuBitId          mask_ = HWInfo::CpuBitId().Not();
        HWInfo::CpuBitId          throttleMask_ = HWInfo::CpuBitId().Not();
        EThreadPriority           prio_ = EThreadPriority::ePrioNormal;
        EThreadThrottle           throttle_ = EThreadThrottle::eNormal;
        bool                      bSupportsAltKill {};
        bool                      userManagingAffinity_ {};
        bool                      exiting_{};
        bool                      contextUsed_{}; // can this thread instance execute code again?
        Primitives::EventShared_t terminated_;
        Primitives::EventShared_t terminateSignal_;
        struct Lock
        {
            bool bLock {};
            AuMutex mutex;
        };
        AuSPtr<Lock>              pFlag = AuMakeSharedPanic<Lock>();
        AuSPtr<AuLoop::ILSEvent>  terminateSignalLs_;
        AuSPtr<AuLoop::ILSEvent>  terminatedSignalLs_;
        bool                      bLongJmpOnce {};
        AuUInt64                  qwExitTimeout { AuSToMS<AuUInt64>(15) };
        bool                      bNotOwned {};
        Primitives::CriticalSection exitOnlyOnce_;
        AuList<AuSPtr<IThreadFeature>> threadFeatures_;
        AuBinarySemaphore         epExecEvent;
        AuUInt64                  uClockCreationTime[3] {};

        AuFunction<void()> task_;

    #if defined(AURORA_IS_MODERNNT_DERIVED)
        HANDLE             handle_ = INVALID_HANDLE_VALUE;
    #elif defined(AURORA_HAS_PTHREADS)
        pthread_t          handle_ {};
    #endif

        AuUInt64 unixThreadId_ = 0;
        bool detached_ {};

    };

    void InitThreading();
}