You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
71 lines
3.0 KiB
71 lines
3.0 KiB
// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
/*
|
|
Long duration lambda wrapper, which are generally not supported by the taskgraph system. New thread per lambda and they will auto-delete upon
|
|
completion.
|
|
*/
|
|
class WINDOWSFILEUTILITY_API WFULambdaRunnable : public FRunnable
|
|
{
|
|
private:
|
|
/** Thread to run the worker FRunnable on */
|
|
FRunnableThread* Thread;
|
|
|
|
// Used to give each thread a unique stat group
|
|
static uint64 ThreadNumber;
|
|
|
|
//Lambda function pointer
|
|
TFunction< void()> FunctionPointer;
|
|
|
|
// A queued threadpool used to run lambda's in the background. This has lazy initialization and is meant to be used with
|
|
// - AddLambdaToQueue
|
|
// - RemoveLAmbdaFromQueue
|
|
static FQueuedThreadPool* ThreadPool;
|
|
public:
|
|
//Constructor / Destructor
|
|
WFULambdaRunnable(TFunction< void()> InFunction);
|
|
virtual ~WFULambdaRunnable();
|
|
|
|
// Begin FRunnable interface.
|
|
virtual uint32 Run() override;
|
|
virtual void Exit() override;
|
|
// End FRunnable interface
|
|
|
|
// Initializes the queued thread pool. This is called lazily when the first task is added to the queue
|
|
// but can also be called by hand to initialize with a specific number of threads. The default number
|
|
// of threads is FPlatformMisc::NumberOfIOWorkerThreadsToSpawn() which last I checked was hard-coded
|
|
// at 4. <NOTE> that if you want to call this by hand, you need to do so before ever calling AddLambdaToQueue.
|
|
static void InitThreadPool(int32 NumberOfThreads);
|
|
|
|
/** Makes sure this thread has stopped properly */
|
|
void EnsureCompletion();
|
|
|
|
// Runs the passed lambda on the background thread, new thread per call
|
|
static WFULambdaRunnable* RunLambdaOnBackGroundThread(TFunction< void()> InFunction);
|
|
|
|
// Adds a lambda to be ran on the queued thread pool. Returns a pointer to IQueuedWork which
|
|
// can be used to later remove the queued job from the pool assuming it hasn't been processed.
|
|
static IQueuedWork* AddLambdaToQueue(TFunction< void()> InFunction);
|
|
|
|
// Removes a lambda from the thread queue
|
|
static bool RemoveLambdaFromQueue(IQueuedWork* Work);
|
|
|
|
// Runs a short lambda on the game thread via task graph system
|
|
static FGraphEventRef RunShortLambdaOnGameThread(TFunction< void()> InFunction);
|
|
|
|
private:
|
|
// This was yanked from Engine/Source/Runtime/Core/Public/Async/Async.h (originally called AsyncPool(..)). FQueuedThreadPool doesn't have
|
|
// much documentation, so using the engine code as reference, pretty much everyone seems to use this templated function to queue up work.
|
|
// It was modified to return an IQueuedWork instead of a TFuture to be more convenient for actually removing items from the queue.
|
|
template<typename ResultType>
|
|
static IQueuedWork* AsyncLambdaPool(FQueuedThreadPool& ThreadPool, TFunction<ResultType()> Function, TFunction<void()> CompletionCallback = TFunction<void()>())
|
|
{
|
|
TPromise<ResultType> Promise(MoveTemp(CompletionCallback));
|
|
TFuture<ResultType> Future = Promise.GetFuture();
|
|
IQueuedWork* Work = new TAsyncQueuedWork<ResultType>(MoveTemp(Function), MoveTemp(Promise));
|
|
ThreadPool.AddQueuedWork(Work);
|
|
return Work;
|
|
}
|
|
};
|
|
|