refactor(memory): optimize module structure and implement internal BitMap

- Reorganize memory module into hierarchical frame, paging, and heap submodules
- Implement internal generic BitMap to remove external bitmap-allocator dependency
- Migrate TaskManager to use the new BitMap for TID allocation
- Add allocator sanity testing and update memory Kconfig settings

Author: moyanj

kernel/src/interrupts/handler.rs

@@ -81,7 +81,7 @@ pub extern "x86-interrupt" fn pagefault_handler(
     };
 
     {
-        let mut ms_lock = crate::memory::vmm::KERNEL_MEMORY_SET.lock();
+        let mut ms_lock = crate::memory::paging::vmm::KERNEL_MEMORY_SET.lock();
         if let Some(ms) = ms_lock.as_mut() {
             if ms.handle_page_fault(fault_address).is_ok() {
                 return;

kernel/src/lib.rs

@@ -29,7 +29,7 @@ pub mod config {
 }
 
 // Re-export common memory management types and functions
-pub use memory::frame_allocator::{format_bytes, FrameStats, LockedFrameAllocator};
+pub use memory::frame::{format_bytes, FrameStats, LockedFrameAllocator};
 pub use memory::paging::{
     get_hhdm_offset, get_memory_stats, init_frame_allocator, init_offset_page_table,
     print_memory_stats,

kernel/src/libs/bitmap.rs

@@ -0,0 +1,63 @@
+//! Generic Bitmap Allocator
+//!
+//! A simple bitset implementation for tracking allocation status of resources.
+
+/// A simple bitmap for tracking free/allocated slots.
+pub struct BitMap<const N: usize> {
+    bits: [u64; N],
+}
+
+impl<const N: usize> BitMap<N> {
+    /// Create a new bitmap with all bits set to 0 (all slots free).
+    pub const fn new() -> Self {
+        Self { bits: [0; N] }
+    }
+
+    /// Mark a bit as allocated (1).
+    pub fn set(&mut self, index: usize) {
+        let word = index / 64;
+        let bit = index % 64;
+        if word < N {
+            self.bits[word] |= 1 << bit;
+        }
+    }
+
+    /// Mark a bit as free (0).
+    pub fn clear(&mut self, index: usize) {
+        let word = index / 64;
+        let bit = index % 64;
+        if word < N {
+            self.bits[word] &= !(1 << bit);
+        }
+    }
+
+    /// Check if a bit is set (allocated).
+    pub fn test(&self, index: usize) -> bool {
+        let word = index / 64;
+        let bit = index % 64;
+        if word < N {
+            (self.bits[word] & (1 << bit)) != 0
+        } else {
+            true // Out of bounds is considered allocated
+        }
+    }
+
+    /// Find the first free slot (0 bit) and mark it as allocated (1).
+    pub fn alloc(&mut self) -> Option<usize> {
+        for i in 0..N {
+            if self.bits[i] != u64::MAX {
+                // Find first trailing one bit in the inverted word
+                // which is the first zero bit in the original word.
+                let bit = (!self.bits[i]).trailing_zeros() as usize;
+                self.bits[i] |= 1 << bit;
+                return Some(i * 64 + bit);
+            }
+        }
+        None
+    }
+
+    /// Get total capacity of the bitmap.
+    pub const fn capacity(&self) -> usize {
+        N * 64
+    }
+}

kernel/src/libs/mod.rs

@@ -1,3 +1,4 @@
+pub mod bitmap;
 pub mod bmp;
 pub mod initrd;
 pub mod logger;

kernel/src/memory/Kconfig.toml

@@ -1,11 +1,11 @@
 title = "Memory Manager"
 
 [[config]]
-name = "KERNEL_DEFAULT_HEAP_SIZE"
+name = "KERNEL_INIT_HEAP_SIZE"
 type = "int"
 default = 8388608
-desc = "The size of the heap memory (Unit: Bytes)."
-help = "Default heap size for the kernel."
+desc = "The size of the init heap memory (Unit: Bytes)."
+help = "Default init heap size for the kernel."
 rust_type = "u64"
 
 [[config]]
@@ -15,3 +15,11 @@ default = 4096
 desc = "The Page Size (Unit: Bytes)."
 help = "The size of per page."
 rust_type = "usize"
+
+[[config]]
+name = "OOM_EXPAND_SIZE"
+type = "int"
+default = 4096
+desc = "The size of expand when OOM (Unit: Bytes)."
+help = "The size of expand when OOM. Maximum expansion is 4MB."
+rust_type = "u64"