fix(doom): various optimizations

optimize screen rendering by removing bounds check and using offsets to give llvm better optimization options

Author: mathisbot

beskar-lib/src/lib.rs

@@ -84,9 +84,10 @@ pub fn __init() {
 #[inline]
 /// In debug builds, triggers a breakpoint interrupt (`int3`).
 pub fn debug_break() {
-    #[cfg(debug_assertions)]
-    unsafe {
-        core::arch::asm!("int3", options(nomem, nostack, preserves_flags));
+    if cfg!(debug_assertions) {
+        unsafe {
+            core::arch::asm!("int3", options(nomem, nostack, preserves_flags));
+        }
     }
 }
 
@@ -95,8 +96,9 @@ pub fn debug_break() {
 ///
 /// The provided value `x` is placed in the `RAX` register before triggering the interrupt.
 pub fn debug_break_value(x: u64) {
-    #[cfg(debug_assertions)]
-    unsafe {
-        core::arch::asm!("int3", in("rax") x, options(nomem, nostack, preserves_flags));
+    if cfg!(debug_assertions) {
+        unsafe {
+            core::arch::asm!("int3", in("rax") x, options(nomem, nostack, preserves_flags));
+        }
     }
 }

kernel/src/process/binary/elf/src/lib.rs

@@ -74,8 +74,6 @@
 #![warn(clippy::pedantic, clippy::nursery)]
 #![no_std]
 
-extern crate alloc;
-
 mod error;
 mod loader;
 pub mod mapper;

kernel/src/process/binary/elf/src/loader.rs

@@ -73,6 +73,7 @@ impl ElfLoader {
         Ok(LoadedBinary {
             entry_point,
             tls_template,
+            image_size: addr_range.size(),
         })
     }
 

kernel/src/process/binary/elf/src/segments.rs

@@ -20,4 +20,6 @@ pub struct LoadedBinary {
     pub entry_point: extern "C" fn(),
     /// TLS template (if present)
     pub tls_template: Option<TlsTemplate>,
+    /// Image size in memory
+    pub image_size: u64,
 }

userspace/doom/build.rs

@@ -29,6 +29,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .flag("-w")
         // compile without simd
         .flag("-mgeneral-regs-only")
+        .flag("-flto")
         .compile("puredoom");
 
     Ok(())

userspace/doom/src/game.rs

@@ -1,5 +1,5 @@
 use core::{
-    ffi::{c_char, c_void},
+    ffi::{CStr, c_char, c_void},
     sync::atomic::{AtomicUsize, Ordering},
 };
 
@@ -33,15 +33,14 @@ pub fn init() {
     unsafe { doom_set_getenv(getenv) };
 }
 
-#[cfg(debug_assertions)]
 extern "C" fn print(s: *const c_char) {
-    let s = unsafe { core::ffi::CStr::from_ptr(s) };
-    if let Ok(s) = s.to_str() {
-        beskar_lib::println!("DOOM: {}", s);
+    if !cfg!(debug_assertions) {
+        let s = unsafe { CStr::from_ptr(s) };
+        if let Ok(s) = s.to_str() {
+            beskar_lib::println!("DOOM: {}", s);
+        }
     }
 }
-#[cfg(not(debug_assertions))]
-extern "C" fn print(_s: *const c_char) {}
 
 extern "C" fn malloc(size: i32) -> *mut c_void {
     // `alloc` states the layout size must be non-zero.
@@ -57,8 +56,7 @@ extern "C" fn malloc(size: i32) -> *mut c_void {
 
     assert!(
         !ptr.is_null(),
-        "malloc failed: out of memory (requested {} bytes)",
-        size
+        "malloc failed: out of memory (requested {size} bytes)",
     );
 
     ptr.cast()

userspace/doom/src/input.rs

@@ -1,4 +1,4 @@
-use beskar_lib::io::keyboard::{KeyCode, KeyEvent, KeyState, KeyboardReader};
+use beskar_lib::io::keyboard::{KeyCode, KeyState, KeyboardReader};
 use hyperdrive::{locks::ticket::TicketLock, once::Once};
 
 #[link(name = "puredoom", kind = "static")]
@@ -164,23 +164,18 @@ impl From<KeyCode> for DoomKeyT {
     }
 }
 
-#[must_use]
-#[inline]
+/// Polls the keyboard and redistributes events to Doom.
+///
 /// # Panics
 ///
-/// This function panics if opening the keyboard file fails (only once).
-fn poll_keyboard() -> Option<KeyEvent> {
+/// This function will panic if the keyboard reader cannot be initialized.
+pub fn poll_inputs() {
     static KEYBOARD_READER: Once<TicketLock<KeyboardReader>> = Once::uninit();
 
     KEYBOARD_READER.call_once(|| TicketLock::new(KeyboardReader::new().unwrap()));
     let mut reader = KEYBOARD_READER.get().unwrap().lock();
 
-    reader.next_event().unwrap_or(None)
-}
-
-/// Polls the keyboard and redistributes events to Doom.
-pub fn poll_inputs() {
-    while let Some(event) = poll_keyboard() {
+    while let Ok(Some(event)) = reader.next_event() {
         let doom_key = DoomKeyT::from(event.key());
         match event.pressed() {
             KeyState::Pressed => unsafe { doom_key_down(doom_key) },

userspace/doom/src/main.rs

@@ -22,8 +22,8 @@ fn main() {
     unsafe { doom_init(1, argv.as_ptr(), 0b111) };
 
     loop {
+        doom::input::poll_inputs();
         unsafe { doom_update() };
         doom::screen::draw();
-        doom::input::poll_inputs();
     }
 }

userspace/doom/src/screen.rs

@@ -24,6 +24,8 @@ pub fn init() {
     SCREEN_INFO.call_once(|| SCREEN.with_locked(|screen| *screen.info()));
 }
 
+#[must_use]
+#[inline]
 /// Returns the screen info.
 ///
 /// # Panics
@@ -33,29 +35,33 @@ fn screen_info() -> &'static Info {
     SCREEN_INFO.get().unwrap()
 }
 
+#[inline]
 fn with_screen<R, F: FnOnce(&mut FrameBuffer) -> R>(f: F) -> R {
     SCREEN.with_locked(f)
 }
 
 /// Draw the Doom framebuffer to the screen
 pub fn draw() {
-    let fb_start = unsafe { doom_get_framebuffer(CHANNELS.try_into().unwrap()) };
-    let fb_raw = core::ptr::slice_from_raw_parts(fb_start, SCREENWIDTH * SCREENHEIGHT * CHANNELS);
+    let fb_start = unsafe { doom_get_framebuffer(CHANNELS as i32) };
 
-    let Some(fb) = (unsafe { fb_raw.as_ref() }) else {
-        beskar_lib::println!("Warning: Doom framebuffer is not initialized");
-        return;
-    };
+    let info = screen_info();
+    let stride_bytes = usize::from(info.stride()) * usize::from(info.bytes_per_pixel());
+    let row_size = SCREENWIDTH * CHANNELS;
 
-    let stride = usize::from(screen_info().stride());
-    let bpp = usize::from(screen_info().bytes_per_pixel());
-    let stride_bytes = stride * bpp;
     with_screen(|screen| {
-        let mut buffer_mut = screen.buffer_mut();
-        for row in fb.chunks_exact(SCREENWIDTH * CHANNELS) {
-            buffer_mut[..SCREENWIDTH * CHANNELS].copy_from_slice(row);
-            buffer_mut = &mut buffer_mut[stride_bytes..];
+        let dst = screen.buffer_mut().as_mut_ptr();
+        let src = fb_start;
+
+        for y in 0..SCREENHEIGHT {
+            unsafe {
+                core::ptr::copy_nonoverlapping(
+                    src.add(y * row_size),
+                    dst.add(y * stride_bytes),
+                    row_size,
+                );
+            }
         }
-        let _ = screen.flush_rows(0..u16::try_from(SCREENHEIGHT).unwrap());
+
+        let _ = screen.flush_rows(0..SCREENHEIGHT as u16);
     });
 }