feat(memory): 优化内存分配器性能并改进TLB刷新策略

Author: moyanj

kernel/src/memory/frame/buddy.rs

@@ -69,9 +69,9 @@ impl<const MAX_ORDER: usize> BuddyAllocator<MAX_ORDER> {
     /// Set the bitmap for the allocator.
     pub fn set_bitmap(&mut self, bitmap: &'static mut [u64]) {
         self.bitmap = bitmap;
-        // Clear bitmap
-        for x in self.bitmap.iter_mut() {
-            *x = 0;
+        // Faster clear using write_bytes
+        unsafe {
+            core::ptr::write_bytes(self.bitmap.as_mut_ptr(), 0, self.bitmap.len());
         }
     }
 
@@ -245,8 +245,31 @@ impl<const MAX_ORDER: usize> BuddyAllocator<MAX_ORDER> {
     pub unsafe fn add_region(&mut self, start: PhysFrame<Size4KiB>, end: PhysFrame<Size4KiB>) {
         let mut current = start;
         while current < end {
-            self.add_frame(current);
-            current += 1;
+            let current_addr = current.start_address().as_u64();
+            let end_addr = end.start_address().as_u64();
+            let remaining_frames = (end_addr - current_addr) / 4096;
+
+            // Find the largest power-of-two block that fits and is aligned
+            let mut order = 0;
+            while order < MAX_ORDER - 1 {
+                let next_order = order + 1;
+                let size_frames = 1 << next_order;
+                let size_bytes = 4096 * size_frames;
+
+                // Check alignment
+                if !current_addr.is_multiple_of(size_bytes) {
+                    break;
+                }
+                // Check size
+                if size_frames > remaining_frames {
+                    break;
+                }
+                order = next_order;
+            }
+
+            self.total_frames += 1 << order;
+            self.merge_block(current, order);
+            current += 1 << order;
         }
     }
 

kernel/src/memory/heap.rs

@@ -54,10 +54,13 @@ impl talc::OomHandler for KernelOomHandler {
                     .page_table
                     .map_to(page, frame, flags, &mut frame_allocator)
                     .map_err(|_| ())?
-                    .flush();
+                    .ignore();
             }
         }
 
+        // Flush TLB once after expanding heap
+        x86_64::instructions::tlb::flush_all();
+
         drop(ms_lock);
 
         unsafe {
@@ -103,10 +106,13 @@ pub fn init_heap(
             .ok_or(MapToError::FrameAllocationFailed)?;
         let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::NO_EXECUTE;
         unsafe {
-            mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+            mapper.map_to(page, frame, flags, frame_allocator)?.ignore();
         }
     }
 
+    // Flush TLB once after initial heap mapping
+    x86_64::instructions::tlb::flush_all();
+
     unsafe {
         ALLOCATOR
             .lock()

kernel/src/memory/paging/vmm.rs

@@ -222,12 +222,15 @@ impl MemorySet {
                     .page_table
                     .map_to(page, phys_frame, flags, &mut frame_allocator)
                 {
-                    Ok(t) => t.flush(),
+                    Ok(t) => t.ignore(),
                     Err(MapToError::PageAlreadyMapped(_)) => continue,
                     Err(_) => return Err("Failed to map page"),
                 }
             }
         }
+
+        // Flush TLB once after all mappings are done
+        x86_64::instructions::tlb::flush_all();
         Ok(())
     }
 }