RenderGraphEvent.inl

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if RHI_NEW_GPU_PROFILER
 
// @todo - new gpu profiler
 
#else
 
#if HAS_GPU_STATS
inline FRDGScope_GPU::FRDGScope_GPU(FRDGScopeState& State, FRHIGPUMask GPUMask, const FName& CsvStatName, const TStatId& Stat, const TCHAR* Description, FRHIDrawStatsCategory const& Category)
    : CurrentCategory(Category.ShouldCountDraws() ? &Category : nullptr),
      bEmitDuringExecute(AreGPUStatsEnabled() && !State.ScopeState.bParallelExecute)
{
    if (AreGPUStatsEnabled())
    {
        if (bEmitDuringExecute)
        { 
            StatName = CsvStatName;
            StatId = Stat;
            StatDescription = FString(Description);
        }
        else
        {
            StartQuery = FRealtimeGPUProfiler::Get()->PushEvent(GPUMask, CsvStatName, Stat, Description);
        }
    }
}
 
inline void FRDGScope_GPU::ImmediateEnd(FRDGScopeState&)
{
    if (StartQuery)
    {
        StopQuery = FRealtimeGPUProfiler::Get()->PopEvent();
    }
}
 
inline FRDGScope_GPU::~FRDGScope_GPU()
{
    if (StartQuery)
    {
        StartQuery.Discard(true);
    }
    if (StopQuery)
    {
        StopQuery.Discard(false);
    }
}
 
inline void FRDGScope_GPU::BeginCPU(FRHIComputeCommandList& RHICmdList, bool bPreScope)
{
    if (CurrentCategory)
    {
        PreviousCategory = RHICmdList.SetDrawStatsCategory(CurrentCategory);
    }
}
 
inline void FRDGScope_GPU::EndCPU(FRHIComputeCommandList& RHICmdList, bool bPreScope)
{
    if (CurrentCategory)
    {
        RHICmdList.SetDrawStatsCategory(PreviousCategory);
    }
}
 
inline void FRDGScope_GPU::BeginGPU(FRHIComputeCommandList& RHICmdList)
{
    if (EnumHasAnyFlags(RHICmdList.GetPipeline(), ERHIPipeline::Graphics))
    {
        if (bEmitDuringExecute)
        {
            FRealtimeGPUProfiler::Get()->PushStat(RHICmdList.GetAsImmediate(), StatName, StatId, *StatDescription);
        }
        else if (StartQuery)
        {
            StartQuery.Submit(static_cast<FRHICommandList&>(RHICmdList), true);
        }
    }
}
 
inline void FRDGScope_GPU::EndGPU(FRHIComputeCommandList& RHICmdList)
{
    if (EnumHasAnyFlags(RHICmdList.GetPipeline(), ERHIPipeline::Graphics))
    {
        if (bEmitDuringExecute)
        {
            FRealtimeGPUProfiler::Get()->PopStat(RHICmdList.GetAsImmediate());
        }
        else if (StopQuery)
        {
            StopQuery.Submit(static_cast<FRHICommandList&>(RHICmdList), false);
        }
    
    }
}
#endif
 
#endif // (RHI_NEW_GPU_PROFILER == 0)
 
#if RDG_EVENTS
 
    template <typename TDesc, typename... TValues>
    inline FRDGScope_RHI::FRDGScope_RHI(FRDGScopeState& State, TRHIBreadcrumbInitializer<TDesc, TValues...>&& Args)
        : FRDGScope_RHI(State, State.GetBreadcrumbAllocator().AllocBreadcrumb(MoveTemp(Args)))
    {}
 
    inline FRDGScope_RHI::FRDGScope_RHI(FRDGScopeState& State, FRHIBreadcrumbNode* Node)
        : Node(Node)
    {
        if (Node)
        {
            Node->SetParent(State.CurrentBreadcrumbRef);
            State.CurrentBreadcrumbRef = Node;
            Node->TraceBeginCPU();
 
            if (!State.ScopeState.bImmediate)
            {
                // Link breadcrumbs together, so we can iterate over them during RDG compilation.
                State.LocalBreadcrumbList.Append(Node);
            }
        }
    }
 
    inline void FRDGScope_RHI::ImmediateEnd(FRDGScopeState& State)
    {
    #if WITH_RHI_BREADCRUMBS
        if (Node)
        {
            Node->TraceEndCPU();
            State.CurrentBreadcrumbRef = Node->GetParent();
        }
    #endif
    }
 
#endif //  RDG_EVENTS
 
template <typename TScopeType>
template <typename... TArgs>
inline TRDGEventScopeGuard<TScopeType>::TRDGEventScopeGuard(FRDGScopeState& State, ERDGScopeFlags Flags, TArgs&&... Args)
    : State(State)
    , Scope(State.Allocators.Root.Alloc<FRDGScope>(State.ScopeState.Current))
{
    if (EnumHasAnyFlags(Flags, ERDGScopeFlags::Final))
    {
        // Mask off any nested scopes of the same type
        State.ScopeState.Mask |= FRDGScope::GetTypeMask<TScopeType>();
    }
 
    State.ScopeState.Current = Scope;
 
    Scope->Impl.Emplace<TScopeType>(State, Forward<TArgs>(Args)...);
 
    if (State.ScopeState.bImmediate)
    {
        Scope->BeginCPU(State.RHICmdList, false);
        Scope->BeginGPU(State.RHICmdList);
    }
}
 
template <typename TScopeType>
inline TRDGEventScopeGuard<TScopeType>::~TRDGEventScopeGuard()
{
    if (Scope)
    {
        if (State.ScopeState.bImmediate)
        {
            Scope->EndGPU(State.RHICmdList);
            Scope->EndCPU(State.RHICmdList, false);
        }
 
        Scope->ImmediateEnd(State);
 
        State.ScopeState.Mask &= ~(FRDGScope::GetTypeMask<TScopeType>());
        State.ScopeState.Current = State.ScopeState.Current->Parent;
    }
}
 
template <typename TScopeType>
inline bool FRDGScopeState::ShouldAllocScope(TOptional<TRDGEventScopeGuard<TScopeType>> const&, ERDGScopeFlags Flags) const
{
    if (ScopeState.ScopeMode == ERDGScopeMode::Disabled && !EnumHasAnyFlags(Flags, ERDGScopeFlags::AlwaysEnable))
    {
        return false;
    }
 
    if (ScopeState.ScopeMode == ERDGScopeMode::TopLevelOnly && (ScopeState.Mask & FRDGScope::GetTypeMask<TScopeType>()))
    {
        return false;
    }
 
    return true;
}