ShaderPipelineCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/List.h"
#include "Stats/Stats.h"
#include "RHI.h"
#include "TickableObjectRenderThread.h"
#include "PipelineFileCache.h"
#include "Delegates/DelegateCombinations.h"
#include "ShaderStableKeyDebugInfoReader.h"
 
class FBlendStateInitializerRHI;
class FRHIBlendState;
class FRHICommandListImmediate;
class FRHIDepthStencilState;
class FRHIRasterizerState;
class FSHAHash;
class FShaderPipelineCacheArchive;
struct FDepthStencilStateInitializerRHI;
struct FRasterizerStateInitializerRHI;
 
class FShaderPipelineCache : public FTickableObjectRenderThread
{
    // the FShaderPipelineCacheTask class represents a pipeline precompile of a single PSO file cache.
    friend class FShaderPipelineCacheTask;
public:
    static RENDERCORE_API void Initialize(EShaderPlatform Platform);
    static RENDERCORE_API void Shutdown();
 
    static RENDERCORE_API void PauseBatching();
    
    enum class BatchMode
    {
        Background, // The maximum batch size is defined by r.ShaderPipelineCache.BackgroundBatchSize
        Fast, // The maximum batch size is defined by r.ShaderPipelineCache.BatchSize
        Precompile // The maximum batch size is defined by r.ShaderPipelineCache.PrecompileBatchSize
    };
    
    static RENDERCORE_API void SetBatchMode(BatchMode Mode);
    
    static RENDERCORE_API void ResumeBatching();
    
    static RENDERCORE_API bool IsPrecompiling();
 
    static RENDERCORE_API uint32 NumPrecompilesRemaining();
    
    static RENDERCORE_API bool OpenPipelineFileCache(EShaderPlatform Platform);
 
    static RENDERCORE_API bool OpenUserPipelineFileCache(EShaderPlatform Platform);
    
    static RENDERCORE_API bool SavePipelineFileCache(FPipelineFileCacheManager::SaveMode Mode);
    
    static RENDERCORE_API void CloseUserPipelineFileCache();
 
    static RENDERCORE_API int32 GetGameVersionForPSOFileCache();
    
    static RENDERCORE_API bool SetGameUsageMaskWithComparison(uint64 Mask, FPSOMaskComparisonFn InComparisonFnPtr);
 
    static RENDERCORE_API bool IsBatchingPaused();
    
    RENDERCORE_API FShaderPipelineCache(EShaderPlatform Platform);
    RENDERCORE_API virtual ~FShaderPipelineCache();
 
    RENDERCORE_API bool IsTickable() const;
 
    RENDERCORE_API void Tick( FRHICommandListImmediate& RHICmdList, float DeltaTime );
 
    UE_DEPRECATED(5.7, "Tick needs a command list")
    RENDERCORE_API void Tick( float DeltaTime );
 
    RENDERCORE_API bool NeedsRenderingResumedForRenderingThreadTick() const;
    
    RENDERCORE_API TStatId GetStatId() const;
    
    enum ELibraryState
    {
        Opened,
        OpenedComponent,
        Closed
    };
    
    static RENDERCORE_API void ShaderLibraryStateChanged(ELibraryState State, EShaderPlatform Platform, FString const& Name, int32 ComponentID);
 
    class FShaderCachePrecompileContext
    {
        bool bSlowPrecompileTask = false;
        FString CacheName;
    public:
        FShaderCachePrecompileContext() = default;
        FShaderCachePrecompileContext(const FString& CacheNameIn) : CacheName(CacheNameIn) {}
 
        const FString& GetCacheName() const { return CacheName; }
        void SetPrecompilationIsSlowTask() { bSlowPrecompileTask = true; }
        bool IsPrecompilationSlowTask() const { return bSlowPrecompileTask; }
    };
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FShaderCachePreOpenDelegate, FString const& /* Name */, EShaderPlatform /* Platform*/, bool& /* Ready */);
    
    static FShaderCachePreOpenDelegate& GetCachePreOpenDelegate() { return OnCachePreOpen; }
    
    DECLARE_MULTICAST_DELEGATE_FiveParams(FShaderCacheOpenedDelegate, FString const& /* Name */, EShaderPlatform /* Platform*/, uint32 /* Count */, const FGuid& /* CacheFileGuid */, FShaderCachePrecompileContext& /*ShaderCachePrecompileContext*/);
    
    static FShaderCacheOpenedDelegate& GetCacheOpenedDelegate() { return OnCachedOpened; }
    
    DECLARE_MULTICAST_DELEGATE_TwoParams(FShaderCacheClosedDelegate, FString const& /* Name */, EShaderPlatform /* Platform*/ );
    
    static FShaderCacheClosedDelegate& GetCacheClosedDelegate() { return OnCachedClosed; }
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FShaderPrecompilationBeginDelegate, uint32 , const FShaderCachePrecompileContext& /*ShaderCachePrecompileContext*/);
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FShaderPrecompilationCompleteDelegate, uint32 , double , const FShaderCachePrecompileContext& /*ShaderCachePrecompileContext*/);
 
    static FShaderPrecompilationBeginDelegate& GetPrecompilationBeginDelegate() { return OnPrecompilationBegin; }
 
    static FShaderPrecompilationCompleteDelegate& GetPrecompilationCompleteDelegate() { return OnPrecompilationComplete; }
 
private:
    static inline FShaderPipelineCache* Get() { return ShaderPipelineCache; }
 
    RENDERCORE_API bool OpenPipelineFileCacheInternal(bool bUserCache, const FString& PSOCacheKey, const FString& CacheName, EShaderPlatform Platform);
 
    RENDERCORE_API void BeginNextPrecompileCacheTask();
    RENDERCORE_API void BeginNextPrecompileCacheTaskInternal();
    RENDERCORE_API bool ReadyForAutoSave() const;
 
    RENDERCORE_API void ClearPendingPrecompileTaskQueue();
    RENDERCORE_API void EnqueuePendingPrecompileTask(const FString& PSOCacheKey);
    RENDERCORE_API int ApplyNewUsageMaskToAllTasks(uint64 Mask);
 
    RENDERCORE_API FRHIBlendState* GetOrCreateBlendState(const FBlendStateInitializerRHI& Initializer);
    RENDERCORE_API FRHIRasterizerState* GetOrCreateRasterizerState(const FRasterizerStateInitializerRHI& Initializer);
    RENDERCORE_API FRHIDepthStencilState* GetOrCreateDepthStencilState(const FDepthStencilStateInitializerRHI& Initializer);
    
private:
    static RENDERCORE_API FShaderPipelineCache* ShaderPipelineCache;
    static RENDERCORE_API uint32 BatchSize;
    static RENDERCORE_API float BatchTime;
    bool bPaused;
    int32 PausedCount;
    double LastAutoSaveTime = 0.0;
    double LastAutoSaveTimeLogBoundPSO = 0.0;
    int32 LastAutoSaveNum = 0;
    TSet<uint32> CompiledHashes;
 
    UE::ShaderUtils::FShaderStableKeyDebugInfoReader ShaderHashToStableKey;
 
    static RENDERCORE_API FString UserCacheTaskKey;
 
    struct FPipelineCachePSOContext
    {
        FString FileName;
        EShaderPlatform CurrentPlatform;
 
        FShaderCachePrecompileContext PrecompileContext;
    };
    
    TMap<FString, TUniquePtr<class FShaderPipelineCacheTask>> ShaderCacheTasks;
 
    class FShaderPipelineCacheTask* GetTask(const FString& Name) {
        TUniquePtr<class FShaderPipelineCacheTask>* CacheTask = FShaderPipelineCache::Get()->ShaderCacheTasks.Find(Name);
        return CacheTask ? CacheTask->Get() : nullptr;
    }
 
    // The list of pending PSO cache names to precompile.
    TArray<FString> PendingPrecompilePSOCacheKeys;
 
    // The name of the current precompiling PSO cache.
    FString CurrentPrecompilingPSOFCKey;
 
    // Used for threadsafe query of pending pipeline compiles.
    std::atomic_bool bHasShaderPipelineTask = false;
 
    mutable FCriticalSection Mutex;
    FGraphEventRef NextPrecompileCacheTask;
 
    static RENDERCORE_API FShaderCachePreOpenDelegate OnCachePreOpen;
    static RENDERCORE_API FShaderCacheOpenedDelegate OnCachedOpened;
    static RENDERCORE_API FShaderCacheClosedDelegate OnCachedClosed;
    static RENDERCORE_API FShaderPrecompilationBeginDelegate OnPrecompilationBegin;
    static RENDERCORE_API FShaderPrecompilationCompleteDelegate OnPrecompilationComplete;
 
    TMap<FBlendStateInitializerRHI, FRHIBlendState*> BlendStateCache;
    TMap<FRasterizerStateInitializerRHI, FRHIRasterizerState*> RasterizerStateCache;
    TMap<FDepthStencilStateInitializerRHI, FRHIDepthStencilState*> DepthStencilStateCache;
};