File size: 7,395 Bytes
7fd553e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | // Copyright Epic Games, Inc. All Rights Reserved.
#include "LyraPerformanceStatSubsystem.h"
#include "Engine/Engine.h"
#include "Engine/GameInstance.h"
#include "Engine/NetConnection.h"
#include "Engine/World.h"
#include "GameFramework/PlayerState.h"
#include "GameModes/LyraGameState.h"
#include "Performance/LyraPerformanceStatTypes.h"
#include "Performance/LatencyMarkerModule.h"
#include "ProfilingDebugging/CsvProfiler.h"
#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraPerformanceStatSubsystem)
CSV_DEFINE_CATEGORY(LyraPerformance, /*bIsEnabledByDefault=*/false);
class FSubsystemCollectionBase;
//////////////////////////////////////////////////////////////////////
// FLyraPerformanceStatCache
void FLyraPerformanceStatCache::StartCharting()
{
}
void FLyraPerformanceStatCache::ProcessFrame(const FFrameData& FrameData)
{
// Record stats about the frame data
{
RecordStat(
ELyraDisplayablePerformanceStat::ClientFPS,
(FrameData.TrueDeltaSeconds != 0.0) ?
1.0 / FrameData.TrueDeltaSeconds :
0.0);
RecordStat(ELyraDisplayablePerformanceStat::IdleTime, FrameData.IdleSeconds);
RecordStat(ELyraDisplayablePerformanceStat::FrameTime, FrameData.TrueDeltaSeconds);
RecordStat(ELyraDisplayablePerformanceStat::FrameTime_GameThread, FrameData.GameThreadTimeSeconds);
RecordStat(ELyraDisplayablePerformanceStat::FrameTime_RenderThread, FrameData.RenderThreadTimeSeconds);
RecordStat(ELyraDisplayablePerformanceStat::FrameTime_RHIThread, FrameData.RHIThreadTimeSeconds);
RecordStat(ELyraDisplayablePerformanceStat::FrameTime_GPU, FrameData.GPUTimeSeconds);
}
if (UWorld* World = MySubsystem->GetGameInstance()->GetWorld())
{
// Record some networking related stats
if (const ALyraGameState* GameState = World->GetGameState<ALyraGameState>())
{
RecordStat(ELyraDisplayablePerformanceStat::ServerFPS, GameState->GetServerFPS());
}
if (APlayerController* LocalPC = GEngine->GetFirstLocalPlayerController(World))
{
if (APlayerState* PS = LocalPC->GetPlayerState<APlayerState>())
{
RecordStat(ELyraDisplayablePerformanceStat::Ping, PS->GetPingInMilliseconds());
}
if (UNetConnection* NetConnection = LocalPC->GetNetConnection())
{
const UNetConnection::FNetConnectionPacketLoss& InLoss = NetConnection->GetInLossPercentage();
RecordStat(ELyraDisplayablePerformanceStat::PacketLoss_Incoming, InLoss.GetAvgLossPercentage());
const UNetConnection::FNetConnectionPacketLoss& OutLoss = NetConnection->GetOutLossPercentage();
RecordStat(ELyraDisplayablePerformanceStat::PacketLoss_Outgoing, OutLoss.GetAvgLossPercentage());
RecordStat(ELyraDisplayablePerformanceStat::PacketRate_Incoming, NetConnection->InPacketsPerSecond);
RecordStat(ELyraDisplayablePerformanceStat::PacketRate_Outgoing, NetConnection->OutPacketsPerSecond);
RecordStat(ELyraDisplayablePerformanceStat::PacketSize_Incoming, (NetConnection->InPacketsPerSecond != 0) ? (NetConnection->InBytesPerSecond / (float)NetConnection->InPacketsPerSecond) : 0.0f);
RecordStat(ELyraDisplayablePerformanceStat::PacketSize_Outgoing, (NetConnection->OutPacketsPerSecond != 0) ? (NetConnection->OutBytesPerSecond / (float)NetConnection->OutPacketsPerSecond) : 0.0f);
}
// Finally, record some input latency related stats if they are enabled
TArray<ILatencyMarkerModule*> LatencyMarkerModules = IModularFeatures::Get().GetModularFeatureImplementations<ILatencyMarkerModule>(ILatencyMarkerModule::GetModularFeatureName());
for (ILatencyMarkerModule* LatencyMarkerModule : LatencyMarkerModules)
{
if (LatencyMarkerModule->GetEnabled())
{
const float TotalLatencyMs = LatencyMarkerModule->GetTotalLatencyInMs();
if (TotalLatencyMs > 0.0f)
{
// Record some stats about the latency of the game
RecordStat(ELyraDisplayablePerformanceStat::Latency_Total, TotalLatencyMs);
RecordStat(ELyraDisplayablePerformanceStat::Latency_Game, LatencyMarkerModule->GetGameLatencyInMs());
RecordStat(ELyraDisplayablePerformanceStat::Latency_Render, LatencyMarkerModule->GetRenderLatencyInMs());
// Record some CSV profile stats.
// You can see these by using the following commands
// Start and stop the profile:
// CsvProfile Start
// CsvProfile Stop
//
// Or, you can profile for a certain number of frames:
// CsvProfile Frames=10
//
// And this will output a .csv file to the Saved\Profiling\CSV folder
#if CSV_PROFILER
if (FCsvProfiler* Profiler = FCsvProfiler::Get())
{
static const FName TotalLatencyStatName = TEXT("Lyra_Latency_Total");
Profiler->RecordCustomStat(TotalLatencyStatName, CSV_CATEGORY_INDEX(LyraPerformance), TotalLatencyMs, ECsvCustomStatOp::Set);
static const FName GameLatencyStatName = TEXT("Lyra_Latency_Game");
Profiler->RecordCustomStat(GameLatencyStatName, CSV_CATEGORY_INDEX(LyraPerformance), LatencyMarkerModule->GetGameLatencyInMs(), ECsvCustomStatOp::Set);
static const FName RenderLatencyStatName = TEXT("Lyra_Latency_Render");
Profiler->RecordCustomStat(RenderLatencyStatName, CSV_CATEGORY_INDEX(LyraPerformance), LatencyMarkerModule->GetRenderLatencyInMs(), ECsvCustomStatOp::Set);
}
#endif
// Some more fine grain latency numbers can be found on the marker module if desired
//LatencyMarkerModule->GetRenderLatencyInMs()));
//LatencyMarkerModule->GetDriverLatencyInMs()));
//LatencyMarkerModule->GetOSRenderQueueLatencyInMs()));
//LatencyMarkerModule->GetGPURenderLatencyInMs()));
break;
}
}
}
}
}
}
void FLyraPerformanceStatCache::StopCharting()
{
}
void FLyraPerformanceStatCache::RecordStat(const ELyraDisplayablePerformanceStat Stat, const double Value)
{
PerfStateCache.FindOrAdd(Stat).RecordSample(Value);
}
double FLyraPerformanceStatCache::GetCachedStat(ELyraDisplayablePerformanceStat Stat) const
{
static_assert((int32)ELyraDisplayablePerformanceStat::Count == 18, "Need to update this function to deal with new performance stats");
if (const FSampledStatCache* Cache = GetCachedStatData(Stat))
{
return Cache->GetLastCachedStat();
}
return 0.0;
}
const FSampledStatCache* FLyraPerformanceStatCache::GetCachedStatData(const ELyraDisplayablePerformanceStat Stat) const
{
static_assert((int32)ELyraDisplayablePerformanceStat::Count == 18, "Need to update this function to deal with new performance stats");
return PerfStateCache.Find(Stat);
}
//////////////////////////////////////////////////////////////////////
// ULyraPerformanceStatSubsystem
void ULyraPerformanceStatSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
Tracker = MakeShared<FLyraPerformanceStatCache>(this);
GEngine->AddPerformanceDataConsumer(Tracker);
}
void ULyraPerformanceStatSubsystem::Deinitialize()
{
GEngine->RemovePerformanceDataConsumer(Tracker);
Tracker.Reset();
}
double ULyraPerformanceStatSubsystem::GetCachedStat(ELyraDisplayablePerformanceStat Stat) const
{
return Tracker->GetCachedStat(Stat);
}
const FSampledStatCache* ULyraPerformanceStatSubsystem::GetCachedStatData(const ELyraDisplayablePerformanceStat Stat) const
{
return Tracker->GetCachedStatData(Stat);
}
|