Use link list for scheduler

* Some clean ups in rendering

Author: Grarak

src/core/cycle_manager.rs

@@ -7,8 +7,44 @@ use crate::core::memory::dma::Dma;
 use crate::core::spu::Spu;
 use crate::core::timers::Timers;
 use crate::core::CpuType::{ARM7, ARM9};
-use std::collections::VecDeque;
+use crate::linked_list::{LinkedList, LinkedListAllocator, LinkedListEntry};
+use std::alloc::{GlobalAlloc, Layout, System};
 use std::intrinsics::unlikely;
+use std::ptr;
+
+struct CycleEventEntry {
+    cycle_count: u64,
+    event_type: EventType,
+}
+
+impl CycleEventEntry {
+    fn new(cycle_count: u64, event_type: EventType) -> Self {
+        CycleEventEntry { cycle_count, event_type }
+    }
+}
+
+#[derive(Default)]
+struct CycleEventsListAllocator(Vec<*mut LinkedListEntry<CycleEventEntry>>);
+
+impl LinkedListAllocator<CycleEventEntry> for CycleEventsListAllocator {
+    fn allocate(&mut self, value: CycleEventEntry) -> *mut LinkedListEntry<CycleEventEntry> {
+        let entry = if self.0.is_empty() {
+            unsafe { System.alloc(Layout::new::<LinkedListEntry<CycleEventEntry>>()) as *mut LinkedListEntry<CycleEventEntry> }
+        } else {
+            unsafe { self.0.pop().unwrap_unchecked() }
+        };
+        unsafe {
+            (*entry).value = value;
+            (*entry).previous = ptr::null_mut();
+            (*entry).next = ptr::null_mut();
+        }
+        entry
+    }
+
+    fn deallocate(&mut self, entry: *mut LinkedListEntry<CycleEventEntry>) {
+        self.0.push(entry);
+    }
+}
 
 #[derive(Debug)]
 pub enum EventType {
@@ -29,14 +65,14 @@ pub enum EventType {
 
 pub struct CycleManager {
     cycle_count: u64,
-    events: VecDeque<(u64, EventType)>,
+    events: LinkedList<CycleEventEntry, CycleEventsListAllocator>,
 }
 
 impl CycleManager {
     pub fn new() -> Self {
         CycleManager {
             cycle_count: 0,
-            events: VecDeque::new(),
+            events: LinkedList::new(),
         }
     }
 
@@ -53,25 +89,25 @@ impl CycleManager {
         let cycle_count = self.cycle_count;
         let mut event_triggered = false;
         while {
-            let (cycles, _) = unsafe { self.events.front().unwrap_unchecked() };
-            unlikely(*cycles <= cycle_count)
+            let entry = &LinkedList::<_, CycleEventsListAllocator>::deref(self.events.root).value;
+            unlikely(entry.cycle_count <= cycle_count)
         } {
             event_triggered = true;
-            let (cycles, event) = unsafe { self.events.pop_front().unwrap_unchecked() };
-            match event {
+            let entry = self.events.remove_begin();
+            match entry.event_type {
                 EventType::CpuInterruptArm9 => CpuRegs::on_interrupt_event::<{ ARM9 }>(emu),
                 EventType::CpuInterruptArm7 => CpuRegs::on_interrupt_event::<{ ARM7 }>(emu),
-                EventType::GpuScanline256 => Gpu::on_scanline256_event(emu),
-                EventType::GpuScanline355 => Gpu::on_scanline355_event(emu),
-                EventType::SoundCmdHle => SoundNitro::on_cmd_event(emu),
-                EventType::SoundAlarmHle(id) => SoundNitro::on_alarm_event(id, emu),
+                EventType::GpuScanline256 => Gpu::on_scanline256_event(self, emu),
+                EventType::GpuScanline355 => Gpu::on_scanline355_event(self, emu),
+                EventType::SoundCmdHle => SoundNitro::on_cmd_event(self, emu),
+                EventType::SoundAlarmHle(id) => SoundNitro::on_alarm_event(id, self, emu),
                 EventType::CartridgeWordReadArm9 => Cartridge::on_word_read_event::<{ ARM9 }>(emu),
                 EventType::CartridgeWordReadArm7 => Cartridge::on_word_read_event::<{ ARM7 }>(emu),
                 EventType::DmaArm9(channel) => Dma::on_event::<{ ARM9 }>(channel, emu),
                 EventType::DmaArm7(channel) => Dma::on_event::<{ ARM7 }>(channel, emu),
                 EventType::SpuSample => Spu::on_sample_event(emu),
-                EventType::TimerArm9(channel) => Timers::on_overflow_event::<{ ARM9 }>(cycles, channel, emu),
-                EventType::TimerArm7(channel) => Timers::on_overflow_event::<{ ARM7 }>(cycles, channel, emu),
+                EventType::TimerArm9(channel) => Timers::on_overflow_event::<{ ARM9 }>(entry.cycle_count, channel, emu),
+                EventType::TimerArm7(channel) => Timers::on_overflow_event::<{ ARM7 }>(entry.cycle_count, channel, emu),
             }
         }
         event_triggered
@@ -80,19 +116,21 @@ 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;
+
+        let mut current_node = self.events.root;
+        while !current_node.is_null() {
+            let entry = LinkedList::<_, CycleEventsListAllocator>::deref(current_node);
+            if entry.value.cycle_count > event_cycle {
+                self.events.insert_entry_begin(current_node, CycleEventEntry::new(event_cycle, event_type));
+                return event_cycle;
             }
+            current_node = entry.next;
         }
-        self.events.insert(index, (event_cycle, event_type));
+        self.events.insert_end(CycleEventEntry::new(event_cycle, event_type));
         event_cycle
     }
 
     pub fn jump_to_next_event(&mut self) {
-        self.cycle_count = unsafe { self.events.front().unwrap_unchecked().0 };
+        self.cycle_count = LinkedList::<_, CycleEventsListAllocator>::deref(self.events.root).value.cycle_count
     }
 }

src/core/graphics/gpu.rs

@@ -1,6 +1,6 @@
 use crate::core::cpu_regs::InterruptFlag;
 use crate::core::cycle_manager::{CycleManager, EventType};
-use crate::core::emu::{get_arm7_hle_mut, get_cm_mut, get_common_mut, get_cpu_regs_mut, get_mem_mut, io_dma, Emu};
+use crate::core::emu::{get_arm7_hle_mut, get_common_mut, get_cpu_regs_mut, get_mem_mut, io_dma, Emu};
 use crate::core::graphics::gpu_2d::registers_2d::Gpu2DRegisters;
 use crate::core::graphics::gpu_2d::Gpu2DEngine::{A, B};
 use crate::core::graphics::gpu_3d::registers_3d::Gpu3DRegisters;
@@ -141,7 +141,8 @@ impl Gpu {
         self.disp_cap_cnt = (self.disp_cap_cnt & !mask) | (value & mask);
     }
 
-    pub fn on_scanline256_event(emu: &mut Emu) {
+    #[inline(never)]
+    pub fn on_scanline256_event(cm: &mut CycleManager, emu: &mut Emu) {
         let gpu = &mut get_common_mut!(emu).gpu;
 
         if gpu.v_count < 192 {
@@ -151,7 +152,7 @@ impl Gpu {
                     .as_mut()
                     .on_scanline(&mut gpu.gpu_2d_regs_a, &mut gpu.gpu_2d_regs_b, gpu.v_count as u8)
             }
-            io_dma!(emu, ARM9).trigger_all(DmaTransferMode::StartAtHBlank, get_cm_mut!(emu));
+            io_dma!(emu, ARM9).trigger_all(DmaTransferMode::StartAtHBlank, cm);
         }
 
         for i in 0..2 {
@@ -162,10 +163,11 @@ impl Gpu {
             }
         }
 
-        get_cm_mut!(emu).schedule((355 - 256) * 6, EventType::GpuScanline355);
+        cm.schedule((355 - 256) * 6, EventType::GpuScanline355);
     }
 
-    pub fn on_scanline355_event(emu: &mut Emu) {
+    #[inline(never)]
+    pub fn on_scanline355_event(cm: &mut CycleManager, emu: &mut Emu) {
         let gpu = &mut get_common_mut!(emu).gpu;
 
         gpu.v_count += 1;
@@ -186,7 +188,7 @@ impl Gpu {
                     disp_stat.set_v_blank_flag(u1::new(1));
                     if disp_stat.v_blank_irq_enable() {
                         get_cpu_regs_mut!(emu, CpuType::from(i as u8)).send_interrupt(InterruptFlag::LcdVBlank, emu);
-                        io_dma!(emu, CpuType::from(i as u8)).trigger_all(DmaTransferMode::StartAtVBlank, get_cm_mut!(emu));
+                        io_dma!(emu, CpuType::from(i as u8)).trigger_all(DmaTransferMode::StartAtVBlank, cm);
                     }
                 }
             }
@@ -225,6 +227,6 @@ impl Gpu {
             get_arm7_hle_mut!(emu).on_scanline(gpu.v_count, emu);
         }
 
-        get_cm_mut!(emu).schedule(256 * 6, EventType::GpuScanline256);
+        cm.schedule(256 * 6, EventType::GpuScanline256);
     }
 }

src/core/graphics/gpu_3d/registers_3d.rs

@@ -7,6 +7,7 @@ use crate::fixed_fifo::FixedFifo;
 use crate::math::{Matrix, Vectorf32, Vectori16, Vectori32, Vectoru16};
 use crate::utils::{rgb5_to_rgb6, HeapMem};
 use bilge::prelude::*;
+use std::arch::arm::{vcvtq_f32_s32, vld1q_s32, vmulq_n_f32, vst1q_f32};
 use std::hint::unreachable_unchecked;
 use std::intrinsics::unlikely;
 use std::mem;
@@ -241,24 +242,39 @@ fn intersect(v1: &Vectorf32<4>, v2: &Vectorf32<4>, val1: f32, val2: f32) -> Vect
         return *v1;
     }
 
-    let mut vertex = Vectorf32::default();
-    let dist_inverse = -d1 / (d2 - d1);
-    vertex[0] = v1[0] + ((v2[0] - v1[0]) * dist_inverse);
-    vertex[1] = v1[1] + ((v2[1] - v1[1]) * dist_inverse);
-    vertex[2] = v1[2] + ((v2[2] - v1[2]) * dist_inverse);
-    vertex[3] = v1[3] + ((v2[3] - v1[3]) * dist_inverse);
+    let mut vertex: Vectorf32<4> = unsafe { MaybeUninit::uninit().assume_init() };
+    let dist_inverse = -d1 as f64 / (d2 - d1) as f64;
+    vertex[0] = v1[0] + (((v2[0] - v1[0]) as f64 * dist_inverse) as f32);
+    vertex[1] = v1[1] + (((v2[1] - v1[1]) as f64 * dist_inverse) as f32);
+    vertex[2] = v1[2] + (((v2[2] - v1[2]) as f64 * dist_inverse) as f32);
+    vertex[3] = v1[3] + (((v2[3] - v1[3]) as f64 * dist_inverse) as f32);
     vertex
 }
 
 fn clip_polygon(unclipped: &[Vectori32<4>; 4], clipped: &mut [Vectorf32<4>; 10], size: &mut usize) -> bool {
     let mut clip = false;
 
     let mut vertices = [Vectorf32::<4>::default(); 10];
-    for i in 0..4 {
-        for j in 0..4 {
-            const NORMALIZE: f32 = 1f32 / 4096f32;
-            vertices[i][j] = unclipped[i][j] as f32 * NORMALIZE;
-        }
+    unsafe {
+        let vertices0 = vld1q_s32(unclipped[0].as_ref().as_ptr());
+        let vertices1 = vld1q_s32(unclipped[1].as_ref().as_ptr());
+        let vertices2 = vld1q_s32(unclipped[2].as_ref().as_ptr());
+        let vertices3 = vld1q_s32(unclipped[3].as_ref().as_ptr());
+
+        let vertices0 = vcvtq_f32_s32(vertices0);
+        let vertices1 = vcvtq_f32_s32(vertices1);
+        let vertices2 = vcvtq_f32_s32(vertices2);
+        let vertices3 = vcvtq_f32_s32(vertices3);
+
+        let vertices0 = vmulq_n_f32(vertices0, 1f32 / 4096f32);
+        let vertices1 = vmulq_n_f32(vertices1, 1f32 / 4096f32);
+        let vertices2 = vmulq_n_f32(vertices2, 1f32 / 4096f32);
+        let vertices3 = vmulq_n_f32(vertices3, 1f32 / 4096f32);
+
+        vst1q_f32(vertices[0].as_mut().as_mut_ptr(), vertices0);
+        vst1q_f32(vertices[1].as_mut().as_mut_ptr(), vertices1);
+        vst1q_f32(vertices[2].as_mut().as_mut_ptr(), vertices2);
+        vst1q_f32(vertices[3].as_mut().as_mut_ptr(), vertices3);
     }
 
     for i in 0..6 {
@@ -269,15 +285,11 @@ fn clip_polygon(unclipped: &[Vectori32<4>; 4], clipped: &mut [Vectorf32<4>; 10],
             let current = unsafe { vertices.get_unchecked(j) };
             let previous = unsafe { vertices.get_unchecked(if unlikely(j == 0) { old_size - 1 } else { j - 1 }) };
 
-            let (current_val, previous_val) = match i {
-                0 => (current[0], previous[0]),
-                1 => (-current[0], -previous[0]),
-                2 => (current[1], previous[1]),
-                3 => (-current[1], -previous[1]),
-                4 => (current[2], previous[2]),
-                5 => (-current[2], -previous[2]),
-                _ => unsafe { unreachable_unchecked() },
-            };
+            let (mut current_val, mut previous_val) = (current[i >> 1], previous[i >> 1]);
+            if i & 1 == 1 {
+                current_val = -current_val;
+                previous_val = -previous_val;
+            }
 
             if current_val >= -current[3] {
                 if previous_val < -previous[3] {
@@ -1218,12 +1230,14 @@ impl Gpu3DRegisters {
 
         let mut unclipped = [Vectori32::<4>::default(); 4];
         for i in 0..size {
-            unclipped[i] = self.vertices.ins[self.saved_polygon.vertices_index + i].coords;
+            unsafe { *unclipped.get_unchecked_mut(i) = self.vertices.ins.get_unchecked(self.saved_polygon.vertices_index + i).coords };
         }
 
         if self.polygon_type == PolygonType::QuadliteralStrips {
-            unclipped.swap(2, 3);
-            self.vertices.ins.swap(self.saved_polygon.vertices_index + 2, self.saved_polygon.vertices_index + 3);
+            unsafe {
+                unclipped.swap_unchecked(2, 3);
+                self.vertices.ins.swap_unchecked(self.saved_polygon.vertices_index + 2, self.saved_polygon.vertices_index + 3);
+            }
         }
 
         let x1 = (unclipped[1][0] - unclipped[0][0]) as i64;
@@ -1265,23 +1279,31 @@ impl Gpu3DRegisters {
                     self.vertices.count_in -= size;
                 }
                 PolygonType::TriangleStrips => {
+                    let Vertices { ins, count_in, .. } = &mut self.vertices;
                     if self.vertex_count == 3 {
-                        self.vertices.ins[self.vertices.count_in - 3] = self.vertices.ins[self.vertices.count_in - 2];
-                        self.vertices.ins[self.vertices.count_in - 2] = self.vertices.ins[self.vertices.count_in - 1];
-                        self.vertices.count_in -= 1;
+                        unsafe {
+                            *ins.get_unchecked_mut(*count_in - 3) = *ins.get_unchecked(*count_in - 2);
+                            *ins.get_unchecked_mut(*count_in - 2) = *ins.get_unchecked(*count_in - 1);
+                        }
+                        *count_in -= 1;
                         self.vertex_count -= 1;
-                    } else if self.vertices.count_in < 6144 {
-                        self.vertices.ins[self.vertices.count_in] = self.vertices.ins[self.vertices.count_in - 1];
-                        self.vertices.ins[self.vertices.count_in - 1] = self.vertices.ins[self.vertices.count_in - 2];
-                        self.vertices.count_in += 1;
+                    } else if *count_in < 6144 {
+                        unsafe {
+                            *ins.get_unchecked_mut(*count_in) = *ins.get_unchecked(*count_in - 1);
+                            *ins.get_unchecked_mut(*count_in - 1) = *ins.get_unchecked(*count_in - 2);
+                        }
+                        *count_in += 1;
                         self.vertex_count = 2;
                     }
                 }
                 PolygonType::QuadliteralStrips => {
                     if self.vertex_count == 4 {
-                        self.vertices.ins[self.vertices.count_in - 4] = self.vertices.ins[self.vertices.count_in - 2];
-                        self.vertices.ins[self.vertices.count_in - 3] = self.vertices.ins[self.vertices.count_in - 1];
-                        self.vertices.count_in -= 2;
+                        let Vertices { ins, count_in, .. } = &mut self.vertices;
+                        unsafe {
+                            *ins.get_unchecked_mut(*count_in - 4) = *ins.get_unchecked(*count_in - 2);
+                            *ins.get_unchecked_mut(*count_in - 3) = *ins.get_unchecked(*count_in - 1);
+                        }
+                        *count_in -= 2;
                         self.vertex_count -= 2;
                     } else {
                         self.vertex_count = 2;

src/core/hle/sound_nitro.rs

@@ -1,4 +1,4 @@
-use crate::core::cycle_manager::EventType;
+use crate::core::cycle_manager::{CycleManager, EventType};
 use crate::core::emu::{get_arm7_hle_mut, get_cm_mut, get_spu, get_spu_mut, Emu};
 use crate::core::hle::arm7_hle::Arm7Hle;
 use crate::core::hle::bios::{PITCH_TABLE, VOLUME_TABLE};
@@ -223,7 +223,7 @@ impl SoundNitro {
         get_cm_mut!(emu).schedule(174592, EventType::SoundCmdHle);
     }
 
-    fn on_alarm(&mut self, alarm_id: usize, emu: &mut Emu) {
+    fn on_alarm(&mut self, alarm_id: usize, cm: &mut CycleManager, emu: &mut Emu) {
         let alarm = &mut self.alarms[alarm_id];
         if !alarm.active {
             return;
@@ -233,7 +233,7 @@ impl SoundNitro {
 
         let delay = alarm.repeat;
         if delay != 0 {
-            get_cm_mut!(emu).schedule(delay * 64, EventType::SoundAlarmHle(alarm_id as u8));
+            cm.schedule(delay * 64, EventType::SoundAlarmHle(alarm_id as u8));
         } else {
             alarm.active = false;
         }
@@ -2164,9 +2164,9 @@ impl SoundNitro {
         (self.counter >> 16) as u16
     }
 
-    fn process(&mut self, param: u32, emu: &mut Emu) {
+    fn process(&mut self, cm: &mut CycleManager, param: u32, emu: &mut Emu) {
         if param != 0 {
-            get_cm_mut!(emu).schedule(174592, EventType::SoundCmdHle);
+            cm.schedule(174592, EventType::SoundCmdHle);
         }
 
         self.update_hardware_channels(emu);
@@ -2179,17 +2179,19 @@ impl SoundNitro {
 
     pub(super) fn ipc_recv(&mut self, data: u32, emu: &mut Emu) {
         if data == 0 {
-            self.process(0, emu);
+            self.process(get_cm_mut!(emu), 0, emu);
         } else if data >= 0x02000000 {
             self.cmd_queue.push_back(data);
         }
     }
 
-    pub fn on_cmd_event(emu: &mut Emu) {
-        get_arm7_hle_mut!(emu).sound.nitro.process(1, emu);
+    #[inline(never)]
+    pub fn on_cmd_event(cm: &mut CycleManager, emu: &mut Emu) {
+        get_arm7_hle_mut!(emu).sound.nitro.process(cm, 1, emu);
     }
 
-    pub fn on_alarm_event(id: u8, emu: &mut Emu) {
-        get_arm7_hle_mut!(emu).sound.nitro.on_alarm(id as usize, emu);
+    #[inline(never)]
+    pub fn on_alarm_event(id: u8, cm: &mut CycleManager, emu: &mut Emu) {
+        get_arm7_hle_mut!(emu).sound.nitro.on_alarm(id as usize, cm, emu);
     }
 }

src/core/memory/dma.rs

@@ -302,6 +302,7 @@ impl Dma {
         }
     }
 
+    #[inline(never)]
     pub fn on_event<const CPU: CpuType>(channel_num: u8, emu: &mut Emu) {
         let channel_num = channel_num as usize;
         unsafe { assert_unchecked(channel_num < CHANNEL_COUNT) };