fix(diagnostics): retain frame latency evidence without pixel capture

This commit is contained in:
rponeawa
2026-11-02 23:25:17 +08:00
committed by bluseliu50
Unverified
parent 768ad84e76
commit 04294cd7b3
4 changed files with 70 additions and 120 deletions
+4 -3
View File
@@ -325,9 +325,10 @@ static id deviceForPort(unsigned port) {
// sheng-diag=1 turns on every diagnostic of the GPU stack in this process: the frontend's frame trace, Turnip's pass stamps and
// submission ring, the runtime's stage ring, and in the render server the status and telemetry lines. Without it none of them runs.
if (bootArgSet("sheng-diag=1") || bootArgSet("sheng-gpu-trace=1")) setenv("SHENG_DIAG", "1", 1);
if (bootArgSet("sheng-gpu-trace=1")) setenv("SHENG_GPU_TRACE", "1", 1);
if (bootArgSet("sheng-gpu-pixels=1")) setenv("SHENG_GPU_PIXELS", "1", 1);
else unsetenv("SHENG_DIAG");
if (bootArgSet("sheng-gpu-trace=1")) setenv("SHENG_GPU_TRACE", "1", 1);
else unsetenv("SHENG_GPU_TRACE");
unsetenv("SHENG_GPU_PIXELS");
if (bootArgSet("sheng-wallpaper-freeze=1")) setenv("NATIVE_METAL_FREEZE_WALLPAPER", "1", 1);
// log-gpu=1: the GPU stack's log lines (NSLog, the pipeline journal); off without it.
if (bootArgSet("log-gpu=1")) setenv("SHENG_LOG_GPU", "1", 1);
@@ -433,7 +434,7 @@ static id deviceForPort(unsigned port) {
#endif
// The runtime's creation log reports each VkPipeline making's time to the device's sink, which the telemetry's V row sums
// (sheng-diag=1).
if (getenv("SHENG_DIAG")) setenv("METAL2VULKAN_LOG_PIPELINES", "1", 0);
unsetenv("METAL2VULKAN_LOG_PIPELINES");
CFPreferencesSetAppValue(CFSTR("CAEnableFramebufferCompression"), kCFBooleanFalse, kCFPreferencesCurrentApplication);
CFPreferencesSetAppValue(CFSTR("CAEnableIOSurfaceCompression"), kCFBooleanFalse, kCFPreferencesCurrentApplication);
char candidates[6][512] = {};
+11 -117
View File
@@ -49,6 +49,7 @@
#include "QueuePriority.h"
#include "NativeBridgeMetalFrontend.h"
#include "NativeGpuTrace.h"
#include "NativeGpuLatency.h"
extern "C" void sys_dcache_flush(void *start, size_t length);
@@ -62,6 +63,7 @@ template<typename... T> static void frameEvent(uint32_t event,T... args) {
if(!frameTraceOn() || !gFrameTransport)return;
NativeGpuTraceRecord rec{};rec.event=event;const uint64_t values[]={uint64_t(args)...};
static_assert(sizeof...(args)<=12,"frame event fields");
if(!native_gpu_latency_event(event,values,sizeof...(args)))return;
memcpy(rec.value,values,sizeof(values));
if(!gFrameTransport(NativeGpuTraceMethod,&rec,sizeof(rec)))++gFrameLost;
else if(uint64_t lost=gFrameLost.exchange(0)) {
@@ -70,7 +72,7 @@ template<typename... T> static void frameEvent(uint32_t event,T... args) {
}
}
static void traceRuntimeWide(uint64_t,uint32_t,uint32_t);
static void frameRuntime(uint32_t event,uint64_t id,uint64_t a,uint64_t b){if(event==39 && a>=40)traceRuntimeWide(id,(uint32_t)a,(uint32_t)b);frameEvent(event,id,a,b);}
static void frameRuntime(uint32_t event,uint64_t id,uint64_t a,uint64_t b){if(event==39 && !native_gpu_latency_stage((uint32_t)a))return;if(event==39 && a>=40)traceRuntimeWide(id,(uint32_t)a,(uint32_t)b);frameEvent(event,id,a,b);}
static void frameText(uint32_t event,const char *text) {
if(!frameTraceOn() || !gFrameTransport || !text)return;
NativeGpuTraceRecord rec{};rec.event=event;strlcpy((char *)rec.value,text,sizeof(rec.value));
@@ -252,6 +254,8 @@ static uint32_t threadIdLow() {uint64_t id=0;pthread_threadid_np(NULL,&id);retur
static bool traceWanted() {static const bool on=diagOn() && !strcmp(getprogname(),"backboardd");return on;}
static void tracePush(const TraceRec &rec) {
if(!traceWanted())return;
if(rec.type==12 && (rec.a>=40 || !native_gpu_latency_stage(rec.a)))return;
if(rec.type==9 || rec.type==10 || rec.type==11)return;
const uint32_t at=gTraceHead.fetch_add(1);
gTrace[at%16384]=rec;
gTrace[at%16384].idx=rec.type==1?rec.idx:at;
@@ -311,7 +315,9 @@ static void detailDefinition(uint64_t key,const char *label) {
}
static void detailPoint(uint64_t id,uint32_t kind,uint32_t phase,uint64_t command,uint64_t object,uint64_t function,
uint64_t began,uint64_t parent,uint64_t queued,uint32_t line=0,uint64_t ended=0) {
uint64_t tid=0;pthread_threadid_np(nullptr,&tid);const uint64_t now=ended?ended:nowUs();
const uint64_t now=ended?ended:nowUs();
if(phase==2 && kind!=1 && kind!=3 && began && now-began<250)return;
uint64_t tid=0;pthread_threadid_np(nullptr,&tid);
TraceRec rec{};rec.type=17;rec.t0=now;rec.t1=id;rec.t2=command;rec.t3=object;
rec.a=kind|(phase<<16);rec.b=(uint32_t)tid;rec.c=(uint32_t)function;rec.d=(uint32_t)(function>>32);
rec.cpu0=(uint32_t)(began?now-began:0);rec.cpu1=line;tracePush(rec);
@@ -349,117 +355,6 @@ static void traceNote(uint32_t tid) {
TraceRec rec={};rec.type=4;rec.tid=tid;pthread_getname_np(pthread_self(),(char *)&rec.t0,24);tracePush(rec);
}
// ---- sampler: where the render thread's CPU goes, inside a command buffer's window (creation to commit) and between windows ----
// A thread suspends the render thread every 2 ms and keeps the program counter plus the frame-pointer chain in a ring (no allocation, no locks: the
// suspended thread may hold any). The writer thread resolves the addresses with dladdr and puts the samples into the frame trace (types 9 and 10,
// below); the leaf and inclusive histograms inside windows and in the gaps between windows (the time the render thread spends on something other
// than encoding) are built offline. Suspending the render thread every 2 ms delays its frames (half of the render server's busiest-thread samples
// in untagged-3f2bd680 were this thread), so it runs only with sheng-diag=1 and sheng-gpu-sample=1 both on the kernel command line.
static std::atomic<mach_port_t> gSampleThread{0};
static std::atomic<uint64_t> gSampleTop{0};
struct StackSample {uint64_t frames[8];uint64_t us;uint32_t gap;};
static std::atomic<bool> gSampleInWindow{false};
static bool samplerWanted() {
static const bool wanted=[]{
if(!diagOn())return false;
char args[1100]={};size_t size=sizeof args-1;
return !sysctlbyname("kern.bootargs",args,&size,NULL,0) && strstr(args,"sheng-gpu-sample=1");
}();
return wanted;
}
static StackSample gSamples[8192];
static std::atomic<uint32_t> gSampleHead{0};
static std::atomic<bool> gSamplerStarted{false};
static void sampleWindowOpen() {
if(!samplerWanted())return;
char name[32]={};pthread_getname_np(pthread_self(),name,sizeof name);
if(strncmp(name,"com.apple.coreanimation",23))return;
gSampleInWindow.store(true);
gSampleTop.store((uint64_t)pthread_get_stackaddr_np(pthread_self()));
gSampleThread.store(pthread_mach_thread_np(pthread_self()));
if(!gSamplerStarted.exchange(true))std::thread([]{
pthread_setname_np("frame-sampler");
for(;;) {
usleep(2000);
const mach_port_t port=gSampleThread.load();
if(!port)continue;
if(thread_suspend(port)!=KERN_SUCCESS)continue;
arm_thread_state64_t state;mach_msg_type_number_t count=ARM_THREAD_STATE64_COUNT;
StackSample sample={};
if(thread_get_state(port,ARM_THREAD_STATE64,(thread_state_t)&state,&count)==KERN_SUCCESS) {
const uint64_t mask=0x0000007fffffffffull,top=gSampleTop.load();
const uint64_t sp=arm_thread_state64_get_sp(state);
unsigned n=0;
sample.frames[n++]=arm_thread_state64_get_pc(state)&mask;
sample.frames[n++]=arm_thread_state64_get_lr(state)&mask;
uint64_t fp=arm_thread_state64_get_fp(state)&mask;
while(n<8 && fp>=sp && fp+16<=top && !(fp&15)) {
const uint64_t *record=(const uint64_t *)fp;
sample.frames[n++]=record[1]&mask;
const uint64_t next=record[0]&mask;
if(next<=fp)break;
fp=next;
}
}
thread_resume(port);
sample.gap=gSampleInWindow.load()?0:1;
sample.us=nowUs();
if(sample.frames[0])gSamples[gSampleHead.fetch_add(1)%8192]=sample;
}
}).detach();
}
static void sampleWindowClose() {
if(gSampleThread.load()==pthread_mach_thread_np(pthread_self()))gSampleInWindow.store(false); // the thread stays sampled: its gaps are the data
}
// The writer thread turns the ring's samples into trace records: type 10 names a function the first time a sample holds it {a id, the name (image`symbol,
// 60 characters) in t0..t3 and b..tid2}, type 9 is one sample {t0 nowUs() when it was taken, t1 1 when it fell between two windows, a..d the eight frames as
// 16-bit function ids, pc first, 0 = no frame}. The offline reader (local-tools/blue-block/prof.py) rebuilds the leaf and inclusive histograms for the
// windows and the gaps from them.
// Type 11 is Turnip's counters for the copies that need a row-by-row path (tu_copy_row_stats), written when they change {t0 nowUs(), t1 buffer to image copies |
// image to buffer copies << 32, t2 how many of each were split per row (same packing), t3 rows of the split buffer to image copies, a rows of the split image to buffer
// copies, b rows of the largest split copy, c its pitch in bytes, d its VkFormat, tid its width, cpu0 its height}.
static void emitDefinition(uint32_t id,const std::string &text) {
char field[60]={};strncpy(field,text.c_str(),sizeof field-1);
TraceRec rec={};rec.type=10;rec.a=id;memcpy(&rec.t0,field,32);memcpy(&rec.b,field+32,28);tracePush(rec);
}
static void sampleEmitTrace(uint32_t &consumed) {
static std::unordered_map<uint64_t,uint32_t> addressId;
static std::unordered_map<std::string,uint32_t> nameId;
static std::vector<std::pair<uint32_t,std::string>> defined; // every definition, repeated every 15 s: the writer drops the oldest records when the ring laps
static uint64_t definedAt=0;
const uint32_t head=gSampleHead.load();
if(head-consumed>8000)consumed=head-8000;
auto identify=[&](uint64_t address)->uint32_t {
auto cached=addressId.find(address);if(cached!=addressId.end())return cached->second;
Dl_info info={};char text[256];
if(dladdr((const void *)address,&info)){
const char *image=info.dli_fname?strrchr(info.dli_fname,'/'):NULL;image=image?image+1:(info.dli_fname?info.dli_fname:"?");
if(info.dli_sname)snprintf(text,sizeof text,"%s`%s",image,info.dli_sname);
else snprintf(text,sizeof text,"%s`+0x%llx",image,(unsigned long long)(address-(uint64_t)info.dli_fbase));
} else snprintf(text,sizeof text,"?");
auto found=nameId.find(text);
if(found!=nameId.end())return addressId[address]=found->second;
uint32_t id=(uint32_t)nameId.size()+1;
if(id>0xfffe)return addressId[address]=0xffff;
nameId[text]=id;
defined.push_back({id,text});
emitDefinition(id,text);
return addressId[address]=id;
};
const uint64_t now=nowUs();
if(now-definedAt>=15000000ull) {
definedAt=now;
for(auto &entry:defined)emitDefinition(entry.first,entry.second);
}
while(consumed<head) {
const StackSample sample=gSamples[consumed%8192];++consumed;
uint32_t ids[8]={};
for(unsigned i=0;i<8 && sample.frames[i];i++)ids[i]=identify(sample.frames[i]);
TraceRec rec={};rec.type=9;rec.t0=sample.us;rec.t1=sample.gap;
rec.a=ids[0]|ids[1]<<16;rec.b=ids[2]|ids[3]<<16;rec.c=ids[4]|ids[5]<<16;rec.d=ids[6]|ids[7]<<16;
tracePush(rec);
}
}
/* The process's slowest pass and its pass total, for a line of the kernel log: "R pass <us> us <w>x<h> mode <m> fmt <f> draws <d> flags <x>
* swap <s> | <passes> passes <total> us". Zero characters before any pass with GPU times was recorded. */
extern "C" size_t nmb_slowest_pass(char *out,size_t size) {
@@ -548,7 +443,7 @@ static void traceStartWriter() {
pthread_setname_np("frame-trace");
int fd=-1;
static const char *const paths[]={"/private/var/mobile/Library/Caches/com.apple.backboardd/m2v/frames.trace","/private/var/root/Library/Caches/com.apple.backboardd/m2v/frames.trace"};
uint32_t written=0,sampled=0;
uint32_t written=0;
struct PassRec {uint64_t ns;uint32_t seq;uint16_t width,height;uint8_t mode,colors,flags,swap;uint16_t draws,format;uint32_t kpx;uint64_t gpuBegin,gpuEnd;uint16_t fsInstrs,fsTex,fsSy,fsSs;int8_t fsWaves,fsRegs;uint8_t samples,ds;uint32_t bandwidth,verts,fsHash;};
struct SubRec {uint64_t ns;uint32_t seq,fence,syncWaitUs,callUs,spaceWaitUs;uint16_t busy;uint8_t chunks,buffers;};
static_assert(sizeof(PassRec)==72 && sizeof(SubRec)==32,"turnip ring records");
@@ -561,7 +456,6 @@ static void traceStartWriter() {
bool header=false;
for(;;) {
usleep(250000);
if(render)sampleEmitTrace(sampled);
if(render && fd<0)for(const char *path:paths){fd=open(path,O_WRONLY|O_CREAT|O_TRUNC,0644);if(fd>=0)break;}
if(render && fd<0)continue;
if(!turnip && !gLoaderPath.empty()) { // the runtime loads Turnip after this thread may have started
@@ -3142,7 +3036,7 @@ static char kUserDictionaryKey;
- (void)setResponsibleTaskIDs:(const void *)ids count:(NSUInteger)count {(void)ids;(void)count;}
- (instancetype)init {
if((self=[super init])){_scheduledHandlers=[NSMutableArray array];_completedHandlers=[NSMutableArray array];_surfaces=[NSMutableSet set];_resourceOwners=[NSMutableSet set];_handlers=dispatch_group_create();_schedulingHandlers=dispatch_group_create();}
if(self){traceNumber=++gFrameNumber;if(frameTraceOn())_traceUsage=[NSMutableDictionary dictionary];createdUs=nowUs();createCpu=threadCpuUs();createTid=threadIdLow();earlyEligible=onRenderServerThread();installDispatchTrace();if(earlyEligible)traceThread(1);frontStage(traceNumber,0,1);sampleWindowOpen();}
if(self){traceNumber=++gFrameNumber;if(frameTraceOn())_traceUsage=[NSMutableDictionary dictionary];createdUs=nowUs();createCpu=threadCpuUs();createTid=threadIdLow();earlyEligible=onRenderServerThread();installDispatchTrace();if(earlyEligible)traceThread(1);frontStage(traceNumber,0,1);}
return self;
}
- (void)dealloc {DetailSpan timing(17,(uintptr_t)_handle);nmb_command_buffer_release(_handle);}
@@ -3486,7 +3380,7 @@ static char kUserDictionaryKey;
if(self.committed){NBLOG(@"native-metal: commit twice");return;}
self.committed=YES;
self.committedUs=nowUs();
commitCpu=threadCpuUs();commitTid=threadIdLow();sampleWindowClose();
commitCpu=threadCpuUs();commitTid=threadIdLow();
{
std::lock_guard<std::mutex> lock(gCommitLock);
// Assign once under the same lock as publication. A concurrent commit cannot reuse this index.
+40
View File
@@ -0,0 +1,40 @@
/* SPDX-License-Identifier: MIT */
#ifndef NATIVE_GPU_LATENCY_H
#define NATIVE_GPU_LATENCY_H
#include <stdint.h>
/* Keep command, memory, completion, scheduling and display causality. */
static inline bool native_gpu_latency_stage(uint32_t stage) {
return (stage >= 1 && stage <= 16) || (stage >= 40 && stage <= 57);
}
static inline bool native_gpu_latency_event(uint32_t event,const uint64_t *v,uint32_t count) {
switch(event) {
case 39:return count >= 3 && native_gpu_latency_stage((uint32_t)v[1]);
case 1:case 3:case 10:case 11:case 12:case 13:case 15:
case 20:case 21:case 22:case 23:case 30:case 32:case 33:case 34:
case 36:case 38:case 41:case 42:case 43:case 45:case 46:case 47:
case 48:case 50:case 51:case 52:case 53:case 55:case 58:
case 60:case 61:case 62:case 63:case 64:case 67:case 68:return true;
default:return false;
}
}
/* A pending display query retains transitions and a 100 ms heartbeat, plus the
* number of identical queries omitted. Completion is always retained. */
struct NativeGpuLatencyWaits {
struct Slot {uint32_t busy=0,pid=0,reason=0;uint64_t request=0,target=0,when=0,omitted=0;};
Slot slots[32]{};
bool keep(uint64_t now,uint32_t pid,uint64_t request,uint32_t reason,uint64_t target,uint64_t &omitted) {
Slot &s=slots[(request ^ pid)&31];uint32_t free=0;
if(!__atomic_compare_exchange_n(&s.busy,&free,1,false,__ATOMIC_ACQUIRE,__ATOMIC_RELAXED))return true;
const bool same=s.request==request && s.pid==pid && s.target==target;
const bool pending=reason==3 || reason==4;
const bool emit=!pending || !same || s.reason!=reason || now-s.when>=100000;
if(emit) {
omitted=same?s.omitted:0;
s.pid=pid;s.request=request;s.target=target;s.reason=reason;s.when=now;s.omitted=0;
} else ++s.omitted;
__atomic_store_n(&s.busy,0,__ATOMIC_RELEASE);return emit;
}
};
#endif
@@ -0,0 +1,15 @@
--- a/crates/metal2vulkan-runtime/src/stage_trace.rs
+++ b/crates/metal2vulkan-runtime/src/stage_trace.rs
@@ -163,6 +163,12 @@
/// Record `stage` of `id` with `arg`, now, where the diagnostics are on ([`diagnostics`]).
pub(crate) fn mark(id: usize, stage: Stage, arg: u32) {
+ // Per-command handoff and completion stages retain scheduler latency.
+ // Idle scheduler turns have no command identity and add no causal link.
+ if matches!(stage, Stage::SchedulerSleep | Stage::SchedulerWake
+ | Stage::SchedulerResumed | Stage::PassBegin | Stage::PassEnd) {
+ return;
+ }
if !diagnostics() {
return;
}