Add back mmu

* Speed up some hot paths

Author: Grarak

src/cartridge_io.rs

@@ -2,16 +2,15 @@ use crate::cartridge_metadata::get_cartridge_metadata;
 use crate::logging::debug_println;
 use crate::mmap::PAGE_SIZE;
 use crate::utils;
-use crate::utils::{rgb5_to_rgb8, NoHashMap};
+use crate::utils::{rgb5_to_rgb8, HeapMemU8, NoHashMap};
 use static_assertions::const_assert_eq;
-use std::cell::RefCell;
+use std::cell::UnsafeCell;
 use std::cmp::min;
 use std::fs::File;
 use std::io::{ErrorKind, Read, Seek};
 use std::ops::{Deref, DerefMut};
 use std::os::unix::fs::FileExt;
 use std::path::PathBuf;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use std::{io, mem};
@@ -85,7 +84,7 @@ pub struct CartridgeIo {
     pub file_name: String,
     pub file_size: u32,
     pub header: CartridgeHeader,
-    content_pages: RefCell<NoHashMap<u32, Rc<[u8; PAGE_SIZE]>>>,
+    content_pages: UnsafeCell<NoHashMap<u32, HeapMemU8<{ PAGE_SIZE * 4 }>>>,
     save_file_path: PathBuf,
     pub save_file_size: u32,
     save_buf: Mutex<(Vec<u8>, bool)>,
@@ -130,31 +129,31 @@ impl CartridgeIo {
             file_name: file_path.file_name().unwrap().to_str().unwrap().to_string(),
             file_size,
             header,
-            content_pages: RefCell::new(NoHashMap::default()),
+            content_pages: UnsafeCell::new(NoHashMap::default()),
             save_file_path,
             save_file_size,
             save_buf: Mutex::new((save_buf, false)),
         })
     }
 
-    fn get_page(&self, page_addr: u32) -> io::Result<Rc<[u8; PAGE_SIZE]>> {
-        debug_assert_eq!(page_addr & (PAGE_SIZE as u32 - 1), 0);
-        let mut pages = self.content_pages.borrow_mut();
+    fn get_page(&self, page_addr: u32) -> io::Result<*const [u8; PAGE_SIZE * 4]> {
+        debug_assert_eq!(page_addr & ((PAGE_SIZE * 4) as u32 - 1), 0);
+        let pages = unsafe { self.content_pages.get().as_mut_unchecked() };
         match pages.get(&page_addr) {
             None => {
-                // exceeds 4MB
-                if pages.len() >= 1024 {
+                // exceeds 8MB
+                if pages.len() >= 512 {
                     debug_println!("clear cartridge pages");
                     pages.clear();
                 }
 
-                let mut buf = [0u8; PAGE_SIZE];
-                self.file.read_at(&mut buf, page_addr as u64)?;
-                let buf = Rc::new(buf);
-                pages.insert(page_addr, buf.clone());
-                Ok(buf)
+                let mut buf = HeapMemU8::new();
+                let ptr = buf.as_ptr();
+                self.file.read_at(buf.as_mut(), page_addr as u64)?;
+                pages.insert(page_addr, buf);
+                Ok(ptr as _)
             }
-            Some(page) => Ok(page.clone()),
+            Some(page) => Ok(page.as_ptr() as _),
         }
     }
 
@@ -163,13 +162,14 @@ impl CartridgeIo {
         while remaining > 0 {
             let slice_start = slice.len() - remaining;
 
-            let page_addr = (offset + slice_start as u32) & !(PAGE_SIZE as u32 - 1);
+            let page_addr = (offset + slice_start as u32) & !((PAGE_SIZE * 4) as u32 - 1);
             let page_offset = offset + slice_start as u32 - page_addr;
             let page = match self.get_page(page_addr) {
                 Ok(page) => page,
                 Err(err) => return Err(err),
             };
-            let page_slice = &page.as_slice()[page_offset as usize..];
+            let page = unsafe { page.as_ref().unwrap_unchecked() };
+            let page_slice = &page[page_offset as usize..];
 
             let read_amount = min(remaining, page_slice.len());
             let slice_end = slice_start + read_amount;

src/core/memory/mem.rs

@@ -2,7 +2,7 @@ use crate::core::cp15::TcmState;
 use crate::core::emu::{get_cp15, Emu};
 use crate::core::memory::io_arm7::IoArm7;
 use crate::core::memory::io_arm9::IoArm9;
-use crate::core::memory::mmu::{MmuArm7, MmuArm9};
+use crate::core::memory::mmu::{MmuArm7, MmuArm9, MMU_PAGE_SHIFT};
 use crate::core::memory::oam::Oam;
 use crate::core::memory::palettes::Palettes;
 use crate::core::memory::regions;
@@ -15,7 +15,8 @@ use crate::jit::jit_memory::{JitMemory, JitRegion};
 use crate::logging::debug_println;
 use crate::mmap::Shm;
 use crate::utils::Convert;
-use std::intrinsics::unlikely;
+use std::hint::unreachable_unchecked;
+use std::intrinsics::{likely, unlikely};
 use std::sync::atomic::AtomicU16;
 use std::sync::Arc;
 use CpuType::ARM7;
@@ -71,47 +72,27 @@ impl Memory {
     pub fn read_with_options<const CPU: CpuType, const TCM: bool, T: Convert>(&mut self, addr: u32, emu: &mut Emu) -> T {
         debug_println!("{:?} memory read at {:x}", CPU, addr);
         let aligned_addr = addr & !(size_of::<T>() as u32 - 1);
+        let aligned_addr = aligned_addr & 0x0FFFFFFF;
 
-        let addr_base = aligned_addr & 0x0F000000;
-        let addr_offset = aligned_addr & !0xFF000000;
-
-        let vmem = {
+        let (vmem, mmu) = {
             let mmu = get_mem_mmu!(self, CPU);
             if CPU == ARM9 && TCM {
-                mmu.get_base_tcm_ptr()
+                (mmu.get_base_tcm_ptr(), mmu.get_mmu_read_tcm())
             } else {
-                mmu.get_base_ptr()
+                (mmu.get_base_ptr(), mmu.get_mmu_read())
             }
         };
 
-        if CPU == ARM9 && TCM {
-            let cp15 = get_cp15!(emu, ARM9);
-            if unlikely(aligned_addr >= cp15.dtcm_addr && aligned_addr < cp15.dtcm_addr + cp15.dtcm_size && cp15.dtcm_state == TcmState::RW) {
-                let ret = unsafe { (vmem.add(aligned_addr as usize) as *const T).read() };
-                debug_println!("{:?} dtcm read at {:x} with value {:x}", CPU, aligned_addr, ret.into());
-                return ret;
-            }
+        let mapped = unsafe { *mmu.get_unchecked((aligned_addr as usize) >> MMU_PAGE_SHIFT) };
+        if likely(mapped) {
+            return unsafe { (vmem.add(aligned_addr as usize) as *const T).read() };
         }
 
+        let addr_base = aligned_addr & 0x0F000000;
+        let addr_offset = aligned_addr & !0xFF000000;
+
         let ret = match addr_base {
-            regions::ITCM_OFFSET | regions::ITCM_OFFSET2 => match CPU {
-                ARM9 => {
-                    let mut ret = T::from(0);
-                    if TCM {
-                        let cp15 = get_cp15!(emu, ARM9);
-                        if aligned_addr < cp15.itcm_size && cp15.itcm_state == TcmState::RW {
-                            debug_println!("{:?} itcm read at {:x}", CPU, aligned_addr);
-                            ret = unsafe { (vmem.add(aligned_addr as usize) as *const T).read() }
-                        }
-                    }
-                    ret
-                }
-                // Bios of arm7 has same offset as itcm on arm9
-                ARM7 => unsafe { (vmem.add(aligned_addr as usize) as *const T).read() },
-            },
-            regions::MAIN_OFFSET | regions::SHARED_WRAM_OFFSET | regions::GBA_ROM_OFFSET | regions::GBA_ROM_OFFSET2 | 0x0F000000 => unsafe {
-                (vmem.add((aligned_addr & 0x0FFFFFFF) as usize) as *const T).read()
-            },
+            regions::ITCM_OFFSET | regions::ITCM_OFFSET2 => T::from(0),
             regions::IO_PORTS_OFFSET => match CPU {
                 ARM9 => self.io_arm9.read(addr_offset, emu),
                 ARM7 => {
@@ -130,8 +111,7 @@ impl Memory {
             regions::STANDARD_PALETTES_OFFSET => self.palettes.read(addr_offset),
             regions::VRAM_OFFSET => self.vram.read::<CPU, _>(addr_offset),
             regions::OAM_OFFSET => self.oam.read(addr_offset),
-            regions::GBA_RAM_OFFSET => T::from(0xFFFFFFFF),
-            _ => unreachable!(),
+            _ => unsafe { unreachable_unchecked() },
         };
 
         debug_println!("{:?} memory read at {:x} with value {:x}", CPU, addr, ret.into());
@@ -223,7 +203,7 @@ impl Memory {
             }
             regions::OAM_OFFSET => self.oam.write(addr_offset, value),
             regions::GBA_ROM_OFFSET => {}
-            _ => unreachable!(),
+            _ => unsafe { unreachable_unchecked() },
         };
     }
 }