RRThreadUtils.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// UE
 
#include "Async/Async.h"
 
#include "Async/AsyncWork.h"
 
#include "HAL/PlatformProcess.h"
 
#include "Kismet/BlueprintFunctionLibrary.h"
 
#include "RenderCommandFence.h"
 
#include "RenderingThread.h"
 
 
 
// RapyutaSimulationPlugins
 
#include "Core/RRActorCommon.h"
 
#include "Core/RRGameSingleton.h"
 
 
 
#include "RRThreadUtils.generated.h"
 
 
 
class RAPYUTASIMULATIONPLUGINS_API URRThreadUtils : public UBlueprintFunctionLibrary
 
{
 
 
 
public:
 
    static bool IsInsideConstructor()
 
    {
 
        auto& ThreadContext = FUObjectThreadContext::Get();
 
        return (ThreadContext.IsInConstructor > 0);
 
    }
 
 
 
    // ----------------------------------------------------------------------------------------------------------
 
    // [ASYNC TASK SERVICES] --
 
    //
 
    template<typename TFunc, typename... TArgs>
 
    static void DoTaskInGameThread(TFunc&& InTaskInGameThread, TArgs&&... InArgs)
 
    {
 
        if (IsInGameThread())
 
        {
 
            Forward<TFunc>(InTaskInGameThread)(Forward<TArgs>(InArgs)...);
 
        }
 
        else
 
        {
 
            AsyncTask(ENamedThreads::GameThread,
 
                      [InTaskInGameThread = Forward<TFunc>(InTaskInGameThread), InArgs = MakeTuple(Forward<TArgs>(InArgs)...)]()
 
                      {
 
                          // This function is equivalent to [std::apply], which is only available since C++17!
 
                          InArgs.ApplyBefore(InTaskInGameThread);
 
                      });
 
        }
 
    }
 
 
 
    template<typename TFunc, typename... TArgs>
 
    static void DoTaskInGameThreadLater(TFunc&& InTaskInGameThread, float InWaitingTime, TArgs&&... Args)
 
    {
 
        DoAsyncTaskInThread<void>(
 
            [InWaitingTime]()
 
            {
 
                // Wait for the physics to complete the computation given earlier vel cmds
 
                FPlatformProcess::Sleep(InWaitingTime);
 
            },
 
            [InTaskInGameThread = Forward<TFunc>(InTaskInGameThread)]() { DoTaskInGameThread(InTaskInGameThread); });
 
    }
 
 
 
    template<typename TResult>
 
    static auto DoAsyncTaskInThread(TFunction<TResult()> InTask,
 
                                    TFunction<void()> InCompletionCallback,
 
                                    const EAsyncExecution InExecutionThread =
 
#if WITH_EDITOR
 
                                        EAsyncExecution::LargeThreadPool
 
#else
 
                                        EAsyncExecution::ThreadPool
 
#endif
 
    )
 
    {
 
        return Async(
 
            InExecutionThread,
 
            MoveTemp(InTask),
 
            TUniqueFunction<void()>([InCompletionCallback = MoveTemp(InCompletionCallback)]() { InCompletionCallback(); }));
 
    }
 
    template<typename TResult>
 
    static void AddAsyncTaskInThreadPool(FRRAsyncJob& OutAsyncJob,
 
                                         const uint64 InCurrentCaptureBatchId,
 
                                         TFunction<TResult()> InTask,
 
                                         TFunction<void()> InCompletionCallback)
 
    {
 
#if RAPYUTA_SIM_DEBUG
 
        UE_LOG_WITH_INFO(LogTemp,
 
                         Warning,
 
                         TEXT("[%ld:%s] ASYNC JOB NUM: %d"),
 
                         InCurrentCaptureBatchId,
 
                         *OutAsyncJob.JobName,
 
                         OutAsyncJob.GetTasksNum());
 
#endif
 
        OutAsyncJob.AddAsyncTask(InCurrentCaptureBatchId, DoAsyncTaskInThread(MoveTemp(InTask), MoveTemp(InCompletionCallback)));
 
    }
 
 
 
    template<typename TResult>
 
    static void AddAsyncTaskToJob(FRRAsyncJob& OutAsyncJob,
 
                                  const uint64 InCurrentCaptureBatchId,
 
                                  TFunction<TResult()> InTask,
 
                                  TFunction<void()> InCompletionCallback,
 
                                  const EAsyncExecution InExecutionThread = EAsyncExecution::ThreadPool)
 
    {
 
#if RAPYUTA_SIM_DEBUG
 
        UE_LOG_WITH_INFO(LogTemp,
 
                         Warning,
 
                         TEXT("[%ld:%s] ASYNC JOB NUM: %d"),
 
                         InCurrentCaptureBatchId,
 
                         *OutAsyncJob.JobName,
 
                         OutAsyncJob.GetTasksNum());
 
#endif
 
        OutAsyncJob.AddAsyncTask(InCurrentCaptureBatchId,
 
                                 DoAsyncTaskInThread(MoveTemp(InTask), MoveTemp(InCompletionCallback), InExecutionThread));
 
    }
 
 
 
    template<typename TAsyncTask>
 
    static void EnsureAsyncTasksCompletion(const TArray<TUniquePtr<FAsyncTask<TAsyncTask>>>& InAsyncTasks)
 
    {
 
        for (auto& task : InAsyncTasks)
 
        {
 
            if (!task->Cancel())
 
            {
 
                task->EnsureCompletion();
 
            }
 
        }
 
    }
 
};