FRenderCommandFence类

FRenderCommandFence用于game线程和渲染线程的同步，UE4最多允许game领先渲染线程一帧，也就是渲染线程跑第N帧的时候，game线程最多跑第N+1帧，这是因为game线程跑的太快没多大意义，还会耗光内存。因为game线程不断的产生数据传递给渲染线程，如果渲染线程消费数据远远慢于产生数据，就会有越来越多的数据存于内存中。

先介绍一下FRenderCommandFence 使用方式.

FRenderCommandFence Fence;
Fence.BeginFence();
Fence.Wait();

上面的代码会使game线程挂起，渲染线程不断执行任务，直到遇到某个任务，这个任务就是唤醒game线程。那么当game线程醒来的时候，渲染线程进度已经跟上来了。

看看BeginFence做了什么

void FRenderCommandFence::BeginFence()
{
	if (!GIsThreadedRendering)
	{
		return;
	}
	{
		//向渲染线程(RenderThread)队列发送一个task(FNullGraphTask)，当前执行该接口的线程为GameThread
		CompletionEvent = TGraphTask<FNullGraphTask>::CreateTask(NULL, ENamedThreads::GameThread).ConstructAndDispatchWhenReady(
			GET_STATID(STAT_FNullGraphTask_FenceRenderCommand), ENamedThreads::RenderThread);
	}
}

TGraphTask<FNullGraphTask>::CreateTask(NULL, ENamedThreads::GameThread)表示创建一个FNullGraphTask任务，并明确指明现在所在的线程是GameThread. 

ConstructAndDispatchWhenReady(GET_STATID(STAT_FNullGraphTask_FenceRenderCommand), ENamedThreads::RenderThread) 将把FNullGraphTask对象会被放到渲染线程的任务队列里，该任务相当于一个哨兵，主线程调用Wait后，只有当该任务被执行了，Wait才会返回，这时该任务之前的任务也被执行完了（这些任务都是在渲染线程中执行的）。

返回值是一个FGraphEventRef，赋予CompletionEvent，用于判断该任务是否完成了.

判断CommandFence是否完成了

bool FRenderCommandFence::IsFenceComplete() const
{
	if (!GIsThreadedRendering)
	{
		return true;
	}
	check(IsInGameThread() || IsInAsyncLoadingThread());
	CheckRenderingThreadHealth();
	if (!CompletionEvent.GetReference() || CompletionEvent->IsComplete())
	{
		// this frees the handle for other uses, the NULL state is considered completed
		CompletionEvent = NULL; 
		return true;
	}
	return false;
}

Wait() 使game线程等待CompletionEvent完成，期间game线程不断挂起，直到渲染线程的当前帧所有任务都执行完， 这个作用是为了防止game线程跑的太快.

void FRenderCommandFence::Wait(bool bProcessGameThreadTasks) const
{
	if (!IsFenceComplete())
	{
		GameThreadWaitForTask(CompletionEvent, bProcessGameThreadTasks);
	}
}

static void GameThreadWaitForTask(const FGraphEventRef& Task, bool bEmptyGameThreadTasks = false)
{
	if (!Task->IsComplete())
	{	
		//创建一个Event，用于挂起game线程，直到任务完成
		FEvent* Event = FPlatformProcess::GetSynchEventFromPool();
		//作用是当Task完成后，将调用Event->Trigger()唤醒game线程，
		FTaskGraphInterface::Get().TriggerEventWhenTaskCompletes(Event, Task, ENamedThreads::GameThread);

		bool bDone;
  //获取睡眠时长
		uint32 WaitTime = FMath::Clamp<uint32>(GTimeToBlockOnRenderFence, 0, 33);
		do
		{	
			//当game线程挂起WaitTime时间后再次醒来，这时bDone=false，只能不断循环
			//当Event->Trigger()唤醒game线程，bDone = true，跳出循环. 
			bDone = Event->Wait(WaitTime);
		}
		while (!bDone);

		FPlatformProcess::ReturnSynchEventToPool(Event);
		Event = nullptr;		
	}
}

下面看看引擎是如何使用该类来进行主线程和渲染线程的同步的，这里涉及到另一个类FFrameEndSync，该类使用两个FRenderCommandFence来同步主线程和渲染线程，这就是为什么主线程可以领先渲染线程一帧

class FFrameEndSync
{
	FRenderCommandFence Fence[2];
	int32 EventIndex;
public:
 //同步主线程和渲染线程
	ENGINE_API void Sync( bool bAllowOneFrameThreadLag );
};

引擎的Tick函数里都会做一次同步的操作，Tick函数就是引擎每帧的执行体.

void FEngineLoop::Tick()
{
	GEngine->Tick( FApp::GetDeltaTime(), bIdleMode );
	static FFrameEndSync FrameEndSync;
	static auto CVarAllowOneFrameThreadLag = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.OneFrameThreadLag"));
	FrameEndSync.Sync( CVarAllowOneFrameThreadLag->GetValueOnGameThread() != 0 );
}

主要操作在Sync接口里

void FFrameEndSync::Sync( bool bAllowOneFrameThreadLag )
{
	Fence[EventIndex].BeginFence();
	bool bEmptyGameThreadTasks = !FTaskGraphInterface::Get().IsThreadProcessingTasks(ENamedThreads::GameThread);

	if (bEmptyGameThreadTasks)
	{
		//这里将允许主线程处理任务，直到空闲才会往下走.
		FTaskGraphInterface::Get().ProcessThreadUntilIdle(ENamedThreads::GameThread);
	}

	//允许主线程领先于渲染线程一帧.
	if( bAllowOneFrameThreadLag )
	{
		EventIndex = (EventIndex + 1) % 2;
	}

	Fence[EventIndex].Wait(bEmptyGameThreadTasks);  
}

分析下执行流程：

bAllowOneFrameThreadLag = false，只使用Fence[0]，这时候调用Fence[0].Wait接口会马上进行同步

bAllowOneFrameThreadLag = true ：

第一帧的时候：Fence[0].BeginFence(); Fence[1].Wait() （Fence[1].Wait()这里并不会使主线程挂起，会立即返回）

第二帧的时候：Fence[1].BeginFence(); Fence[0].Wait() （如果Fence[0]的事件被执行了，说明渲染线程跑的速度和主线程差不多，这时也是不需要挂起主线程的）

第三帧的时候：Fence[0].BeginFence(); Fence[1].Wait()

由此可见，Fence[index].BeginFence()和Fence[index].Wait()调用永远都隔了一帧，从而可以使主线程可以领先渲染线程一帧（如果主线程跑的足够快的话）.