RunnableThread.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "HAL/PlatformTLS.h"
#include "HAL/PlatformAffinity.h"
 
class FRunnable;
class FTlsAutoCleanup;
 
class FRunnableThread
{
    friend class FThreadSingletonInitializer;
    friend class FTlsAutoCleanup;
    friend class FThreadManager;
    friend class FForkableThread;
    friend class FForkProcessHelper;
 
    static CORE_API uint32 RunnableTlsSlot;
 
public:
 
    static CORE_API uint32 GetTlsSlot();
 
    static CORE_API FRunnableThread* Create(
        class FRunnable* InRunnable,
        const TCHAR* ThreadName,
        uint32 InStackSize = 0,
        EThreadPriority InThreadPri = TPri_Normal,
        uint64 InThreadAffinityMask = FPlatformAffinity::GetNoAffinityMask(),
        EThreadCreateFlags InCreateFlags = EThreadCreateFlags::None);
 
    virtual void SetThreadPriority( EThreadPriority NewPriority ) = 0;
 
    virtual bool SetThreadAffinity( const FThreadAffinity& Affinity ) { return false; };
 
    virtual void Suspend( bool bShouldPause = true ) = 0;
 
    virtual bool Kill( bool bShouldWait = true ) = 0;
 
    virtual void WaitForCompletion() = 0;
 
    enum class ThreadType
    {
        // Regular thread that executes the runnable object in it's own context
        Real,
        // Fake threads are created for a single threaded environment and are always executed from the main tick
        Fake,
        // Forkable threads will behave like fake threads for the master process, but will become real threads on forked processes
        Forkable,
    };
 
    virtual FRunnableThread::ThreadType GetThreadType() const
    {
        return ThreadType::Real;
    }
 
    const uint32 GetThreadID() const
    {
        return ThreadID;
    }
 
    const FString& GetThreadName() const
    {
        return ThreadName;
    }
 
    EThreadPriority GetThreadPriority() const
    {
        return ThreadPriority;
    }
 
    CORE_API FRunnableThread();
 
    CORE_API virtual ~FRunnableThread();
 
    static FRunnableThread* GetRunnableThread()
    {
        FRunnableThread* RunnableThread = (FRunnableThread*)FPlatformTLS::GetTlsValue(RunnableTlsSlot);
        return RunnableThread;
    }
 
protected:
 
    virtual bool CreateInternal( FRunnable* InRunnable, const TCHAR* InThreadName,
        uint32 InStackSize = 0,
        EThreadPriority InThreadPri = TPri_Normal, uint64 InThreadAffinityMask = 0, 
        EThreadCreateFlags InCreateFlags = EThreadCreateFlags::None) = 0;
 
    CORE_API void SetTls();
 
    CORE_API void FreeTls();
 
    FString ThreadName;
 
    FRunnable* Runnable;
 
    FEvent* ThreadInitSyncEvent;
 
    uint64 ThreadAffinityMask;
 
    EThreadPriority ThreadPriority;
 
    uint32 ThreadID;
 
private:
 
    static CORE_API void SetupCreatedThread(FRunnableThread*& NewThread, class FRunnable* InRunnable, const TCHAR* ThreadName, uint32 InStackSize, EThreadPriority InThreadPri, uint64 InThreadAffinityMask, EThreadCreateFlags InCreateFlags);
 
    virtual void Tick() {}
 
    virtual void OnPreFork()
    {
        checkf(false, TEXT("Only forkable threads should receive OnPreFork."));
    }
 
    virtual void OnPostFork()
    {
        checkf(false, TEXT("Only forkable threads should receive OnPostFork."));
    }
 
    CORE_API void PostCreate(EThreadPriority ThreadPriority);
};