Optimize multiple io operations

* dma optimizations
* ldm/stm optimizations
* Use fifo with smaller overhead
* Cache div sqrt results

Author: Grarak

.cargo/config.toml

@@ -1,3 +1,3 @@
 [target.armv7-unknown-linux-gnueabihf]
 linker = "/usr/bin/clang"
-rustflags = ["-C", "link-args=-target armv7-unknown-linux-gnueabihf -fuse-ld=lld", "-C", "target-feature=+neon,+thumb-mode,+thumb2,+v5te,+v6,+v6k,+v6t2,+v7,+vfp2,+vfp3"]
+rustflags = ["-C", "link-args=-target armv7-unknown-linux-gnueabihf -fuse-ld=lld", "-C", "target-feature=+neon,+thumb-mode,+thumb2,+v5te,+v6,+v6k,+v6t2,+v7,+vfp2,+vfp3", "-Clink-arg=-Wl,--no-rosegment"]

src/core/cycle_manager.rs

@@ -80,15 +80,19 @@ impl CycleManager {
     pub fn schedule(&mut self, in_cycles: u32, event_type: EventType) -> u64 {
         debug_assert_ne!(in_cycles, 0);
         let event_cycle = self.cycle_count + in_cycles as u64;
-        let mut index = self.events.len();
-        for i in 0..self.events.len() {
-            let (cycles, _) = unsafe { self.events.get(i).unwrap_unchecked() };
-            if *cycles > event_cycle {
-                index = i;
-                break;
+        if in_cycles == 1 {
+            self.events.insert(0, (event_cycle, event_type))
+        } else {
+            let mut index = self.events.len();
+            for i in 0..self.events.len() {
+                let (cycles, _) = unsafe { self.events.get(i).unwrap_unchecked() };
+                if *cycles > event_cycle {
+                    index = i;
+                    break;
+                }
             }
+            self.events.insert(index, (event_cycle, event_type));
         }
-        self.events.insert(index, (event_cycle, event_type));
         event_cycle
     }
 

src/core/div_sqrt.rs

@@ -1,12 +1,17 @@
+use std::hint::unreachable_unchecked;
+use std::intrinsics::{unchecked_div, unchecked_rem};
+
 pub struct DivSqrt {
     pub sqrt_cnt: u16,
-    pub sqrt_result: u32,
+    sqrt_result: u32,
     sqrt_param: u64,
+    sqrt_dirty: bool,
     pub div_cnt: u16,
     div_numer: i64,
     div_denom: i64,
     div_result: i64,
     divrem_result: i64,
+    div_dirty: bool,
 }
 
 impl DivSqrt {
@@ -15,11 +20,13 @@ impl DivSqrt {
             sqrt_cnt: 0,
             sqrt_result: 0,
             sqrt_param: 0,
+            sqrt_dirty: true,
             div_cnt: 0,
             div_numer: 0,
             div_denom: 0,
             div_result: 0,
             divrem_result: 0,
+            div_dirty: true,
         }
     }
 
@@ -31,7 +38,16 @@ impl DivSqrt {
         (self.sqrt_param >> 32) as u32
     }
 
+    pub fn get_sqrt_result(&mut self) -> u32 {
+        self.sqrt();
+        self.sqrt_result
+    }
+
     fn sqrt(&mut self) {
+        if !self.sqrt_dirty {
+            return;
+        }
+        self.sqrt_dirty = false;
         if self.sqrt_cnt & 1 == 0 {
             self.sqrt_result = (self.sqrt_param as u32).isqrt();
         } else {
@@ -42,17 +58,17 @@ impl DivSqrt {
     pub fn set_sqrt_cnt(&mut self, mut mask: u16, value: u16) {
         mask &= 0x1;
         self.sqrt_cnt = (self.sqrt_cnt & !mask) | (value & mask);
-        self.sqrt();
+        self.sqrt_dirty = true;
     }
 
     pub fn set_sqrt_param_l(&mut self, mask: u32, value: u32) {
         self.sqrt_param = (self.sqrt_param & !(mask as u64)) | (value & mask) as u64;
-        self.sqrt();
+        self.sqrt_dirty = true;
     }
 
     pub fn set_sqrt_param_h(&mut self, mask: u32, value: u32) {
         self.sqrt_param = (self.sqrt_param & !((mask as u64) << 32)) | (((value & mask) as u64) << 32);
-        self.sqrt();
+        self.sqrt_dirty = true;
     }
 
     pub fn get_div_numer_l(&self) -> u32 {
@@ -71,23 +87,31 @@ impl DivSqrt {
         (self.div_denom as u64 >> 32) as u32
     }
 
-    pub fn get_div_result_l(&self) -> u32 {
+    pub fn get_div_result_l(&mut self) -> u32 {
+        self.div();
         self.div_result as u32
     }
 
-    pub fn get_div_result_h(&self) -> u32 {
+    pub fn get_div_result_h(&mut self) -> u32 {
+        self.div();
         (self.div_result as u64 >> 32) as u32
     }
 
-    pub fn get_divrem_result_l(&self) -> u32 {
+    pub fn get_divrem_result_l(&mut self) -> u32 {
+        self.div();
         self.divrem_result as u32
     }
 
-    pub fn get_divrem_result_h(&self) -> u32 {
+    pub fn get_divrem_result_h(&mut self) -> u32 {
+        self.div();
         (self.divrem_result as u64 >> 32) as u32
     }
 
     fn div(&mut self) {
+        if !self.div_dirty {
+            return;
+        }
+        self.div_dirty = false;
         if self.div_denom == 0 {
             self.div_cnt |= 1 << 14;
         } else {
@@ -98,74 +122,48 @@ impl DivSqrt {
             0 => {
                 let num = self.div_numer as i32;
                 let denom = self.div_denom as i32;
-                if num == i32::MIN && denom == -1 {
-                    self.div_result = (num as u64 ^ ((!0u32 as u64) << 32)) as i64;
-                    self.divrem_result = 0;
-                } else if denom != 0 {
-                    self.div_result = (num / denom) as i64;
-                    self.divrem_result = (num % denom) as i64;
-                } else {
-                    self.div_result = (if num < 0 { 1 } else { -1i32 } as u64 ^ ((!0u32 as u64) << 32)) as i64;
-                    self.divrem_result = num as i64;
-                }
+                self.div_result = unsafe { unchecked_div(num, denom) } as i64;
+                self.divrem_result = unsafe { unchecked_rem(num, denom) } as i64;
             }
             1 => {
                 let num = self.div_numer;
                 let denom = self.div_denom as i32;
-                if num == i64::MIN && denom == -1 {
-                    self.div_result = num;
-                    self.divrem_result = 0;
-                } else if denom != 0 {
-                    self.div_result = num / denom as i64;
-                    self.divrem_result = num % denom as i64;
-                } else {
-                    self.div_result = if num < 0 { 1 } else { -1 };
-                    self.divrem_result = num;
-                }
+                self.div_result = unsafe { unchecked_div(num, denom as i64) };
+                self.divrem_result = unsafe { unchecked_rem(num, denom as i64) };
             }
             2 => {
                 let num = self.div_numer;
                 let denom = self.div_denom;
-                if num == i64::MIN && denom == -1 {
-                    self.div_result = num;
-                    self.divrem_result = 0;
-                } else if denom != 0 {
-                    self.div_result = num / denom;
-                    self.divrem_result = num % denom;
-                } else {
-                    self.div_result = if num < 0 { 1 } else { -1 };
-                    self.divrem_result = num;
-                }
-            }
-            _ => {
-                unreachable!()
+                self.div_result = unsafe { unchecked_div(num, denom) };
+                self.divrem_result = unsafe { unchecked_rem(num, denom) };
             }
+            _ => unsafe { unreachable_unchecked() },
         }
     }
 
     pub fn set_div_cnt(&mut self, mut mask: u16, value: u16) {
         mask &= 0x3;
         self.div_cnt = (self.div_cnt & !mask) | (value & mask);
-        self.div();
+        self.div_dirty = true;
     }
 
     pub fn set_div_numer_l(&mut self, mask: u32, value: u32) {
         self.div_numer = ((self.div_numer as u64 & !(mask as u64)) | (value & mask) as u64) as i64;
-        self.div();
+        self.div_dirty = true;
     }
 
     pub fn set_div_numer_h(&mut self, mask: u32, value: u32) {
         self.div_numer = ((self.div_numer as u64 & !((mask as u64) << 32)) | (((value & mask) as u64) << 32)) as i64;
-        self.div();
+        self.div_dirty = true;
     }
 
     pub fn set_div_denom_l(&mut self, mask: u32, value: u32) {
         self.div_denom = ((self.div_denom as u64 & !(mask as u64)) | (value & mask) as u64) as i64;
-        self.div();
+        self.div_dirty = true;
     }
 
     pub fn set_div_denom_h(&mut self, mask: u32, value: u32) {
         self.div_denom = ((self.div_denom as u64 & !((mask as u64) << 32)) | (((value & mask) as u64) << 32)) as i64;
-        self.div();
+        self.div_dirty = true;
     }
 }

src/core/graphics/gpu_3d/registers_3d.rs

@@ -3,11 +3,12 @@ use crate::core::emu::{get_cm_mut, get_cpu_regs_mut, get_mem_mut, io_dma, Emu};
 use crate::core::graphics::gpu::{DISPLAY_HEIGHT, DISPLAY_WIDTH};
 use crate::core::memory::dma::DmaTransferMode;
 use crate::core::CpuType::ARM9;
+use crate::fixed_fifo::FixedFifo;
 use crate::math::{Matrix, Vectori16, Vectori32, Vectoru16};
 use crate::utils::{rgb5_to_rgb6, HeapMem};
 use bilge::prelude::*;
-use std::collections::VecDeque;
 use std::hint::unreachable_unchecked;
+use std::intrinsics::unlikely;
 use std::mem;
 
 #[bitsize(32)]
@@ -157,7 +158,7 @@ const FIFO_PARAM_COUNTS: [u8; 128] = [
     3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x70-0x7F
 ];
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Default)]
 struct Entry {
     cmd: u8,
     param: u32,
@@ -257,7 +258,11 @@ fn clip_polygon(unclipped: &[Vectori32<4>; 4], clipped: &mut [Vectori32<4>; 10],
 
         for j in 0..old_size {
             let current = &vertices[j];
-            let previous = &vertices[(j.wrapping_sub(1).wrapping_add(old_size)) % old_size];
+            let mut previous_index = j + 1;
+            if unlikely(previous_index == old_size) {
+                previous_index = 0;
+            }
+            let previous = &vertices[previous_index];
 
             let (current_val, previous_val) = match i {
                 0 => (current[0], previous[0]),
@@ -390,7 +395,7 @@ pub struct Polygons {
 
 #[derive(Default)]
 pub struct Gpu3DRegisters {
-    cmd_fifo: VecDeque<Entry>,
+    cmd_fifo: FixedFifo<Entry, 512>,
     cmd_pipe_size: u8,
     test_queue: u32,
     mtx_queue: u32,
@@ -496,16 +501,17 @@ impl Gpu3DRegisters {
 
         while !self.cmd_fifo.is_empty() && executed_cycles < cycle_diff && !self.flushed {
             let mut params = Vec::new();
-            let entry = unsafe { *self.cmd_fifo.front().unwrap_unchecked() };
-            let mut param_count = FIFO_PARAM_COUNTS[entry.cmd as usize];
+            let entry = unsafe { *self.cmd_fifo.front_unchecked() };
+            let mut param_count = unsafe { *FIFO_PARAM_COUNTS.get_unchecked(entry.cmd as usize) };
             if param_count > 1 {
                 if param_count as usize > self.cmd_fifo.len() {
                     break;
                 }
 
                 params.reserve(param_count as usize);
                 for _ in 0..param_count {
-                    params.push(unsafe { self.cmd_fifo.pop_front().unwrap_unchecked().param });
+                    params.push(unsafe { self.cmd_fifo.front_unchecked().param });
+                    self.cmd_fifo.pop_front();
                 }
             } else {
                 param_count = 1;
@@ -1322,8 +1328,8 @@ impl Gpu3DRegisters {
     }
 
     fn queue_entry(&mut self, entry: Entry, emu: &mut Emu) {
-        if self.cmd_fifo.is_empty() && !self.is_cmd_pipe_full() {
-            self.cmd_fifo.push_back(entry);
+        if !self.is_cmd_pipe_full() {
+            unsafe { self.cmd_fifo.push_back_unchecked(entry) };
             self.cmd_pipe_size += 1;
             self.gx_stat.set_geometry_busy(true);
         } else {
@@ -1332,7 +1338,7 @@ impl Gpu3DRegisters {
                 get_cpu_regs_mut!(emu, ARM9).halt(1);
             }
 
-            self.cmd_fifo.push_back(entry);
+            unsafe { self.cmd_fifo.push_back_unchecked(entry) };
             self.gx_stat.set_num_entries_cmd_fifo(u9::new(self.cmd_fifo.len() as u16 - self.cmd_pipe_size as u16));
             self.gx_stat.set_cmd_fifo_empty(false);
 
@@ -1387,13 +1393,13 @@ impl Gpu3DRegisters {
             self.queue_entry(Entry::new(self.gx_fifo as u8, value & mask), emu);
             self.cmd_fifo_param_count += 1;
 
-            if self.cmd_fifo_param_count == unsafe { *FIFO_PARAM_COUNTS.get_unchecked((self.gx_fifo & 0xFF) as usize) } as u32 {
+            if self.cmd_fifo_param_count == FIFO_PARAM_COUNTS[(self.gx_fifo & 0x7F) as usize] as u32 {
                 self.gx_fifo >>= 8;
                 self.cmd_fifo_param_count = 0;
             }
         }
 
-        while self.gx_fifo != 0 && unsafe { *FIFO_PARAM_COUNTS.get_unchecked((self.gx_fifo & 0xFF) as usize) } == 0 {
+        while self.gx_fifo != 0 && FIFO_PARAM_COUNTS[(self.gx_fifo & 0x7F) as usize] == 0 {
             self.queue_entry(Entry::new(self.gx_fifo as u8, value & mask), emu);
             self.gx_fifo >>= 8;
         }