fix: PSP 60fps rendering pipeline + EBOOT XMB assets (#72)

* fix: PSP 60fps rendering pipeline + EBOOT XMB assets

Fix frame-doubling (60→30fps) in PSP Desktop mode caused by three
compounding bottlenecks:

1. swap_buffers pipeline: reorder sceGuSync after sceDisplayWaitVblankStart
   so the GE renders the display list in parallel with the vsync wait
   instead of stalling sequentially on both.

2. SDI draw overhead: replace 108 dashboard SDI objects (HashMap lookups,
   z-sort, prefix filtering per frame) with direct GU draw calls via
   chrome::draw_dashboard(). Add allocation-free draw_with_clips_noalloc()
   to WindowManager using stack-buffer SDI name formatting and
   closure-based filtering instead of Vec<String> allocations.

3. Kernel syscall throttling: rate-limit StatusBarInfo::poll() (6+ kernel
   calls) and sceKernelTotalFreeMemSize/MaxFreeMemSize (heap walks) to
   ~4Hz instead of 60Hz. Replace format!() heap allocations in sysmon,
   music, settings, and network windows with stack-buffer formatting.

Also add EBOOT XMB assets (Psp.toml + ICON0.PNG + PIC1.PNG) so the
homebrew shows an icon and background in the PSP menu.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: resolve doc link for draw_with_clips_noalloc

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: address AI review feedback (iteration 1)

Automated fix by Claude in response to Gemini/Codex review.

Iteration: 1/5

Co-Authored-By: AI Review Agent <noreply@anthropic.com>

---------

Co-authored-by: AI Agent Bot <ai-agent@localhost>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: AI Review Agent <ai-review-agent@localhost>

Author: 4 people

crates/oasis-backend-psp/Psp.toml

@@ -0,0 +1,3 @@
+title = "OASIS OS"
+xmb_icon_png = "assets/ICON0.PNG"
+xmb_background_png = "assets/PIC1.PNG"

crates/oasis-backend-psp/assets/ICON0.PNG

@@ -267,14 +267,13 @@ pub(crate) fn draw_music_windowed(
     if audio.is_playing() {
         let center_x = cx + cw as i32 / 2;
         be.draw_text(file_name, cx + 4, cy + 4, 8, Color::rgb(255, 200, 200))?;
-        let info = format!(
-            "{}Hz {}kbps {}ch",
-            audio.sample_rate(),
-            audio.bitrate(),
-            audio.channels(),
+        let mut buf = [0u8; 64];
+        let info = stack_fmt(
+            &mut buf,
+            format_args!("{}Hz {}kbps {}ch", audio.sample_rate(), audio.bitrate(), audio.channels()),
         );
         let info_x = center_x - (info.len() as i32 * 8) / 2;
-        be.draw_text(&info, info_x, cy + 18, 8, Color::rgb(180, 180, 180))?;
+        be.draw_text(info, info_x, cy + 18, 8, Color::rgb(180, 180, 180))?;
         let status = if audio.is_paused() {
             "PAUSED"
         } else {
@@ -317,13 +316,14 @@ pub(crate) fn draw_settings_windowed(
     let val = Color::WHITE;
     let mut y = cy + 16;
     let vx = cx + 110;
+    let mut buf = [0u8; 64];
 
     be.draw_text("CPU Clock:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&format!("{} MHz", clock_mhz), vx, y, 8, val)?;
+    be.draw_text(stack_fmt(&mut buf, format_args!("{} MHz", clock_mhz)), vx, y, 8, val)?;
     y += 10;
 
     be.draw_text("Bus Clock:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&format!("{} MHz", bus_mhz), vx, y, 8, val)?;
+    be.draw_text(stack_fmt(&mut buf, format_args!("{} MHz", bus_mhz)), vx, y, 8, val)?;
     y += 10;
 
     let profile = match clock_mhz {
@@ -344,7 +344,10 @@ pub(crate) fn draw_settings_windowed(
         let used_kb = (total - remaining) / 1024;
         let total_kb = total / 1024;
         be.draw_text("Tex Cache:", cx + 4, y, 8, lbl)?;
-        be.draw_text(&format!("{}/{} KB", used_kb, total_kb), vx, y, 8, val)?;
+        be.draw_text(
+            stack_fmt(&mut buf, format_args!("{}/{} KB", used_kb, total_kb)),
+            vx, y, 8, val,
+        )?;
     } else {
         be.draw_text("Tex Cache:", cx + 4, y, 8, lbl)?;
         be.draw_text("N/A (PSP-1000)", vx, y, 8, Color::rgb(140, 140, 140))?;
@@ -397,9 +400,10 @@ pub(crate) fn draw_network_windowed(
     y += 10;
 
     if status.battery_percent >= 0 {
+        let mut buf = [0u8; 64];
         be.draw_text("Battery:", cx + 4, y, 8, lbl)?;
         be.draw_text(
-            &format!("{}%", status.battery_percent),
+            stack_fmt(&mut buf, format_args!("{}%", status.battery_percent)),
             vx,
             y,
             8,
@@ -439,6 +443,9 @@ pub(crate) fn draw_sysmon_windowed(
     let mut y = cy + 16;
     let vx = cx + 100;
 
+    // Use a stack buffer to avoid heap allocations from format!() every frame.
+    let mut buf = [0u8; 64];
+
     let fps_clr = if fps >= 55.0 {
         Color::rgb(120, 255, 120)
     } else if fps >= 30.0 {
@@ -447,32 +454,34 @@ pub(crate) fn draw_sysmon_windowed(
         Color::rgb(255, 80, 80)
     };
     be.draw_text("FPS:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&format!("{:.1}", fps), vx, y, 8, fps_clr)?;
+    let s = stack_fmt(&mut buf, format_args!("{:.1}", fps));
+    be.draw_text(s, vx, y, 8, fps_clr)?;
     y += 11;
 
     be.draw_text("CPU/Bus/ME:", cx + 4, y, 8, lbl)?;
-    be.draw_text(
-        &format!("{}/{}/{}", sysinfo.cpu_mhz, sysinfo.bus_mhz, sysinfo.me_mhz),
-        vx,
-        y,
-        8,
-        val,
-    )?;
+    let s = stack_fmt(
+        &mut buf,
+        format_args!("{}/{}/{}", sysinfo.cpu_mhz, sysinfo.bus_mhz, sysinfo.me_mhz),
+    );
+    be.draw_text(s, vx, y, 8, val)?;
     y += 11;
 
     be.draw_text("Free RAM:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&format!("{} KB", free_kb), vx, y, 8, val)?;
+    let s = stack_fmt(&mut buf, format_args!("{} KB", free_kb));
+    be.draw_text(s, vx, y, 8, val)?;
     y += 11;
 
     be.draw_text("Max Block:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&format!("{} KB", max_blk_kb), vx, y, 8, val)?;
+    let s = stack_fmt(&mut buf, format_args!("{} KB", max_blk_kb));
+    be.draw_text(s, vx, y, 8, val)?;
     y += 11;
 
     if let Some((total, remaining)) = vol_info {
         let used_kb = (total - remaining) / 1024;
         let total_kb = total / 1024;
         be.draw_text("Tex VRAM:", cx + 4, y, 8, lbl)?;
-        be.draw_text(&format!("{}/{} KB", used_kb, total_kb), vx, y, 8, val)?;
+        let s = stack_fmt(&mut buf, format_args!("{}/{} KB", used_kb, total_kb));
+        be.draw_text(s, vx, y, 8, val)?;
         y += 11;
     }
 
@@ -483,19 +492,19 @@ pub(crate) fn draw_sysmon_windowed(
     } else {
         Color::rgb(255, 80, 80)
     };
-    let bat_str = if status.battery_percent >= 0 {
+    be.draw_text("Battery:", cx + 4, y, 8, lbl)?;
+    let bat_s = if status.battery_percent >= 0 {
         if status.battery_charging {
-            format!("{}% CHG", status.battery_percent)
+            stack_fmt(&mut buf, format_args!("{}% CHG", status.battery_percent))
         } else {
-            format!("{}%", status.battery_percent)
+            stack_fmt(&mut buf, format_args!("{}%", status.battery_percent))
         }
     } else if status.ac_power {
-        "AC".into()
+        "AC"
     } else {
-        "N/A".into()
+        "N/A"
     };
-    be.draw_text("Battery:", cx + 4, y, 8, lbl)?;
-    be.draw_text(&bat_str, vx, y, 8, bat_clr)?;
+    be.draw_text(bat_s, vx, y, 8, bat_clr)?;
     y += 11;
 
     let wifi_str = if status.wifi_on { "ON" } else { "OFF" };
@@ -606,6 +615,31 @@ pub(crate) fn draw_radio_windowed(
 // Loading indicator
 // ---------------------------------------------------------------------------
 
+/// Format into a stack buffer, returning a `&str`. Avoids heap allocation.
+fn stack_fmt<'a>(buf: &'a mut [u8; 64], args: core::fmt::Arguments<'_>) -> &'a str {
+    use core::fmt::Write;
+
+    struct BufWriter<'b> {
+        buf: &'b mut [u8],
+        pos: usize,
+    }
+    impl core::fmt::Write for BufWriter<'_> {
+        fn write_str(&mut self, s: &str) -> core::fmt::Result {
+            let bytes = s.as_bytes();
+            let avail = self.buf.len() - self.pos;
+            // Avoid splitting a multi-byte UTF-8 character at the boundary.
+            let len = s.floor_char_boundary(bytes.len().min(avail));
+            self.buf[self.pos..self.pos + len].copy_from_slice(&bytes[..len]);
+            self.pos += len;
+            Ok(())
+        }
+    }
+    let mut w = BufWriter { buf: &mut buf[..], pos: 0 };
+    let _ = w.write_fmt(args);
+    let n = w.pos;
+    core::str::from_utf8(&buf[..n]).unwrap_or("???")
+}
+
 pub(crate) fn draw_loading_indicator(backend: &mut PspBackend, msg: &str) {
     let bg = Color::rgba(0, 0, 0, 200);
     backend.fill_rect_inner(0, CONTENT_TOP as i32, SCREEN_WIDTH, CONTENT_H, bg);

crates/oasis-backend-psp/assets/PIC1.PNG

@@ -452,13 +452,21 @@ impl PspBackend {
 
     /// Finalize the current display list, swap buffers, and open the next
     /// frame.
+    ///
+    /// The GE renders the display list asynchronously after `sceGuFinish`.
+    /// By waiting for vsync *before* blocking on `sceGuSync`, the GE
+    /// executes in parallel with the vsync wait instead of sequentially,
+    /// preventing frame-doubling (60→30fps) when the display list is heavy
+    /// (e.g. window dragging, music playback bus contention).
     pub fn swap_buffers_inner(&mut self) {
         // SAFETY: GU frame lifecycle calls. DISPLAY_LIST is exclusively
         // accessed from the single-threaded main loop (init/swap_buffers).
         unsafe {
             sys::sceGuFinish();
-            sys::sceGuSync(GuSyncMode::Finish, GuSyncBehavior::Wait);
+            // Vsync first: GE renders in parallel while CPU waits for vblank.
             sys::sceDisplayWaitVblankStart();
+            // GE is likely done by now; block only if it isn't.
+            sys::sceGuSync(GuSyncMode::Finish, GuSyncBehavior::Wait);
             sys::sceGuSwapBuffers();
             sys::sceGuStart(GuContextType::Direct, &raw mut DISPLAY_LIST as *mut c_void);
         }

crates/oasis-backend-psp/src/desktop.rs

@@ -289,6 +289,11 @@ fn psp_main() {
     dbg_log("[EBOOT] entering main loop");
     psp::thread::sleep_ms(400);
 
+    // Cached values for expensive kernel queries (throttled to ~4Hz).
+    let mut cached_status = StatusBarInfo::poll();
+    let mut cached_free_kb: i32 = 0;
+    let mut cached_max_blk_kb: i32 = 0;
+
     loop {
         let _dt = frame_timer.tick();
         // Log first frame only.
@@ -420,7 +425,12 @@ fn psp_main() {
         }
 
         // -- Render --
-        let status = StatusBarInfo::poll();
+        // Throttle expensive kernel syscalls to every 15th frame (~4Hz at 60fps).
+        // StatusBarInfo::poll() issues 6+ kernel calls (battery, RTC, USB, WiFi).
+        if viz_frame % 15 == 0 {
+            cached_status = StatusBarInfo::poll();
+        }
+        let status = cached_status;
         let fps = frame_timer.fps();
         let usb_active = usb_storage.is_some();
 
@@ -492,13 +502,32 @@ fn psp_main() {
             },
 
             AppMode::Desktop => {
-                // Show dashboard icons behind windows in Desktop mode.
+                // Always hide SDI dashboard icons in Desktop mode -- drawing
+                // ~108 SDI objects (HashMap lookups + z-sort + prefix filter)
+                // eats the frame budget. Instead, draw icons directly via the
+                // backend which is much cheaper (direct GU calls, no SDI overhead).
+                dashboard::hide_dashboard_sdi(&mut dashboard_state, &mut sdi);
+                terminal_sdi::set_terminal_visible(&mut sdi, false);
+
+                // Draw desktop icons directly (bypasses SDI entirely).
                 if !icons_hidden {
-                    dashboard::show_dashboard_sdi(&mut dashboard_state, &mut sdi, &active_theme);
-                } else {
-                    dashboard::hide_dashboard_sdi(&mut dashboard_state, &mut sdi);
+                    chrome::draw_dashboard(
+                        &mut backend,
+                        dashboard_state.selected,
+                        dashboard_state.page,
+                        viz_frame,
+                    );
+                }
+
+                // Throttle kernel heap queries (~4Hz). These walk kernel
+                // memory structures and are expensive on every frame.
+                if viz_frame % 15 == 0 {
+                    // SAFETY: scalar FFI returning available memory stats.
+                    unsafe {
+                        cached_free_kb = psp::sys::sceKernelTotalFreeMemSize() as i32 / 1024;
+                        cached_max_blk_kb = psp::sys::sceKernelMaxFreeMemSize() as i32 / 1024;
+                    }
                 }
-                terminal_sdi::set_terminal_visible(&mut sdi, false);
 
                 render_desktop(
                     &mut backend,
@@ -509,6 +538,8 @@ fn psp_main() {
                     &sysinfo,
                     fps,
                     usb_active,
+                    cached_free_kb,
+                    cached_max_blk_kb,
                     &term,
                     &fm,
                     &pv,
@@ -1008,6 +1039,8 @@ fn render_desktop(
     sysinfo: &SystemInfo,
     fps: f32,
     usb_active: bool,
+    free_kb: i32,
+    max_blk_kb: i32,
     term: &TerminalState,
     fm: &FileManagerState,
     pv: &PhotoViewerState,
@@ -1018,16 +1051,9 @@ fn render_desktop(
     let settings_clock = config.get_i32("clock_mhz").unwrap_or(333);
     let settings_bus = config.get_i32("bus_mhz").unwrap_or(166);
     let current_vol = backend.volatile_mem_info();
-    // SAFETY: scalar FFI returning available memory stats.
-    let (free_kb, max_blk_kb) = unsafe {
-        (
-            psp::sys::sceKernelTotalFreeMemSize() as i32 / 1024,
-            psp::sys::sceKernelMaxFreeMemSize() as i32 / 1024,
-        )
-    };
 
     backend.force_bitmap_font = true;
-    let _ = wm.draw_with_clips(
+    let _ = wm.draw_with_clips_noalloc(
         sdi,
         backend,
         |window_id, cx, cy, cw, ch, be| match window_id {

crates/oasis-backend-psp/src/lib.rs

@@ -63,6 +63,7 @@ const MONTH_NAMES: [&str; 12] = [
 ];
 
 /// Dynamic status info polled each frame (or periodically).
+#[derive(Clone, Copy)]
 pub struct StatusBarInfo {
     /// Battery charge percentage (0-100), or -1 if no battery.
     pub battery_percent: i32,

crates/oasis-backend-psp/src/main.rs

@@ -382,6 +382,47 @@ impl SdiRegistry {
         Ok(())
     }
 
+    /// Draw only the base layer, keeping objects for which `keep` returns true.
+    ///
+    /// Allocation-free alternative to `draw_base_excluding_prefixes`.
+    pub fn draw_base_filtered<F>(&mut self, backend: &mut dyn SdiBackend, keep: F) -> Result<()>
+    where
+        F: Fn(&str) -> bool,
+    {
+        self.ensure_z_sorted();
+        for name in &self.z_sorted_base {
+            let obj = &self.objects[name];
+            if !obj.visible || obj.alpha == 0 {
+                continue;
+            }
+            if !keep(name) {
+                continue;
+            }
+            Self::draw_object(obj, backend)?;
+        }
+        Ok(())
+    }
+
+    /// Draw only the overlay layer, keeping objects for which `keep` returns true.
+    ///
+    /// Allocation-free alternative to `draw_overlay_excluding_prefixes`.
+    pub fn draw_overlay_filtered<F>(&self, backend: &mut dyn SdiBackend, keep: F) -> Result<()>
+    where
+        F: Fn(&str) -> bool,
+    {
+        for name in &self.z_sorted_overlay {
+            let obj = &self.objects[name];
+            if !obj.visible || obj.alpha == 0 {
+                continue;
+            }
+            if !keep(name) {
+                continue;
+            }
+            Self::draw_object(obj, backend)?;
+        }
+        Ok(())
+    }
+
     /// Render a single SDI object to the backend.
     ///
     /// Dispatch order for non-textured objects with nonzero area: