IR JIT: Add --jit-bench, and time compiles with the CPU counter

--jit-bench=N recompiles every block in the cache five times after N flips
(at the next safe point), and logs each run and the best, split by phase. With
a state loaded, it gives the same set of blocks every time, so changes to the
compiler can be compared run to run. Game frames vary too much for that.

The compile timing reads cntvct_el0 on ARM64 Linux/Android rather than calling
clock_gettime(), through time_now_fast_ticks(). The counter's rate is measured
against time_now_raw(), since a Galaxy S8 reports 0 in cntfrq_el0 (it runs at
26 MHz there).

The IR pass list in DoJit is a fixed array instead of a vector.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Henrik RydgårdandClaude Opus 5.5 committed 2026-11-10 19:38:19 +01:00
1 parent 6860e78bf7
commit f4b35e08f7
13 files changed
+155 -28

No files matched your search

+36 -8
View File
@@ -102,6 +102,10 @@ void TimeShutdown() {
#endif
}
double fast_ticks_to_nanos() {
return 1.0;
}
double time_now_d() {
LARGE_INTEGER time;
QueryPerformanceCounter(&time);
@@ -164,10 +168,6 @@ int64_t Instant::ElapsedNanos() const {
return (int64_t)(ElapsedSeconds() * 1000000000.0);
}
int64_t Instant::NanosSince(const Instant &earlier) const {
return (int64_t)((double)(int64_t)(nativeStart_ - earlier.nativeStart_) * frequencyMult * 1000000000.0);
}
#else
// Monotonic, in nanoseconds, and the clock VK_GOOGLE_display_timing reports in.
@@ -206,6 +206,7 @@ void TimeInit() {
if (g_startTime == 0) {
g_startTime = time_now_raw();
g_startUnixTime = time_now_unix_utc();
fast_ticks_to_nanos();
}
}
@@ -213,6 +214,37 @@ void TimeShutdown() {
// Nothing to do.
}
#if PPSSPP_ARCH(ARM64) && (PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(LINUX)) && !defined(_MSC_VER)
// Firmware doesn't always fill in cntfrq_el0 (a Galaxy S8 reads 0), so the counter is measured against
// time_now_raw(), from the first call (TimeInit()) to one at least 50 ms later.
static double MeasureFastTicks() {
static uint64_t startTicks = 0;
static uint64_t startRaw = 0;
static double nanosPerTick = 0.0;
if (nanosPerTick != 0.0)
return nanosPerTick;
const uint64_t ticks = time_now_fast_ticks();
const uint64_t raw = time_now_raw();
if (startRaw == 0) {
startTicks = ticks;
startRaw = raw;
} else if (raw - startRaw >= 50000000 && ticks > startTicks) {
nanosPerTick = (double)(raw - startRaw) / (double)(ticks - startTicks);
return nanosPerTick;
}
// Too early to tell. Most counters run at 19.2-26 MHz.
return 1e9 / 19200000.0;
}
#endif
double fast_ticks_to_nanos() {
#if PPSSPP_ARCH(ARM64) && (PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(LINUX)) && !defined(_MSC_VER)
return MeasureFastTicks();
#else
return 1.0;
#endif
}
double from_time_raw(uint64_t raw_time) {
// Signed, so a timestamp from before TimeInit() comes out negative rather than enormous.
return (double)(int64_t)(raw_time - g_startTime) * (1.0 / nanos);
@@ -246,10 +278,6 @@ int64_t Instant::ElapsedNanos() const {
return (int64_t)(time_now_raw() - nativeStart_);
}
int64_t Instant::NanosSince(const Instant &earlier) const {
return (int64_t)(nativeStart_ - earlier.nativeStart_);
}
double Instant::ElapsedSeconds() const {
return (double)ElapsedNanos() * (1.0 / nanos);
}
+16 -2
View File
@@ -1,6 +1,8 @@
#pragma once
#include <cstdint>
#include "ppsspp_config.h"
void TimeInit();
void TimeShutdown(); // Not really necessary to call, just for completeness.
@@ -11,6 +13,20 @@ double time_now_d();
// The only intended use is to match the timings from VK_GOOGLE_display_timing.
uint64_t time_now_raw();
// A timestamp for timing short spans, in units of fast_ticks_to_nanos(). Where the CPU has a counter
// user code can read (ARM64 Linux and Android), it's read directly: clock_gettime() costs around
// 0.3us on a Galaxy S8. Elsewhere it's time_now_raw().
inline uint64_t time_now_fast_ticks() {
#if PPSSPP_ARCH(ARM64) && (PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(LINUX)) && !defined(_MSC_VER)
uint64_t ticks;
__asm__ volatile("mrs %0, cntvct_el0" : "=r"(ticks));
return ticks;
#else
return time_now_raw();
#endif
}
double fast_ticks_to_nanos();
// This is only interesting for Linux, in relation to VK_GOOGLE_display_timing.
double from_time_raw(uint64_t raw_time);
double from_time_raw_relative(uint64_t raw_time);
@@ -49,8 +65,6 @@ public:
double ElapsedSeconds() const;
double ElapsedMs() const { return ElapsedSeconds() * 1000.0; }
int64_t ElapsedNanos() const;
// From an earlier Instant to this one, without reading the clock again.
int64_t NanosSince(const Instant &earlier) const;
private:
// Windows: raw QPC ticks. Everything else: nanoseconds, from time_now_raw().
uint64_t nativeStart_;
+4
View File
@@ -231,6 +231,7 @@ static const CommandLineParam g_autoParams[] = {
{POFF(bench), CmdParamType::Bool, "bench", 'b', "Enable benchmark mode", CmdLineMode::Headless},
{POFF(oldAtrac), CmdParamType::Bool, "old-atrac", '\0', "Use old ATRAC decoder"},
{POFF(jitProfile), CmdParamType::String, "jit-profile", '\0', "Profile the CPU core and write its hottest blocks to FILE on exit"},
{POFF(jitBench), CmdParamType::Int, "jit-bench", '\0', "After N flips, recompile every block in the JIT cache a few times and log how long it took"},
{POFF(memStickInserted), CmdParamType::BoolInverse, "no-memstick", '\0', "Run with the memory stick removed"},
{POFF(log), CmdParamType::String, "log", '\0', "Output log to FILE", CmdLineMode::Application},
{POFF(enableLogging), CmdParamType::Bool, "log", '\0', "Full log output, not just emulated printfs", CmdLineMode::Headless},
@@ -725,6 +726,9 @@ void CommandLineOptions::ApplyToConfig() const {
if (jitProfile.has_value()) {
g_Config.sJitProfileFile = jitProfile.value();
}
if (jitBench.has_value()) {
g_Config.iJitBenchFlip = jitBench.value();
}
if (root.has_value()) {
// No DoNotSaveSetting() here - mountRoot isn't an ordinary setting and never gets
+1
View File
@@ -175,6 +175,7 @@ struct CommandLineOptions {
std::optional<bool> oldAtrac;
std::optional<std::string> jitProfile;
std::optional<int> jitBench;
// Headless options that may also be mildly useful in application mode
std::optional<int> resolutionScale;
+2
View File
@@ -191,6 +191,8 @@ public:
bool bBreakOnFrameTimeout; // not saved
// Sample the JIT and write a report of the hottest blocks to this file. Not saved.
std::string sJitProfileFile;
// After this many flips, time recompiling the whole JIT cache (--jit-bench). Not saved.
int iJitBenchFlip = 0;
// General
bool bScreenshotsAsPNG;
+3
View File
@@ -106,6 +106,9 @@ static double CheckJitStall(double now) {
static void CalculateFPS() {
double now = time_now_d();
const double jitSeconds = CheckJitStall(now);
if (g_Config.iJitBenchFlip > 0 && actualFlips == g_Config.iJitBenchFlip) {
mipsr4k.BenchmarkJitDeferred();
}
if (now >= lastFpsTime + 1.0) {
double frames = (numVBlanks - lastFpsFrame);
+12 -8
View File
@@ -318,7 +318,7 @@ MIPSOpcode IRFrontend::GetOffsetInstruction(int offset) {
}
void IRFrontend::DoJit(u32 em_address, std::vector<IRInst> &instructions, u32 &mipsBytes) {
const Instant start = Instant::Now();
const uint64_t start = time_now_fast_ticks();
js.cancel = false;
js.blockStart = em_address;
js.compilerPC = em_address;
@@ -355,9 +355,9 @@ void IRFrontend::DoJit(u32 em_address, std::vector<IRInst> &instructions, u32 &m
IRWriter simplified;
IRWriter *code = &ir;
Instant passStart = Instant::Now();
const uint64_t passStart = time_now_fast_ticks();
if (!js.hadBreakpoints) {
std::vector<IRPassFunc> passes{
IRPassFunc passes[16]{
&ApplyMemoryValidation,
&RemoveLoadStoreLeftRight,
&OptimizeFPMoves,
@@ -370,12 +370,15 @@ void IRFrontend::DoJit(u32 em_address, std::vector<IRInst> &instructions, u32 &m
// &MergeLoadStore,
// &ThreeOpToTwoOp,
};
size_t numPasses = 0;
while (passes[numPasses])
numPasses++;
if (opts.optimizeForInterpreter) {
// Add special passes here.
passes.push_back(&OptimizeForInterpreter);
passes[numPasses++] = &OptimizeForInterpreter;
}
if (IRApplyPasses(passes.data(), passes.size(), ir, simplified, opts))
if (IRApplyPasses(passes, numPasses, ir, simplified, opts))
logBlocks = 1;
code = &simplified;
//if (ir.GetInstructions().size() >= 24)
@@ -394,9 +397,10 @@ void IRFrontend::DoJit(u32 em_address, std::vector<IRInst> &instructions, u32 &m
instructions.push_back({ IROp::LogIRBlock, {0}, 0, 0, INVALID_TRACE_INDEX });
std::copy(block_instructions.begin() + 1, block_instructions.end(), std::back_inserter(instructions));
}
lastEnd_ = Instant::Now();
lastFrontendNanos_ = passStart.NanosSince(start);
lastPassNanos_ = lastEnd_.NanosSince(passStart);
lastEnd_ = time_now_fast_ticks();
const double nanosPerTick = fast_ticks_to_nanos();
lastFrontendNanos_ = (int64_t)((passStart - start) * nanosPerTick);
lastPassNanos_ = (int64_t)((lastEnd_ - passStart) * nanosPerTick);
if (logBlocks > 0 && dontLogBlocks == 0) {
char temp2[256];
+3 -2
View File
@@ -106,7 +106,8 @@ public:
// How long the last DoJit spent making the IR, and running the passes over it, and when it ended.
int64_t LastFrontendNanos() const { return lastFrontendNanos_; }
int64_t LastPassNanos() const { return lastPassNanos_; }
const Instant &LastEnd() const { return lastEnd_; }
// In time_now_fast_ticks() units.
uint64_t LastEnd() const { return lastEnd_; }
void EatPrefix() override {
js.EatPrefix();
@@ -188,7 +189,7 @@ private:
int64_t lastFrontendNanos_ = 0;
int64_t lastPassNanos_ = 0;
Instant lastEnd_;
uint64_t lastEnd_ = 0;
private:
bool IsMediaEngine() const;
+60 -8
View File
@@ -172,10 +172,10 @@ void IRInterpreterJit::WriteProfileReport() {
}
void IRJit::InvalidateCacheAt(u32 em_address, int length) {
const Instant start = Instant::Now();
const uint64_t start = time_now_fast_ticks();
std::vector<int> numbers = blocks_.FindInvalidatedBlockNumbers(em_address, length);
if (numbers.empty()) {
g_jitCompileTimes.invalidateNanos += start.ElapsedNanos();
g_jitCompileTimes.invalidateNanos += (int64_t)((time_now_fast_ticks() - start) * fast_ticks_to_nanos());
return;
}
@@ -187,7 +187,7 @@ void IRJit::InvalidateCacheAt(u32 em_address, int length) {
// TODO: We are invalidating a lot of blocks that are already invalid (yu gi oh).
InvalidateBlock(block_num);
}
g_jitCompileTimes.invalidateNanos += start.ElapsedNanos();
g_jitCompileTimes.invalidateNanos += (int64_t)((time_now_fast_ticks() - start) * fast_ticks_to_nanos());
}
void IRJit::InvalidateBlock(int block_num) {
@@ -259,6 +259,57 @@ void IRJit::Compile(u32 em_address) {
}
}
void IRJit::BenchmarkCompile() {
std::vector<u32> starts;
for (int i = 0; i < blocks_.GetNumBlocks(); i++) {
const JitBlock *block = blocks_.GetBlock(i);
if (block->IsValid())
starts.push_back(block->GetOriginalStart());
}
std::sort(starts.begin(), starts.end());
starts.erase(std::unique(starts.begin(), starts.end()), starts.end());
if (starts.empty()) {
NOTICE_LOG(Log::JIT, "JIT bench: no blocks to compile");
return;
}
// The best of a few runs, since a phone's clocks and core assignment vary a lot.
constexpr int RUNS = 5;
JitCompileTimes best{};
int64_t bestTotal = INT64_MAX;
std::vector<IRInst> instructions;
for (int run = 0; run < RUNS; run++) {
ClearCache();
const JitCompileTimes before = g_jitCompileTimes;
for (u32 start : starts) {
u32 mipsBytes;
if (CompileBlock(start, instructions, mipsBytes) != CompileResult::OK) {
ERROR_LOG(Log::JIT, "JIT bench: the cache filled up, stopping");
ClearCache();
return;
}
}
const JitCompileTimes &after = g_jitCompileTimes;
JitCompileTimes t{};
t.frontendNanos = after.frontendNanos - before.frontendNanos;
t.passNanos = after.passNanos - before.passNanos;
t.backendNanos = after.backendNanos - before.backendNanos;
t.finalizeNanos = after.finalizeNanos - before.finalizeNanos;
t.mipsInstructions = after.mipsInstructions - before.mipsInstructions;
t.irInstructions = after.irInstructions - before.irInstructions;
NOTICE_LOG(Log::JIT, "JIT bench run %d: %d blocks in %0.2f ms (frontend %0.2f, passes %0.2f, backend %0.2f, finalize %0.2f)",
run, (int)starts.size(), t.TotalNanos() * 1e-6, t.frontendNanos * 1e-6, t.passNanos * 1e-6, t.backendNanos * 1e-6, t.finalizeNanos * 1e-6);
if (t.TotalNanos() < bestTotal) {
bestTotal = t.TotalNanos();
best = t;
}
}
NOTICE_LOG(Log::JIT, "JIT bench: %0.3f ns per timer tick", fast_ticks_to_nanos());
NOTICE_LOG(Log::JIT, "JIT bench best: %d blocks, %d MIPS -> %d IR instructions, %0.2f ms, %0.2f us/block (frontend %0.2f, passes %0.2f, backend %0.2f, finalize %0.2f)",
(int)starts.size(), (int)best.mipsInstructions, (int)best.irInstructions, bestTotal * 1e-6, bestTotal * 1e-3 / starts.size(),
best.frontendNanos * 1e-3 / starts.size(), best.passNanos * 1e-3 / starts.size(), best.backendNanos * 1e-3 / starts.size(), best.finalizeNanos * 1e-3 / starts.size());
}
void IRJit::TimedClearCache() {
const Instant start = Instant::Now();
ClearCache();
@@ -277,8 +328,9 @@ IRJit::CompileResult IRJit::CompileBlock(u32 em_address, std::vector<IRInst> &in
times.passNanos += frontend_.LastPassNanos();
times.mipsInstructions += mipsBytes / 4;
times.irInstructions += instructions.size();
// Reading the clock isn't free (around 0.3us on a Galaxy S8), so each phase ends where the next starts.
const Instant &backendStart = frontend_.LastEnd();
// Each phase ends where the next starts, to read the clock as little as possible.
const uint64_t backendStart = frontend_.LastEnd();
const double nanosPerTick = fast_ticks_to_nanos();
if (mipsTracer.tracing_enabled && instructions.size() > 1 && instructions[1].op == IROp::LogIRBlock) {
// Before the IR interpreter's block cache takes its copy.
@@ -295,8 +347,8 @@ IRJit::CompileResult IRJit::CompileBlock(u32 em_address, std::vector<IRInst> &in
// Caller handles a full arena or code space.
const CompileResult result = CompileTargetBlock(block_num, instructions);
const Instant finalizeStart = Instant::Now();
const int64_t backendNanos = finalizeStart.NanosSince(backendStart);
const uint64_t finalizeStart = time_now_fast_ticks();
const int64_t backendNanos = (int64_t)((finalizeStart - backendStart) * nanosPerTick);
times.backendNanos += backendNanos;
if (result != CompileResult::OK)
return result;
@@ -304,7 +356,7 @@ IRJit::CompileResult IRJit::CompileBlock(u32 em_address, std::vector<IRInst> &in
// Updates stats, also enters the block in the block shadow.
blocks_.FinalizeBlock(block_num);
FinalizeTargetBlock(block_num);
const int64_t finalizeNanos = finalizeStart.ElapsedNanos();
const int64_t finalizeNanos = (int64_t)((time_now_fast_ticks() - finalizeStart) * nanosPerTick);
times.finalizeNanos += finalizeNanos;
times.blocks++;
const int64_t blockNanos = frontend_.LastFrontendNanos() + frontend_.LastPassNanos() + backendNanos + finalizeNanos;
+1
View File
@@ -194,6 +194,7 @@ public:
void InvalidateCacheExcept(const std::vector<std::pair<u32, u32>> &keep) override;
void UpdateFCR31() override;
void GetStats(JitStats *stats) const override;
void BenchmarkCompile() override;
void FlushProfile() override;
+2
View File
@@ -170,6 +170,8 @@ namespace MIPSComp {
virtual const u8 *GetCrashHandler() const = 0;
virtual JitBlockCacheDebugInterface *GetBlockCacheDebugInterface() = 0;
virtual void InvalidateCacheAt(u32 em_address, int length = 4) = 0;
// Recompiles every block a few times and logs how long it took. Only the IR JITs do it.
virtual void BenchmarkCompile() {}
// Invalidates every block not entirely inside one of the (address, size) ranges.
virtual void InvalidateCacheExcept(const std::vector<std::pair<u32, u32>> &keep) = 0;
virtual void DoState(PointerWrap &p) = 0;
+12
View File
@@ -582,6 +582,18 @@ void MIPSState::ProcessPendingInvalidates() {
jit->ClearCache();
}
}
if (benchmarkJit_) {
benchmarkJit_ = false;
if (jit)
jit->BenchmarkCompile();
}
}
void MIPSState::BenchmarkJitDeferred() {
benchmarkJit_ = true;
if (jit && !IsMediaEngine()) {
Core_ReenterDispatcher();
}
}
void MIPSState::InvalidateICacheRangeDeferred(u32 address, u32 length) {
+3
View File
@@ -317,6 +317,8 @@ public:
// Actual clearing is deferred until execution begins again.
void InvalidateICacheRangeDeferred(u32 address, u32 length);
void ClearJitCacheDeferred();
// Times recompiling the whole JIT cache, when execution begins again (--jit-bench).
void BenchmarkJitDeferred();
void ProcessPendingInvalidates();
@@ -324,6 +326,7 @@ public:
// Doesn't need save stating.
std::vector<PendingCacheOperation> pendingInvalidates_;
bool invalidateAll_ = false;
bool benchmarkJit_ = false;
std::vector<std::pair<u32, u32>> keepJitBlocks_;
// Owned. Null on the interpreter.