Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

dedupe IPC deliver_pending schedules via a delivery_scheduled flag, FFCC is very chatty, is this a wii thing? 50% boost in FFCC

Laylecd33bba6ae9a
diff --git a/crates/gecko/Cargo.toml b/crates/gecko/Cargo.toml
index 49470c4..4a3529f 100644
--- a/crates/gecko/Cargo.toml
+++ b/crates/gecko/Cargo.toml
@@ -23,7 +23,7 @@ jit = [
"dep:cranelift-module",
"dep:cranelift-native",
]
-jit-stats = ["jit"]
+jit-stats = ["jit", "dep:backtrace"]
fps-counter = []
profile = ["dep:backtrace", "dep:windows-sys"]
diff --git a/crates/gecko/src/profile.rs b/crates/gecko/src/profile.rs
index d13d9a2..47ede80 100644
--- a/crates/gecko/src/profile.rs
+++ b/crates/gecko/src/profile.rs
@@ -36,6 +36,19 @@ pub fn ensure_dir(path: &Path) -> std::io::Result<()> {
std::fs::create_dir_all(path)
}
+#[cfg(any(feature = "profile", feature = "jit-stats"))]
+pub fn resolve_symbol(addr: usize) -> Option<String> {
+ let mut name: Option<String> = None;
+ backtrace::resolve(addr as *mut std::ffi::c_void, |sym| {
+ if name.is_none() {
+ if let Some(n) = sym.name() {
+ name = Some(format!("{:#}", n));
+ }
+ }
+ });
+ name
+}
+
pub fn write_file_atomic(
path: &Path,
write: impl FnOnce(&mut std::fs::File) -> std::io::Result<()>,
@@ -199,16 +212,7 @@ mod win_sampler {
let mut resolved: FxHashMap<String, u64> = FxHashMap::default();
let mut unresolved: u64 = 0;
for (ip, n) in &counts {
- let mut name: Option<String> = None;
- backtrace::resolve(*ip as *mut std::ffi::c_void, |sym| {
- if name.is_none() {
- if let Some(n) = sym.name() {
- name = Some(format!("{:#}", n));
- }
- }
- });
-
- match name {
+ match super::resolve_symbol(*ip as usize) {
Some(n_str) => *resolved.entry(n_str).or_insert(0) += n,
None => unresolved += n,
}
diff --git a/crates/gecko/src/scheduler.rs b/crates/gecko/src/scheduler.rs
index 5839c18..d285bad 100644
--- a/crates/gecko/src/scheduler.rs
+++ b/crates/gecko/src/scheduler.rs
@@ -44,6 +44,8 @@ pub struct Scheduler<const SYSTEM: SystemId> {
pub(crate) next_deadline: u64,
pub(crate) timebase_offset: i64,
events: VecDeque<ScheduledEvent<SYSTEM>>,
+ #[cfg(feature = "jit-stats")]
+ pub(crate) event_fire_counts: rustc_hash::FxHashMap<usize, u64>,
}
impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {
@@ -53,6 +55,8 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {
next_deadline: u64::MAX,
timebase_offset: 0,
events: VecDeque::with_capacity(8),
+ #[cfg(feature = "jit-stats")]
+ event_fire_counts: rustc_hash::FxHashMap::default(),
}
}
@@ -108,6 +112,10 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {
if self.cycles >= front.deadline {
let f = self.events.pop_front().unwrap().f;
self.refresh_deadline();
+ #[cfg(feature = "jit-stats")]
+ {
+ *self.event_fire_counts.entry(f as *const () as usize).or_insert(0) += 1;
+ }
Some(f)
} else {
None
diff --git a/crates/gecko/src/starlet.rs b/crates/gecko/src/starlet.rs
index 08a0758..9f9a5dc 100644
--- a/crates/gecko/src/starlet.rs
+++ b/crates/gecko/src/starlet.rs
@@ -32,6 +32,7 @@ pub struct Starlet {
next_fd: i32,
pub pending: VecDeque<PendingResponse>,
pub host_fs_root: PathBuf,
+ delivery_scheduled: bool,
}
impl Starlet {
@@ -42,6 +43,7 @@ impl Starlet {
next_fd: 1,
pending: VecDeque::new(),
host_fs_root: self::default_host_fs_root(),
+ delivery_scheduled: false,
}
}
@@ -176,15 +178,21 @@ impl System<{ crate::WII }> {
pub fn dispatch_command<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, cmd_paddr: u32) {
let result = self::process_command(sys, cmd_paddr);
sys.starlet.pending.push_back(PendingResponse { cmd_paddr, result });
- sys.scheduler.schedule_in(
- microseconds_to_cycles(SYSTEM, FINALIZE_DELAY_US),
- self::deliver_pending::<SYSTEM>,
- );
+ self::ensure_delivery_scheduled::<SYSTEM>(sys, FINALIZE_DELAY_US);
}
pub fn schedule_drain<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {
+ self::ensure_delivery_scheduled::<SYSTEM>(sys, ACK_TO_NEXT_DELAY_US);
+}
+
+fn ensure_delivery_scheduled<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, delay_us: u64) {
+ if sys.starlet.delivery_scheduled {
+ return;
+ }
+
+ sys.starlet.delivery_scheduled = true;
sys.scheduler.schedule_in(
- microseconds_to_cycles(SYSTEM, ACK_TO_NEXT_DELAY_US),
+ microseconds_to_cycles(SYSTEM, delay_us),
self::deliver_pending::<SYSTEM>,
);
}
@@ -354,11 +362,18 @@ fn bind_fd_context(starlet: &Starlet, ctx: &mut DeviceContext<'_>, fd: i32) -> S
}
fn deliver_pending<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {
+ sys.starlet.delivery_scheduled = false;
+
if sys.hollywood.ipc.ppcctrl.arm_response() {
tracing::trace!(
queue_len = sys.starlet.pending.len(),
"deliver_pending: arm_response still set, skipping"
);
+
+ if !sys.starlet.pending.is_empty() {
+ self::ensure_delivery_scheduled::<SYSTEM>(sys, ACK_TO_NEXT_DELAY_US);
+ }
+
return;
}
@@ -366,11 +381,17 @@ fn deliver_pending<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {
tracing::trace!("deliver_pending: queue empty");
return;
};
+
tracing::trace!(
cmd_paddr = format!("{:#010X}", p.cmd_paddr),
result = p.result,
remaining = sys.starlet.pending.len(),
"deliver_pending"
);
+
crate::hollywood::ipc::deliver_response(sys, p.cmd_paddr, p.result);
+
+ if !sys.starlet.pending.is_empty() {
+ self::ensure_delivery_scheduled::<SYSTEM>(sys, ACK_TO_NEXT_DELAY_US);
+ }
}
diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rs
index 7342626..e268f22 100644
--- a/crates/gecko/src/system.rs
+++ b/crates/gecko/src/system.rs
@@ -277,19 +277,47 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
let dsp_suspends = crate::flipper::dsp::DSP_SUSPEND_COUNT.load(Ordering::Relaxed);
let dsp_wakes = crate::flipper::dsp::DSP_WAKE_COUNT.load(Ordering::Relaxed);
+ let event_breakdown = self.event_breakdown_top_n(20);
+
let path = self.heatmap.out_dir.join("idle-skip.txt");
let result = crate::profile::write_file_atomic(&path, |f| {
writeln!(
f,
"vsync_count={}\nppc_idle_calls={}\nppc_cycles_advanced={}\nppc_avg_advance={:.1}\ndsp_suspends={}\ndsp_wakes={}",
self.vsync_count, calls, cycles, avg, dsp_suspends, dsp_wakes
- )
+ )?;
+
+ writeln!(f, "\n--- top scheduler events by fire count ---")?;
+
+ for (name, count) in &event_breakdown {
+ writeln!(f, "{:>10} {}", count, name)?;
+ }
+
+ Ok(())
});
if let Err(err) = result {
tracing::warn!(?err, "idle-skip sidecar write failed");
}
}
+ #[cfg(all(feature = "jit-stats", feature = "jit"))]
+ fn event_breakdown_top_n(&self, n: usize) -> Vec<(String, u64)> {
+ let mut entries: Vec<(String, u64)> = self
+ .scheduler
+ .event_fire_counts
+ .iter()
+ .map(|(&addr, &count)| (Self::resolve_handler_name(addr), count))
+ .collect();
+ entries.sort_by(|a, b| b.1.cmp(&a.1));
+ entries.truncate(n);
+ entries
+ }
+
+ #[cfg(all(feature = "jit-stats", feature = "jit"))]
+ fn resolve_handler_name(addr: usize) -> String {
+ crate::profile::resolve_symbol(addr).unwrap_or_else(|| format!("<unresolved {:#018x}>", addr))
+ }
+
#[cfg(feature = "profile")]
fn tick_pprof_session(&mut self) {
if self.pprof_session.is_none() {