r.RDG.Validation

r.RDG.Validation

#Overview

name: r.RDG.Validation

This variable is created as a Console Variable (cvar).

It is referenced in 58 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of r.RDG.Validation is to enable validation of correctness in API calls and pass parameter dependencies within the Render Dependency Graph (RDG) system of Unreal Engine 5. This setting variable is primarily used for debugging and ensuring the proper usage of the RDG system.

Key points about r.RDG.Validation:

  1. It is used by the Render Core subsystem, specifically within the RDG implementation.

  2. The value is set through a console variable, allowing it to be changed at runtime. By default, it is enabled (value of 1).

  3. It is associated with the GRDGValidation variable, which is used throughout the code to conditionally execute validation checks.

  4. When enabled, it performs various checks such as:

    • Validating resource creation and usage
    • Checking for proper pass creation and execution
    • Ensuring correct access patterns for resources
    • Detecting unused or improperly used resources

  5. Developers should be aware that enabling this variable may have a performance impact, as it adds additional checks throughout the RDG system.

  6. Best practices when using this variable:

    • Keep it enabled during development and testing to catch potential issues early
    • Disable it in shipping builds for optimal performance
    • Use it in conjunction with other RDG debug variables for comprehensive debugging

The associated variable GRDGValidation is an integer that directly reflects the value of r.RDG.Validation. It is used throughout the RDG implementation to conditionally execute validation code. When GRDGValidation is non-zero, various validation checks are performed to ensure the correct usage of the RDG system.

Developers should be aware that GRDGValidation is used extensively in conditional statements throughout the RDG code. When it is enabled, it adds additional overhead to RDG operations, which may impact performance. However, it provides valuable debugging information and helps catch potential issues in RDG usage.

Best practices for using GRDGValidation:

  1. Use it during development and testing phases to catch RDG-related issues early.
  2. Consider disabling it in performance-critical scenarios or shipping builds.
  3. When debugging RDG-related issues, enable this variable along with other RDG debug options for comprehensive diagnostics.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphPrivate.cpp:19

Scope: file

Source code excerpt:

int32 GRDGValidation = 1;
FAutoConsoleVariableRef CVarRDGValidation(
	TEXT("r.RDG.Validation"),
	GRDGValidation,
	TEXT("Enables validation of correctness in API calls and pass parameter dependencies.\n")
	TEXT(" 0: disabled;\n")
	TEXT(" 1: enabled (default);\n"),
	ECVF_RenderThreadSafe);

#Associated Variable and Callsites

This variable is associated with another variable named GRDGValidation. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphBuilder.cpp:2321

Scope (from outer to inner):

file
function     void FRDGBuilder::SetupPassInternals

Source code excerpt:


#if RDG_GPU_DEBUG_SCOPES && RDG_ENABLE_DEBUG
	if (GRDGValidation != 0)
	{
		if (const FRDGEventScope* Scope = Pass->GPUScopes.Event)
		{
			Pass->FullPathIfDebug = Scope->GetPath(Pass->Name);
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphBuilder.cpp:4268

Scope (from outer to inner):

file
function     void FRDGBuilder::ClobberPassOutputs

Source code excerpt:

void FRDGBuilder::ClobberPassOutputs(const FRDGPass* Pass)
{
	if (!GRDGValidation || !GRDGClobberResources || !AuxiliaryPasses.IsClobberAllowed())
	{
		return;
	}

	RDG_RECURSION_COUNTER_SCOPE(AuxiliaryPasses.Clobber);
	RDG_EVENT_SCOPE(*this, "RDG ClobberResources");

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphEvent.cpp:525

Scope (from outer to inner):

file
function     FRDGEventName::FRDGEventName

Source code excerpt:

	check(InEventFormat);

	if (GRDGValidation != 0)
	{
		va_list VAList;
		va_start(VAList, InEventFormat);
		TCHAR TempStr[256];
		// Build the string in the temp buffer
		FCString::GetVarArgs(TempStr, UE_ARRAY_COUNT(TempStr), InEventFormat, VAList);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphPrivate.cpp:17

Scope: file

Source code excerpt:

	ECVF_RenderThreadSafe);

int32 GRDGValidation = 1;
FAutoConsoleVariableRef CVarRDGValidation(
	TEXT("r.RDG.Validation"),
	GRDGValidation,
	TEXT("Enables validation of correctness in API calls and pass parameter dependencies.\n")
	TEXT(" 0: disabled;\n")
	TEXT(" 1: enabled (default);\n"),
	ECVF_RenderThreadSafe);

int32 GRDGDebug = 0;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphPrivate.cpp:524

Scope (from outer to inner):

file
function     void InitRenderGraph

Source code excerpt:

	if (FParse::Value(FCommandLine::Get(), TEXT("rdgvalidation="), ValidationValue))
	{
		GRDGValidation = ValidationValue;
	}

	if (FParse::Param(FCommandLine::Get(), TEXT("rdgdebug")))
	{
		GRDGDebug = 1;
	}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphPrivate.h:31

Scope: file

Source code excerpt:

extern int32 GRDGAsyncCompute;
extern int32 GRDGClobberResources;
extern int32 GRDGValidation;
extern int32 GRDGDebug;
extern int32 GRDGDebugFlushGPU;
extern int32 GRDGDebugExtendResourceLifetimes;
extern int32 GRDGDebugDisableTransientResources;
extern int32 GRDGBreakpoint;
extern int32 GRDGTransitionLog;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphPrivate.h:94

Scope: file

Source code excerpt:


const int32 GRDGClobberResources = 0;
const int32 GRDGValidation = 0;
const int32 GRDGDebug = 0;
const int32 GRDGDebugFlushGPU = 0;
const int32 GRDGDebugExtendResourceLifetimes = 0;
const int32 GRDGDebugDisableTransientResources = 0;
const int32 GRDGBreakpoint = 0;
const int32 GRDGTransitionLog = 0;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:32

Scope (from outer to inner):

file
function     void FRDGResource::MarkResourceAsUsed

Source code excerpt:

void FRDGResource::MarkResourceAsUsed()
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateRHIAccess();

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:44

Scope (from outer to inner):

file
function     void FRDGResource::ValidateRHIAccess

Source code excerpt:

void FRDGResource::ValidateRHIAccess() const
{
	if (!GRDGValidation)
	{
		return;
	}

	check(DebugData);
	checkf(DebugData->bAllowRHIAccess || GRDGAllowRHIAccess,

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:58

Scope (from outer to inner):

file
function     FRDGResourceDebugData& FRDGResource::GetDebugData

Source code excerpt:

FRDGResourceDebugData& FRDGResource::GetDebugData() const
{
	check(GRDGValidation != 0);
	check(DebugData);
	return *DebugData;
}

struct FRDGViewableResourceDebugData
{

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:77

Scope (from outer to inner):

file
function     FRDGViewableResourceDebugData& FRDGViewableResource::GetViewableDebugData

Source code excerpt:

FRDGViewableResourceDebugData& FRDGViewableResource::GetViewableDebugData() const
{
	check(GRDGValidation != 0);
	check(ViewableDebugData);
	return *ViewableDebugData;
}

struct FRDGTextureDebugData
{

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:93

Scope (from outer to inner):

file
function     FRDGTextureDebugData& FRDGTexture::GetTextureDebugData

Source code excerpt:

FRDGTextureDebugData& FRDGTexture::GetTextureDebugData() const
{
	check(GRDGValidation != 0);
	check(TextureDebugData);
	return *TextureDebugData;
}

struct FRDGBufferDebugData
{

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:106

Scope (from outer to inner):

file
function     FRDGBufferDebugData& FRDGBuffer::GetBufferDebugData

Source code excerpt:

FRDGBufferDebugData& FRDGBuffer::GetBufferDebugData() const
{
	check(GRDGValidation != 0);
	check(BufferDebugData);
	return *BufferDebugData;
}

void FRDGUniformBuffer::MarkResourceAsUsed()
{
	if (!GRDGValidation)
	{
		return;
	}

	FRDGResource::MarkResourceAsUsed();

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:166

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateTexture

Source code excerpt:

void FRDGUserValidation::ValidateCreateTexture(FRDGTextureRef Texture)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateViewableResource(Texture);
	Texture->TextureDebugData = Allocator.AllocNoDestruct<FRDGTextureDebugData>();

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:181

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateBuffer

Source code excerpt:

void FRDGUserValidation::ValidateCreateBuffer(FRDGBufferRef Buffer)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateViewableResource(Buffer);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:199

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateSRV

Source code excerpt:

void FRDGUserValidation::ValidateCreateSRV(FRDGTextureSRVRef SRV)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateResource(SRV);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:209

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateSRV

Source code excerpt:

void FRDGUserValidation::ValidateCreateSRV(FRDGBufferSRVRef SRV)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateResource(SRV);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:219

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUAV

Source code excerpt:

void FRDGUserValidation::ValidateCreateUAV(FRDGTextureUAVRef UAV)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateResource(UAV);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:229

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUAV

Source code excerpt:

void FRDGUserValidation::ValidateCreateUAV(FRDGBufferUAVRef UAV)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateResource(UAV);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:239

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUniformBuffer

Source code excerpt:

void FRDGUserValidation::ValidateCreateUniformBuffer(FRDGUniformBufferRef UniformBuffer)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateResource(UniformBuffer);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:252

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateRegisterExternalTexture

Source code excerpt:

	ERDGTextureFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	checkf(Name!=nullptr, TEXT("Attempted to register external texture with NULL name."));
	checkf(ExternalPooledTexture.IsValid(), TEXT("Attempted to register NULL external texture."));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:264

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateRegisterExternalBuffer

Source code excerpt:

void FRDGUserValidation::ValidateRegisterExternalBuffer(const TRefCountPtr<FRDGPooledBuffer>& ExternalPooledBuffer, const TCHAR* Name, ERDGBufferFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	checkf(Name!=nullptr, TEXT("Attempted to register external buffer with NULL name."));
	checkf(ExternalPooledBuffer.IsValid(), TEXT("Attempted to register NULL external buffer."));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:276

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateRegisterExternalTexture

Source code excerpt:

void FRDGUserValidation::ValidateRegisterExternalTexture(FRDGTextureRef Texture)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateTexture(Texture);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:286

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateRegisterExternalBuffer

Source code excerpt:

void FRDGUserValidation::ValidateRegisterExternalBuffer(FRDGBufferRef Buffer)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateCreateBuffer(Buffer);
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:296

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateTexture

Source code excerpt:

void FRDGUserValidation::ValidateCreateTexture(const FRDGTextureDesc& Desc, const TCHAR* Name, ERDGTextureFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	checkf(Name!=nullptr, TEXT("Creating a texture requires a valid debug name."));
	ExecuteGuard(TEXT("CreateTexture"), Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:322

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateBuffer

Source code excerpt:

void FRDGUserValidation::ValidateCreateBuffer(const FRDGBufferDesc& Desc, const TCHAR* Name, ERDGBufferFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	checkf(Name!=nullptr, TEXT("Creating a buffer requires a valid debug name."));
	ExecuteGuard(TEXT("CreateBuffer"), Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:340

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateSRV

Source code excerpt:

void FRDGUserValidation::ValidateCreateSRV(const FRDGTextureSRVDesc& Desc)
{
	if (!GRDGValidation)
	{
		return;
	}

	FRDGTextureRef Texture = Desc.Texture;
	checkf(Texture, TEXT("Texture SRV created with a null texture."));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:353

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateSRV

Source code excerpt:

void FRDGUserValidation::ValidateCreateSRV(const FRDGBufferSRVDesc& Desc)
{
	if (!GRDGValidation)
	{
		return;
	}

	FRDGBufferRef Buffer = Desc.Buffer;
	checkf(Buffer, TEXT("Buffer SRV created with a null buffer."));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:365

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUAV

Source code excerpt:

void FRDGUserValidation::ValidateCreateUAV(const FRDGTextureUAVDesc& Desc)
{
	if (!GRDGValidation)
	{
		return;
	}

	FRDGTextureRef Texture = Desc.Texture;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:381

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUAV

Source code excerpt:

void FRDGUserValidation::ValidateCreateUAV(const FRDGBufferUAVDesc& Desc)
{
	if (!GRDGValidation)
	{
		return;
	}

	FRDGBufferRef Buffer = Desc.Buffer;
	checkf(Buffer, TEXT("Buffer UAV created with a null buffer."));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:393

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCreateUniformBuffer

Source code excerpt:

void FRDGUserValidation::ValidateCreateUniformBuffer(const void* ParameterStruct, const FShaderParametersMetadata* Metadata)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Metadata);
	const TCHAR* Name = Metadata->GetShaderVariableName();

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:406

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUploadBuffer

Source code excerpt:

void FRDGUserValidation::ValidateUploadBuffer(FRDGBufferRef Buffer, const void* InitialData, uint64 InitialDataSize)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(!Buffer->bQueuedForUpload, TEXT("Buffer %s already has an upload queued. Only one upload can be done for each graph."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:418

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUploadBuffer

Source code excerpt:

void FRDGUserValidation::ValidateUploadBuffer(FRDGBufferRef Buffer, const void* InitialData, uint64 InitialDataSize, const FRDGBufferInitialDataFreeCallback& InitialDataFreeCallback)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(!Buffer->bQueuedForUpload, TEXT("Buffer %s already has an upload queued. Only one upload can be done for each graph."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:430

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUploadBuffer

Source code excerpt:

void FRDGUserValidation::ValidateUploadBuffer(FRDGBufferRef Buffer, const FRDGBufferInitialDataFillCallback& InitialDataFillCallback)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(!Buffer->bQueuedForUpload, TEXT("Buffer %s already has an upload queued. Only one upload can be done for each graph."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:442

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUploadBuffer

Source code excerpt:

void FRDGUserValidation::ValidateUploadBuffer(FRDGBufferRef Buffer, const FRDGBufferInitialDataCallback& InitialDataCallback, const FRDGBufferInitialDataSizeCallback& InitialDataSizeCallback)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(!Buffer->bQueuedForUpload, TEXT("Buffer %s already has an upload queued. Only one upload can be done for each graph."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:454

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUploadBuffer

Source code excerpt:

void FRDGUserValidation::ValidateUploadBuffer(FRDGBufferRef Buffer, const FRDGBufferInitialDataCallback& InitialDataCallback, const FRDGBufferInitialDataSizeCallback& InitialDataSizeCallback, const FRDGBufferInitialDataFreeCallback& InitialDataFreeCallback)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(!Buffer->bQueuedForUpload, TEXT("Buffer %s already has an upload queued. Only one upload can be done for each graph."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:466

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateCommitBuffer

Source code excerpt:

void FRDGUserValidation::ValidateCommitBuffer(FRDGBufferRef Buffer, uint64 CommitSizeInBytes)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(EnumHasAnyFlags(Buffer->Desc.Usage, BUF_ReservedResource), TEXT("Buffer %s is not marked as reserved and thus cannot be queued for reserved resource commit."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:479

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExtractTexture

Source code excerpt:

void FRDGUserValidation::ValidateExtractTexture(FRDGTextureRef Texture, TRefCountPtr<IPooledRenderTarget>* OutTexturePtr)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateExtractResource(Texture);
	checkf(OutTexturePtr, TEXT("Texture %s was extracted, but the output texture pointer is null."), Texture->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:490

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExtractBuffer

Source code excerpt:

void FRDGUserValidation::ValidateExtractBuffer(FRDGBufferRef Buffer, TRefCountPtr<FRDGPooledBuffer>* OutBufferPtr)
{
	if (!GRDGValidation)
	{
		return;
	}

	ValidateExtractResource(Buffer);
	checkf(OutBufferPtr, TEXT("Texture %s was extracted, but the output texture pointer is null."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:516

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateConvertToExternalResource

Source code excerpt:

void FRDGUserValidation::ValidateConvertToExternalResource(FRDGViewableResource* Resource)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Resource);
	checkf(!bHasExecuteBegun || !Resource->bTransient,

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:529

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateConvertToExternalUniformBuffer

Source code excerpt:

void FRDGUserValidation::ValidateConvertToExternalUniformBuffer(FRDGUniformBuffer* UniformBuffer)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(UniformBuffer);
	checkf(!bHasExecuteBegun,

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:542

Scope (from outer to inner):

file
function     void FRDGUserValidation::RemoveUnusedWarning

Source code excerpt:

void FRDGUserValidation::RemoveUnusedWarning(FRDGViewableResource* Resource)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Resource);
	ExecuteGuard(TEXT("RemoveUnusedResourceWarning"), Resource->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:559

Scope (from outer to inner):

file
function     bool FRDGUserValidation::TryMarkForClobber

Source code excerpt:

bool FRDGUserValidation::TryMarkForClobber(FRDGViewableResource* Resource) const
{
	if (!GRDGValidation)
	{
		return false;
	}

	check(Resource);
	FRDGViewableResourceDebugData& DebugData = Resource->GetViewableDebugData();

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:579

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateGetPooledTexture

Source code excerpt:

void FRDGUserValidation::ValidateGetPooledTexture(FRDGTextureRef Texture) const
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Texture);
	checkf(Texture->bExternal, TEXT("GetPooledTexture called on texture %s, but it is not external. Call PreallocateTexture or register as an external texture instead."), Texture->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:590

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateGetPooledBuffer

Source code excerpt:

void FRDGUserValidation::ValidateGetPooledBuffer(FRDGBufferRef Buffer) const
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Buffer);
	checkf(Buffer->bExternal, TEXT("GetPooledBuffer called on buffer %s, but it is not external. Call PreallocateBuffer or register as an external buffer instead."), Buffer->Name);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:601

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateSetAccessFinal

Source code excerpt:

void FRDGUserValidation::ValidateSetAccessFinal(FRDGViewableResource* Resource, ERHIAccess AccessFinal)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Resource);
	check(AccessFinal != ERHIAccess::Unknown && IsValidAccess(AccessFinal));

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:614

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUseExternalAccessMode

Source code excerpt:

void FRDGUserValidation::ValidateUseExternalAccessMode(FRDGViewableResource* Resource, ERHIAccess ReadOnlyAccess, ERHIPipeline Pipelines)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Resource);
	check(Pipelines != ERHIPipeline::None);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:645

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateUseInternalAccessMode

Source code excerpt:

void FRDGUserValidation::ValidateUseInternalAccessMode(FRDGViewableResource* Resource)
{
	if (!GRDGValidation)
	{
		return;
	}

	check(Resource);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:658

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExternalAccess

Source code excerpt:

void FRDGUserValidation::ValidateExternalAccess(FRDGViewableResource* Resource, ERHIAccess Access, const FRDGPass* Pass)
{
	if (!GRDGValidation)
	{
		return;
	}

	const auto& AccessModeState = Resource->AccessModeState;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:676

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateAddSubresourceAccess

Source code excerpt:

void FRDGUserValidation::ValidateAddSubresourceAccess(FRDGViewableResource* Resource, const FRDGSubresourceState& Subresource, ERHIAccess Access)
{
	if (!GRDGValidation)
	{
		return;
	}

	const bool bOldAccessMergeable = EnumHasAnyFlags(Subresource.Access, GRHIMergeableAccessMask) || Subresource.Access == ERHIAccess::Unknown;
	const bool bNewAccessMergeable = EnumHasAnyFlags(Access, GRHIMergeableAccessMask);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:691

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateAddPass

Source code excerpt:

void FRDGUserValidation::ValidateAddPass(const FRDGEventName& Name, ERDGPassFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	ExecuteGuard(TEXT("AddPass"), Name.GetTCHAR());

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:704

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateAddPass

Source code excerpt:

void FRDGUserValidation::ValidateAddPass(const void* ParameterStruct, const FShaderParametersMetadata* Metadata, const FRDGEventName& Name, ERDGPassFlags Flags)
{
	if (!GRDGValidation)
	{
		return;
	}

	checkf(ParameterStruct, TEXT("Pass '%s' created with null parameters."), Name.GetTCHAR());
	ExecuteGuard(TEXT("AddPass"), Name.GetTCHAR());

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:730

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateAddPass

Source code excerpt:

void FRDGUserValidation::ValidateAddPass(const FRDGPass* Pass, bool bSkipPassAccessMarking)
{
	if (!GRDGValidation)
	{
		return;
	}

	const FRenderTargetBindingSlots* RenderTargetBindingSlots = nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:1050

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExecuteEnd

Source code excerpt:

	GRDGBuilderActive = false;

	if (GRDGDebug && GRDGValidation)
	{
		auto ValidateResourceAtExecuteEnd = [](const FRDGViewableResource* Resource)
		{
			const auto& ViewableDebugData = Resource->GetViewableDebugData();
			const bool bProducedButNeverUsed = ViewableDebugData.PassAccessCount == 1 && ViewableDebugData.FirstProducer;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:1103

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExecutePassBegin

Source code excerpt:

void FRDGUserValidation::ValidateExecutePassBegin(const FRDGPass* Pass)
{
	if (bParallelExecuteEnabled || !GRDGValidation)
	{
		return;
	}

	SetAllowRHIAccess(Pass, true);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:1203

Scope (from outer to inner):

file
function     void FRDGUserValidation::ValidateExecutePassEnd

Source code excerpt:

void FRDGUserValidation::ValidateExecutePassEnd(const FRDGPass* Pass)
{
	if (bParallelExecuteEnabled || !GRDGValidation)
	{
		return;
	}

	SetAllowRHIAccess(Pass, false);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/RenderGraphValidation.cpp:1267

Scope (from outer to inner):

file
function     void FRDGUserValidation::SetAllowRHIAccess

Source code excerpt:

void FRDGUserValidation::SetAllowRHIAccess(const FRDGPass* Pass, bool bAllowAccess)
{
	if (!GRDGValidation)
	{
		return;
	}

	Pass->GetParameters().Enumerate([&](FRDGParameter Parameter)
	{