Files
dusk/src/dusk/perf/perf.c
T
YourWishesandClaude Sonnet 5 f303d24f4a Add a perf timing/stack module and start using it to diagnose PSP hitching
New src/dusk/perf module: a simple push/pop tick-stack (perfPush/perfPop/
perfReport) for measuring how long a labeled span of code takes, wired
into engine.c's init/dispose. perfGetTick() is a placeholder - real time
on DUSK_LINUX (clock_gettime) and DUSK_PSP (sceKernelGetSystemTimeWide),
0 elsewhere until a proper cross-platform answer is settled on.

Used it this session to chase a reported PSP hitch when crossing a chunk
boundary. Confirmed mapPositionSet itself (unload/load sweeps, chunk
order rebuild, entity chunkIndex recompute) is consistently under ~3ms -
not the cause. Along the way, found and fixed a real, unrelated bug:
logDebug()/logError() on PSP did a fopen+write+fclose to the Memory
Stick on every single call, which was massively inflating any perf
measurement that logged from inside another measurement (the actual
source of the ~29-128ms numbers first seen). That's now gated behind a
new DUSK_PSP_LOG_FILE CMake option (default off).

Also, as a real test based on this session's findings:
- MAP_CHUNK_LOAD_CONCURRENCY dropped from 2 to 1 (8 and 4 both crashed/
  were untested further on real PSP hardware; 1 is confirmed safe).
- MAP_CHUNK_LOAD_DELAY_TEST: an intentionally exaggerated (now 50ms)
  artificial delay between starting successive chunk loads, gated in
  mapChunkLoadNext/mapUpdate, to observe the effect on framerate.

All perf instrumentation call sites added during this investigation
(assetChunkLoaderSync, assetMeshLoaderSync, mapPositionSet, the map area
callback invocation, engine.c's frame boundary) were removed again once
they'd served their purpose - only the reusable perf module itself and
the two real fixes above remain.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
2026-09-09 15:16:48 -05:00

89 lines
2.6 KiB
C

/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "perf.h"
#include "assert/assert.h"
#include "util/memory.h"
#include "console/console.h"
#if defined(DUSK_LINUX)
#include <time.h>
#elif defined(DUSK_PSP)
#include <pspthreadman.h>
#endif
perf_t PERF;
void perfInit(void) {
assertIsMainThread("Must be called from the main thread.");
memoryZero(&PERF, sizeof(perf_t));
}
void perfDispose(void) {
assertIsMainThread("Must be called from the main thread.");
}
uint64_t perfGetTick(void) {
assertIsMainThread("Must be called from the main thread.");
#if defined(DUSK_LINUX)
// TEST - CLOCK_MONOTONIC via clock_gettime(), Linux desktop only for
// now. Not a cross-platform answer yet (see perfGetTick's doc
// comment in perf.h) - just something real to look at while that
// gets settled. Returns nanoseconds since some unspecified starting
// point, so only differences between two calls are meaningful.
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
#elif defined(DUSK_PSP)
// TEST - sceKernelGetSystemTimeWide(), microseconds since boot at
// ~1us resolution (the standard PSP homebrew idiom for elapsed-time
// measurement - psprtc.h's sceRtcGetCurrentTick is for wall-clock
// date/time instead, already used by timepsp.c for that purpose).
// Scaled to nanoseconds to match every other platform's tick unit.
return (uint64_t)sceKernelGetSystemTimeWide() * 1000ull;
#else
return 0;
#endif
}
void perfPushItem(
const char_t *label, const char_t *file, const int32_t line
) {
assertIsMainThread("Must be called from the main thread.");
assertNotNull(label, "Perf item label cannot be NULL.");
assertNotNull(file, "Perf item file cannot be NULL.");
assertTrue(PERF.stackSize < PERF_STACK_SIZE, "Perf stack overflow.");
PERF.stack[PERF.stackSize++] = (perfitem_t){
.label = label,
.file = file,
.line = line,
.tick = perfGetTick()
};
}
void perfPopItem(void) {
assertIsMainThread("Must be called from the main thread.");
assertTrue(PERF.stackSize > 0, "Perf stack underflow.");
PERF.stackSize--;
}
void perfReport(void) {
assertIsMainThread("Must be called from the main thread.");
if(PERF.stackSize == 0) return;
const perfitem_t *item = &PERF.stack[PERF.stackSize - 1];
uint64_t elapsedNs = perfGetTick() - item->tick;
double_t elapsedMs = (double_t)elapsedNs / 1000000.0;
consolePrint(
"perf: %s (%s:%d, %.4fms)",
item->label, item->file, item->line, elapsedMs
);
}