use std::cell::RefCell;
use std::sync::atomic::{AtomicU8, Ordering};
use std::time::{Duration, Instant};
const HOW_OFTEN: Duration = Duration::from_secs(1);
static ENABLED: AtomicU8 = AtomicU8::new(0);
#[inline]
pub fn enabled() -> bool {
match ENABLED.load(Ordering::Relaxed) {
1 => false,
2 => true,
_ => {
let on = std::env::var("SK_PERF")
.map(|v| {
let v = v.trim().to_ascii_lowercase();
!(v.is_empty() || v == "0" || v == "false" || v == "off")
})
.unwrap_or(false);
ENABLED.store(if on { 2 } else { 1 }, Ordering::Relaxed);
on
}
}
}
struct State {
boot: Instant,
first_frame: Option<Instant>,
last_frame: Option<Instant>,
window_start: Instant,
samples: Vec<f32>,
tag: String,
tagged_frames: u64,
tag_start: Instant,
cursor: Instant,
pump_ms: f32,
setup_ms: f32,
render_ms: f32,
tail_draw_ms: f32,
tail_idle_ms: f32,
draws: u32,
drew: bool,
}
thread_local! {
static STATE: RefCell<Option<State>> = const { RefCell::new(None) };
static FIRST_FRAME_SEEN: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
pub fn boot() {
#[cfg(sk_devtools)]
ROLL.with(|r| r.borrow_mut().boot = Instant::now());
#[cfg(sk_devtools)]
gpui::observe_frames(on_frame_work);
if !enabled() {
return;
}
let now = Instant::now();
STATE.with(|s| {
*s.borrow_mut() = Some(State {
boot: now,
first_frame: None,
last_frame: None,
window_start: now,
samples: Vec::with_capacity(256),
tag: "startup".into(),
tagged_frames: 0,
tag_start: now,
cursor: now,
pump_ms: 0.0,
setup_ms: 0.0,
render_ms: 0.0,
tail_draw_ms: 0.0,
tail_idle_ms: 0.0,
draws: 0,
drew: false,
});
});
eprintln!(
"[sk-perf] probe on (SK_PERF) — frame stats every {}s",
HOW_OFTEN.as_secs()
);
}
#[cfg(sk_devtools)]
pub const ROLL_LEN: usize = 600;
#[cfg(sk_devtools)]
pub const FLAG_PACED: u8 = 1;
#[cfg(sk_devtools)]
pub const FLAG_DREW: u8 = 2;
#[cfg(sk_devtools)]
pub const FLAG_THROTTLED: u8 = 4;
#[cfg(sk_devtools)]
struct Roll {
ms: [f32; ROLL_LEN],
work: [f32; ROLL_LEN],
flags: [u8; ROLL_LEN],
head: usize,
filled: usize,
frames: u64,
last: Option<Instant>,
boot: Instant,
first_frame: Option<Instant>,
}
#[cfg(sk_devtools)]
thread_local! {
static ROLL: RefCell<Roll> = RefCell::new(Roll {
ms: [0.0; ROLL_LEN],
work: [0.0; ROLL_LEN],
flags: [0; ROLL_LEN],
head: 0,
filled: 0,
frames: 0,
last: None,
boot: Instant::now(),
first_frame: None,
});
}
#[cfg(sk_devtools)]
pub struct Snapshot {
pub samples: Vec<f32>,
pub work: Vec<f32>,
pub flags: Vec<u8>,
pub frames: u64,
pub boot_to_first_frame_ms: Option<f32>,
pub uptime_ms: f32,
}
#[cfg(sk_devtools)]
impl Snapshot {
pub fn stats(&self) -> (f32, f32, f32, f32, f32) {
if self.samples.is_empty() {
return (0.0, 0.0, 0.0, 0.0, 0.0);
}
let mut sorted = self.samples.clone();
sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let sum: f32 = sorted.iter().sum();
let avg = sum / sorted.len() as f32;
let at = |q: f32| sorted[((sorted.len() as f32 - 1.0) * q).round() as usize];
(
avg,
at(0.5),
at(0.95),
sorted[sorted.len() - 1],
if avg > 0.0 { 1000.0 / avg } else { 0.0 },
)
}
pub fn work_stats(&self) -> (f32, f32, f32) {
if self.work.is_empty() {
return (0.0, 0.0, 0.0);
}
let mut sorted = self.work.clone();
sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let at = |q: f32| sorted[((sorted.len() as f32 - 1.0) * q).round() as usize];
(at(0.5), at(0.95), sorted[sorted.len() - 1])
}
pub fn share(&self, flag: u8) -> f32 {
if self.flags.is_empty() {
return 0.0;
}
self.flags.iter().filter(|f| *f & flag != 0).count() as f32 / self.flags.len() as f32
}
}
#[cfg(sk_devtools)]
pub fn snapshot() -> Snapshot {
ROLL.with(|r| {
let r = r.borrow();
let mut samples = Vec::with_capacity(r.filled);
let mut work = Vec::with_capacity(r.filled);
let mut flags = Vec::with_capacity(r.filled);
let start = (r.head + ROLL_LEN - r.filled) % ROLL_LEN;
for i in 1..r.filled {
let (before, at) = ((start + i - 1) % ROLL_LEN, (start + i) % ROLL_LEN);
samples.push(r.ms[at]);
work.push(r.work[before].min(r.ms[at]));
flags.push((r.flags[before] & !FLAG_PACED) | (r.flags[at] & FLAG_PACED));
}
Snapshot {
samples,
work,
flags,
frames: r.frames,
boot_to_first_frame_ms: r.first_frame.map(|f| ms_since(r.boot, f)),
uptime_ms: ms_since(r.boot, Instant::now()),
}
})
}
#[cfg(sk_devtools)]
#[inline]
fn roll_frame(now: Instant) {
ROLL.with(|r| {
let mut r = r.borrow_mut();
if r.first_frame.is_none() {
r.first_frame = Some(now);
}
if let Some(prev) = r.last {
let head = r.head;
r.ms[head] = (now - prev).as_secs_f32() * 1000.0;
r.work[head] = 0.0;
r.flags[head] = if crate::idle::last_paced() {
FLAG_PACED
} else {
0
};
r.head = (head + 1) % ROLL_LEN;
r.filled = (r.filled + 1).min(ROLL_LEN);
r.frames += 1;
}
r.last = Some(now);
});
}
#[cfg(sk_devtools)]
fn on_frame_work(frame: gpui::FrameWork) {
ROLL.with(|r| {
let mut r = r.borrow_mut();
if r.filled == 0 {
return;
}
let at = (r.head + ROLL_LEN - 1) % ROLL_LEN;
match frame.outcome {
gpui::FrameOutcome::Throttled => r.flags[at] |= FLAG_THROTTLED,
outcome => {
r.work[at] += frame
.ended
.saturating_duration_since(frame.started)
.as_secs_f32()
* 1000.0;
if outcome == gpui::FrameOutcome::Drew {
r.flags[at] |= FLAG_DREW;
}
}
}
});
}
struct BootJs {
parts: Vec<(&'static str, u32, f32)>,
closed: bool,
}
thread_local! {
static BOOT_JS: RefCell<BootJs> = const { RefCell::new(BootJs { parts: Vec::new(), closed: false }) };
}
pub fn boot_eval<T>(label: &'static str, f: impl FnOnce() -> T) -> T {
let start = Instant::now();
let out = f();
let ms = ms_since(start, Instant::now());
BOOT_JS.with(|b| {
let mut b = b.borrow_mut();
if b.closed {
return;
}
match b.parts.iter_mut().find(|p| p.0 == label) {
Some(p) => {
p.1 += 1;
p.2 += ms;
}
None => b.parts.push((label, 1, ms)),
}
});
out
}
pub fn boot_js() -> Vec<(&'static str, u32, f32)> {
BOOT_JS.with(|b| b.borrow().parts.clone())
}
fn close_boot_js() {
BOOT_JS.with(|b| b.borrow_mut().closed = true);
}
fn boot_js_line(boot_ms: f32) -> String {
let parts = boot_js();
let total: f32 = parts.iter().map(|p| p.2).sum();
let detail: Vec<String> = parts
.iter()
.map(|(label, n, ms)| {
if *n > 1 {
format!("{label}×{n} {ms:.1}")
} else {
format!("{label} {ms:.1}")
}
})
.collect();
format!(
"[sk-perf] boot js {:.1}ms ({:.0}% of boot) {}",
total,
if boot_ms > 0.0 {
total / boot_ms * 100.0
} else {
0.0
},
detail.join(" · ")
)
}
#[inline]
pub fn frame() {
#[cfg(sk_devtools)]
crate::devtools::trace::frame_start();
#[cfg(sk_devtools)]
roll_frame(Instant::now());
if !enabled() {
if !FIRST_FRAME_SEEN.with(|f| f.replace(true)) {
close_boot_js();
}
return;
}
let now = Instant::now();
STATE.with(|s| {
let mut slot = s.borrow_mut();
let Some(st) = slot.as_mut() else { return };
if st.first_frame.is_none() {
st.first_frame = Some(now);
let boot_ms = (now - st.boot).as_secs_f32() * 1000.0;
eprintln!("[sk-perf] boot->first-frame {boot_ms:.1}ms");
eprintln!("{}", boot_js_line(boot_ms));
close_boot_js();
}
if let Some(prev) = st.last_frame {
st.samples.push((now - prev).as_secs_f32() * 1000.0);
st.tagged_frames += 1;
}
st.last_frame = Some(now);
let tail = ms_since(st.cursor, now);
if std::mem::take(&mut st.drew) {
st.tail_draw_ms += tail;
} else {
st.tail_idle_ms += tail;
}
st.cursor = now;
if now - st.window_start >= HOW_OFTEN {
report(st, now);
st.samples.clear();
st.window_start = now;
}
});
}
fn ms_since(then: Instant, now: Instant) -> f32 {
now.saturating_duration_since(then).as_secs_f32() * 1000.0
}
fn stamp(f: impl FnOnce(&mut State, f32)) {
if !enabled() {
return;
}
let now = Instant::now();
STATE.with(|s| {
let mut slot = s.borrow_mut();
let Some(st) = slot.as_mut() else { return };
let dt = ms_since(st.cursor, now);
st.cursor = now;
f(st, dt);
});
}
pub fn pump_done() {
#[cfg(sk_devtools)]
crate::devtools::trace::pump_done();
stamp(|st, dt| st.pump_ms += dt);
}
pub fn render_begin() {
#[cfg(sk_devtools)]
crate::devtools::trace::render_begin();
stamp(|st, dt| st.setup_ms += dt);
}
pub fn render_done() {
#[cfg(sk_devtools)]
crate::devtools::trace::render_done();
stamp(|st, dt| {
st.render_ms += dt;
st.draws += 1;
st.drew = true;
});
}
pub fn mark(tag: &str) {
#[cfg(sk_devtools)]
crate::devtools::trace::mark(tag);
if !enabled() {
return;
}
let now = Instant::now();
STATE.with(|s| {
let mut slot = s.borrow_mut();
let Some(st) = slot.as_mut() else { return };
if !st.samples.is_empty() {
report(st, now);
}
eprintln!(
"[sk-perf] ---- mark: {tag} (previous tag {:?} ran {:.1}s / {} frames) ----",
st.tag,
(now - st.tag_start).as_secs_f32(),
st.tagged_frames
);
st.samples.clear();
st.window_start = now;
st.tag = tag.to_string();
st.tag_start = now;
st.tagged_frames = 0;
});
}
fn compact(n: u64) -> String {
match n {
0..=9_999 => n.to_string(),
10_000..=999_999 => format!("{:.1}K", n as f64 / 1e3),
_ => format!("{:.2}M", n as f64 / 1e6),
}
}
fn report_frame_split(st: &mut State) {
let total = st.pump_ms + st.setup_ms + st.render_ms + st.tail_draw_ms + st.tail_idle_ms;
if total <= 0.0 {
return;
}
let per_draw = if st.draws > 0 {
(st.setup_ms + st.tail_draw_ms) / st.draws as f32
} else {
0.0
};
eprintln!(
"[sk-perf] frame draws={:<4} pump={:.1}ms ({:.0}%) render={:.1}ms ({:.0}%) \
gpui={:.1}ms ({:.0}%, {:.1}/draw) idle-wait={:.1}ms",
st.draws,
st.pump_ms,
100.0 * st.pump_ms / total,
st.render_ms,
100.0 * st.render_ms / total,
st.setup_ms + st.tail_draw_ms,
100.0 * (st.setup_ms + st.tail_draw_ms) / total,
per_draw,
st.tail_idle_ms,
);
st.pump_ms = 0.0;
st.setup_ms = 0.0;
st.render_ms = 0.0;
st.tail_draw_ms = 0.0;
st.tail_idle_ms = 0.0;
st.draws = 0;
}
fn report_phases() {
let Some(p) = sk_tree::perf::take() else {
return;
};
if p.restyle_passes > 0 {
eprintln!(
"[sk-perf] restyle passes={:<4} nodes={:<7} sel={:<7} total={:.1}ms \
avg={:.2} max={:.2} [inline {:.1} · cascade {:.1} (match {:.1} · vars {:.1} · \
fold {:.1}) · store {:.1}]",
p.restyle_passes,
compact(p.nodes_cascaded),
compact(p.rules_tested),
p.restyle_ms,
p.restyle_ms / p.restyle_passes as f32,
p.restyle_max_ms,
p.inline_ms,
p.cascade_ms,
p.match_ms,
p.vars_ms,
p.fold_ms,
p.store_ms,
);
let [any, tag, class, id, root, parent] = p.rules_split.by_bucket;
eprintln!(
"[sk-perf] sel by bucket: any {} · tag {} · class {} · id {} · root {} · parent {} matched {}",
compact(any),
compact(tag),
compact(class),
compact(id),
compact(root),
compact(parent),
compact(p.rules_split.matched),
);
eprintln!(
"[sk-perf] fold shared: {} of {} asked ({} cascaded)",
compact(p.share_hits),
compact(p.share_asked),
compact(p.nodes_cascaded),
);
}
if p.build_passes > 0 {
eprintln!(
"[sk-perf] build passes={:<4} nodes={:<7} {:<22} total={:.1}ms \
avg={:.2} max={:.2}",
p.build_passes,
compact(p.elements_built),
if p.cache_offers + p.cache_standdowns > 0 {
format!(
"cache={}/{}/{}",
p.cache_offers.saturating_sub(p.cached_renders),
p.cached_renders,
p.cache_standdowns
)
} else {
String::new()
},
p.build_ms,
p.build_ms / p.build_passes as f32,
p.build_max_ms,
);
}
if p.draw_passes > 0 {
eprintln!(
"[sk-perf] gpui draws={:<4} layout-req={:.1}ms taffy={:.1}ms \
prepaint={:.1}ms paint={:.1}ms (per draw: {:.1} + {:.1} + {:.1} + {:.1})",
p.draw_passes,
p.layout_req_ms,
p.taffy_ms,
p.prepaint_ms,
p.paint_ms,
p.layout_req_ms / p.draw_passes as f32,
p.taffy_ms / p.draw_passes as f32,
p.prepaint_ms / p.draw_passes as f32,
p.paint_ms / p.draw_passes as f32,
);
}
if p.js_passes > 0 {
eprintln!(
"[sk-perf] js events={:<3} {:<28} total={:.1}ms avg={:.2} max={:.2} \
(inside pump/paint+wait, not extra)",
p.js_passes,
"",
p.js_ms,
p.js_ms / p.js_passes as f32,
p.js_max_ms,
);
}
}
fn report(st: &mut State, now: Instant) {
if st.samples.is_empty() {
return;
}
let mut sorted = st.samples.clone();
sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let n = sorted.len();
let sum: f32 = sorted.iter().sum();
let avg = sum / n as f32;
let pct = |p: f32| sorted[((n as f32 * p).ceil() as usize).clamp(1, n) - 1];
eprintln!(
"[sk-perf] tag={:<22} t=+{:.1}s frames={:<4} avg={:.2} p50={:.2} p95={:.2} p99={:.2} \
max={:.2} fps={:.1} >33ms={}",
st.tag,
(now - st.boot).as_secs_f32(),
n,
avg,
pct(0.50),
pct(0.95),
pct(0.99),
sorted[n - 1],
1000.0 / avg,
sorted.iter().filter(|&&v| v > 33.0).count(),
);
report_frame_split(st);
report_phases();
}