CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Runtime/RHI/Private/PipelineFileCache.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

4531 lines
155 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
/*=============================================================================
PipelineFileCache.cpp: Pipeline state cache implementation.
=============================================================================*/
#include "PipelineFileCache.h"
#include "Containers/List.h"
#include "Containers/Ticker.h"
#include "PipelineStateCache.h"
#include "HAL/IConsoleManager.h"
#include "Misc/EngineVersion.h"
#include "HAL/PlatformFile.h"
#include "Serialization/MemoryReader.h"
#include "Misc/CommandLine.h"
#include "Serialization/MemoryWriter.h"
#include "DataDrivenShaderPlatformInfo.h"
#include "Misc/ScopeRWLock.h"
#include "Misc/Paths.h"
#include "Async/AsyncFileHandle.h"
#include "HAL/PlatformFileManager.h"
#include "Misc/FileHelper.h"
#include "ProfilingDebugging/CsvProfiler.h"
#include "RHIStrings.h"
#include "String/LexFromString.h"
#include "String/ParseTokens.h"
#include "Misc/ScopeExit.h"
#include <Algo/ForEach.h>
static FString JOURNAL_FILE_EXTENSION(TEXT(".jnl"));
// Loaded + New created
#if STATS // If STATS are not enabled RHI_API will DLLEXPORT on an empty line
RHI_API DEFINE_STAT(STAT_TotalGraphicsPipelineStateCount);
RHI_API DEFINE_STAT(STAT_TotalComputePipelineStateCount);
RHI_API DEFINE_STAT(STAT_TotalRayTracingPipelineStateCount);
#endif
// CSV category for PSO encounter and save events
CSV_DEFINE_CATEGORY(PSO, true);
// New Saved count
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("Serialized Graphics Pipeline State Count"), STAT_SerializedGraphicsPipelineStateCount, STATGROUP_PipelineStateCache );
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("Serialized Compute Pipeline State Count"), STAT_SerializedComputePipelineStateCount, STATGROUP_PipelineStateCache );
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("Serialized RayTracing Pipeline State Count"), STAT_SerializedRayTracingPipelineStateCount, STATGROUP_PipelineStateCache);
// New created - Cache Miss count
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("New Graphics Pipeline State Count"), STAT_NewGraphicsPipelineStateCount, STATGROUP_PipelineStateCache );
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("New Compute Pipeline State Count"), STAT_NewComputePipelineStateCount, STATGROUP_PipelineStateCache );
DECLARE_DWORD_ACCUMULATOR_STAT(TEXT("New RayTracing Pipeline State Count"), STAT_NewRayTracingPipelineStateCount, STATGROUP_PipelineStateCache);
// Memory - Only track the file representation and new state cache stats
DECLARE_MEMORY_STAT(TEXT("New Cached PSO"), STAT_NewCachedPSOMemory, STATGROUP_PipelineStateCache);
DECLARE_MEMORY_STAT(TEXT("PSO Stat"), STAT_PSOStatMemory, STATGROUP_PipelineStateCache);
DECLARE_MEMORY_STAT(TEXT("File Cache"), STAT_FileCacheMemory, STATGROUP_PipelineStateCache);
void LexFromString(ETextureCreateFlags& OutValue, const FStringView& InString)
{
__underlying_type(ETextureCreateFlags) TmpFlags = static_cast<__underlying_type(ETextureCreateFlags)>(OutValue);
LexFromString(TmpFlags, InString);
OutValue = static_cast<ETextureCreateFlags>(TmpFlags);
}
enum class EPipelineCacheFileFormatVersions : uint32
{
FirstWorking = 7,
LibraryID = 9,
ShaderMetaData = 10,
SortedVertexDesc = 11,
TOCMagicGuard = 12,
PSOUsageMask = 13,
PSOBindCount = 14,
EOFMarker = 15,
EngineFlags = 16,
Subpass = 17,
PatchSizeReduction_NoDuplicatedGuid = 18,
AlphaToCoverage = 19,
AddingMeshShaders = 20,
RemovingTessellationShaders = 21,
LastUsedTime = 22,
MoreRenderTargetFlags = 23,
FragmentDensityAttachment = 24,
AddingDepthClipMode = 25,
BeforeStableCacheVersioning = 26,
RemovingLineAA = 27,
AddingDepthBounds = 28,
AddRTPSOShaderBindingLayout = 29,
};
const uint64 FPipelineCacheFileFormatMagic = 0x5049504543414348; // PIPECACH
const uint64 FPipelineCacheTOCFileFormatMagic = 0x544F435354415232; // TOCSTAR2
const uint64 FPipelineCacheEOFFileFormatMagic = 0x454F462D4D41524B; // EOF-MARK
const RHI_API uint32 FPipelineCacheFileFormatCurrentVersion = (uint32)EPipelineCacheFileFormatVersions::AddRTPSOShaderBindingLayout;
const int32 FPipelineCacheGraphicsDescPartsNum = 67; // parser will expect this number of parts in a description string
/**
* PipelineFileCache API access
**/
static TAutoConsoleVariable<int32> CVarPSOFileCacheEnabled(
TEXT("r.ShaderPipelineCache.Enabled"),
PIPELINE_CACHE_DEFAULT_ENABLED,
TEXT("1 Enables the PipelineFileCache, 0 disables it."),
ECVF_Default | ECVF_RenderThreadSafe
);
static TAutoConsoleVariable<int32> CVarPSOFileCacheLogPSO(
TEXT("r.ShaderPipelineCache.LogPSO"),
PIPELINE_CACHE_DEFAULT_ENABLED,
TEXT("1 Logs new PSO entries into the file cache and allows saving."),
ECVF_Default | ECVF_RenderThreadSafe
);
static TAutoConsoleVariable<int32> CVarPSOFileCacheReportPSO(
TEXT("r.ShaderPipelineCache.ReportPSO"),
PIPELINE_CACHE_DEFAULT_ENABLED,
TEXT("1 reports new PSO entries via a delegate, but does not record or modify any cache file. New PSOs are reported in bulk once per frame."),
ECVF_Default | ECVF_RenderThreadSafe
);
static int32 GPSOExcludePrecachePSOsInFileCache = 0;
static FAutoConsoleVariableRef CVarPSOFileCacheExcludePrecachePSO(
TEXT("r.ShaderPipelineCache.ExcludePrecachePSO"),
GPSOExcludePrecachePSOsInFileCache,
TEXT("1 excludes saving runtime-precached graphics PSOs in the file cache, 0 (default) includes them. Excluding precached PSOs requires PSO precaching to be enabled."),
ECVF_ReadOnly
);
static int32 GPSOFileCachePrintNewPSODescriptors = 0;
static FAutoConsoleVariableRef CVarPSOFileCachePrintNewPSODescriptors(
TEXT("r.ShaderPipelineCache.PrintNewPSODescriptors"),
GPSOFileCachePrintNewPSODescriptors,
TEXT("1 prints descriptions for all new PSO entries to the log/console while 0 does not. 2 prints additional details about graphics PSO. Defaults to 0."),
ECVF_Default
);
static TAutoConsoleVariable<int32> CVarPSOFileCacheSaveUserCache(
TEXT("r.ShaderPipelineCache.SaveUserCache"),
PIPELINE_CACHE_DEFAULT_ENABLED && UE_BUILD_SHIPPING,
TEXT("If > 0 then any missed PSOs will be saved to a writable user cache file for subsequent runs to load and avoid in-game hitches. Enabled by default on macOS only."),
ECVF_Default | ECVF_RenderThreadSafe
);
static TAutoConsoleVariable<int32> CVarPSOFileCacheUserCacheUnusedElementRetainDays(
TEXT("r.ShaderPipelineCache.UserCacheUnusedElementRetainDays"),
30,
TEXT("The amount of time in days to keep unused PSO entries in the cache."),
ECVF_Default
);
static TAutoConsoleVariable<int32> CVarPSOFileCacheUserCacheUnusedElementCheckPeriod(
TEXT("r.ShaderPipelineCache.UserCacheUnusedElementCheckPeriod"),
-1,
TEXT("The amount of time in days between running the garbage collection on unused PSOs in the user cache. Use a negative value to disable."),
ECVF_Default
);
static TAutoConsoleVariable<int32> CVarLazyLoadShadersWhenPSOCacheIsPresent(
TEXT("r.ShaderPipelineCache.LazyLoadShadersWhenPSOCacheIsPresent"),
0,
TEXT("Non-Zero: If we load a PSO cache, then lazy load from the shader code library. This assumes the PSO cache is more or less complete. This will only work on RHIs that support the library+Hash CreateShader API (GRHISupportsLazyShaderCodeLoading == true)."),
ECVF_RenderThreadSafe);
static TAutoConsoleVariable<int32> CVarClearOSPSOFileCache(
TEXT("r.ShaderPipelineCache.ClearOSCache"),
0,
TEXT("1 Enables the OS level clear after install, 0 disables it."),
ECVF_Default | ECVF_RenderThreadSafe
);
static TAutoConsoleVariable<int32> CVarAlwaysGeneratePOSSOFileCache(
TEXT("r.ShaderPipelineCache.AlwaysGenerateOSCache"),
1,
TEXT("1 generates the cache every run, 0 generates it only when it is missing."),
ECVF_Default | ECVF_RenderThreadSafe
);
FRWLock FPipelineFileCacheManager::FileCacheLock;
TMap<FString, TUniquePtr< class FPipelineCacheFile>> FPipelineFileCacheManager::FileCacheMap;
TMap<FGuid, FString> FPipelineFileCacheManager::GameGuidToCacheKey;
TMap<uint32, FPSOUsageData> FPipelineFileCacheManager::RunTimeToPSOUsage;
TMap<uint32, FPSOUsageData> FPipelineFileCacheManager::NewPSOUsage;
TMap<uint32, FPipelineStateStats*> FPipelineFileCacheManager::Stats;
TSet<FPipelineCacheFileFormatPSO> FPipelineFileCacheManager::NewPSOs;
TMpscQueue<FPipelineCacheFileFormatPSO> FPipelineFileCacheManager::NewPSOsToReport;
TSet<uint32> FPipelineFileCacheManager::NewPSOHashes;
uint32 FPipelineFileCacheManager::NumNewPSOs;
FString FPipelineFileCacheManager::UserCacheKey;
FPipelineFileCacheManager::PSOOrder FPipelineFileCacheManager::RequestedOrder = FPipelineFileCacheManager::PSOOrder::MostToLeastUsed;
bool FPipelineFileCacheManager::FileCacheEnabled = false;
FPipelineFileCacheManager::FPipelineStateLoggedEvent FPipelineFileCacheManager::PSOLoggedEvent;
uint64 FPipelineFileCacheManager::GameUsageMask = 0;
bool FPipelineFileCacheManager::GameUsageMaskSet = false;
bool FPipelineFileCacheManager::LogNewPSOsToConsoleAndCSV = true;
static int64 GetCurrentUnixTime()
{
return FDateTime::UtcNow().ToUnixTimestamp();
}
bool DefaultPSOMaskComparisonFunction(uint64 ReferenceMask, uint64 PSOMask)
{
return (ReferenceMask & PSOMask) == ReferenceMask;
}
FPSOMaskComparisonFn FPipelineFileCacheManager::MaskComparisonFn = DefaultPSOMaskComparisonFunction;
static inline bool IsReferenceMaskSet(uint64 ReferenceMask, uint64 PSOMask)
{
return (ReferenceMask & PSOMask) == ReferenceMask;
}
#if PLATFORM_WINDOWS
FRHIShader::~FRHIShader()
{
if (InUseByPSOCompilation > 0)
{
UE_LOG(LogRHI, Fatal, TEXT("FRHIShader with hash: %s and Frequency: %d still in use by PSO compilation when being destroyed"), *Hash.ToString(), Frequency);
}
}
void FRHIShader::SetInUseByPSOCompilation(bool bInUse)
{
if (bInUse)
{
FPlatformAtomics::InterlockedIncrement(&InUseByPSOCompilation);
}
else
{
check(InUseByPSOCompilation > 0);
FPlatformAtomics::InterlockedDecrement(&InUseByPSOCompilation);
}
}
#endif // PLATFORM_WINDOWS
void FRHIComputeShader::UpdateStats()
{
FPipelineStateStats::UpdateStats(Stats);
}
void FPipelineStateStats::UpdateStats(FPipelineStateStats* Stats)
{
if (Stats)
{
FPlatformAtomics::InterlockedExchange(&Stats->LastFrameUsed, GFrameCounter);
FPlatformAtomics::InterlockedIncrement(&Stats->TotalBindCount);
FPlatformAtomics::InterlockedCompareExchange(&Stats->FirstFrameUsed, GFrameCounter, -1);
}
}
struct FPipelineCacheFileFormatHeader
{
uint64 Magic; // Sanity check
uint32 Version; // File version must match engine version, otherwise we ignore
uint32 GameVersion; // Same as above but game specific code can invalidate
TEnumAsByte<EShaderPlatform> Platform; // The shader platform for all referenced PSOs.
FGuid Guid; // Guid to identify the file uniquely
uint64 TableOffset; // absolute file offset to TOC
int64 LastGCUnixTime; // Last time that the cache was scanned to remove out of date elements.
friend FArchive& operator<<(FArchive& Ar, FPipelineCacheFileFormatHeader& Info)
{
Ar << Info.Magic;
Ar << Info.Version;
Ar << Info.GameVersion;
Ar << Info.Platform;
Ar << Info.Guid;
Ar << Info.TableOffset;
if (Info.Version >= (uint32)EPipelineCacheFileFormatVersions::LastUsedTime)
{
Ar << Info.LastGCUnixTime;
}
return Ar;
}
};
FArchive& operator<<( FArchive& Ar, FPipelineStateStats& Info )
{
Ar << Info.FirstFrameUsed;
Ar << Info.LastFrameUsed;
Ar << Info.CreateCount;
Ar << Info.TotalBindCount;
Ar << Info.PSOHash;
return Ar;
}
/**
* PipelineFileCache MetaData Engine Flags
**/
const uint16 FPipelineCacheFlagInvalidPSO = 1 << 0;
struct FPipelineCacheFileFormatPSOMetaData
{
FPipelineCacheFileFormatPSOMetaData()
: FileOffset(0)
, UsageMask(0)
, LastUsedUnixTime(0)
, EngineFlags(0)
{
}
~FPipelineCacheFileFormatPSOMetaData()
{
}
uint64 FileOffset;
uint64 FileSize;
FGuid FileGuid;
FPipelineStateStats Stats;
TSet<FSHAHash> Shaders;
uint64 UsageMask;
int64 LastUsedUnixTime;
uint16 EngineFlags;
void AddShaders(const FPipelineCacheFileFormatPSO& NewEntry)
{
switch (NewEntry.Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
INC_DWORD_STAT(STAT_SerializedComputePipelineStateCount);
Shaders.Add(NewEntry.ComputeDesc.ComputeShader);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
INC_DWORD_STAT(STAT_SerializedGraphicsPipelineStateCount);
if (NewEntry.GraphicsDesc.VertexShader != FSHAHash())
Shaders.Add(NewEntry.GraphicsDesc.VertexShader);
if (NewEntry.GraphicsDesc.FragmentShader != FSHAHash())
Shaders.Add(NewEntry.GraphicsDesc.FragmentShader);
if (NewEntry.GraphicsDesc.GeometryShader != FSHAHash())
Shaders.Add(NewEntry.GraphicsDesc.GeometryShader);
if (NewEntry.GraphicsDesc.MeshShader != FSHAHash())
Shaders.Add(NewEntry.GraphicsDesc.MeshShader);
if (NewEntry.GraphicsDesc.AmplificationShader != FSHAHash())
Shaders.Add(NewEntry.GraphicsDesc.AmplificationShader);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
INC_DWORD_STAT(STAT_SerializedRayTracingPipelineStateCount);
Shaders.Add(NewEntry.RayTracingDesc.ShaderHash);
break;
}
default:
{
check(false);
break;
}
}
}
friend FArchive& operator<<(FArchive& Ar, FPipelineCacheFileFormatPSOMetaData& Info)
{
Ar << Info.FileOffset;
Ar << Info.FileSize;
// if FileGuid is zeroed out (a frequent case), don't write all 16 bytes of it
uint8 ArchiveFullGuid = 1;
if (Ar.GameNetVer() == (uint32)EPipelineCacheFileFormatVersions::PatchSizeReduction_NoDuplicatedGuid)
{
if (Ar.IsSaving())
{
ArchiveFullGuid = (Info.FileGuid != FGuid()) ? 1 : 0;
}
Ar << ArchiveFullGuid;
}
if (ArchiveFullGuid != 0)
{
Ar << Info.FileGuid;
}
Ar << Info.Stats;
if (Ar.GameNetVer() == (uint32)EPipelineCacheFileFormatVersions::LibraryID)
{
TSet<uint32> IDs;
Ar << IDs;
}
else if (Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::ShaderMetaData)
{
Ar << Info.Shaders;
}
if(Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::PSOUsageMask)
{
Ar << Info.UsageMask;
}
if(Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::EngineFlags)
{
Ar << Info.EngineFlags;
}
if (Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::LastUsedTime)
{
Ar << Info.LastUsedUnixTime;
}
return Ar;
}
};
RHI_API FArchive& operator<<(FArchive& Ar, FPipelineFileCacheRasterizerState& RasterizerStateInitializer)
{
Ar << RasterizerStateInitializer.DepthBias;
Ar << RasterizerStateInitializer.SlopeScaleDepthBias;
Ar << RasterizerStateInitializer.FillMode;
Ar << RasterizerStateInitializer.CullMode;
Ar << RasterizerStateInitializer.DepthClipMode;
Ar << RasterizerStateInitializer.bAllowMSAA;
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::RemovingLineAA)
{
bool bEnableLineAA = false;
Ar << bEnableLineAA;
}
return Ar;
}
FString FPipelineFileCacheRasterizerState::ToString() const
{
return FString::Printf(TEXT("<%f %f %u %u %u %u>")
, DepthBias
, SlopeScaleDepthBias
, uint32(FillMode)
, uint32(CullMode)
, uint32(DepthClipMode)
, uint32(!!bAllowMSAA)
);
}
void FPipelineFileCacheRasterizerState::FromString(const FStringView& Src)
{
constexpr int32 PartCount = 6;
TArray<FStringView, TInlineAllocator<PartCount>> Parts;
UE::String::ParseTokensMultiple(Src.TrimStartAndEnd(), {TEXT('\r'), TEXT('\n'), TEXT('\t'), TEXT('<'), TEXT('>'), TEXT(' ')},
[&Parts](FStringView Part) { if (!Part.IsEmpty()) { Parts.Add(Part); } });
check(Parts.Num() == PartCount && sizeof(FillMode) == 1 && sizeof(CullMode) == 1 && sizeof(DepthClipMode) == 1 && sizeof(bAllowMSAA) == 1); //not a very robust parser
const FStringView* PartIt = Parts.GetData();
LexFromString(DepthBias, *PartIt++);
LexFromString(SlopeScaleDepthBias, *PartIt++);
LexFromString((uint8&)FillMode, *PartIt++);
LexFromString((uint8&)CullMode, *PartIt++);
LexFromString((uint8&)DepthClipMode, *PartIt++);
LexFromString((uint8&)bAllowMSAA, *PartIt++);
check(Parts.GetData() + PartCount == PartIt);
}
FString FPipelineCacheFileFormatPSO::ComputeDescriptor::ToString() const
{
return ComputeShader.ToString();
}
void FPipelineCacheFileFormatPSO::ComputeDescriptor::AddToReadableString(TReadableStringBuilder& OutBuilder) const
{
OutBuilder << TEXT(" CS:");
OutBuilder << ComputeShader.ToString();
}
void FPipelineCacheFileFormatPSO::ComputeDescriptor::FromString(const FStringView& Src)
{
ComputeShader.FromString(Src.TrimStartAndEnd());
}
FString FPipelineCacheFileFormatPSO::ComputeDescriptor::HeaderLine()
{
return FString(TEXT("ComputeShader"));
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::ShadersToString() const
{
FString Result;
Result += FString::Printf(TEXT("%s,%s,%s,%s,%s")
, *VertexShader.ToString()
, *FragmentShader.ToString()
, *GeometryShader.ToString()
, *MeshShader.ToString()
, *AmplificationShader.ToString()
);
return Result;
}
void FPipelineCacheFileFormatPSO::GraphicsDescriptor::AddShadersToReadableString(TReadableStringBuilder& OutBuilder) const
{
if (VertexShader != FSHAHash())
{
OutBuilder << TEXT(" VS:");
OutBuilder << VertexShader;
}
if (MeshShader != FSHAHash())
{
OutBuilder << TEXT(" MS:");
OutBuilder << MeshShader;
}
if (GeometryShader != FSHAHash())
{
OutBuilder << TEXT(" GS:");
OutBuilder << GeometryShader;
}
if (AmplificationShader != FSHAHash())
{
OutBuilder << TEXT(" AS:");
OutBuilder << AmplificationShader;
}
if (FragmentShader != FSHAHash())
{
OutBuilder << TEXT(" PS:");
OutBuilder << FragmentShader;
}
}
void FPipelineCacheFileFormatPSO::GraphicsDescriptor::ShadersFromString(const FStringView& Src)
{
constexpr int32 PartCount = 5;
TArray<FStringView, TInlineAllocator<PartCount>> Parts;
UE::String::ParseTokens(Src.TrimStartAndEnd(), TEXT(','), [&Parts](FStringView Part) { Parts.Add(Part); });
check(Parts.Num() == PartCount); //not a very robust parser
const FStringView* PartIt = Parts.GetData();
VertexShader.FromString(*PartIt++);
FragmentShader.FromString(*PartIt++);
GeometryShader.FromString(*PartIt++);
MeshShader.FromString(*PartIt++);
AmplificationShader.FromString(*PartIt++);
check(Parts.GetData() + PartCount == PartIt);
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::ShaderHeaderLine()
{
return FString(TEXT("VertexShader,FragmentShader,GeometryShader,MeshShader,AmplificationShader"));
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::StateToString() const
{
FString Result;
Result += FString::Printf(TEXT("%s,%s,%s,")
, *BlendState.ToString()
, *RasterizerState.ToString()
, *DepthStencilState.ToString()
);
Result += FString::Printf(TEXT("%d,%d,%lld,")
, MSAASamples
, uint32(DepthStencilFormat)
, DepthStencilFlags
);
Result += FString::Printf(TEXT("%d,%d,%d,%d,%d,")
, uint32(DepthLoad)
, uint32(StencilLoad)
, uint32(DepthStore)
, uint32(StencilStore)
, uint32(PrimitiveType)
);
Result += FString::Printf(TEXT("%d,")
, RenderTargetsActive
);
for (int32 Index = 0; Index < MaxSimultaneousRenderTargets; Index++)
{
Result += FString::Printf(TEXT("%d,%lld,%d,%d,")
, uint32(RenderTargetFormats[Index])
, RenderTargetFlags[Index]
, 0/*Load*/
, 0/*Store*/
);
}
Result += FString::Printf(TEXT("%d,%d,")
, uint32(SubpassHint)
, uint32(SubpassIndex)
);
Result += FString::Printf(TEXT("%d,%d,")
, uint32(MultiViewCount)
, uint32(bHasFragmentDensityAttachment)
);
Result += FString::Printf(TEXT("%d,")
, uint32(bDepthBounds)
);
FVertexElement NullVE;
FMemory::Memzero(NullVE);
Result += FString::Printf(TEXT("%d,")
, VertexDescriptor.Num()
);
for (int32 Index = 0; Index < MaxVertexElementCount; Index++)
{
if (Index < VertexDescriptor.Num())
{
Result += FString::Printf(TEXT("%s,")
, *VertexDescriptor[Index].ToString()
);
}
else
{
Result += FString::Printf(TEXT("%s,")
, *NullVE.ToString()
);
}
}
return Result.Left(Result.Len() - 1); // remove trailing comma
}
void FPipelineCacheFileFormatPSO::GraphicsDescriptor::AddStateToReadableString(TReadableStringBuilder& OutBuilder) const
{
OutBuilder << TEXT(" BS:");
OutBuilder << BlendState.ToString();
OutBuilder << TEXT(" RS:");
OutBuilder << RasterizerState.ToString();
OutBuilder << TEXT(" DSS:");
OutBuilder << DepthStencilState.ToString();
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" NumMSAA:");
OutBuilder << MSAASamples;
OutBuilder << TEXT(" DSfmt:");
OutBuilder << uint32(DepthStencilFormat);
OutBuilder << TEXT(" DSflags:");
OutBuilder << uint64(DepthStencilFlags);
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" DL:");
OutBuilder << uint32(DepthLoad);
OutBuilder << TEXT(" SL:");
OutBuilder << uint32(StencilLoad);
OutBuilder << TEXT(" DS:");
OutBuilder << uint32(DepthStore);
OutBuilder << TEXT(" SS:");
OutBuilder << uint32(StencilStore);
OutBuilder << TEXT(" PT:");
OutBuilder << uint32(PrimitiveType);
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" RTA ");
OutBuilder << RenderTargetsActive;
OutBuilder << TEXT("\n");
if (RenderTargetsActive)
{
OutBuilder << TEXT(" ");
for (uint32 Index = 0; Index < RenderTargetsActive; Index++)
{
OutBuilder << TEXT(" RT");
OutBuilder << Index,
OutBuilder << TEXT(":fmt=");
OutBuilder << uint32(RenderTargetFormats[Index]);
OutBuilder << TEXT(" flg=");
OutBuilder << uint64(RenderTargetFlags[Index]);
}
OutBuilder << TEXT("\n");
}
OutBuilder << TEXT(" SuH:");
OutBuilder << uint32(SubpassHint);
OutBuilder << TEXT(" SuI:");
OutBuilder << uint32(SubpassIndex);
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" MVC:");
OutBuilder << MultiViewCount;
OutBuilder << TEXT(" HasFDM:");
OutBuilder << bHasFragmentDensityAttachment;
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" DB:");
OutBuilder << bDepthBounds;
OutBuilder << TEXT("\n");
OutBuilder << TEXT(" NumVE ");
OutBuilder << VertexDescriptor.Num();
OutBuilder << TEXT("\n");
for (int32 Index = 0; Index < VertexDescriptor.Num(); Index++)
{
OutBuilder << TEXT(" ");
OutBuilder << Index;
OutBuilder << TEXT(":");
OutBuilder << VertexDescriptor[Index].ToString();
}
}
bool FPipelineCacheFileFormatPSO::GraphicsDescriptor::StateFromString(const FStringView& Src)
{
static_assert(sizeof(EPixelFormat) == 1);
static_assert(sizeof(ERenderTargetLoadAction) == 1);
static_assert(sizeof(ERenderTargetStoreAction) == 1);
static_assert(sizeof(DepthLoad) == 1);
static_assert(sizeof(DepthStore) == 1);
static_assert(sizeof(StencilLoad) == 1);
static_assert(sizeof(StencilStore) == 1);
static_assert(sizeof(PrimitiveType) == 4);
constexpr int32 PartCount = FPipelineCacheGraphicsDescPartsNum;
TArray<FStringView, TInlineAllocator<PartCount>> Parts;
UE::String::ParseTokens(Src.TrimStartAndEnd(), TEXT(','), [&Parts](FStringView Part) { Parts.Add(Part); });
// check if we have expected number of parts
if (Parts.Num() != PartCount)
{
// instead of crashing let caller handle this case
return false;
}
const FStringView* PartIt = Parts.GetData();
const FStringView* PartEnd = PartIt + PartCount;
check(PartEnd - PartIt >= 3); //not a very robust parser
BlendState.FromString(*PartIt++);
RasterizerState.FromString(*PartIt++);
DepthStencilState.FromString(*PartIt++);
check(PartEnd - PartIt >= 3); //not a very robust parser
LexFromString(MSAASamples, *PartIt++);
LexFromString((uint32&)DepthStencilFormat, *PartIt++);
ETextureCreateFlags DSFlags;
LexFromString(DSFlags, *PartIt++);
DepthStencilFlags = ReduceDSFlags(DSFlags);
check(PartEnd - PartIt >= 5); //not a very robust parser
LexFromString((uint32&)DepthLoad, *PartIt++);
LexFromString((uint32&)StencilLoad, *PartIt++);
LexFromString((uint32&)DepthStore, *PartIt++);
LexFromString((uint32&)StencilStore, *PartIt++);
LexFromString((uint32&)PrimitiveType, *PartIt++);
check(PartEnd - PartIt >= 1); //not a very robust parser
LexFromString(RenderTargetsActive, *PartIt++);
for (int32 Index = 0; Index < MaxSimultaneousRenderTargets; Index++)
{
check(PartEnd - PartIt >= 4); //not a very robust parser
LexFromString((uint8&)(RenderTargetFormats[Index]), *PartIt++);
ETextureCreateFlags RTFlags;
LexFromString(RTFlags, *PartIt++);
// going forward, the flags will already be reduced when logging the PSOs to disk. However as of 2021-06-17 there are still old stable cache files in existence that have flags recorded as is
RenderTargetFlags[Index] = ReduceRTFlags(RTFlags);
uint8 Load, Store;
LexFromString(Load, *PartIt++);
LexFromString(Store, *PartIt++);
}
// parse sub-pass information
{
uint32 LocalSubpassHint = 0;
uint32 LocalSubpassIndex = 0;
check(PartEnd - PartIt >= 2);
LexFromString(LocalSubpassHint, *PartIt++);
LexFromString(LocalSubpassIndex, *PartIt++);
SubpassHint = LocalSubpassHint;
SubpassIndex = LocalSubpassIndex;
}
// parse multiview and FDM information
{
uint32 LocalMultiViewCount = 0;
uint32 LocalHasFDM = 0;
check(PartEnd - PartIt >= 2);
LexFromString(LocalMultiViewCount, *PartIt++);
LexFromString(LocalHasFDM, *PartIt++);
MultiViewCount = (uint8)LocalMultiViewCount;
bHasFragmentDensityAttachment = (bool)LocalHasFDM;
}
// parse depth bounds
{
uint32 DepthBounds = 0;
check(PartEnd - PartIt >= 1);
LexFromString(DepthBounds, *PartIt++);
bDepthBounds = (bool)DepthBounds;
}
check(PartEnd - PartIt >= 1); //not a very robust parser
int32 VertDescNum = 0;
LexFromString(VertDescNum, *PartIt++);
check(VertDescNum >= 0 && VertDescNum <= MaxVertexElementCount);
VertexDescriptor.Empty(VertDescNum);
VertexDescriptor.AddZeroed(VertDescNum);
check(PartEnd - PartIt == MaxVertexElementCount); //not a very robust parser
for (int32 Index = 0; Index < VertDescNum; Index++)
{
VertexDescriptor[Index].FromString(*PartIt++);
}
check(PartIt + MaxVertexElementCount == PartEnd + VertDescNum);
VertexDescriptor.Sort([](FVertexElement const& A, FVertexElement const& B)
{
if (A.StreamIndex < B.StreamIndex)
{
return true;
}
if (A.StreamIndex > B.StreamIndex)
{
return false;
}
if (A.Offset < B.Offset)
{
return true;
}
if (A.Offset > B.Offset)
{
return false;
}
if (A.AttributeIndex < B.AttributeIndex)
{
return true;
}
if (A.AttributeIndex > B.AttributeIndex)
{
return false;
}
return false;
});
return true;
}
ETextureCreateFlags FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceRTFlags(ETextureCreateFlags InFlags)
{
// We care about flags that influence RT formats (which is the only thing the underlying API cares about).
// In most RHIs, the format is only influenced by TexCreate_SRGB. D3D12 additionally uses TexCreate_Shared in its format selection logic.
return (InFlags & FGraphicsPipelineStateInitializer::RelevantRenderTargetFlagMask);
}
ETextureCreateFlags FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceDSFlags(ETextureCreateFlags InFlags)
{
return (InFlags & FGraphicsPipelineStateInitializer::RelevantDepthStencilFlagMask);
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::StateHeaderLine()
{
FString Result;
Result += FString::Printf(TEXT("%s,%s,%s,")
, TEXT("BlendState")
, TEXT("RasterizerState")
, TEXT("DepthStencilState")
);
Result += FString::Printf(TEXT("%s,%s,%s,")
, TEXT("MSAASamples")
, TEXT("DepthStencilFormat")
, TEXT("DepthStencilFlags")
);
Result += FString::Printf(TEXT("%s,%s,%s,%s,%s,")
, TEXT("DepthLoad")
, TEXT("StencilLoad")
, TEXT("DepthStore")
, TEXT("StencilStore")
, TEXT("PrimitiveType")
);
Result += FString::Printf(TEXT("%s,")
, TEXT("RenderTargetsActive")
);
for (int32 Index = 0; Index < MaxSimultaneousRenderTargets; Index++)
{
Result += FString::Printf(TEXT("%s%d,%s%d,%s%d,%s%d,")
, TEXT("RenderTargetFormats"), Index
, TEXT("RenderTargetFlags"), Index
, TEXT("RenderTargetsLoad"), Index
, TEXT("RenderTargetsStore"), Index
);
}
Result += FString::Printf(TEXT("%s,%s,")
, TEXT("SubpassHint")
, TEXT("SubpassIndex")
);
Result += FString::Printf(TEXT("%s,%s,")
, TEXT("MultiViewCount")
, TEXT("bHasFDMAttachment")
);
Result += FString::Printf(TEXT("%s,")
, TEXT("VertexDescriptorNum")
);
for (int32 Index = 0; Index < MaxVertexElementCount; Index++)
{
Result += FString::Printf(TEXT("%s%d,")
, TEXT("VertexDescriptor"), Index
);
}
return Result.Left(Result.Len() - 1); // remove trailing comma
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::ToString() const
{
return FString::Printf(TEXT("%s,%s"), *ShadersToString(), *StateToString());
}
void FPipelineCacheFileFormatPSO::GraphicsDescriptor::AddToReadableString(TReadableStringBuilder& OutBuilder) const
{
AddShadersToReadableString(OutBuilder);
OutBuilder << TEXT("\n");
AddStateToReadableString(OutBuilder);
OutBuilder << TEXT("\n");
}
bool FPipelineCacheFileFormatPSO::GraphicsDescriptor::FromString(const FStringView& Src)
{
constexpr int32 NumShaderParts = 5;
int32 StateOffset = 0;
for (int32 CommaCount = 0; CommaCount < NumShaderParts; ++CommaCount)
{
int32 CommaOffset = 0;
bool FoundComma = Src.RightChop(StateOffset).FindChar(TEXT(','), CommaOffset);
check(FoundComma);
StateOffset += CommaOffset + 1;
}
ShadersFromString(Src.Left(StateOffset - 1));
return StateFromString(Src.RightChop(StateOffset));
}
FString FPipelineCacheFileFormatPSO::GraphicsDescriptor::HeaderLine()
{
return FString::Printf(TEXT("%s,%s"), *ShaderHeaderLine(), *StateHeaderLine());
}
FString FPipelineCacheFileFormatPSO::CommonHeaderLine()
{
return TEXT("BindCount,UsageMask");
}
FString FPipelineCacheFileFormatPSO::CommonToString() const
{
uint64 Mask = 0;
int64 Count = 0;
#if PSO_COOKONLY_DATA
Mask = UsageMask;
Count = BindCount;
#endif
return FString::Printf(TEXT("\"%" INT64_FMT ",%" UINT64_FMT "\""), Count, Mask);
}
FString FPipelineCacheFileFormatPSO::ToStringReadable() const
{
TReadableStringBuilder Builder;
Builder << TEXT("PSO hash ");
Builder << GetTypeHash(*this);
#if PSO_COOKONLY_DATA
Builder << TEXT(" mask ");
Builder << UsageMask;
Builder << TEXT(" bindc ");
Builder << BindCount;
#endif
Builder << TEXT("\n");
if (Type == DescriptorType::Graphics)
{
GraphicsDesc.AddToReadableString(Builder);
}
else if (Type == DescriptorType::Compute)
{
ComputeDesc.AddToReadableString(Builder);
}
else if (Type == DescriptorType::RayTracing)
{
RayTracingDesc.AddToReadableString(Builder);
}
else
{
Builder << TEXT(" Unknown PSO type ");
Builder << static_cast<int32>(Type);
}
return FString(FStringView(Builder));
}
void FPipelineCacheFileFormatPSO::CommonFromString(const FStringView& Src)
{
#if PSO_COOKONLY_DATA
TArray<FStringView, TInlineAllocator<2>> Parts;
UE::String::ParseTokens(Src.TrimStartAndEnd(), TEXT(','), [&Parts](FStringView Part) { Parts.Add(Part); });
if (Parts.Num() == 1)
{
LexFromString(UsageMask, Parts[0]);
}
else if(Parts.Num() > 1)
{
LexFromString(BindCount, Parts[0]);
LexFromString(UsageMask, Parts[1]);
}
#endif
}
bool FPipelineCacheFileFormatPSO::Verify() const
{
if(Type == DescriptorType::Compute)
{
return ComputeDesc.ComputeShader != FSHAHash();
}
else if(Type == DescriptorType::Graphics)
{
if (GraphicsDesc.VertexShader == FSHAHash() && GraphicsDesc.MeshShader == FSHAHash())
{
// No vertex or mesh shader - no graphics - nothing else matters
return false;
}
#if PLATFORM_SUPPORTS_MESH_SHADERS
if (GraphicsDesc.MeshShader != FSHAHash())
{
// this check is also done in commandlets, which don't set RHI settings properly. Exempt them.
if (!IsRunningCommandlet() && !GRHISupportsMeshShadersTier0)
{
// do not allow precompilation of mesh shaders if runtime doesn't support them
return false;
}
if (GraphicsDesc.VertexShader != FSHAHash())
{
// Vertex shader and mesh shader are mutually exclusive
return false;
}
if (GraphicsDesc.VertexDescriptor.Num() > 0)
{
// mesh shader should not have descriptors
return false;
}
}
#endif
#if PLATFORM_SUPPORTS_GEOMETRY_SHADERS
// Is there anything to actually test here?
#endif
if( GraphicsDesc.RenderTargetsActive > MaxSimultaneousRenderTargets ||
GraphicsDesc.MSAASamples > 16 ||
(uint32)GraphicsDesc.PrimitiveType >= (uint32)EPrimitiveType::PT_Num ||
(uint32)GraphicsDesc.DepthStencilFormat >= (uint32)EPixelFormat::PF_MAX ||
(uint8)GraphicsDesc.DepthLoad >= (uint8)ERenderTargetLoadAction::Num ||
(uint8)GraphicsDesc.StencilLoad >= (uint8)ERenderTargetLoadAction::Num ||
(uint8)GraphicsDesc.DepthStore >= (uint8)ERenderTargetStoreAction::Num ||
(uint8)GraphicsDesc.StencilStore >= (uint8)ERenderTargetStoreAction::Num )
{
return false;
}
for(uint32 rt = 0;rt < GraphicsDesc.RenderTargetsActive;++rt)
{
if((uint32)GraphicsDesc.RenderTargetFormats[rt] >= (uint32)EPixelFormat::PF_MAX)
{
return false;
}
if( GraphicsDesc.BlendState.RenderTargets[rt].ColorBlendOp >= EBlendOperation::EBlendOperation_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].AlphaBlendOp >= EBlendOperation::EBlendOperation_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].ColorSrcBlend >= EBlendFactor::EBlendFactor_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].ColorDestBlend >= EBlendFactor::EBlendFactor_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].AlphaSrcBlend >= EBlendFactor::EBlendFactor_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].AlphaDestBlend >= EBlendFactor::EBlendFactor_Num ||
GraphicsDesc.BlendState.RenderTargets[rt].ColorWriteMask > 0xf)
{
return false;
}
}
if( (uint8)GraphicsDesc.RasterizerState.FillMode >= (uint8)ERasterizerFillMode::ERasterizerFillMode_Num ||
(uint8)GraphicsDesc.RasterizerState.CullMode >= (uint8)ERasterizerCullMode_Num)
{
return false;
}
if( (uint8)GraphicsDesc.DepthStencilState.DepthTest >= (uint8)ECompareFunction::ECompareFunction_Num ||
(uint8)GraphicsDesc.DepthStencilState.FrontFaceStencilTest >= (uint8)ECompareFunction::ECompareFunction_Num ||
(uint8)GraphicsDesc.DepthStencilState.BackFaceStencilTest >= (uint8)ECompareFunction::ECompareFunction_Num ||
(uint8)GraphicsDesc.DepthStencilState.FrontFaceStencilFailStencilOp >= (uint8)EStencilOp::EStencilOp_Num ||
(uint8)GraphicsDesc.DepthStencilState.FrontFaceDepthFailStencilOp >= (uint8)EStencilOp::EStencilOp_Num ||
(uint8)GraphicsDesc.DepthStencilState.FrontFacePassStencilOp >= (uint8)EStencilOp::EStencilOp_Num ||
(uint8)GraphicsDesc.DepthStencilState.BackFaceStencilFailStencilOp >= (uint8)EStencilOp::EStencilOp_Num ||
(uint8)GraphicsDesc.DepthStencilState.BackFaceDepthFailStencilOp >= (uint8)EStencilOp::EStencilOp_Num ||
(uint8)GraphicsDesc.DepthStencilState.BackFacePassStencilOp >= (uint8)EStencilOp::EStencilOp_Num)
{
return false;
}
uint32 ElementCount = (uint32)GraphicsDesc.VertexDescriptor.Num();
for (uint32 i = 0; i < ElementCount;++i)
{
if(GraphicsDesc.VertexDescriptor[i].Type >= EVertexElementType::VET_MAX)
{
return false;
}
}
return true;
}
else if (Type == DescriptorType::RayTracing)
{
return RayTracingDesc.ShaderHash != FSHAHash() &&
RayTracingDesc.Frequency >= SF_RayGen &&
RayTracingDesc.Frequency <= SF_RayCallable;
}
else
{
checkNoEntry();
}
return false;
}
/**
* FPipelineCacheFileFormatPSO
**/
/*friend*/ uint32 GetTypeHash(const FPipelineCacheFileFormatPSO &Key)
{
uint32 KeyHash = GetTypeHash(Key.Type);
switch(Key.Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
KeyHash ^= GetTypeHash(Key.ComputeDesc.ComputeShader);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RenderTargetsActive, sizeof(Key.GraphicsDesc.RenderTargetsActive), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.MSAASamples, sizeof(Key.GraphicsDesc.MSAASamples), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.PrimitiveType, sizeof(Key.GraphicsDesc.PrimitiveType), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.VertexShader.Hash, sizeof(Key.GraphicsDesc.VertexShader.Hash), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.FragmentShader.Hash, sizeof(Key.GraphicsDesc.FragmentShader.Hash), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.GeometryShader.Hash, sizeof(Key.GraphicsDesc.GeometryShader.Hash), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.MeshShader.Hash, sizeof(Key.GraphicsDesc.MeshShader.Hash), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.AmplificationShader.Hash, sizeof(Key.GraphicsDesc.AmplificationShader.Hash), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilFormat, sizeof(Key.GraphicsDesc.DepthStencilFormat), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilFlags, sizeof(Key.GraphicsDesc.DepthStencilFlags), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthLoad, sizeof(Key.GraphicsDesc.DepthLoad), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.StencilLoad, sizeof(Key.GraphicsDesc.StencilLoad), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStore, sizeof(Key.GraphicsDesc.DepthStore), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.StencilStore, sizeof(Key.GraphicsDesc.StencilStore), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.bUseIndependentRenderTargetBlendStates, sizeof(Key.GraphicsDesc.BlendState.bUseIndependentRenderTargetBlendStates), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.bUseAlphaToCoverage, sizeof(Key.GraphicsDesc.BlendState.bUseAlphaToCoverage), KeyHash);
for( uint32 i = 0; i < MaxSimultaneousRenderTargets; i++ )
{
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].ColorBlendOp, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].ColorBlendOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].ColorSrcBlend, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].ColorSrcBlend), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].ColorDestBlend, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].ColorDestBlend), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].ColorWriteMask, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].ColorWriteMask), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaBlendOp, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaBlendOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaSrcBlend, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaSrcBlend), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaDestBlend, sizeof(Key.GraphicsDesc.BlendState.RenderTargets[i].AlphaDestBlend), KeyHash);
}
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RenderTargetFormats, sizeof(Key.GraphicsDesc.RenderTargetFormats), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RenderTargetFlags, sizeof(Key.GraphicsDesc.RenderTargetFlags), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.SubpassHint, sizeof(Key.GraphicsDesc.SubpassHint), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.SubpassIndex, sizeof(Key.GraphicsDesc.SubpassIndex), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.MultiViewCount, sizeof(Key.GraphicsDesc.MultiViewCount), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.bHasFragmentDensityAttachment, sizeof(Key.GraphicsDesc.bHasFragmentDensityAttachment), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.bDepthBounds, sizeof(Key.GraphicsDesc.bDepthBounds), KeyHash);
for(auto const& Element : Key.GraphicsDesc.VertexDescriptor)
{
KeyHash = FCrc::MemCrc32(&Element, sizeof(FVertexElement), KeyHash);
}
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RasterizerState.DepthBias, sizeof(Key.GraphicsDesc.RasterizerState.DepthBias), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RasterizerState.SlopeScaleDepthBias, sizeof(Key.GraphicsDesc.RasterizerState.SlopeScaleDepthBias), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RasterizerState.FillMode, sizeof(Key.GraphicsDesc.RasterizerState.FillMode), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RasterizerState.CullMode, sizeof(Key.GraphicsDesc.RasterizerState.CullMode), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.RasterizerState.bAllowMSAA, sizeof(Key.GraphicsDesc.RasterizerState.bAllowMSAA), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.bEnableDepthWrite, sizeof(Key.GraphicsDesc.DepthStencilState.bEnableDepthWrite), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.DepthTest, sizeof(Key.GraphicsDesc.DepthStencilState.DepthTest), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.bEnableFrontFaceStencil, sizeof(Key.GraphicsDesc.DepthStencilState.bEnableFrontFaceStencil), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.FrontFaceStencilTest, sizeof(Key.GraphicsDesc.DepthStencilState.FrontFaceStencilTest), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.FrontFaceStencilFailStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.FrontFaceStencilFailStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.FrontFaceDepthFailStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.FrontFaceDepthFailStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.FrontFacePassStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.FrontFacePassStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.bEnableBackFaceStencil, sizeof(Key.GraphicsDesc.DepthStencilState.bEnableBackFaceStencil), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.BackFaceStencilTest, sizeof(Key.GraphicsDesc.DepthStencilState.BackFaceStencilTest), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.BackFaceStencilFailStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.BackFaceStencilFailStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.BackFaceDepthFailStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.BackFaceDepthFailStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.BackFacePassStencilOp, sizeof(Key.GraphicsDesc.DepthStencilState.BackFacePassStencilOp), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.StencilReadMask, sizeof(Key.GraphicsDesc.DepthStencilState.StencilReadMask), KeyHash);
KeyHash = FCrc::MemCrc32(&Key.GraphicsDesc.DepthStencilState.StencilWriteMask, sizeof(Key.GraphicsDesc.DepthStencilState.StencilWriteMask), KeyHash);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
KeyHash ^= GetTypeHash(Key.RayTracingDesc);
break;
}
default:
{
checkNoEntry();
}
}
return KeyHash;
}
/*friend*/ FArchive& operator<<( FArchive& Ar, FPipelineCacheFileFormatPSO& Info )
{
Ar << Info.Type;
#if PSO_COOKONLY_DATA
/* Ignore: Ar << Info.UsageMask; during serialization */
/* Ignore: Ar << Info.BindCoun during serialization*/
#endif
switch (Info.Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
Ar << Info.ComputeDesc.ComputeShader;
if (Ar.GameNetVer() == (uint32)EPipelineCacheFileFormatVersions::LibraryID)
{
uint32 ID = 0;
Ar << ID;
}
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
Ar << Info.GraphicsDesc.VertexShader;
Ar << Info.GraphicsDesc.FragmentShader;
Ar << Info.GraphicsDesc.GeometryShader;
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::RemovingTessellationShaders)
{
FSHAHash HullShader;
Ar << HullShader;
FSHAHash DomainShader;
Ar << DomainShader;
}
if (Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::AddingMeshShaders)
{
Ar << Info.GraphicsDesc.MeshShader;
Ar << Info.GraphicsDesc.AmplificationShader;
}
if (Ar.GameNetVer() == (uint32)EPipelineCacheFileFormatVersions::LibraryID)
{
for (uint32 i = 0; i < SF_Compute; i++)
{
uint32 ID = 0;
Ar << ID;
}
}
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::SortedVertexDesc)
{
check(Ar.IsLoading());
FVertexDeclarationElementList Elements;
Ar << Elements;
Elements.Sort([](FVertexElement const& A, FVertexElement const& B)
{
if (A.StreamIndex < B.StreamIndex)
{
return true;
}
if (A.StreamIndex > B.StreamIndex)
{
return false;
}
if (A.Offset < B.Offset)
{
return true;
}
if (A.Offset > B.Offset)
{
return false;
}
if (A.AttributeIndex < B.AttributeIndex)
{
return true;
}
if (A.AttributeIndex > B.AttributeIndex)
{
return false;
}
return false;
});
Info.GraphicsDesc.VertexDescriptor.AddZeroed(Elements.Num());
for (uint32 i = 0; i < (uint32)Elements.Num(); i++)
{
Info.GraphicsDesc.VertexDescriptor[i].StreamIndex = Elements[i].StreamIndex;
Info.GraphicsDesc.VertexDescriptor[i].Offset = Elements[i].Offset;
Info.GraphicsDesc.VertexDescriptor[i].Type = Elements[i].Type;
Info.GraphicsDesc.VertexDescriptor[i].AttributeIndex = Elements[i].AttributeIndex;
Info.GraphicsDesc.VertexDescriptor[i].Stride = Elements[i].Stride;
Info.GraphicsDesc.VertexDescriptor[i].bUseInstanceIndex = Elements[i].bUseInstanceIndex;
}
}
else
{
Ar << Info.GraphicsDesc.VertexDescriptor;
}
Ar << Info.GraphicsDesc.BlendState;
Ar << Info.GraphicsDesc.RasterizerState;
Ar << Info.GraphicsDesc.DepthStencilState;
for ( uint32 i = 0; i < MaxSimultaneousRenderTargets; i++ )
{
uint32 Format = (uint32)Info.GraphicsDesc.RenderTargetFormats[i];
Ar << Format;
Info.GraphicsDesc.RenderTargetFormats[i] = (EPixelFormat)Format;
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::MoreRenderTargetFlags)
{
uint32 RTFlags = 0;
Ar << RTFlags;
// going forward, the flags will already be reduced when logging the PSOs to disk. However as of 2021-06-17 there still exist cache files (e.g. user ones) that have flags recorded as is
Info.GraphicsDesc.RenderTargetFlags[i] = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceRTFlags(static_cast<ETextureCreateFlags>(RTFlags));
}
else
{
static_assert(sizeof(uint64) == sizeof(Info.GraphicsDesc.RenderTargetFlags[i]), "ETextureCreateFlags size changed, please change serialization");
uint64 RTFlags = static_cast<uint64>(FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceRTFlags(Info.GraphicsDesc.RenderTargetFlags[i]));
Ar << RTFlags;
Info.GraphicsDesc.RenderTargetFlags[i] = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceRTFlags(static_cast<ETextureCreateFlags>(RTFlags));
}
uint8 LoadStore = 0;
Ar << LoadStore;
Ar << LoadStore;
}
Ar << Info.GraphicsDesc.RenderTargetsActive;
Ar << Info.GraphicsDesc.MSAASamples;
uint32 PrimType = (uint32)Info.GraphicsDesc.PrimitiveType;
Ar << PrimType;
Info.GraphicsDesc.PrimitiveType = (EPrimitiveType)PrimType;
uint32 Format = (uint32)Info.GraphicsDesc.DepthStencilFormat;
Ar << Format;
Info.GraphicsDesc.DepthStencilFormat = (EPixelFormat)Format;
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::MoreRenderTargetFlags)
{
uint32 DepthStencilFlags = 0;
Ar << DepthStencilFlags;
Info.GraphicsDesc.DepthStencilFlags = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceDSFlags(static_cast<ETextureCreateFlags>(DepthStencilFlags));
}
else
{
static_assert(sizeof(uint64) == sizeof(Info.GraphicsDesc.DepthStencilFlags), "ETextureCreateFlags size changed, please change serialization");
uint64 DepthStencilFlags = static_cast<uint64>(FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceDSFlags(Info.GraphicsDesc.DepthStencilFlags));
Ar << DepthStencilFlags;
Info.GraphicsDesc.DepthStencilFlags = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceDSFlags(static_cast<ETextureCreateFlags>(DepthStencilFlags));
}
Ar << Info.GraphicsDesc.DepthLoad;
Ar << Info.GraphicsDesc.StencilLoad;
Ar << Info.GraphicsDesc.DepthStore;
Ar << Info.GraphicsDesc.StencilStore;
Ar << Info.GraphicsDesc.SubpassHint;
Ar << Info.GraphicsDesc.SubpassIndex;
if (Ar.GameNetVer() < (uint32)EPipelineCacheFileFormatVersions::FragmentDensityAttachment)
{
uint8 MultiViewCount = 0;
Ar << MultiViewCount;
bool bHasFragmentDensityAttachment = false;
Ar << bHasFragmentDensityAttachment;
}
else
{
Ar << Info.GraphicsDesc.MultiViewCount;
Ar << Info.GraphicsDesc.bHasFragmentDensityAttachment;
}
if (Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::AddingDepthBounds)
{
Ar << Info.GraphicsDesc.bDepthBounds;
}
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
Ar << Info.RayTracingDesc.ShaderHash;
// Not used, kept for binary format compatibility
Ar << Info.RayTracingDesc.DeprecatedMaxPayloadSizeInBytes;
uint32 Frequency = uint32(Info.RayTracingDesc.Frequency);
Ar << Frequency;
Info.RayTracingDesc.Frequency = EShaderFrequency(Frequency);
if (Ar.GameNetVer() >= (uint32)EPipelineCacheFileFormatVersions::AddRTPSOShaderBindingLayout)
{
// Serialize RHIShaderBindingLayout
Ar << Info.RayTracingDesc.ShaderBindingLayout;
}
break;
}
default:
{
checkNoEntry();
}
}
return Ar;
}
FPipelineCacheFileFormatPSO::FPipelineCacheFileFormatPSO()
#if PSO_COOKONLY_DATA
: UsageMask(0)
, BindCount(0)
#endif
{
}
/*static*/ bool FPipelineCacheFileFormatPSO::Init(FPipelineCacheFileFormatPSO& PSO, FRHIComputeShader const* Init)
{
check(Init);
PSO.Type = DescriptorType::Compute;
#if PSO_COOKONLY_DATA
PSO.UsageMask = 0;
PSO.BindCount = 0;
#endif
// Because of the cheat in the copy constructor - lets play this safe
FMemory::Memset(&PSO.ComputeDesc, 0, sizeof(ComputeDescriptor));
PSO.ComputeDesc.ComputeShader = Init->GetHash();
bool bOK = true;
#if !UE_BUILD_SHIPPING
bOK = PSO.Verify();
#endif
return bOK;
}
/*static*/ bool FPipelineCacheFileFormatPSO::Init(FPipelineCacheFileFormatPSO& PSO, FGraphicsPipelineStateInitializer const& Init)
{
bool bOK = true;
PSO.Type = DescriptorType::Graphics;
#if PSO_COOKONLY_DATA
PSO.UsageMask = 0;
PSO.BindCount = 0;
#endif
// Because of the cheat in the copy constructor - lets play this safe
FMemory::Memset(&PSO.GraphicsDesc, 0, sizeof(GraphicsDescriptor));
#if PLATFORM_SUPPORTS_MESH_SHADERS
checkf(Init.BoundShaderState.GetVertexShader() || Init.BoundShaderState.GetMeshShader(), TEXT("A graphics pipeline must always have either a vertex or a mesh shader"));
if (Init.BoundShaderState.GetVertexShader())
#else
checkf(Init.BoundShaderState.GetVertexShader(), TEXT("A graphics pipeline must always have a vertex shader"));
#endif
{
check (Init.BoundShaderState.VertexDeclarationRHI);
check (Init.BoundShaderState.VertexDeclarationRHI->IsValid());
{
bOK &= Init.BoundShaderState.VertexDeclarationRHI->GetInitializer(PSO.GraphicsDesc.VertexDescriptor);
check(bOK);
PSO.GraphicsDesc.VertexDescriptor.Sort([](FVertexElement const& A, FVertexElement const& B)
{
if (A.StreamIndex < B.StreamIndex)
{
return true;
}
if (A.StreamIndex > B.StreamIndex)
{
return false;
}
if (A.Offset < B.Offset)
{
return true;
}
if (A.Offset > B.Offset)
{
return false;
}
if (A.AttributeIndex < B.AttributeIndex)
{
return true;
}
if (A.AttributeIndex > B.AttributeIndex)
{
return false;
}
return false;
});
}
PSO.GraphicsDesc.VertexShader = Init.BoundShaderState.VertexShaderRHI->GetHash();
}
if (Init.BoundShaderState.GetMeshShader())
{
PSO.GraphicsDesc.MeshShader = Init.BoundShaderState.GetMeshShader()->GetHash();
}
if (Init.BoundShaderState.GetAmplificationShader())
{
PSO.GraphicsDesc.AmplificationShader = Init.BoundShaderState.GetAmplificationShader()->GetHash();
}
if (Init.BoundShaderState.PixelShaderRHI)
{
PSO.GraphicsDesc.FragmentShader = Init.BoundShaderState.PixelShaderRHI->GetHash();
}
if (Init.BoundShaderState.GetGeometryShader())
{
PSO.GraphicsDesc.GeometryShader = Init.BoundShaderState.GetGeometryShader()->GetHash();
}
check (Init.BlendState);
{
bOK &= Init.BlendState->GetInitializer(PSO.GraphicsDesc.BlendState);
check(bOK);
}
check (Init.RasterizerState);
{
FRasterizerStateInitializerRHI Temp;
bOK &= Init.RasterizerState->GetInitializer(Temp);
check(bOK);
PSO.GraphicsDesc.RasterizerState = Temp;
}
check (Init.DepthStencilState);
{
bOK &= Init.DepthStencilState->GetInitializer(PSO.GraphicsDesc.DepthStencilState);
check(bOK);
}
for (uint32 i = 0; i < MaxSimultaneousRenderTargets; i++)
{
PSO.GraphicsDesc.RenderTargetFormats[i] = (EPixelFormat)Init.RenderTargetFormats[i];
PSO.GraphicsDesc.RenderTargetFlags[i] = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceRTFlags(Init.RenderTargetFlags[i]);
}
PSO.GraphicsDesc.RenderTargetsActive = Init.RenderTargetsEnabled;
PSO.GraphicsDesc.MSAASamples = Init.NumSamples;
PSO.GraphicsDesc.DepthStencilFormat = Init.DepthStencilTargetFormat;
PSO.GraphicsDesc.DepthStencilFlags = FPipelineCacheFileFormatPSO::GraphicsDescriptor::ReduceDSFlags(Init.DepthStencilTargetFlag);
PSO.GraphicsDesc.DepthLoad = Init.DepthTargetLoadAction;
PSO.GraphicsDesc.StencilLoad = Init.StencilTargetLoadAction;
PSO.GraphicsDesc.DepthStore = Init.DepthTargetStoreAction;
PSO.GraphicsDesc.StencilStore = Init.StencilTargetStoreAction;
PSO.GraphicsDesc.PrimitiveType = Init.PrimitiveType;
PSO.GraphicsDesc.SubpassHint = (uint8)Init.SubpassHint;
PSO.GraphicsDesc.SubpassIndex = Init.SubpassIndex;
PSO.GraphicsDesc.MultiViewCount = (uint8)Init.MultiViewCount;
PSO.GraphicsDesc.bHasFragmentDensityAttachment = Init.bHasFragmentDensityAttachment;
PSO.GraphicsDesc.bDepthBounds = Init.bDepthBounds;
#if !UE_BUILD_SHIPPING
bOK = bOK && PSO.Verify();
#endif
return bOK;
}
FPipelineCacheFileFormatPSO::~FPipelineCacheFileFormatPSO()
{
}
bool FPipelineCacheFileFormatPSO::operator==(const FPipelineCacheFileFormatPSO& Other) const
{
bool bSame = true;
if (this != &Other)
{
bSame = Type == Other.Type;
#if PSO_COOKONLY_DATA
/* Ignore: [UsageMask == UsageMask] in this test. */
/* Ignore: [BindCount == BindCount] in this test. */
#endif
if(Type == Other.Type)
{
switch(Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
bSame = (FMemory::Memcmp(&ComputeDesc, &Other.ComputeDesc, sizeof(ComputeDescriptor)) == 0);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
bSame = GraphicsDesc.VertexDescriptor.Num() == Other.GraphicsDesc.VertexDescriptor.Num();
for (uint32 i = 0; i < (uint32)FMath::Min(GraphicsDesc.VertexDescriptor.Num(), Other.GraphicsDesc.VertexDescriptor.Num()); i++)
{
bSame &= (FMemory::Memcmp(&GraphicsDesc.VertexDescriptor[i], &Other.GraphicsDesc.VertexDescriptor[i], sizeof(FVertexElement)) == 0);
}
bSame &=
GraphicsDesc.PrimitiveType == Other.GraphicsDesc.PrimitiveType &&
GraphicsDesc.VertexShader == Other.GraphicsDesc.VertexShader &&
GraphicsDesc.FragmentShader == Other.GraphicsDesc.FragmentShader &&
GraphicsDesc.GeometryShader == Other.GraphicsDesc.GeometryShader &&
GraphicsDesc.MeshShader == Other.GraphicsDesc.MeshShader &&
GraphicsDesc.AmplificationShader == Other.GraphicsDesc.AmplificationShader &&
GraphicsDesc.RenderTargetsActive == Other.GraphicsDesc.RenderTargetsActive &&
GraphicsDesc.MSAASamples == Other.GraphicsDesc.MSAASamples && GraphicsDesc.DepthStencilFormat == Other.GraphicsDesc.DepthStencilFormat &&
GraphicsDesc.DepthStencilFlags == Other.GraphicsDesc.DepthStencilFlags && GraphicsDesc.DepthLoad == Other.GraphicsDesc.DepthLoad &&
GraphicsDesc.DepthStore == Other.GraphicsDesc.DepthStore && GraphicsDesc.StencilLoad == Other.GraphicsDesc.StencilLoad && GraphicsDesc.StencilStore == Other.GraphicsDesc.StencilStore &&
GraphicsDesc.SubpassHint == Other.GraphicsDesc.SubpassHint && GraphicsDesc.SubpassIndex == Other.GraphicsDesc.SubpassIndex &&
GraphicsDesc.MultiViewCount == Other.GraphicsDesc.MultiViewCount && GraphicsDesc.bHasFragmentDensityAttachment == Other.GraphicsDesc.bHasFragmentDensityAttachment &&
GraphicsDesc.bDepthBounds == Other.GraphicsDesc.bDepthBounds &&
FMemory::Memcmp(&GraphicsDesc.BlendState, &Other.GraphicsDesc.BlendState, sizeof(FBlendStateInitializerRHI)) == 0 &&
FMemory::Memcmp(&GraphicsDesc.RasterizerState, &Other.GraphicsDesc.RasterizerState, sizeof(FPipelineFileCacheRasterizerState)) == 0 &&
FMemory::Memcmp(&GraphicsDesc.DepthStencilState, &Other.GraphicsDesc.DepthStencilState, sizeof(FDepthStencilStateInitializerRHI)) == 0 &&
FMemory::Memcmp(&GraphicsDesc.RenderTargetFormats, &Other.GraphicsDesc.RenderTargetFormats, sizeof(GraphicsDesc.RenderTargetFormats)) == 0 &&
FMemory::Memcmp(&GraphicsDesc.RenderTargetFlags, &Other.GraphicsDesc.RenderTargetFlags, sizeof(GraphicsDesc.RenderTargetFlags)) == 0;
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
bSame &= RayTracingDesc == Other.RayTracingDesc;
break;
}
default:
{
check(false);
break;
}
}
}
}
return bSame;
}
FPipelineCacheFileFormatPSO::FPipelineCacheFileFormatPSO(const FPipelineCacheFileFormatPSO& Other)
: Type(Other.Type)
#if PSO_COOKONLY_DATA
, UsageMask(Other.UsageMask)
, BindCount(Other.BindCount)
#endif
{
switch(Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
FMemory::Memcpy(&ComputeDesc, &Other.ComputeDesc, sizeof(ComputeDescriptor));
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
FMemory::Memcpy(&GraphicsDesc, &Other.GraphicsDesc, sizeof(GraphicsDescriptor));
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
RayTracingDesc = Other.RayTracingDesc;
break;
}
default:
{
check(false);
break;
}
}
}
FPipelineCacheFileFormatPSO& FPipelineCacheFileFormatPSO::operator=(const FPipelineCacheFileFormatPSO& Other)
{
if(this != &Other)
{
Type = Other.Type;
#if PSO_COOKONLY_DATA
UsageMask = Other.UsageMask;
BindCount = Other.BindCount;
#endif
switch(Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
FMemory::Memcpy(&ComputeDesc, &Other.ComputeDesc, sizeof(ComputeDescriptor));
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
// If we implement a classic copy constructor without memcpy - remove memset in ::Init() function above
FMemory::Memcpy(&GraphicsDesc, &Other.GraphicsDesc, sizeof(GraphicsDescriptor));
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
RayTracingDesc = Other.RayTracingDesc;
break;
}
default:
{
check(false);
break;
}
}
}
return *this;
}
struct FPipelineCacheFileFormatTOC
{
FPipelineCacheFileFormatTOC()
: SortedOrder(FPipelineFileCacheManager::PSOOrder::MostToLeastUsed)
{}
FPipelineFileCacheManager::PSOOrder SortedOrder;
TMap<uint32, FPipelineCacheFileFormatPSOMetaData> MetaData;
void DumpToLog() const
{
for (TMap<uint32, FPipelineCacheFileFormatPSOMetaData>::TConstIterator It(MetaData); It; ++It)
{
const FPipelineCacheFileFormatPSOMetaData& dat = It.Value();
UE_LOG(LogRHI, VeryVerbose, TEXT("PSO hash %u - guid (%s), stats(FF %" INT64_FMT ", LF %" INT64_FMT ", bind %" INT64_FMT ")"), It.Key(), *dat.FileGuid.ToString(), dat.Stats.FirstFrameUsed, dat.Stats.LastFrameUsed, dat.Stats.TotalBindCount)
}
UE_LOG(LogRHI, VeryVerbose, TEXT("Total PSOs %d"), MetaData.Num());
}
friend FArchive& operator<<(FArchive& Ar, FPipelineCacheFileFormatTOC& Info)
{
// TOC is assumed to be at the end of the file
// If this changes then the EOF read check and write need to moved out of here
// if all entries are using the same GUID (which is the norm when saving a packaged cache with the "buildsc" command of the commandlet),
// do not save it with every entry, reducing the surface of changes (GUID is regenerated on each save even if entries are the same)
bool bAllEntriesUseSameGuid = true;
FGuid FirstEntryGuid;
if(Ar.IsLoading())
{
uint64 TOCMagic = 0;
Ar << TOCMagic;
if(FPipelineCacheTOCFileFormatMagic != TOCMagic)
{
Ar.SetError();
return Ar;
}
uint64 EOFMagic = 0;
const int64 FileSize = Ar.TotalSize();
const int64 FilePosition = Ar.Tell();
Ar.Seek(FileSize - sizeof(FPipelineCacheEOFFileFormatMagic));
Ar << EOFMagic;
Ar.Seek(FilePosition);
if(FPipelineCacheEOFFileFormatMagic != EOFMagic)
{
Ar.SetError();
return Ar;
}
}
else
{
uint64 TOCMagic = FPipelineCacheTOCFileFormatMagic;
Ar << TOCMagic;
// check if the whole file is using the same GUID
bool bGuidSet = false;
for (TMap<uint32, FPipelineCacheFileFormatPSOMetaData>::TConstIterator It(Info.MetaData); It; ++It)
{
if (bGuidSet)
{
if (It.Value().FileGuid != FirstEntryGuid)
{
bAllEntriesUseSameGuid = false;
break;
}
}
else
{
FirstEntryGuid = It.Value().FileGuid;
bGuidSet = true;
}
}
if (!bGuidSet)
{
bAllEntriesUseSameGuid = false; // no entries, so don't do save the guid at all
}
// if the whole file uses the same guids, zero out
if (bAllEntriesUseSameGuid)
{
for (TMap<uint32, FPipelineCacheFileFormatPSOMetaData>::TIterator It(Info.MetaData); It; ++It)
{
It.Value().FileGuid = FGuid();
}
}
}
uint8 AllEntriesUseSameGuid = bAllEntriesUseSameGuid ? 1 : 0;
Ar << AllEntriesUseSameGuid;
bAllEntriesUseSameGuid = AllEntriesUseSameGuid != 0;
if (bAllEntriesUseSameGuid)
{
Ar << FirstEntryGuid;
}
Ar << Info.SortedOrder;
Ar << Info.MetaData;
if(Ar.IsSaving())
{
uint64 EOFMagic = FPipelineCacheEOFFileFormatMagic;
Ar << EOFMagic;
}
else if (bAllEntriesUseSameGuid)
{
for (TMap<uint32, FPipelineCacheFileFormatPSOMetaData>::TIterator It(Info.MetaData); It; ++It)
{
It.Value().FileGuid = FirstEntryGuid;
}
}
return Ar;
}
};
static bool ShouldDeleteExistingUserCache()
{
static bool bOnce = false;
static bool bCmdLineForce = false;
if (!bOnce)
{
bOnce = true;
bCmdLineForce = FParse::Param(FCommandLine::Get(), TEXT("deleteuserpsocache")) || FParse::Param(FCommandLine::Get(), TEXT("logPSO"));
UE_CLOG(bCmdLineForce, LogRHI, Warning, TEXT("****************************** Deleting user-writable PSO cache as requested on command line"));
}
return bCmdLineForce;
}
class FPipelineCacheFile
{
FString Name;
EShaderPlatform ShaderPlatform;
FName PlatformName;
uint64 TOCOffset;
FPipelineCacheFileFormatTOC TOC;
FGuid FileGuid;
FString FilePath;
TSharedPtr<IAsyncReadFileHandle, ESPMode::ThreadSafe> AsyncFileHandle;
FString RecordingFilename;
public:
enum class EStatus : uint8
{
Unknown,
BundledCache,
UserCacheOpened, // a user cache was successfully opened
NewUserCache, // user cache failed to open, started empty.
};
EStatus CacheStatus = EStatus::Unknown;
static uint32 GameVersion;
FPipelineCacheFile()
: TOCOffset(0)
, AsyncFileHandle(nullptr)
{
}
~FPipelineCacheFile()
{
DEC_MEMORY_STAT_BY(STAT_FileCacheMemory, TOC.MetaData.GetAllocatedSize());
}
static bool OpenPipelineFileCache(const FString& FilePath, EShaderPlatform ShaderPlatform, FGuid& Guid, TSharedPtr<IAsyncReadFileHandle, ESPMode::ThreadSafe>& Handle, FPipelineCacheFileFormatTOC& Content, uint64& TOCOffsetOUT)
{
bool bSuccess = false;
FArchive* FileReader = IFileManager::Get().CreateFileReader(*FilePath);
if (FileReader)
{
FileReader->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
FPipelineCacheFileFormatHeader Header = {};
*FileReader << Header;
if (Header.Magic == FPipelineCacheFileFormatMagic && Header.Version == FPipelineCacheFileFormatCurrentVersion && Header.GameVersion == GameVersion && Header.Platform == ShaderPlatform)
{
check(Header.TableOffset > 0);
check(FileReader->TotalSize() > 0);
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile Header Game Version: %d"), Header.GameVersion);
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile Header Engine Data Version: %d"), Header.Version);
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile Header TOC Offset: %llu"), Header.TableOffset);
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile File Size: %lld Bytes"), FileReader->TotalSize());
if(Header.TableOffset < (uint64)FileReader->TotalSize())
{
FileReader->Seek(Header.TableOffset);
*FileReader << Content;
// FPipelineCacheFileFormatTOC archive read can set the FArchive to error on failure
bSuccess = !FileReader->IsError();
}
if(!bSuccess)
{
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile: %s is corrupt reading TOC"), *FilePath);
}
}
else
{
bool bMagicMatch = (Header.Magic == FPipelineCacheFileFormatMagic);
bool bVersionMatch = (Header.Version == FPipelineCacheFileFormatCurrentVersion);
bool bGameVersionMatch = (Header.GameVersion == GameVersion);
bool bSPMatch = (Header.Platform == ShaderPlatform);
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile: skipping %s (different %s%s%s%s)"), *FilePath,
bMagicMatch ? TEXT("") : TEXT(" magic"),
bVersionMatch ? TEXT("") : TEXT(" version"),
bGameVersionMatch ? TEXT("") : TEXT(" gameversion"),
bSPMatch ? TEXT("") : TEXT(" shaderplatform")
);
}
if(!FileReader->Close())
{
bSuccess = false;
}
delete FileReader;
FileReader = nullptr;
if(bSuccess)
{
Handle = MakeShareable(FPlatformFileManager::Get().GetPlatformFile().OpenAsyncRead(*FilePath));
if(Handle.IsValid())
{
UE_LOG(LogRHI, Log, TEXT("Opened FPipelineCacheFile: %s (GUID: %s) with %d entries."), *FilePath, *Header.Guid.ToString(), Content.MetaData.Num());
Guid = Header.Guid;
TOCOffsetOUT = Header.TableOffset;
}
else
{
UE_LOG(LogRHI, Log, TEXT("Failed to create async read file handle to FPipelineCacheFile: %s (GUID: %s)"), *FilePath, *Header.Guid.ToString());
bSuccess = false;
}
}
}
else
{
UE_LOG(LogRHI, Log, TEXT("Could not open FPipelineCacheFile: %s"), *FilePath);
}
return bSuccess;
}
void GarbageCollectUserCache(FString const& UserCacheFilePath, const TSet<FGuid>& KnownGuids)
{
UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile: GarbageCollectUserCache() Begin"));
ON_SCOPE_EXIT{ UE_LOG(LogRHI, Log, TEXT("FPipelineCacheFile: GarbageCollectUserCache() End")); };
int32 GCPeriodInDays = CVarPSOFileCacheUserCacheUnusedElementCheckPeriod.GetValueOnAnyThread();
if (GCPeriodInDays < 0)
{
UE_LOG(LogRHI, Log, TEXT("User cache GC is disabled"));
return;
}
FArchive* FileReader = IFileManager::Get().CreateFileReader(*UserCacheFilePath);
if (!FileReader)
{
UE_LOG(LogRHI, Log, TEXT("No user cache file found"));
return;
}
ON_SCOPE_EXIT
{
if (FileReader)
{
FileReader->Close();
delete FileReader;
}
};
FileReader->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
FPipelineCacheFileFormatHeader Header;
*FileReader << Header;
if (!(Header.Magic == FPipelineCacheFileFormatMagic && Header.Version == FPipelineCacheFileFormatCurrentVersion && Header.GameVersion == GameVersion && Header.Platform == ShaderPlatform))
{
UE_LOG(LogRHI, Error, TEXT("File has invalid or out of date header"));
return;
}
FTimespan GCPeriod = FTimespan::FromDays(GCPeriodInDays);
int64 NextGCTime = Header.LastGCUnixTime + GCPeriod.GetTotalSeconds();
const int64 UnixTime = GetCurrentUnixTime();
if (UnixTime < NextGCTime)
{
const FTimespan TimespanToNextGC = FTimespan::FromSeconds(NextGCTime - UnixTime);
const double DaysToNextGC = TimespanToNextGC.GetTotalDays();
UE_LOG(LogRHI, Log, TEXT("Next GC on user cache is in %0.3f days."), DaysToNextGC);
return;
}
FPipelineCacheFileFormatTOC Content;
if (Header.TableOffset < (uint64)FileReader->TotalSize())
{
FileReader->Seek(Header.TableOffset);
*FileReader << Content;
// FPipelineCacheFileFormatTOC archive read can set the FArchive to error on failure
if (FileReader->IsError())
{
UE_LOG(LogRHI, Log, TEXT("Failed to read TOC"));
return;
}
}
int64 StaleDays = CVarPSOFileCacheUserCacheUnusedElementRetainDays.GetValueOnAnyThread();
FTimespan StaleTimespan = FTimespan::FromDays(StaleDays);
int64 EvictionTime = UnixTime - (int64)StaleTimespan.GetTotalSeconds();
auto EntryShouldBeRemovedFromUserCache = [&Header, FileGuid=this->FileGuid, EvictionTime,&KnownGuids](const FPipelineCacheFileFormatPSOMetaData& MetaData)
{
// Remove the element if it is in the user cache and the time has elapsed, or if it was in a cache that no longer exists.
if (MetaData.FileGuid == Header.Guid)
{
return EvictionTime >= MetaData.LastUsedUnixTime;
}
else
{
// TODO: right now we do not have a way to supply known guids.
// we use only the expired date check for now.
// return !KnownGuids.Contains(MetaData.FileGuid);
return EvictionTime >= MetaData.LastUsedUnixTime;
}
};
int32 NumOutOfDateEntries = 0;
for (auto const& Entry : Content.MetaData)
{
if (EntryShouldBeRemovedFromUserCache(Entry.Value))
{
NumOutOfDateEntries++;
}
}
if (NumOutOfDateEntries == 0)
{
UE_LOG(LogRHI, Log, TEXT("No out of date entries."));
return;
}
if (NumOutOfDateEntries == Content.MetaData.Num())
{
FileReader->Close();
delete FileReader;
FileReader = nullptr;
if (IFileManager::Get().FileExists(*UserCacheFilePath))
{
IFileManager::Get().Delete(*UserCacheFilePath);
}
UE_LOG(LogRHI, Log, TEXT("All entries are out of date, recreating cache."));
return;
}
UE_LOG(LogRHI, Log, TEXT("%d/%d elements are out of date, performing GC."), NumOutOfDateEntries, Content.MetaData.Num());
TArray<uint8> Buffer;
FMemoryWriter MemoryWriter(Buffer);
MemoryWriter.SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
FPipelineCacheFileFormatHeader NewHeader = Header;
check(NewHeader.Magic == FPipelineCacheFileFormatMagic);
check(NewHeader.Platform == ShaderPlatform);
NewHeader.Version = FPipelineCacheFileFormatCurrentVersion;
NewHeader.LastGCUnixTime = UnixTime;
NewHeader.TableOffset = 0; // Will overwrite with the correct offset after building the TOC
MemoryWriter << NewHeader;
FPipelineCacheFileFormatTOC NewTOC;
NewTOC.SortedOrder = Content.SortedOrder; // Removal maintains sort order of existing cache
for (auto const& Entry : Content.MetaData)
{
if (!EntryShouldBeRemovedFromUserCache(Entry.Value))
{
// Copy the meta data, and the FPipelineCacheFileFormatPSO if it exists in the user cache (the meta data can point into the game cache).
FPipelineCacheFileFormatPSOMetaData NewEntry = Entry.Value;
if (Entry.Value.FileGuid == Header.Guid && Entry.Value.FileSize > 0)
{
NewEntry.FileSize = Entry.Value.FileSize;
NewEntry.FileOffset = MemoryWriter.Tell();
// Copy from file to new memory writer
FPipelineCacheFileFormatPSO ExistingPSO;
FileReader->Seek(Entry.Value.FileOffset);
*FileReader << ExistingPSO;
MemoryWriter << ExistingPSO;
}
check(NewEntry.FileGuid != FGuid());
NewTOC.MetaData.Add(Entry.Key, NewEntry);
}
}
NewHeader.TableOffset = MemoryWriter.Tell();
MemoryWriter << NewTOC;
MemoryWriter.Seek(0);
MemoryWriter << NewHeader;
UE_LOG(LogRHI, Log, TEXT("Deleting existing cache file"));
int64 OriginalSize = FileReader->TotalSize();
FileReader->Close();
delete FileReader;
FileReader = nullptr;
if (IFileManager::Get().FileExists(*UserCacheFilePath))
{
IFileManager::Get().Delete(*UserCacheFilePath);
}
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*UserCacheFilePath);
if (!FileWriter)
{
UE_LOG(LogRHI, Log, TEXT("Unable to open new cache file for writing"));
return;
}
int64 NewSize = MemoryWriter.TotalSize();
FileWriter->Serialize(Buffer.GetData(), MemoryWriter.TotalSize());
FileWriter->Close();
delete FileWriter;
UE_LOG(LogRHI, Log, TEXT("Rewrote cache file. Old Size %lld, new size %lld (%lld byte reduction)"), OriginalSize, NewSize, OriginalSize - NewSize);
}
bool OpenPipelineFileCache(FString const& NameIn, EShaderPlatform Platform, FGuid& OutGameFileGuid)
{
check(CacheStatus == EStatus::Unknown);
OutGameFileGuid = FGuid();
TOC.SortedOrder = FPipelineFileCacheManager::PSOOrder::Default;
TOC.MetaData.Empty();
Name = NameIn;
ShaderPlatform = Platform;
PlatformName = LegacyShaderPlatformToShaderFormat(Platform);
FString GamePath = FPaths::ProjectContentDir() / TEXT("PipelineCaches") / ANSI_TO_TCHAR(FPlatformProperties::IniPlatformName()) / FString::Printf(TEXT("%s_%s.stable.upipelinecache"), *Name, *PlatformName.ToString());
static bool bCommandLineNotStable = FParse::Param(FCommandLine::Get(), TEXT("nostablepipelinecache"));
if (bCommandLineNotStable)
{
GamePath.Empty();
}
const bool bGameFileOk = OpenPipelineFileCache(GamePath, ShaderPlatform, FileGuid, AsyncFileHandle, TOC, TOCOffset);
if (bGameFileOk)
{
FilePath = GamePath;
OutGameFileGuid = FileGuid;
CacheStatus = EStatus::BundledCache;
}
if (bGameFileOk && GRHISupportsLazyShaderCodeLoading && CVarLazyLoadShadersWhenPSOCacheIsPresent.GetValueOnAnyThread())
{
UE_LOG(LogRHI, Log, TEXT("Lazy loading from the shader code library is enabled."));
GRHILazyShaderCodeLoading = true;
}
#if !UE_BUILD_SHIPPING
uint32 InvalidEntryCount = 0;
#endif
for (auto const& Entry : TOC.MetaData)
{
FPipelineStateStats* Stat = FPipelineFileCacheManager::Stats.FindRef(Entry.Key);
if (!Stat)
{
Stat = new FPipelineStateStats;
Stat->PSOHash = Entry.Key;
Stat->TotalBindCount = -1;
FPipelineFileCacheManager::Stats.Add(Entry.Key, Stat);
}
UE_CLOG(!!FPipelineFileCacheManager::NewPSOUsage.Find(Entry.Key), LogRHI, Warning, TEXT("loaded PSOFC %s contains entry (%u) previously marked as new "), *Name, (Entry.Key));
#if !UE_BUILD_SHIPPING
if((Entry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
++InvalidEntryCount;
}
#endif
}
#if !UE_BUILD_SHIPPING
if(InvalidEntryCount > 0)
{
UE_LOG(LogRHI, Warning, TEXT("Found %d / %d PSO entries marked as invalid."), InvalidEntryCount, TOC.MetaData.Num());
}
#endif
INC_MEMORY_STAT_BY(STAT_FileCacheMemory, TOC.MetaData.GetAllocatedSize());
UE_LOG(LogRHI, VeryVerbose, TEXT("-- opened bundled %s cache:"), *NameIn);
TOC.DumpToLog();
UE_LOG(LogRHI, VeryVerbose, TEXT("-- end of dump (%s)"), *NameIn);
return bGameFileOk;
}
//
bool OpenUserPipelineFileCache(FString const& CacheNameIn, EShaderPlatform Platform)
{
bool bUserFileOk = false;
if (CacheStatus == EStatus::Unknown)
{
SET_DWORD_STAT(STAT_TotalGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_TotalComputePipelineStateCount, 0);
SET_DWORD_STAT(STAT_TotalRayTracingPipelineStateCount, 0);
SET_DWORD_STAT(STAT_SerializedGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_SerializedComputePipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewComputePipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewRayTracingPipelineStateCount, 0);
// one time attempt to open the user cache.
TOC.SortedOrder = FPipelineFileCacheManager::PSOOrder::Default;
TOC.MetaData.Empty();
Name = CacheNameIn;
ShaderPlatform = Platform;
PlatformName = LegacyShaderPlatformToShaderFormat(Platform);
FGuid UniqueFileGuid;
FPlatformMisc::CreateGuid(UniqueFileGuid); // not very unique on android, but won't matter much here
RecordingFilename = FString::Printf(TEXT("%s-CL-%u-"), *FEngineVersion::Current().GetBranchDescriptor(), FEngineVersion::Current().GetChangelist());
RecordingFilename += FString::Printf(TEXT("%s_%s_%s.rec.upipelinecache"), *Name, *PlatformName.ToString(), *UniqueFileGuid.ToString());
RecordingFilename = FPaths::ProjectSavedDir() / TEXT("CollectedPSOs") / RecordingFilename;
UE_LOG(LogRHI, Log, TEXT("Base name for record PSOs is %s"), *RecordingFilename);
FilePath = FPaths::ProjectSavedDir() / FString::Printf(TEXT("%s_%s.upipelinecache"), *Name, *PlatformName.ToString());
if (ShouldDeleteExistingUserCache())
{
UE_LOG(LogRHI, Log, TEXT("Deleting FPipelineCacheFile: %s"), *FilePath);
if (IFileManager::Get().FileExists(*FilePath))
{
IFileManager::Get().Delete(*FilePath);
}
}
FString JournalPath = FilePath + JOURNAL_FILE_EXTENSION;
bool const bJournalFileExists = IFileManager::Get().FileExists(*JournalPath);
if (bJournalFileExists || ShouldDeleteExistingUserCache())
{
UE_LOG(LogRHI, Log, TEXT("Deleting FPipelineCacheFile: %s"), *FilePath);
// If either of the above are true we need to dispose of this case as we consider it invalid
if (IFileManager::Get().FileExists(*FilePath))
{
IFileManager::Get().Delete(*FilePath);
}
if (bJournalFileExists)
{
IFileManager::Get().Delete(*JournalPath);
}
}
// TODO: we currently do not know the full set of valid PSOFC guids.
// KnownGuids is a placeholder for all possible PSO cache guids.
TSet<FGuid> KnownGuids;
GarbageCollectUserCache(FilePath, KnownGuids);
FPipelineCacheFileFormatTOC UserTOC;
bUserFileOk = OpenPipelineFileCache(FilePath, ShaderPlatform, FileGuid, AsyncFileHandle, TOC, TOCOffset);
CacheStatus = bUserFileOk ? EStatus::UserCacheOpened : EStatus::NewUserCache;
if (!bUserFileOk)
{
FileGuid = FGuid::NewGuid();
// Start the file again!
IFileManager::Get().Delete(*FilePath);
TOCOffset = 0;
}
#if !UE_BUILD_SHIPPING
uint32 InvalidEntryCount = 0;
#endif
for (auto const& Entry : TOC.MetaData)
{
FPipelineStateStats* Stat = FPipelineFileCacheManager::Stats.FindRef(Entry.Key);
if (!Stat)
{
Stat = new FPipelineStateStats;
Stat->PSOHash = Entry.Key;
Stat->TotalBindCount = -1;
FPipelineFileCacheManager::Stats.Add(Entry.Key, Stat);
}
#if !UE_BUILD_SHIPPING
if ((Entry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
++InvalidEntryCount;
}
#endif
}
#if !UE_BUILD_SHIPPING
if (InvalidEntryCount > 0)
{
UE_LOG(LogRHI, Warning, TEXT("Found %d / %d PSO entries marked as invalid."), InvalidEntryCount, TOC.MetaData.Num());
}
#endif
}
INC_MEMORY_STAT_BY(STAT_FileCacheMemory, TOC.MetaData.GetAllocatedSize());
return bUserFileOk;
}
static void MergePSOUsageToMetaData(TMap<uint32, FPSOUsageData>& NewPSOUsage, TMap<uint32, FPipelineCacheFileFormatPSOMetaData>& MetaData, int64 CurrentUnixTime, bool bRemoveUpdatedentries = false)
{
for(auto It = NewPSOUsage.CreateIterator(); It; ++It)
{
auto& MaskEntry = *It;
//Don't use FindChecked as if new PSO was not bound - it might not be in the TOC.MetaData - they are not always added in every save mode - this is not an error
auto* PSOMetaData = MetaData.Find(MaskEntry.Key);
if(PSOMetaData != nullptr)
{
PSOMetaData->UsageMask |= MaskEntry.Value.UsageMask;
PSOMetaData->EngineFlags |= MaskEntry.Value.EngineFlags;
PSOMetaData->LastUsedUnixTime = CurrentUnixTime;
if(bRemoveUpdatedentries)
{
It.RemoveCurrent();
}
}
}
}
bool SavePipelineFileCache(FPipelineFileCacheManager::SaveMode Mode, TMap<uint32, FPipelineStateStats*> const& Stats, TSet<FPipelineCacheFileFormatPSO>& NewEntries, FPipelineFileCacheManager::PSOOrder Order, TMap<uint32, FPSOUsageData>& NewPSOUsage)
{
check(CacheStatus == EStatus::NewUserCache || CacheStatus == EStatus::UserCacheOpened);
// remove from stats because this operation will modify the content and re-set the stat at the end.
DEC_MEMORY_STAT_BY(STAT_FileCacheMemory, TOC.MetaData.GetAllocatedSize());
QUICK_SCOPE_CYCLE_COUNTER(STAT_SavePipelineFileCache);
double StartTime = FPlatformTime::Seconds();
FString SaveFilePath = FilePath;
if (FPipelineFileCacheManager::SaveMode::BoundPSOsOnly == Mode)
{
SaveFilePath = GetRecordingFilename();
}
bool bFileWriteSuccess = false;
bool bPerformWrite = true;
if (FPipelineFileCacheManager::SaveMode::Incremental == Mode)
{
bPerformWrite = NewEntries.Num() || Order != TOC.SortedOrder || NewPSOUsage.Num();
bFileWriteSuccess = !bPerformWrite;
}
if (bPerformWrite)
{
uint32 NumNewEntries = 0;
int64 UnixTime = GetCurrentUnixTime();
FString JournalPath;
if (Mode != FPipelineFileCacheManager::SaveMode::BoundPSOsOnly)
{
JournalPath = SaveFilePath + JOURNAL_FILE_EXTENSION;
FArchive* JournalWriter = IFileManager::Get().CreateFileWriter(*JournalPath);
check(JournalWriter);
// Header
{
FPipelineCacheFileFormatHeader Header;
Header.Magic = FPipelineCacheFileFormatMagic;
Header.Version = FPipelineCacheFileFormatCurrentVersion;
Header.GameVersion = GameVersion;
Header.Platform = ShaderPlatform;
Header.Guid = FileGuid;
Header.TableOffset = 0;
Header.LastGCUnixTime = UnixTime;
*JournalWriter << Header;
}
check(!JournalWriter->IsError());
JournalWriter->Close();
delete JournalWriter;
bPerformWrite = IFileManager::Get().FileExists(*JournalPath);
}
if (bPerformWrite)
{
struct FMemoryReaderAndMemory
{
// Non-copyable
FMemoryReaderAndMemory(const FMemoryReaderAndMemory&) = delete;
FMemoryReaderAndMemory& operator=(const FMemoryReaderAndMemory&) = delete;
TArray<uint8> Bytes;
TUniquePtr<FMemoryReader> Reader;
explicit FMemoryReaderAndMemory(FPipelineCacheFile* PipelineFile)
{
if(PipelineFile)
{
int64 FileSize = IFileManager::Get().FileSize(*PipelineFile->FilePath);
if (FileSize > 0)
{
Bytes.SetNumUninitialized(FileSize);
if (PipelineFile->AsyncFileHandle.IsValid())
{
IAsyncReadRequest* Request = PipelineFile->AsyncFileHandle->ReadRequest(0, FileSize, AIOP_Normal, nullptr, Bytes.GetData());
Request->WaitCompletion();
delete Request;
UE_LOG(LogRHI, VeryVerbose, TEXT("1 Opening %s as guid %s, size %" INT64_FMT), *PipelineFile->FilePath, *PipelineFile->GetFileGuid().ToString(), FileSize);
}
else
{
bool bReadOK = FFileHelper::LoadFileToArray(Bytes, *PipelineFile->FilePath);
UE_LOG(LogRHI, VeryVerbose, TEXT("2 Opening %s as guid %s, size %" INT64_FMT), *PipelineFile->FilePath, *PipelineFile->GetFileGuid().ToString(), FileSize);
UE_CLOG(!bReadOK, LogRHI, Warning, TEXT("Failed to read %lld bytes from %s while re-saving the PipelineFileCache!"), FileSize, *PipelineFile->FilePath);
}
Reader = MakeUnique<FMemoryReader>(Bytes);
Reader->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
}
}
}
FMemoryReader* GetReader() { return Reader.Get(); }
};
TMap<FGuid, TUniquePtr<FMemoryReaderAndMemory>> GuidToFileCacheReader;
auto GetFileCacheReaderFromGuid = [&GuidToFileCacheReader](const FGuid& guid)
{
check(guid != FGuid());
if(!GuidToFileCacheReader.Contains(guid))
{
const FString& FoundKey = FPipelineFileCacheManager::GameGuidToCacheKey.FindRef(guid);
FPipelineCacheFile* FoundPipelineFile = FPipelineFileCacheManager::GetPipelineCacheFileFromKey(FoundKey);
GuidToFileCacheReader.Add(guid, MakeUnique<FMemoryReaderAndMemory>(FoundPipelineFile));
}
if (TUniquePtr<FMemoryReaderAndMemory>* Found = GuidToFileCacheReader.Find(guid))
{
return (*Found)->GetReader();
}
checkNoEntry();
return static_cast<FMemoryReader*>(nullptr);
};
// Assume caller has handled Platform specifc path + filename
TArray<uint8> SaveBytes;
FArchive* FileWriter;
bool bUseMemoryWriter = (Mode == FPipelineFileCacheManager::SaveMode::BoundPSOsOnly);
FString TempPath = SaveFilePath;
// Only use a file switcheroo on Apple platforms as they are the only ones tested so far.
// At least two other platforms MoveFile implementation looks broken when moving from a writable source file to a writeable destination.
// They only handle moves/renames between the read-only -> writeable directories/devices.
if ((PLATFORM_APPLE || PLATFORM_ANDROID) && Mode != FPipelineFileCacheManager::SaveMode::Incremental)
{
TempPath += TEXT(".tmp");
}
if (bUseMemoryWriter)
{
FileWriter = new FMemoryWriter(SaveBytes, true, false, FName(*SaveFilePath));
}
else
{
// parent directory creation is necessary because the deploy process from
// AndroidPlatform.Automation.cs destroys the parent directories and recreates them
IFileManager::Get().MakeDirectory(*FPaths::GetPath(TempPath), true);
FileWriter = IFileManager::Get().CreateFileWriter(*TempPath, FILEWRITE_Append);
}
if (FileWriter)
{
FileWriter->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
FileWriter->Seek(0);
// Header
FPipelineCacheFileFormatHeader Header;
{
Header.Magic = FPipelineCacheFileFormatMagic;
Header.Version = FPipelineCacheFileFormatCurrentVersion;
Header.GameVersion = GameVersion;
Header.Platform = ShaderPlatform;
Header.Guid = FileGuid;
Header.TableOffset = 0;
Header.LastGCUnixTime = UnixTime;
*FileWriter << Header;
TOCOffset = FMath::Max(TOCOffset, (uint64)FileWriter->Tell());
}
uint32 TotalEntries = 0;
uint32 ConsolidatedEntries = 0;
uint32 RemovedEntries = 0;
switch (Mode)
{
// This mode just writes new, used, entries to the end of the file and updates the TOC which will contain entries from the Game-Content file that are redundant.
// Any current tasks are unaffected as the prior offsets are still valid.
case FPipelineFileCacheManager::SaveMode::Incremental:
{
// PSO Descriptors
uint64 PSOOffset = TOCOffset;
FileWriter->Seek(PSOOffset);
// Add new entries
for(auto It = NewEntries.CreateIterator(); It; ++It)
{
FPipelineCacheFileFormatPSO& NewEntry = *It;
uint32 PSOHash = GetTypeHash(NewEntry);
bool bFound = FPipelineFileCacheManager::IsPSOEntryCached(NewEntry, nullptr);
if (bFound)
{
// this could happen if another PSOFC loads after the PSO was encountered, if desired we could remove things from newentries when a psofc is mounted..
UE_LOG(LogRHI, Display, TEXT("Incrementally saving new PSOs but entry (%u), is already cached.."), PSOHash);
// Not removing it as the cached item could be legit if co-owner is not always loaded.
}
FPipelineStateStats const* Stat = Stats.FindRef(PSOHash);
if (Stat && Stat->TotalBindCount > 0)
{
FPipelineCacheFileFormatPSOMetaData Meta;
Meta.Stats.PSOHash = PSOHash;
Meta.FileOffset = PSOOffset;
Meta.FileGuid = FileGuid;
Meta.AddShaders(NewEntry);
TArray<uint8> Bytes;
FMemoryWriter Wr(Bytes);
Wr.SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
Wr << NewEntry;
FileWriter->Serialize(Bytes.GetData(), Wr.TotalSize());
Meta.FileSize = Wr.TotalSize();
check(Meta.FileGuid != FGuid());
TOC.MetaData.Add(PSOHash, Meta);
PSOOffset += Meta.FileSize;
check(PSOOffset == FileWriter->Tell());
NumNewEntries++;
It.RemoveCurrent();
UE_LOG(LogRHI, VeryVerbose, TEXT("Incremental save is appending new PSOs (%u)"), PSOHash);
}
}
// We're appending to the current user cache here, Our TOC is the total.
TotalEntries = TOC.MetaData.Num();
if(Order != FPipelineFileCacheManager::PSOOrder::Default)
{
SortMetaData(TOC.MetaData, Order);
TOC.SortedOrder = Order;
}
else
{
// Added new entries and not re-sorted - the sort order invalid - reset to default
TOC.SortedOrder = FPipelineFileCacheManager::PSOOrder::Default;
}
// Update TOC Metadata usage and clear relevant entries in NewPSOUsage as we are saving this file cache TOC
MergePSOUsageToMetaData(NewPSOUsage, TOC.MetaData, UnixTime, true);
Header.TableOffset = PSOOffset;
TOCOffset = PSOOffset;
FileWriter->Seek(Header.TableOffset);
// use a temp here because serializing can destroy our metadata guids.
FPipelineCacheFileFormatTOC TempTOC = TOC;
*FileWriter << TempTOC;
break;
}
// This mode actually saves to a separate file that records only PSOs that were bound.
// BoundPSOsOnly will record all those PSOs used in this run of the game.
case FPipelineFileCacheManager::SaveMode::BoundPSOsOnly:
{
FPipelineCacheFileFormatTOC TempTOC;
// Merge all of the existing PSO caches together, including this (user cache)
for (TPair<FString, TUniquePtr<class FPipelineCacheFile>>& PipelineCachePair : FPipelineFileCacheManager::FileCacheMap)
{
TempTOC.MetaData.Append(PipelineCachePair.Value->TOC.MetaData);
}
TMap<uint32, FPipelineCacheFileFormatPSO> PSOs;
Header.Guid = FGuid::NewGuid();
for (auto& Entry : NewEntries)
{
FPipelineCacheFileFormatPSOMetaData Meta;
Meta.Stats.PSOHash = GetTypeHash(Entry);
Meta.FileOffset = 0;
Meta.FileSize = 0;
Meta.FileGuid = Header.Guid;
Meta.AddShaders(Entry);
check(Meta.FileGuid != FGuid());
TempTOC.MetaData.Add(Meta.Stats.PSOHash, Meta);
PSOs.Add(Meta.Stats.PSOHash, Entry);
}
// Update TOC Metadata usage masks - don't clear NewPSOUsage as we are using a TempTOC
MergePSOUsageToMetaData(NewPSOUsage, TempTOC.MetaData, UnixTime);
for (auto& Pair : Stats)
{
auto* MetaPtr = TempTOC.MetaData.Find(Pair.Key);
if (MetaPtr)
{
auto& Meta = *MetaPtr;
check(Meta.Stats.PSOHash == Pair.Value->PSOHash);
Meta.Stats.CreateCount += Pair.Value->CreateCount;
if (Pair.Value->FirstFrameUsed > Meta.Stats.FirstFrameUsed)
{
Meta.Stats.FirstFrameUsed = Pair.Value->FirstFrameUsed;
}
if (Pair.Value->LastFrameUsed > Meta.Stats.LastFrameUsed)
{
Meta.Stats.LastFrameUsed = Pair.Value->LastFrameUsed;
}
Meta.Stats.TotalBindCount = (int64)FMath::Min((uint64)INT64_MAX, (uint64)FMath::Max(Meta.Stats.TotalBindCount, 0ll) + (uint64)FMath::Max(Pair.Value->TotalBindCount, 0ll));
}
}
for (auto It = TempTOC.MetaData.CreateIterator(); It; ++It)
{
FPipelineStateStats const* Stat = Stats.FindRef(It->Key);
bool bUsed = (Stat && (Stat->TotalBindCount > 0));
if (bUsed)
{
if (!PSOs.Contains(It->Key))
{
check(It->Value.FileSize > 0);
FMemoryReader* Reader = GetFileCacheReaderFromGuid(It->Value.FileGuid);
if (Reader)
{
UE_LOG(LogRHI, VeryVerbose, TEXT("reading PSO (%u) from guid %s, Off %" UINT64_FMT " // %" INT64_FMT), It->Key, *It->Value.FileGuid.ToString(), (It->Value.FileOffset), Reader->TotalSize());
check(It->Value.FileOffset < (uint32)Reader->TotalSize());
Reader->Seek(It->Value.FileOffset);
FPipelineCacheFileFormatPSO PSO;
(*Reader) << PSO;
PSOs.Add(It->Key, PSO);
}
else
{
FString GameGuids;
Algo::ForEach(FPipelineFileCacheManager::FileCacheMap, [&GameGuids](auto& MapPair) { GameGuids += FString::Printf(TEXT("[%s - %s]"), *MapPair.Value->Name, *MapPair.Value->FileGuid.ToString()); });
UE_LOG(LogRHI, Display, \
TEXT("Trying to reconcile from unknown file GUID: %s but bound log file is: %s user file is: %s and the currently known game files are: %s - this means you have stale entries in a local cache file or the relevant game content file is yet to be mounted."), \
*(It->Value.FileGuid.ToString()), *(Header.Guid.ToString()), *(FileGuid.ToString()), *(GameGuids));
RemovedEntries++;
It.RemoveCurrent();
}
}
}
else
{
RemovedEntries++;
It.RemoveCurrent();
}
}
TotalEntries = TempTOC.MetaData.Num();
SortMetaData(TempTOC.MetaData, Order);
TempTOC.SortedOrder = Order;
uint64 TempTOCOffset = (uint64)FileWriter->Tell();
uint64 PSOOffset = TempTOCOffset;
for (auto& Entry : TempTOC.MetaData)
{
FPipelineCacheFileFormatPSO& PSO = PSOs.FindChecked(Entry.Key);
FileWriter->Seek(PSOOffset);
Entry.Value.FileGuid = Header.Guid;
Entry.Value.FileOffset = PSOOffset;
int64 At = FileWriter->Tell();
(*FileWriter) << PSO;
Entry.Value.FileSize = FileWriter->Tell() - At;
PSOOffset += Entry.Value.FileSize;
check(PSOOffset == FileWriter->Tell());
NumNewEntries++;
}
Header.TableOffset = PSOOffset;
TempTOCOffset = PSOOffset;
FileWriter->Seek(Header.TableOffset);
*FileWriter << TempTOC;
break;
}
default:
{
check(false);
break;
}
}
// Overwrite the header now that we have the TOC location.
FileWriter->Seek(0);
*FileWriter << Header;
FileWriter->Flush();
bFileWriteSuccess = !FileWriter->IsError();
if(!FileWriter->Close())
{
bFileWriteSuccess = false;
}
if (bFileWriteSuccess && bUseMemoryWriter)
{
if (TotalEntries > 0)
{
bFileWriteSuccess = FFileHelper::SaveArrayToFile(SaveBytes, *TempPath);
}
else
{
delete FileWriter;
float ThisTimeMS = float(FPlatformTime::Seconds() - StartTime) * 1000.0f;
UE_LOG(LogRHI, Log, TEXT("FPipelineFileCacheManager skipping saving empty .upipelinecache (took %6.2fms): %s."), ThisTimeMS, *SaveFilePath);
return false;
}
}
if (bFileWriteSuccess)
{
delete FileWriter;
// As on POSIX only file moves on the same device are atomic
if ((SaveFilePath == TempPath) || IFileManager::Get().Move(*SaveFilePath, *TempPath, true, true, true, true))
{
float ThisTimeMS = float(FPlatformTime::Seconds() - StartTime) * 1000.0f;
TCHAR const* ModeName = nullptr;
switch (Mode)
{
default:
checkNoEntry();
case FPipelineFileCacheManager::SaveMode::Incremental:
ModeName = TEXT("Incremental");
break;
case FPipelineFileCacheManager::SaveMode::BoundPSOsOnly:
ModeName = TEXT("BoundPSOsOnly");
break;
}
UE_LOG(LogRHI, Log, TEXT("FPipelineFileCacheManager %s saved %u total, %u new, %u removed, %u cons .upipelinecache (took %6.2fms): %s."), ModeName, TotalEntries, NumNewEntries, RemovedEntries, ConsolidatedEntries, ThisTimeMS, *SaveFilePath);
if (JournalPath.Len())
{
IFileManager::Get().Delete(*JournalPath);
}
}
else
{
float ThisTimeMS = float(FPlatformTime::Seconds() - StartTime) * 1000.0f;
UE_LOG(LogRHI, Error, TEXT("Failed to move .upipelinecache from %s to %s (took %6.2fms)."), *TempPath, *SaveFilePath, ThisTimeMS);
}
}
else
{
delete FileWriter;
IFileManager::Get().Delete(*TempPath);
float ThisTimeMS = float(FPlatformTime::Seconds() - StartTime) * 1000.0f;
UE_LOG(LogRHI, Error, TEXT("Failed to write .upipelinecache, (took %6.2fms): %s."), ThisTimeMS, *SaveFilePath);
}
}
else
{
UE_LOG(LogRHI, Error, TEXT("Failed to open .upipelinecache for write: %s."), *SaveFilePath);
}
}
}
INC_MEMORY_STAT_BY(STAT_FileCacheMemory, TOC.MetaData.GetAllocatedSize());
return bFileWriteSuccess;
}
bool IsPSOEntryCachedInternal(FPipelineCacheFileFormatPSO const& NewEntry, FPSOUsageData* EntryData = nullptr) const
{
uint32 PSOHash = GetTypeHash(NewEntry);
check(!EntryData || EntryData->PSOHash == PSOHash);
FPipelineCacheFileFormatPSOMetaData const * const Existing = TOC.MetaData.Find(PSOHash);
if(Existing != nullptr && EntryData != nullptr)
{
EntryData->UsageMask = Existing->UsageMask;
EntryData->EngineFlags = Existing->EngineFlags;
}
return Existing != nullptr;
}
bool IsBSSEquivalentPSOEntryCachedInternal(FPipelineCacheFileFormatPSO const& NewEntry) const
{
check(!IsPSOEntryCachedInternal(NewEntry)); // this routine should only be called after we have done the much faster test
bool bResult = false;
if (NewEntry.Type == FPipelineCacheFileFormatPSO::DescriptorType::Graphics)
{
// this is O(N) and potentially slow, measured timing is 10s of us.
TSet<FSHAHash> TempShaders;
TempShaders.Add(NewEntry.GraphicsDesc.VertexShader);
if (NewEntry.GraphicsDesc.FragmentShader != FSHAHash())
{
TempShaders.Add(NewEntry.GraphicsDesc.FragmentShader);
}
if (NewEntry.GraphicsDesc.GeometryShader != FSHAHash())
{
TempShaders.Add(NewEntry.GraphicsDesc.GeometryShader);
}
if (NewEntry.GraphicsDesc.MeshShader != FSHAHash())
{
TempShaders.Add(NewEntry.GraphicsDesc.MeshShader);
}
if (NewEntry.GraphicsDesc.AmplificationShader != FSHAHash())
{
TempShaders.Add(NewEntry.GraphicsDesc.AmplificationShader);
}
for (auto const& Hash : TOC.MetaData)
{
if (LegacyCompareEqual(TempShaders, Hash.Value.Shaders))
{
bResult = true;
break;
}
}
}
return bResult;
}
static void SortMetaData(TMap<uint32, FPipelineCacheFileFormatPSOMetaData>& MetaData, FPipelineFileCacheManager::PSOOrder Order)
{
// Only sorting metadata ordering - this should not affect PSO data offsets / lookups
switch(Order)
{
case FPipelineFileCacheManager::PSOOrder::FirstToLatestUsed:
{
MetaData.ValueSort([](const FPipelineCacheFileFormatPSOMetaData& A, const FPipelineCacheFileFormatPSOMetaData& B) {return A.Stats.FirstFrameUsed > B.Stats.FirstFrameUsed;});
break;
}
case FPipelineFileCacheManager::PSOOrder::MostToLeastUsed:
{
MetaData.ValueSort([](const FPipelineCacheFileFormatPSOMetaData& A, const FPipelineCacheFileFormatPSOMetaData& B) {return A.Stats.TotalBindCount > B.Stats.TotalBindCount;});
break;
}
case FPipelineFileCacheManager::PSOOrder::Default:
default:
{
// NOP - leave as is
break;
}
}
}
void GetOrderedPSOHashes(TArray<FPipelineCachePSOHeader>& PSOHashes, FPipelineFileCacheManager::PSOOrder Order, int64 MinBindCount, TSet<uint32> const& AlreadyCompiledHashes)
{
if(Order != TOC.SortedOrder)
{
SortMetaData(TOC.MetaData, Order);
TOC.SortedOrder = Order;
}
for (auto const& Hash : TOC.MetaData)
{
if( (Hash.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) == 0 &&
FPipelineFileCacheManager::MaskComparisonFn(FPipelineFileCacheManager::GameUsageMask, Hash.Value.UsageMask) &&
Hash.Value.Stats.TotalBindCount >= MinBindCount &&
!AlreadyCompiledHashes.Contains(Hash.Key))
{
FPipelineCachePSOHeader Header;
Header.Hash = Hash.Key;
Header.Shaders = Hash.Value.Shaders;
PSOHashes.Add(Header);
}
}
}
bool OnExternalReadCallback(FPipelineCacheFileFormatPSORead* Entry, double RemainingTime)
{
TSharedPtr<IAsyncReadRequest, ESPMode::ThreadSafe> LocalReadRequest = Entry->ReadRequest;
check(LocalReadRequest.IsValid());
if (RemainingTime < 0.0 && !LocalReadRequest->PollCompletion())
{
return false;
}
else if (RemainingTime >= 0.0 && !LocalReadRequest->WaitCompletion(RemainingTime))
{
return false;
}
Entry->bReadCompleted = 1;
return true;
}
void FetchPSODescriptors(TDoubleLinkedList<FPipelineCacheFileFormatPSORead*>& Batch)
{
for (TDoubleLinkedList<FPipelineCacheFileFormatPSORead*>::TIterator It(Batch.GetHead()); It; ++It)
{
FPipelineCacheFileFormatPSORead* Entry = *It;
FPipelineCacheFileFormatPSOMetaData const& Meta = TOC.MetaData.FindChecked(Entry->Hash);
if((Meta.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
// In reality we should not get to this case as GetOrderedPSOHashes() won't pass back PSOs that have this flag set
UE_LOG(LogRHI, Verbose, TEXT("Encountered a PSO entry %u marked invalid - ignoring"), Entry->Hash);
Entry->bValid = false;
continue;
}
if (Meta.FileGuid == FileGuid)
{
FPipelineCacheFileFormatPSOMetaData const* GameMeta = TOC.MetaData.Find(Entry->Hash);
if (GameMeta && ensure(AsyncFileHandle.IsValid()))
{
Entry->Data.SetNum(GameMeta->FileSize);
Entry->ParentFileHandle = AsyncFileHandle;
Entry->ReadRequest = MakeShareable(AsyncFileHandle->ReadRequest(GameMeta->FileOffset, GameMeta->FileSize, AIOP_Normal, nullptr, Entry->Data.GetData()));
}
else
{
UE_LOG(LogRHI, Verbose, TEXT("Encountered a PSO entry %u that has been removed from the cache file: %s "), Entry->Hash, *Meta.FileGuid.ToString());
Entry->bValid = false;
continue;
}
}
else
{
UE_LOG(LogRHI, Warning, TEXT("Encountered a PSO entry %u that references unknown file ID: %s"), Entry->Hash, *Meta.FileGuid.ToString());
Entry->bValid = false;
continue;
}
Entry->bValid = true;
FExternalReadCallback ExternalReadCallback = [this, Entry](double ReaminingTime)
{
return this->OnExternalReadCallback(Entry, ReaminingTime);
};
if (!Entry->Ar || !Entry->Ar->AttachExternalReadDependency(ExternalReadCallback))
{
ExternalReadCallback(0.0);
check(Entry->bReadCompleted);
}
}
}
FName GetPlatformName() const
{
return PlatformName;
}
const FString& GetRecordingFilename() const
{
return RecordingFilename;
}
const FString& GetCacheFilename() const
{
return Name;
}
const FGuid& GetFileGuid() const
{
return FileGuid;
}
const int32 GetTOCMetaDataSize() const
{
return TOC.MetaData.Num();
}
};
uint32 FPipelineCacheFile::GameVersion = 0;
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
bool FPipelineFileCacheManager::IsBSSEquivalentPSOEntryCached(FPipelineCacheFileFormatPSO const& NewEntry)
{
check(!IsPSOEntryCached(NewEntry)); // this routine should only be called after we have done the much faster test
bool bFound = false;
for (auto MapIt = FileCacheMap.CreateIterator(); !bFound && MapIt; ++MapIt)
{
bFound = MapIt->Value->IsBSSEquivalentPSOEntryCachedInternal(NewEntry);
}
return bFound;
}
// note: when EntryData is supplied it also performs a state update, we may need to verify all occurrences are coherent...
bool FPipelineFileCacheManager::IsPSOEntryCached(FPipelineCacheFileFormatPSO const& NewEntry, FPSOUsageData* EntryData)
{
bool bFound = false;
for (auto MapIt = FileCacheMap.CreateIterator(); !bFound && MapIt; ++MapIt)
{
bFound = MapIt->Value->IsPSOEntryCachedInternal(NewEntry, EntryData);
}
return bFound;
}
bool FPipelineFileCacheManager::IsPipelineFileCacheEnabled()
{
static bool bOnce = false;
static bool bCmdLineForce = false;
if (!bOnce)
{
bOnce = true;
bCmdLineForce = FParse::Param(FCommandLine::Get(), TEXT("psocache"));
UE_CLOG(bCmdLineForce, LogRHI, Warning, TEXT("****************************** Forcing PSO cache from command line"));
}
return FileCacheEnabled && (bCmdLineForce || CVarPSOFileCacheEnabled.GetValueOnAnyThread() == 1);
}
bool FPipelineFileCacheManager::LogPSOtoFileCache()
{
static bool bOnce = false;
static bool bCmdLineForce = false;
if (!bOnce)
{
bOnce = true;
bCmdLineForce = FParse::Param(FCommandLine::Get(), TEXT("logpso"));
UE_CLOG(bCmdLineForce, LogRHI, Warning, TEXT("****************************** Forcing logging of PSOs from command line"));
}
return (bCmdLineForce || CVarPSOFileCacheLogPSO.GetValueOnAnyThread() == 1);
}
bool FPipelineFileCacheManager::ReportNewPSOs()
{
static bool bOnce = false;
static bool bCmdLineForce = false;
if (!bOnce)
{
bOnce = true;
bCmdLineForce = FParse::Param(FCommandLine::Get(), TEXT("reportpso"));
UE_CLOG(bCmdLineForce, LogRHI, Warning, TEXT("****************************** Forcing reporting of new PSOs from command line"));
}
return (bCmdLineForce || CVarPSOFileCacheReportPSO.GetValueOnAnyThread() == 1);
}
bool FPipelineFileCacheManager::LogPSODetails()
{
static bool bOnce = false;
static bool bCmdLineOption = false;
#if !UE_BUILD_SHIPPING
if (!bOnce)
{
bOnce = true;
bCmdLineOption = FParse::Param(FCommandLine::Get(), TEXT("logpsodetails"));
}
#endif
return bCmdLineOption;
}
void FPipelineFileCacheManager::Initialize(uint32 InGameVersion)
{
ClearOSPipelineCache();
// Make enabled explicit on a flag not the existence of "FileCache" object as we are using that behind a lock and in Open / Close operations
FileCacheEnabled = ShouldEnableFileCache();
FPipelineCacheFile::GameVersion = InGameVersion;
if (FPipelineCacheFile::GameVersion == 0)
{
// Defaulting the CL is fine though
FPipelineCacheFile::GameVersion = (uint32)FEngineVersion::Current().GetChangelist();
}
SET_MEMORY_STAT(STAT_NewCachedPSOMemory, 0);
SET_MEMORY_STAT(STAT_PSOStatMemory, 0);
}
bool FPipelineFileCacheManager::ShouldEnableFileCache()
{
if (!GRHISupportsPipelineFileCache)
{
return false;
}
#if PLATFORM_IOS
if (CVarAlwaysGeneratePOSSOFileCache.GetValueOnAnyThread() == 0)
{
struct stat FileInfo;
static FString PrivateWritePathBase = FString([NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0]) + TEXT("/");
FString Result = PrivateWritePathBase + FString([NSString stringWithFormat:@"/Caches/%@/com.apple.metal/functions.data", [NSBundle mainBundle].bundleIdentifier]);
FString Result2 = PrivateWritePathBase + FString([NSString stringWithFormat:@"/Caches/%@/com.apple.metal/usecache.txt", [NSBundle mainBundle].bundleIdentifier]);
if (stat(TCHAR_TO_UTF8(*Result), &FileInfo) != -1 && stat(TCHAR_TO_UTF8(*Result2), &FileInfo) != -1)
{
return false;
}
}
#endif
return true;
}
void FPipelineFileCacheManager::PreCompileComplete()
{
#if PLATFORM_IOS
// write out a file signifying we have completed a pre-compile of the PSO cache. Used on successive runs of the game to determine how much caching we need to still perform
static FString PrivateWritePathBase = FString([NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0]) + TEXT("/");
FString Result = PrivateWritePathBase + FString([NSString stringWithFormat:@"/Caches/%@/com.apple.metal/usecache.txt", [NSBundle mainBundle].bundleIdentifier]);
int32 Handle = open(TCHAR_TO_UTF8(*Result), O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
FString Version = FEngineVersion::Current().ToString();
write(Handle, TCHAR_TO_ANSI(*Version), Version.Len());
close(Handle);
#endif
}
void FPipelineFileCacheManager::ClearOSPipelineCache()
{
UE_LOG(LogTemp, Display, TEXT("Clearing the OS Cache"));
bool bCmdLineSkip = FParse::Param(FCommandLine::Get(), TEXT("skippsoclear"));
if (CVarClearOSPSOFileCache.GetValueOnAnyThread() > 0 && !bCmdLineSkip)
{
// clear the PSO cache on IOS if the executable is newer
#if PLATFORM_IOS
SCOPED_AUTORELEASE_POOL;
static FString ExecutablePath = FString([[NSBundle mainBundle] bundlePath]) + TEXT("/") + FPlatformProcess::ExecutableName();
struct stat FileInfo;
if(stat(TCHAR_TO_UTF8(*ExecutablePath), &FileInfo) != -1)
{
// TODO: add ability to only do this change on major release as opposed to minor release (e.g. 10.30 -> 10.40 (delete) vs 10.40 -> 10.40.1 (don't delete)), this is very much game specific, so need a way to have games be able to modify this
FTimespan ExecutableTime(0, 0, FileInfo.st_atime);
static FString PrivateWritePathBase = FString([NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0]) + TEXT("/");
FString Result = PrivateWritePathBase + FString([NSString stringWithFormat:@"/Caches/%@/com.apple.metal/functions.data", [NSBundle mainBundle].bundleIdentifier]);
if (stat(TCHAR_TO_UTF8(*Result), &FileInfo) != -1)
{
FTimespan DataTime(0, 0, FileInfo.st_atime);
if (ExecutableTime > DataTime)
{
UE_LOG(LogTemp, Display, TEXT("Clearing functions.data"));
unlink(TCHAR_TO_UTF8(*Result));
}
}
Result = PrivateWritePathBase + FString([NSString stringWithFormat:@"/Caches/%@/com.apple.metal/functions.maps", [NSBundle mainBundle].bundleIdentifier]);
if (stat(TCHAR_TO_UTF8(*Result), &FileInfo) != -1)
{
FTimespan MapsTime(0, 0, FileInfo.st_atime);
if (ExecutableTime > MapsTime)
{
UE_LOG(LogTemp, Display, TEXT("Clearing functions.maps"));
unlink(TCHAR_TO_UTF8(*Result));
}
}
}
#elif PLATFORM_MAC && (UE_BUILD_TEST || UE_BUILD_SHIPPING)
if (!FPlatformProcess::IsSandboxedApplication())
{
SCOPED_AUTORELEASE_POOL;
static FString ExecutablePath = FString([[NSBundle mainBundle] executablePath]);
struct stat FileInfo;
if (stat(TCHAR_TO_UTF8(*ExecutablePath), &FileInfo) != -1)
{
FTimespan ExecutableTime(0, 0, FileInfo.st_atime);
FString CacheDir = FString([NSString stringWithFormat:@"%@/../C/%@/com.apple.metal", NSTemporaryDirectory(), [NSBundle mainBundle].bundleIdentifier]);
TArray<FString> FoundFiles;
IPlatformFile::GetPlatformPhysical().FindFilesRecursively(FoundFiles, *CacheDir, TEXT(".data"));
// Find functions.data file in cache subfolders. If it's older than the executable, delete the whole cache.
bool bIsCacheOutdated = false;
for (FString& DataFile : FoundFiles)
{
if (FPaths::GetCleanFilename(DataFile) == TEXT("functions.data") && stat(TCHAR_TO_UTF8(*DataFile), &FileInfo) != -1)
{
FTimespan DataTime(0, 0, FileInfo.st_atime);
if (ExecutableTime > DataTime)
{
bIsCacheOutdated = true;
}
}
}
if (bIsCacheOutdated)
{
IPlatformFile::GetPlatformPhysical().DeleteDirectoryRecursively(*CacheDir);
}
}
}
#endif
}
}
int32 FPipelineFileCacheManager::GetTotalPSOCount(const FString& PSOCacheKey)
{
int32 TotalPSOs = 0;
if (IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
FPipelineCacheFile* Found = GetPipelineCacheFileFromKey(PSOCacheKey);
TotalPSOs = Found ? Found->GetTOCMetaDataSize() : 0;
}
return TotalPSOs;
}
uint64 FPipelineFileCacheManager::SetGameUsageMaskWithComparison(uint64 InGameUsageMask, FPSOMaskComparisonFn InComparisonFnPtr)
{
uint64 OldMask = 0;
if(IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
OldMask = FPipelineFileCacheManager::GameUsageMask;
FPipelineFileCacheManager::GameUsageMask = InGameUsageMask;
if(InComparisonFnPtr == nullptr)
{
InComparisonFnPtr = DefaultPSOMaskComparisonFunction;
}
FPipelineFileCacheManager::MaskComparisonFn = InComparisonFnPtr;
FPipelineFileCacheManager::GameUsageMaskSet = true;
}
return OldMask;
}
void FPipelineFileCacheManager::Shutdown()
{
if(IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
for (auto const& Pair : Stats)
{
delete Pair.Value;
}
Stats.Empty();
NewPSOs.Empty();
NewPSOHashes.Empty();
NumNewPSOs = 0;
FileCacheMap.Empty();
FileCacheEnabled = false;
SET_MEMORY_STAT(STAT_NewCachedPSOMemory, 0);
SET_MEMORY_STAT(STAT_PSOStatMemory, 0);
}
}
bool FPipelineFileCacheManager::HasPipelineFileCache(const FString & Key)
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
return FileCacheMap.Contains(Key);
}
bool FPipelineFileCacheManager::OpenPipelineFileCache(const FString& Key, const FString& CacheName, EShaderPlatform Platform, FGuid& OutGameFileGuid)
{
bool bOk = false;
OutGameFileGuid = FGuid();
if(IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
bool bFound = FileCacheMap.Contains(Key);
if(!bFound)
{
TUniquePtr<FPipelineCacheFile> NewFileCache = MakeUnique<FPipelineCacheFile>();
bOk = NewFileCache->OpenPipelineFileCache(CacheName, Platform, OutGameFileGuid);
if (!bOk)
{
NewFileCache = nullptr;
}
else
{
UE_LOG(LogRHI, Display, TEXT("FPipelineCacheFile[%s] opened %s, filename %s, guid %s. "), *Key, *CacheName, *NewFileCache->GetCacheFilename(), *NewFileCache->GetFileGuid().ToString());
FileCacheMap.Add(Key, MoveTemp(NewFileCache));
check(!GameGuidToCacheKey.Contains(OutGameFileGuid));
GameGuidToCacheKey.Add(OutGameFileGuid, Key);
}
}
}
return bOk;
}
bool FPipelineFileCacheManager::OpenUserPipelineFileCache(const FString& Key, const FString& CacheName, EShaderPlatform Platform, FGuid& OutGameFileGuid)
{
// close any existing cache and reset the user cache's PSO recording containers.
CloseUserPipelineFileCache();
bool bUserFileOpened = false;
if (IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
UserCacheKey = Key;
FPipelineCacheFile* FileCache = GetPipelineCacheFileFromKey(UserCacheKey);
if(ensure(!FileCache))
{
TUniquePtr<FPipelineCacheFile> NewFileCache = MakeUnique<FPipelineCacheFile>();
FileCache = NewFileCache.Get();
bUserFileOpened = NewFileCache->OpenUserPipelineFileCache(CacheName, Platform);
// we always add the user cache, even if we did not open a file
FileCacheMap.Add(UserCacheKey, MoveTemp(NewFileCache));
check(!GameGuidToCacheKey.Contains(FileCache->GetFileGuid()));
GameGuidToCacheKey.Add(FileCache->GetFileGuid(), UserCacheKey);
}
OutGameFileGuid = FileCache->GetFileGuid();
UE_LOG(LogRHI, Display, TEXT("FPipelineCacheFile User cache [key:%s] opened '%s'=%d, filename %s, guid %s. "), *UserCacheKey, *CacheName, (int)bUserFileOpened, *FileCache->GetCacheFilename(), *FileCache->GetFileGuid().ToString());
// User Cache now exists - these caches should be empty for this file otherwise will have false positives from any previous file caching - if not something has been caching when it should not be
check(NewPSOs.Num() == 0);
check(NewPSOHashes.Num() == 0);
check(RunTimeToPSOUsage.Num() == 0);
}
return bUserFileOpened;
}
void FPipelineFileCacheManager::CloseUserPipelineFileCache()
{
if (IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
if(GetPipelineCacheFileFromKey(UserCacheKey))
{
const FGuid& UserGuid = GetPipelineCacheFileFromKey(UserCacheKey)->GetFileGuid();
GameGuidToCacheKey.Remove(UserGuid);
FileCacheMap.Remove(UserCacheKey);
}
// Reset stats tracking for the next file.
for (auto const& Pair : Stats)
{
FPlatformAtomics::InterlockedExchange((int64*)&Pair.Value->TotalBindCount, -1);
FPlatformAtomics::InterlockedExchange((int64*)&Pair.Value->FirstFrameUsed, -1);
FPlatformAtomics::InterlockedExchange((int64*)&Pair.Value->LastFrameUsed, -1);
}
// Reset serialized counts
SET_DWORD_STAT(STAT_SerializedGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_SerializedComputePipelineStateCount, 0);
// Not tracking when there is no file clear other stats as well
SET_DWORD_STAT(STAT_TotalGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_TotalComputePipelineStateCount, 0);
SET_DWORD_STAT(STAT_TotalRayTracingPipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewGraphicsPipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewComputePipelineStateCount, 0);
SET_DWORD_STAT(STAT_NewRayTracingPipelineStateCount, 0);
// Clear Runtime hashes otherwise we can't start adding newPSO's for a newly opened file
RunTimeToPSOUsage.Empty();
NewPSOUsage.Empty();
NewPSOs.Empty();
NewPSOHashes.Empty();
NumNewPSOs = 0;
SET_MEMORY_STAT(STAT_NewCachedPSOMemory, 0);
}
}
bool FPipelineFileCacheManager::SavePipelineFileCache(SaveMode Mode)
{
bool bOk = false;
if (IsPipelineFileCacheEnabled() && LogPSOtoFileCache())
{
CSV_EVENT(PSO, TEXT("Saving PSO cache"));
FRWScopeLock Lock(FileCacheLock, SLT_Write);
FPipelineCacheFile* UserCache = GetPipelineCacheFileFromKey(UserCacheKey);
bOk = (UserCache != nullptr) && UserCache->SavePipelineFileCache(Mode, Stats, NewPSOs, RequestedOrder, NewPSOUsage);
// If successful clear new PSO's as they should have been saved out
// Leave everything else in-tact (e.g stats) for subsequent in place save operations
if (bOk)
{
NumNewPSOs = NewPSOs.Num();
SET_MEMORY_STAT(STAT_NewCachedPSOMemory, (NumNewPSOs * (sizeof(FPipelineCacheFileFormatPSO) + sizeof(uint32) + sizeof(uint32))));
}
}
return bOk;
}
void FPipelineFileCacheManager::RegisterPSOUsageDataUpdateForNextSave(FPSOUsageData& UsageData)
{
FPSOUsageData& CurrentEntry = NewPSOUsage.FindOrAdd(UsageData.PSOHash);
CurrentEntry.PSOHash = UsageData.PSOHash;
CurrentEntry.UsageMask |= UsageData.UsageMask;
CurrentEntry.EngineFlags |= UsageData.EngineFlags;
}
void FPipelineFileCacheManager::LogNewGraphicsPSOToConsoleAndCSV(FPipelineCacheFileFormatPSO& PSO, uint32 PSOHash, bool bWasPSOPrecached)
{
if (!LogNewPSOsToConsoleAndCSV)
{
return;
}
if (!bWasPSOPrecached)
{
CSV_EVENT(PSO, TEXT("Encountered new graphics PSO"));
UE_LOG(LogRHI, Display, TEXT("Encountered a new graphics PSO: %u"), PSOHash);
int32 LogDetailLevel = LogPSODetails() ? 2 : GPSOFileCachePrintNewPSODescriptors;
if (LogDetailLevel > 0)
{
UE_LOG(LogRHI, Display, TEXT("New Graphics PSO (%u)"), PSOHash);
if (LogDetailLevel > 1)
{
UE_LOG(LogRHI, Display, TEXT("%s"), *PSO.ToStringReadable());
}
}
}
else
{
UE_LOG(LogRHI, Verbose, TEXT("Encountered a new graphics PSO for the file cache but it was already precached at runtime: %u"), PSOHash);
}
}
void FPipelineFileCacheManager::LogNewComputePSOToConsoleAndCSV(FPipelineCacheFileFormatPSO& PSO, uint32 PSOHash, bool bWasPSOPrecached)
{
if (!LogNewPSOsToConsoleAndCSV)
{
return;
}
if (!bWasPSOPrecached)
{
CSV_EVENT(PSO, TEXT("Encountered new compute PSO"));
UE_LOG(LogRHI, Display, TEXT("Encountered a new compute PSO: %u"), PSOHash);
if (GPSOFileCachePrintNewPSODescriptors > 0)
{
UE_LOG(LogRHI, Display, TEXT("New compute PSO (%u) Description: %s"), PSOHash, *PSO.ComputeDesc.ComputeShader.ToString());
}
}
else
{
UE_LOG(LogRHI, Verbose, TEXT("Encountered a new compute PSO for the file cache but it was already precached at runtime: %u"), PSOHash);
}
}
void FPipelineFileCacheManager::LogNewRaytracingPSOToConsole(FPipelineCacheFileFormatPSO& PSO, uint32 PSOHash, bool bIsNonBlockingPSO)
{
// When non-blocking creation is used, encountering a non-cached RTPSO is not likely to cause a hitch and so the logging is not useful/actionable.
if (!LogNewPSOsToConsoleAndCSV || bIsNonBlockingPSO)
{
return;
}
UE_LOG(LogRHI, Display, TEXT("Encountered a new ray tracing PSO: %u"), PSOHash);
if (GPSOFileCachePrintNewPSODescriptors > 0)
{
UE_LOG(LogRHI, Display, TEXT("New ray tracing PSO (%u) Description: %s"), PSOHash, *PSO.RayTracingDesc.ToString());
}
}
void FPipelineFileCacheManager::BroadcastNewPSOsDelegate()
{
TArray<FPipelineCacheFileFormatPSO> PSOs;
{
FPipelineCacheFileFormatPSO PSO;
while (NewPSOsToReport.Dequeue(PSO))
{
PSOs.Emplace(MoveTemp(PSO));
}
}
if (!PSOs.IsEmpty() && ReportNewPSOs())
{
// It's not safe to touch UObjects-based delegates from the render thread.
ExecuteOnGameThread(TEXT("OnPipelineStateLoggedBroadcastGT"), [InPSOs = MoveTemp(PSOs)]()
{
if (PSOLoggedEvent.IsBound())
{
for (const FPipelineCacheFileFormatPSO& PSO : InPSOs)
{
PSOLoggedEvent.Broadcast(PSO);
}
}
});
}
}
void FPipelineFileCacheManager::CacheGraphicsPSO(uint32 RunTimeHash, FGraphicsPipelineStateInitializer const& Initializer, bool bWasPSOPrecached, FPipelineStateStats** OutStats)
{
if(IsPipelineFileCacheEnabled() && (LogPSOtoFileCache() || ReportNewPSOs()))
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
FPSOUsageData* PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr || !IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr)
{
FPipelineCacheFileFormatPSO NewEntry;
bool bOK = FPipelineCacheFileFormatPSO::Init(NewEntry, Initializer);
check(bOK);
uint32 PSOHash = GetTypeHash(NewEntry);
FPSOUsageData CurrentUsageData(PSOHash, 0, 0);
if (!FPipelineFileCacheManager::IsPSOEntryCached(NewEntry, &CurrentUsageData))
{
bool bActuallyNewPSO = !NewPSOHashes.Contains(PSOHash);
if (Initializer.bFromPSOFileCache)
{
// FIXME: this is a workaround. Needs proper investigation
UE_LOG(LogRHI, Warning, TEXT("PSO from the cache was not found in the cache! PSOHash: %u"), PSOHash);
bActuallyNewPSO = false;
}
if (bActuallyNewPSO && IsOpenGLPlatform(GMaxRHIShaderPlatform)) // OpenGL is a BSS platform and so we don't report BSS matches as missing.
{
bActuallyNewPSO = !FPipelineFileCacheManager::IsBSSEquivalentPSOEntryCached(NewEntry);
}
if (bActuallyNewPSO)
{
LogNewGraphicsPSOToConsoleAndCSV(NewEntry, PSOHash, bWasPSOPrecached);
if (bWasPSOPrecached)
{
bActuallyNewPSO = !GPSOExcludePrecachePSOsInFileCache;
}
}
if (bActuallyNewPSO)
{
if (LogPSOtoFileCache())
{
NewPSOs.Add(NewEntry);
INC_MEMORY_STAT_BY(STAT_NewCachedPSOMemory, sizeof(FPipelineCacheFileFormatPSO) + sizeof(uint32) + sizeof(uint32));
}
NewPSOHashes.Add(PSOHash);
NumNewPSOs++;
INC_DWORD_STAT(STAT_NewGraphicsPipelineStateCount);
INC_DWORD_STAT(STAT_TotalGraphicsPipelineStateCount);
if (ReportNewPSOs())
{
NewPSOsToReport.Enqueue(MoveTemp(NewEntry));
}
}
}
// Only set if the file cache doesn't have this Mask for the PSO - avoid making more entries and unnessary file saves
if(!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, CurrentUsageData.UsageMask))
{
CurrentUsageData.UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(CurrentUsageData);
}
// Apply the existing file PSO Usage mask and current to our "fast" runtime check
RunTimeToPSOUsage.Add(RunTimeHash, CurrentUsageData);
}
else if(!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
PSOUsage->UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(*PSOUsage);
}
}
// Optionally supply stats to share the lock scope
if (OutStats)
{
*OutStats = RegisterPSOStatsInternal(Lock, RunTimeHash);
}
}
}
void FPipelineFileCacheManager::CacheComputePSO(uint32 RunTimeHash, FRHIComputeShader const* Initializer, bool bWasPSOPrecached, FPipelineStateStats** OutStats)
{
if(IsPipelineFileCacheEnabled() && (LogPSOtoFileCache() || ReportNewPSOs()))
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
{
FPSOUsageData* PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr || !IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr)
{
FPipelineCacheFileFormatPSO NewEntry;
bool bOK = FPipelineCacheFileFormatPSO::Init(NewEntry, Initializer);
check(bOK);
uint32 PSOHash = GetTypeHash(NewEntry);
FPSOUsageData CurrentUsageData(PSOHash, 0, 0);
if (!FPipelineFileCacheManager::IsPSOEntryCached(NewEntry, &CurrentUsageData))
{
bool bActuallyNewPSO = !NewPSOHashes.Contains(PSOHash);
if (bActuallyNewPSO)
{
LogNewComputePSOToConsoleAndCSV(NewEntry, PSOHash, bWasPSOPrecached);
if (bWasPSOPrecached)
{
bActuallyNewPSO = !GPSOExcludePrecachePSOsInFileCache;
}
}
if (bActuallyNewPSO)
{
if (LogPSOtoFileCache())
{
NewPSOs.Add(NewEntry);
INC_MEMORY_STAT_BY(STAT_NewCachedPSOMemory, sizeof(FPipelineCacheFileFormatPSO) + sizeof(uint32) + sizeof(uint32));
}
NewPSOHashes.Add(PSOHash);
NumNewPSOs++;
INC_DWORD_STAT(STAT_NewComputePipelineStateCount);
INC_DWORD_STAT(STAT_TotalComputePipelineStateCount);
if (ReportNewPSOs())
{
NewPSOsToReport.Enqueue(MoveTemp(NewEntry));
}
}
}
// Only set if the file cache doesn't have this Mask for the PSO - avoid making more entries and unnessary file saves
if(!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, CurrentUsageData.UsageMask))
{
CurrentUsageData.UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(CurrentUsageData);
}
// Apply the existing file PSO Usage mask and current to our "fast" runtime check
RunTimeToPSOUsage.Add(RunTimeHash, CurrentUsageData);
}
else if(!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
PSOUsage->UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(*PSOUsage);
}
}
}
// Optionally supply stats to share the lock scope
if (OutStats)
{
*OutStats = RegisterPSOStatsInternal(Lock, RunTimeHash);
}
}
}
void FPipelineFileCacheManager::CacheRayTracingPSO(const FRayTracingPipelineStateInitializer& Initializer, ERayTracingPipelineCacheFlags Flags)
{
if (!IsPipelineFileCacheEnabled() || !(LogPSOtoFileCache() || ReportNewPSOs()))
{
return;
}
TArrayView<FRHIRayTracingShader*> ShaderTables[] =
{
Initializer.GetRayGenTable(),
Initializer.GetMissTable(),
Initializer.GetHitGroupTable(),
Initializer.GetCallableTable()
};
const bool bIsNonBlocking = !EnumHasAnyFlags(Flags, ERayTracingPipelineCacheFlags::NonBlocking);
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
for (TArrayView<FRHIRayTracingShader*>& Table : ShaderTables)
{
for (FRHIRayTracingShader* Shader : Table)
{
FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc Desc(Initializer, Shader);
uint32 RunTimeHash = GetTypeHash(Desc);
FPSOUsageData* PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if (PSOUsage == nullptr || !IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if (PSOUsage == nullptr)
{
FPipelineCacheFileFormatPSO NewEntry;
bool bOK = FPipelineCacheFileFormatPSO::Init(NewEntry, Desc);
check(bOK);
uint32 PSOHash = GetTypeHash(NewEntry);
FPSOUsageData CurrentUsageData(PSOHash, 0, 0);
if (!FPipelineFileCacheManager::IsPSOEntryCached(NewEntry, &CurrentUsageData))
{
LogNewRaytracingPSOToConsole(NewEntry, PSOHash, bIsNonBlocking);
if (LogPSOtoFileCache())
{
NewPSOs.Add(NewEntry);
INC_MEMORY_STAT_BY(STAT_NewCachedPSOMemory, sizeof(FPipelineCacheFileFormatPSO) + sizeof(uint32) + sizeof(uint32));
}
NumNewPSOs++;
INC_DWORD_STAT(STAT_NewRayTracingPipelineStateCount);
INC_DWORD_STAT(STAT_TotalRayTracingPipelineStateCount);
if (ReportNewPSOs())
{
NewPSOsToReport.Enqueue(MoveTemp(NewEntry));
}
}
// Only set if the file cache doesn't have this Mask for the PSO - avoid making more entries and unnessary file saves
if (!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, CurrentUsageData.UsageMask))
{
CurrentUsageData.UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(CurrentUsageData);
}
// Apply the existing file PSO Usage mask and current to our "fast" runtime check
RunTimeToPSOUsage.Add(RunTimeHash, CurrentUsageData);
// Immediately register usage of this ray tracing shader
FPipelineStateStats* Stat = Stats.FindRef(PSOHash);
if (Stat == nullptr)
{
Stat = new FPipelineStateStats;
Stat->FirstFrameUsed = 0;
Stat->LastFrameUsed = 0;
Stat->CreateCount = 1;
Stat->TotalBindCount = 1;
Stat->PSOHash = PSOHash;
Stats.Add(PSOHash, Stat);
INC_MEMORY_STAT_BY(STAT_PSOStatMemory, sizeof(FPipelineStateStats) + sizeof(uint32));
}
}
}
else if (!IsReferenceMaskSet(FPipelineFileCacheManager::GameUsageMask, PSOUsage->UsageMask))
{
PSOUsage->UsageMask |= FPipelineFileCacheManager::GameUsageMask;
RegisterPSOUsageDataUpdateForNextSave(*PSOUsage);
}
}
}
}
void FPipelineFileCacheManager::RegisterPSOCompileFailure(uint32 RunTimeHash, FGraphicsPipelineStateInitializer const& Initializer)
{
if(IsPipelineFileCacheEnabled() && (LogPSOtoFileCache() || ReportNewPSOs()) && Initializer.bFromPSOFileCache)
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
FPSOUsageData* PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr || !IsReferenceMaskSet(FPipelineCacheFlagInvalidPSO, PSOUsage->EngineFlags))
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if(PSOUsage == nullptr)
{
FPipelineCacheFileFormatPSO ShouldBeExistingEntry;
bool bOK = FPipelineCacheFileFormatPSO::Init(ShouldBeExistingEntry, Initializer);
check(bOK);
uint32 PSOHash = GetTypeHash(ShouldBeExistingEntry);
FPSOUsageData CurrentUsageData(PSOHash, 0, 0);
bool bCached = FPipelineFileCacheManager::IsPSOEntryCached(ShouldBeExistingEntry, &CurrentUsageData);
check(bCached); //bFromPSOFileCache was set but not in the cache something has gone wrong
{
CurrentUsageData.EngineFlags |= FPipelineCacheFlagInvalidPSO;
RegisterPSOUsageDataUpdateForNextSave(CurrentUsageData);
RunTimeToPSOUsage.Add(RunTimeHash, CurrentUsageData);
UE_LOG(LogRHI, Warning, TEXT("Graphics PSO (%u) compile failure registering to File Cache"), PSOHash);
}
}
else if(!IsReferenceMaskSet(FPipelineCacheFlagInvalidPSO, PSOUsage->EngineFlags))
{
PSOUsage->EngineFlags |= FPipelineCacheFlagInvalidPSO;
RegisterPSOUsageDataUpdateForNextSave(*PSOUsage);
UE_LOG(LogRHI, Warning, TEXT("Graphics PSO (%u) compile failure registering to File Cache"), PSOUsage->PSOHash);
}
}
}
}
FPipelineStateStats* FPipelineFileCacheManager::RegisterPSOStats(uint32 RunTimeHash)
{
if(IsPipelineFileCacheEnabled() && LogPSOtoFileCache())
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
return RegisterPSOStatsInternal(Lock, RunTimeHash);
}
return nullptr;
}
FPipelineStateStats* FPipelineFileCacheManager::RegisterPSOStatsInternal(FRWScopeLock& Lock, uint32 RunTimeHash)
{
// May fail registration if the user cache has been closed
FPSOUsageData* PSOUsage = RunTimeToPSOUsage.Find(RunTimeHash);
if (!PSOUsage)
{
UE_LOG(LogRHI, Display, TEXT("PSO (%u) missing from cache, please instead use the OutStats parameter in CacheGraphicsPSO/CacheComputePSO"), RunTimeHash);
return nullptr;
}
uint32 PSOHash = PSOUsage->PSOHash;
FPipelineStateStats* Stat = Stats.FindRef(PSOHash);
if (!Stat)
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
Stat = Stats.FindRef(PSOHash);
if (!Stat)
{
Stat = new FPipelineStateStats;
Stat->PSOHash = PSOHash;
Stats.Add(PSOHash, Stat);
INC_MEMORY_STAT_BY(STAT_PSOStatMemory, sizeof(FPipelineStateStats) + sizeof(uint32));
}
}
Stat->CreateCount++;
return Stat;
}
void FPipelineFileCacheManager::GetOrderedPSOHashes(const FString& PSOCacheKey, TArray<FPipelineCachePSOHeader>& PSOHashes, PSOOrder Order, int64 MinBindCount, TSet<uint32> const& AlreadyCompiledHashes)
{
if(IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_Write);
RequestedOrder = Order;
FPipelineCacheFile* FileCache = GetPipelineCacheFileFromKey(PSOCacheKey);
if(FileCache)
{
FileCache->GetOrderedPSOHashes(PSOHashes, Order, MinBindCount, AlreadyCompiledHashes);
}
}
}
void FPipelineFileCacheManager::FetchPSODescriptors(const FString& PSOCacheKey, TDoubleLinkedList<FPipelineCacheFileFormatPSORead*>& Batch)
{
if(IsPipelineFileCacheEnabled())
{
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
FPipelineCacheFile* FileCache = GetPipelineCacheFileFromKey(PSOCacheKey);
if(FileCache)
{
FileCache->FetchPSODescriptors(Batch);
}
}
}
struct FPipelineCacheFileData
{
FPipelineCacheFileFormatHeader Header;
TMap<uint32, FPipelineCacheFileFormatPSO> PSOs;
FPipelineCacheFileFormatTOC TOC;
static FPipelineCacheFileData Open(FString const& FilePath)
{
FPipelineCacheFileData Data;
Data.Header.Magic = 0;
FArchive* FileAReader = IFileManager::Get().CreateFileReader(*FilePath);
if (FileAReader)
{
*FileAReader << Data.Header;
if (Data.Header.Magic == FPipelineCacheFileFormatMagic && Data.Header.Version >= (uint32)EPipelineCacheFileFormatVersions::FirstWorking)
{
FileAReader->SetGameNetVer(Data.Header.Version);
check(Data.Header.TableOffset > 0);
FileAReader->Seek(Data.Header.TableOffset);
*FileAReader << Data.TOC;
if (!FileAReader->IsError())
{
for (auto& Entry : Data.TOC.MetaData)
{
if ( (Entry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) == 0 &&
Entry.Value.FileGuid == Data.Header.Guid &&
Entry.Value.FileSize > sizeof(FPipelineCacheFileFormatPSO::DescriptorType))
{
FPipelineCacheFileFormatPSO PSO;
FileAReader->Seek(Entry.Value.FileOffset);
*FileAReader << PSO;
#if PSO_COOKONLY_DATA
// Tools get cook data populated into the PSO as the PSOs can be independant from Meta data
if(Data.Header.Version >= (uint32)EPipelineCacheFileFormatVersions::PSOUsageMask)
{
PSO.UsageMask = Entry.Value.UsageMask;
}
if(Data.Header.Version >= (uint32)EPipelineCacheFileFormatVersions::PSOBindCount)
{
PSO.BindCount = Entry.Value.Stats.TotalBindCount;
}
#endif
Data.PSOs.Add(Entry.Key, PSO);
}
}
}
if (FileAReader->IsError())
{
UE_LOG(LogRHI, Error, TEXT("Failed to read: %s."), *FilePath);
Data.Header.Magic = 0;
}
else
{
if (Data.Header.Version < (uint32)EPipelineCacheFileFormatVersions::ShaderMetaData)
{
for (auto& Entry : Data.TOC.MetaData)
{
FPipelineCacheFileFormatPSO& PSO = Data.PSOs.FindChecked(Entry.Key);
switch(PSO.Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
Entry.Value.Shaders.Add(PSO.ComputeDesc.ComputeShader);
break;
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
Entry.Value.Shaders.Add(PSO.GraphicsDesc.VertexShader);
if (PSO.GraphicsDesc.FragmentShader != FSHAHash())
{
Entry.Value.Shaders.Add(PSO.GraphicsDesc.FragmentShader);
}
if (PSO.GraphicsDesc.GeometryShader != FSHAHash())
{
Entry.Value.Shaders.Add(PSO.GraphicsDesc.GeometryShader);
}
if (PSO.GraphicsDesc.MeshShader != FSHAHash())
{
Entry.Value.Shaders.Add(PSO.GraphicsDesc.MeshShader);
}
if (PSO.GraphicsDesc.AmplificationShader != FSHAHash())
{
Entry.Value.Shaders.Add(PSO.GraphicsDesc.AmplificationShader);
}
break;
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
Entry.Value.Shaders.Add(PSO.RayTracingDesc.ShaderHash);
break;
default:
check(false);
break;
}
}
}
if (Data.Header.Version < (uint32)EPipelineCacheFileFormatVersions::SortedVertexDesc)
{
TMap<uint32, FPipelineCacheFileFormatPSOMetaData> MetaData;
TMap<uint32, FPipelineCacheFileFormatPSO> PSOs;
for (auto& Entry : Data.TOC.MetaData)
{
FPipelineCacheFileFormatPSO& PSO = Data.PSOs.FindChecked(Entry.Key);
PSOs.Add(GetTypeHash(PSO), PSO);
check(Entry.Value.FileGuid != FGuid());
MetaData.Add(GetTypeHash(PSO), Entry.Value);
}
Data.TOC.MetaData = MetaData;
Data.PSOs = PSOs;
}
Data.Header.Version = FPipelineCacheFileFormatCurrentVersion;
}
}
FileAReader->Close();
delete FileAReader;
}
else
{
UE_LOG(LogRHI, Error, TEXT("Failed to open: %s."), *FilePath);
}
return Data;
}
};
uint32 FPipelineFileCacheManager::NumPSOsLogged()
{
uint32 Result = 0;
if(IsPipelineFileCacheEnabled() && LogPSOtoFileCache())
{
// Only count PSOs that are both new and have at least one bind or have been marked invalid (compile failure) otherwise we can ignore them
FRWScopeLock Lock(FileCacheLock, SLT_ReadOnly);
// We now need to know if the number of usage masks changes - this number should be as least the same as before but could be conceptually more if an existing PSO has an extra usage mask applied
if(NewPSOUsage.Num() > 0)
{
for(auto& MaskEntry : NewPSOUsage)
{
FPipelineStateStats const* Stat = Stats.FindRef(MaskEntry.Key);
if ((Stat && Stat->TotalBindCount > 0) || (MaskEntry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
Result++;
}
}
}
if(Result == 0 && NumNewPSOs > 0)
{
// This can happen if the Mask was zero at some point
for (auto& PSO : NewPSOs)
{
FPipelineStateStats const* Stat = Stats.FindRef(GetTypeHash(PSO));
if (Stat && Stat->TotalBindCount > 0)
{
Result++;
}
}
}
}
return Result;
}
FPipelineFileCacheManager::FPipelineStateLoggedEvent& FPipelineFileCacheManager::OnPipelineStateLogged()
{
return PSOLoggedEvent;
}
bool FPipelineFileCacheManager::LoadPipelineFileCacheInto(FString const& Path, TSet<FPipelineCacheFileFormatPSO>& PSOs)
{
FPipelineCacheFileData A = FPipelineCacheFileData::Open(Path);
bool bAny = false;
for (const auto& Pair : A.PSOs)
{
PSOs.Add(Pair.Value);
bAny = true;
}
return bAny;
}
bool FPipelineFileCacheManager::SavePipelineFileCacheFrom(uint32 GameVersion, EShaderPlatform Platform, FString const& Path, const TSet<FPipelineCacheFileFormatPSO>& PSOs)
{
FPipelineCacheFileData Output;
Output.Header.Magic = FPipelineCacheFileFormatMagic;
Output.Header.Version = FPipelineCacheFileFormatCurrentVersion;
Output.Header.GameVersion = GameVersion;
Output.Header.Platform = Platform;
Output.Header.TableOffset = 0;
Output.Header.Guid = FGuid::NewGuid();
Output.TOC.MetaData.Reserve(PSOs.Num());
for (const FPipelineCacheFileFormatPSO& Item : PSOs)
{
FPipelineCacheFileFormatPSOMetaData Meta;
Meta.Stats.PSOHash = GetTypeHash(Item);
Meta.FileGuid = Output.Header.Guid;
Meta.FileSize = 0;
#if PSO_COOKONLY_DATA
Meta.UsageMask = Item.UsageMask;
Meta.Stats.TotalBindCount = Item.BindCount;
#endif
switch (Item.Type)
{
case FPipelineCacheFileFormatPSO::DescriptorType::Compute:
{
INC_DWORD_STAT(STAT_SerializedComputePipelineStateCount);
Meta.Shaders.Add(Item.ComputeDesc.ComputeShader);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::Graphics:
{
INC_DWORD_STAT(STAT_SerializedGraphicsPipelineStateCount);
if (Item.GraphicsDesc.VertexShader != FSHAHash())
Meta.Shaders.Add(Item.GraphicsDesc.VertexShader);
if (Item.GraphicsDesc.FragmentShader != FSHAHash())
Meta.Shaders.Add(Item.GraphicsDesc.FragmentShader);
if (Item.GraphicsDesc.GeometryShader != FSHAHash())
Meta.Shaders.Add(Item.GraphicsDesc.GeometryShader);
if (Item.GraphicsDesc.MeshShader != FSHAHash())
Meta.Shaders.Add(Item.GraphicsDesc.MeshShader);
if (Item.GraphicsDesc.AmplificationShader != FSHAHash())
Meta.Shaders.Add(Item.GraphicsDesc.AmplificationShader);
break;
}
case FPipelineCacheFileFormatPSO::DescriptorType::RayTracing:
{
INC_DWORD_STAT(STAT_SerializedRayTracingPipelineStateCount);
Meta.Shaders.Add(Item.RayTracingDesc.ShaderHash);
break;
}
default:
{
check(false);
break;
}
}
check(Meta.FileGuid != FGuid());
Output.TOC.MetaData.Add(Meta.Stats.PSOHash, Meta);
Output.PSOs.Add(Meta.Stats.PSOHash, Item);
}
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*Path);
if (!FileWriter)
{
return false;
}
FileWriter->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
*FileWriter << Output.Header;
uint64 PSOOffset = (uint64)FileWriter->Tell();
for (auto& Entry : Output.TOC.MetaData)
{
FPipelineCacheFileFormatPSO& PSO = Output.PSOs.FindChecked(Entry.Key);
uint32 PSOHash = Entry.Key;
Entry.Value.FileOffset = PSOOffset;
Entry.Value.FileGuid = Output.Header.Guid;
TArray<uint8> Bytes;
FMemoryWriter Wr(Bytes);
Wr.SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
Wr << PSO;
FileWriter->Serialize(Bytes.GetData(), Wr.TotalSize());
Entry.Value.FileSize = Wr.TotalSize();
PSOOffset += Entry.Value.FileSize;
}
FileWriter->Seek(0);
Output.Header.TableOffset = PSOOffset;
*FileWriter << Output.Header;
FileWriter->Seek(PSOOffset);
*FileWriter << Output.TOC;
FileWriter->Flush();
bool bOK = !FileWriter->IsError();
FileWriter->Close();
delete FileWriter;
return bOK;
}
bool FPipelineFileCacheManager::MergePipelineFileCaches(FString const& PathA, FString const& PathB, FPipelineFileCacheManager::PSOOrder Order, FString const& OutputPath)
{
bool bOK = false;
FPipelineCacheFileData A = FPipelineCacheFileData::Open(PathA);
FPipelineCacheFileData B = FPipelineCacheFileData::Open(PathB);
if (A.Header.Magic == FPipelineCacheFileFormatMagic && B.Header.Magic == FPipelineCacheFileFormatMagic && A.Header.GameVersion == B.Header.GameVersion && A.Header.Platform == B.Header.Platform && A.Header.Version == FPipelineCacheFileFormatCurrentVersion && B.Header.Version == FPipelineCacheFileFormatCurrentVersion)
{
FPipelineCacheFileData Output;
Output.Header.Magic = FPipelineCacheFileFormatMagic;
Output.Header.Version = FPipelineCacheFileFormatCurrentVersion;
Output.Header.GameVersion = A.Header.GameVersion;
Output.Header.Platform = A.Header.Platform;
Output.Header.TableOffset = 0;
Output.Header.Guid = FGuid::NewGuid();
uint32 MergeCount = 0;
for (auto const& Entry : A.TOC.MetaData)
{
// Don't merge PSOs that have the invalid bit set
if((Entry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
continue;
}
Output.TOC.MetaData.Add(Entry.Key, Entry.Value);
}
for (auto const& Entry : B.TOC.MetaData)
{
// Don't merge PSOs that have the invalid bit set
if((Entry.Value.EngineFlags & FPipelineCacheFlagInvalidPSO) != 0)
{
continue;
}
// Make sure these usage masks for the same PSOHash find their way in
auto* ExistingMetaEntry = Output.TOC.MetaData.Find(Entry.Key);
if(ExistingMetaEntry != nullptr)
{
ExistingMetaEntry->UsageMask |= Entry.Value.UsageMask;
ExistingMetaEntry->EngineFlags |= Entry.Value.EngineFlags;
++MergeCount;
}
else
{
Output.TOC.MetaData.Add(Entry.Key, Entry.Value);
}
}
FPipelineCacheFile::SortMetaData(Output.TOC.MetaData, Order);
Output.TOC.SortedOrder = Order;
FArchive* FileWriter = IFileManager::Get().CreateFileWriter(*OutputPath);
if (FileWriter)
{
FileWriter->SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
FileWriter->Seek(0);
*FileWriter << Output.Header;
uint64 PSOOffset = (uint64)FileWriter->Tell();
TSet<uint32> HashesToRemove;
for (auto& Entry : Output.TOC.MetaData)
{
FPipelineCacheFileFormatPSO PSO;
if (Entry.Value.FileGuid == A.Header.Guid)
{
PSO = A.PSOs.FindChecked(Entry.Key);
}
else if (Entry.Value.FileGuid == B.Header.Guid)
{
PSO = B.PSOs.FindChecked(Entry.Key);
}
else
{
HashesToRemove.Add(Entry.Key);
continue;
}
uint32 PSOHash = Entry.Key;
Entry.Value.FileOffset = PSOOffset;
Entry.Value.FileGuid = Output.Header.Guid;
TArray<uint8> Bytes;
FMemoryWriter Wr(Bytes);
Wr.SetGameNetVer(FPipelineCacheFileFormatCurrentVersion);
Wr << PSO;
FileWriter->Serialize(Bytes.GetData(), Wr.TotalSize());
Entry.Value.FileSize = Wr.TotalSize();
PSOOffset += Entry.Value.FileSize;
}
for (uint32 Key : HashesToRemove)
{
Output.TOC.MetaData.Remove(Key);
}
FileWriter->Seek(0);
Output.Header.TableOffset = PSOOffset;
*FileWriter << Output.Header;
FileWriter->Seek(PSOOffset);
*FileWriter << Output.TOC;
FileWriter->Flush();
bOK = !FileWriter->IsError();
UE_CLOG(!bOK, LogRHI, Error, TEXT("Failed to write output file: %s."), *OutputPath);
FileWriter->Close();
delete FileWriter;
}
else
{
UE_LOG(LogRHI, Error, TEXT("Failed to open output file: %s."), *OutputPath);
}
}
else if (A.Header.GameVersion != B.Header.GameVersion)
{
UE_LOG(LogRHI, Error, TEXT("Incompatible game versions: %u vs. %u."), A.Header.GameVersion, B.Header.GameVersion);
}
else if (A.Header.Platform != B.Header.Platform)
{
UE_LOG(LogRHI, Error, TEXT("Incompatible shader platforms: %s vs. %s."), *LegacyShaderPlatformToShaderFormat(A.Header.Platform).ToString(), *LegacyShaderPlatformToShaderFormat(B.Header.Platform).ToString());
}
else if (A.Header.Version != B.Header.Version)
{
UE_LOG(LogRHI, Error, TEXT("Incompatible file versions: %u vs. %u."), A.Header.Version, B.Header.Version);
}
else
{
UE_LOG(LogRHI, Error, TEXT("Incompatible file headers: %" UINT64_FMT " vs. %" UINT64_FMT ": expected %" UINT64_FMT "."), A.Header.Magic, B.Header.Magic, FPipelineCacheFileFormatMagic);
}
return bOK;
}
FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc::FPipelineFileCacheRayTracingDesc(const FRayTracingPipelineStateInitializer& Initializer, const FRHIRayTracingShader* ShaderRHI)
: ShaderHash(ShaderRHI->GetHash())
, Frequency(ShaderRHI->GetFrequency())
, ShaderBindingLayout(Initializer.ShaderBindingLayout ? *Initializer.ShaderBindingLayout : FRHIShaderBindingLayout())
{
}
FString FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc::HeaderLine() const
{
FString Result(TEXT("RayTracingShader,DeprecatedMaxPayloadSizeInBytes,Frequency,ShaderBindingLayout-Hash,ShaderBindingLayout-Flags,ShaderBindingLayout-NumUBEntries"));
for (int32 Index = 0; Index < FRHIShaderBindingLayout::MaxUniformBufferEntries; Index++)
{
Result += FString::Printf(TEXT(",%s%d,%s%d,%s%d,%s%d,%s%d,%s%d")
, TEXT("ShaderBindingLayout-UBEntry-Name"), Index
, TEXT("ShaderBindingLayout-UBEntry-RegisterSpace"), Index
, TEXT("ShaderBindingLayout-UBEntry-CBVResourceIndex"), Index
, TEXT("ShaderBindingLayout-UBEntry-BaseSRVResourceIndex"), Index
, TEXT("ShaderBindingLayout-UBEntry-BaseUAVResourceIndex"), Index
, TEXT("ShaderBindingLayout-UBEntry-BaseSamplerResourceIndex"), Index
);
}
return Result;
}
FString FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc::ToString() const
{
FString Result = FString::Printf(TEXT("%s,%d,%d,%d,%d,%d")
, *ShaderHash.ToString()
, DeprecatedMaxPayloadSizeInBytes
, uint32(Frequency)
, ShaderBindingLayout.GetHash()
, ShaderBindingLayout.GetFlags()
, ShaderBindingLayout.GetNumUniformBufferEntries()
);
for (uint32 Index = 0; Index < FRHIShaderBindingLayout::MaxUniformBufferEntries; Index++)
{
FRHIUniformBufferShaderBindingLayout Entry = Index < ShaderBindingLayout.GetNumUniformBufferEntries() ? ShaderBindingLayout.GetUniformBufferEntry(Index) : FRHIUniformBufferShaderBindingLayout();
Result += FString::Printf(TEXT(",%s,%d,%d,%d,%d,%d")
, Entry.LayoutName.Len() > 0 ? *Entry.LayoutName : TEXT("None")
, Entry.RegisterSpace
, Entry.CBVResourceIndex
, Entry.BaseSRVResourceIndex
, Entry.BaseUAVResourceIndex
, Entry.BaseSamplerResourceIndex
);
}
return Result;
}
void FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc::AddToReadableString(TReadableStringBuilder& OutBuilder) const
{
// TODO: probably needs a better implementation once we get to this
switch (Frequency)
{
case SF_RayGen:
OutBuilder << TEXT(" RGS:");
break;
case SF_RayCallable:
OutBuilder << TEXT(" RCS:");
break;
case SF_RayHitGroup:
OutBuilder << TEXT(" RHGS:");
break;
case SF_RayMiss:
OutBuilder << TEXT(" RMS:");
break;
}
OutBuilder << ShaderHash.ToString();
OutBuilder << TEXT(" AHGI ");
}
void FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc::FromString(const FString& Src)
{
TArray<FString> Parts;
Src.TrimStartAndEnd().ParseIntoArray(Parts, TEXT(","));
// make sure we have required number of parts
if (Parts.Num() != (6 + 6 * FRHIShaderBindingLayout::MaxUniformBufferEntries))
{
return;
}
ShaderHash.FromString(Parts[0]);
// Not used, but kept for back-compatibility
LexFromString(DeprecatedMaxPayloadSizeInBytes, Parts[1]);
uint32 Temp = 0;
LexFromString(Temp, Parts[2]);
Frequency = EShaderFrequency(Temp);
uint32 ShaderBiningLayoutHash;
LexFromString(ShaderBiningLayoutHash, Parts[3]);
LexFromString(Temp, Parts[4]);
EShaderBindingLayoutFlags ShaderBindingLayoutFlags = (EShaderBindingLayoutFlags) Temp;
uint32 ShaderBindingLayoutNumUniformBuffers;
LexFromString(ShaderBindingLayoutNumUniformBuffers, Parts[5]);
uint32 CurrentPartIndex = 6;
TArray<FRHIUniformBufferShaderBindingLayout> ShaderBindingLayoutUBEntries;
ShaderBindingLayoutUBEntries.SetNum(ShaderBindingLayoutNumUniformBuffers);
for (uint32 UBEntryIndex = 0; UBEntryIndex < ShaderBindingLayoutNumUniformBuffers; ++UBEntryIndex)
{
FRHIUniformBufferShaderBindingLayout& UBEntry = ShaderBindingLayoutUBEntries[UBEntryIndex];
UBEntry.LayoutName = Parts[CurrentPartIndex++];
LexFromString(Temp, Parts[CurrentPartIndex++]);
UBEntry.RegisterSpace = Temp;
LexFromString(Temp, Parts[CurrentPartIndex++]);
UBEntry.CBVResourceIndex = Temp;
LexFromString(Temp, Parts[CurrentPartIndex++]);
UBEntry.BaseSRVResourceIndex = Temp;
LexFromString(Temp, Parts[CurrentPartIndex++]);
UBEntry.BaseUAVResourceIndex = Temp;
LexFromString(Temp, Parts[CurrentPartIndex++]);
UBEntry.BaseSamplerResourceIndex = Temp;
}
ShaderBindingLayout = FRHIShaderBindingLayout(ShaderBindingLayoutFlags, ShaderBindingLayoutUBEntries);
check(ShaderBindingLayout.GetHash() == ShaderBiningLayoutHash);
}
bool FPipelineCacheFileFormatPSO::Init(FPipelineCacheFileFormatPSO& PSO, FPipelineCacheFileFormatPSO::FPipelineFileCacheRayTracingDesc const& Desc)
{
PSO.Type = DescriptorType::RayTracing;
#if PSO_COOKONLY_DATA
PSO.UsageMask = 0;
PSO.BindCount = 0;
#endif
PSO.RayTracingDesc = Desc;
return true;
}
Reference in New Issue View Git Blame Copy Permalink