Rust 記憶體配置器實戰:從基礎到進階的完整技術指南

use std::alloc::Layout;

fn demonstrate_layout_usage() {
    let layout_i64 = Layout::new::<i64>();
    println!("i64 配置大小: {} 位元組, 對齊需求: {} 位元組", 
        layout_i64.size(), layout_i64.align());
    
    let layout_array = Layout::array::<u32>(100)
        .expect("配置大小計算溢位");
    println!("100 個 u32 配置大小: {} 位元組, 對齊需求: {} 位元組",
        layout_array.size(), layout_array.align());
    
    let custom_layout = Layout::from_size_align(256, 32)
        .expect("無效的對齊值");
    println!("自訂配置大小: {} 位元組, 對齊需求: {} 位元組",
        custom_layout.size(), custom_layout.align());
}

#![feature(allocator_api)]

use std::alloc::{AllocError, Allocator, Global, Layout};
use std::ptr::NonNull;

pub struct PassThroughAllocator;

unsafe impl Allocator for PassThroughAllocator {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        Global.allocate(layout)
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        Global.deallocate(ptr, layout)
    }
}

fn test_basic_allocator() {
    let mut vec: Vec<i32, _> = Vec::with_capacity_in(10, PassThroughAllocator);
    
    for i in 0..10 {
        vec.push(i * 2);
    }
    
    println!("使用自訂配置器的向量: {:?}", vec);
    println!("向量容量: {}", vec.capacity());
    println!("向量長度: {}", vec.len());
}

#![feature(allocator_api)]

use std::alloc::{AllocError, Allocator, Layout};
use std::ptr::NonNull;

pub struct MallocAllocator;

unsafe impl Allocator for MallocAllocator {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        unsafe {
            let ptr = libc::malloc(layout.size());
            
            if ptr.is_null() {
                return Err(AllocError);
            }
            
            let slice = std::slice::from_raw_parts_mut(
                ptr as *mut u8,
                layout.size()
            );
            
            Ok(NonNull::new_unchecked(slice))
        }
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, _layout: Layout) {
        libc::free(ptr.as_ptr() as *mut libc::c_void);
    }
    
    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        unsafe {
            let ptr = libc::calloc(1, layout.size());
            
            if ptr.is_null() {
                return Err(AllocError);
            }
            
            let slice = std::slice::from_raw_parts_mut(
                ptr as *mut u8,
                layout.size()
            );
            
            Ok(NonNull::new_unchecked(slice))
        }
    }
}

fn test_malloc_allocator() {
    let mut vec: Vec<String, _> = Vec::with_capacity_in(5, MallocAllocator);
    
    vec.push("台北".to_string());
    vec.push("台中".to_string());
    vec.push("台南".to_string());
    vec.push("高雄".to_string());
    
    println!("城市清單: {:?}", vec);
}

use std::alloc::{AllocError, Allocator, Layout};
use std::ptr::NonNull;

pub struct GuardedAllocator {
    page_size: usize,
}

impl GuardedAllocator {
    pub fn new() -> Self {
        let page_size = unsafe { 
            libc::sysconf(libc::_SC_PAGESIZE) as usize 
        };
        Self { page_size }
    }
    
    fn round_to_page(&self, size: usize) -> usize {
        (size + self.page_size - 1) & !(self.page_size - 1)
    }
}

unsafe impl Allocator for GuardedAllocator {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        let rounded_size = self.round_to_page(layout.size());
        let total_size = rounded_size + 2 * self.page_size;
        
        let mut ptr = std::ptr::null_mut();
        let ret = unsafe {
            libc::posix_memalign(
                &mut ptr,
                self.page_size,
                total_size
            )
        };
        
        if ret != 0 {
            return Err(AllocError);
        }
        
        unsafe {
            libc::mprotect(
                ptr,
                self.page_size,
                libc::PROT_NONE
            );
            
            let back_guard = ptr.add(self.page_size + rounded_size);
            libc::mprotect(
                back_guard as *mut _,
                self.page_size,
                libc::PROT_NONE
            );
            
            let data_ptr = ptr.add(self.page_size);
            libc::mprotect(
                data_ptr,
                rounded_size,
                libc::PROT_READ | libc::PROT_WRITE
            );
            
            let slice = std::slice::from_raw_parts_mut(
                data_ptr as *mut u8,
                layout.size()
            );
            
            Ok(NonNull::new_unchecked(slice))
        }
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        let original_ptr = ptr.as_ptr().sub(self.page_size);
        let rounded_size = self.round_to_page(layout.size());
        
        libc::mprotect(
            original_ptr as *mut _,
            self.page_size,
            libc::PROT_READ | libc::PROT_WRITE
        );
        
        let back_guard = original_ptr.add(self.page_size + rounded_size);
        libc::mprotect(
            back_guard as *mut _,
            self.page_size,
            libc::PROT_READ | libc::PROT_WRITE
        );
        
        libc::free(original_ptr as *mut libc::c_void);
    }
}

fn test_guarded_allocator() {
    let allocator = GuardedAllocator::new();
    let mut vec: Vec<u8, _> = Vec::with_capacity_in(1024, allocator);
    
    for i in 0..1024 {
        vec.push((i % 256) as u8);
    }
    
    println!("使用保護配置器的向量已建立");
    println!("向量大小: {} 位元組", vec.len());
}

pub struct PlatformAllocator {
    page_size: usize,
}

impl PlatformAllocator {
    pub fn new() -> Self {
        #[cfg(unix)]
        let page_size = unsafe {
            libc::sysconf(libc::_SC_PAGESIZE) as usize
        };
        
        #[cfg(windows)]
        let page_size = unsafe {
            let mut info: winapi::um::sysinfoapi::SYSTEM_INFO = 
                std::mem::zeroed();
            winapi::um::sysinfoapi::GetSystemInfo(&mut info);
            info.dwPageSize as usize
        };
        
        #[cfg(not(any(unix, windows)))]
        let page_size = 4096;
        
        Self { page_size }
    }
}

#[cfg(unix)]
unsafe fn allocate_aligned_memory(size: usize, align: usize) -> *mut u8 {
    let mut ptr = std::ptr::null_mut();
    let ret = libc::posix_memalign(
        &mut ptr,
        align,
        size
    );
    
    if ret == 0 {
        ptr as *mut u8
    } else {
        std::ptr::null_mut()
    }
}

#[cfg(windows)]
unsafe fn allocate_aligned_memory(size: usize, _align: usize) -> *mut u8 {
    use winapi::um::memoryapi::VirtualAlloc;
    use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_READWRITE};
    
    VirtualAlloc(
        std::ptr::null_mut(),
        size,
        MEM_COMMIT | MEM_RESERVE,
        PAGE_READWRITE
    ) as *mut u8
}

#[cfg(unix)]
unsafe fn protect_memory(ptr: *mut u8, size: usize, readable: bool, writable: bool) {
    let mut prot = 0;
    if readable { prot |= libc::PROT_READ; }
    if writable { prot |= libc::PROT_WRITE; }
    
    libc::mprotect(ptr as *mut libc::c_void, size, prot);
}

#[cfg(windows)]
unsafe fn protect_memory(ptr: *mut u8, size: usize, readable: bool, writable: bool) {
    use winapi::um::winnt::{PAGE_NOACCESS, PAGE_READONLY, PAGE_READWRITE};
    use winapi::um::memoryapi::VirtualProtect;
    
    let protect = if !readable && !writable {
        PAGE_NOACCESS
    } else if readable && !writable {
        PAGE_READONLY
    } else {
        PAGE_READWRITE
    };
    
    let mut old_protect = 0;
    VirtualProtect(
        ptr as *mut _,
        size,
        protect,
        &mut old_protect
    );
}

#[cfg(unix)]
unsafe fn lock_memory(ptr: *mut u8, size: usize) -> Result<(), String> {
    if libc::mlock(ptr as *const libc::c_void, size) == 0 {
        Ok(())
    } else {
        Err("記憶體鎖定失敗".to_string())
    }
}

#[cfg(windows)]
unsafe fn lock_memory(ptr: *mut u8, size: usize) -> Result<(), String> {
    use winapi::um::memoryapi::VirtualLock;
    
    if VirtualLock(ptr as *mut _, size) != 0 {
        Ok(())
    } else {
        Err("記憶體鎖定失敗".to_string())
    }
}

#[cfg_attr(target_os = "linux", inline(always))]
#[cfg_attr(target_os = "windows", inline)]
fn platform_specific_optimization() {
    // 函式實作
}

fn select_allocation_strategy() -> &'static str {
    if cfg!(target_os = "linux") && cfg!(target_arch = "x86_64") {
        "使用 jemalloc 最佳化"
    } else if cfg!(target_os = "windows") {
        "使用 Windows 堆積管理器"
    } else {
        "使用標準配置器"
    }
}

struct TreeNode {
    value: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

impl TreeNode {
    fn new(value: i32) -> Self {
        TreeNode {
            value,
            left: None,
            right: None,
        }
    }
    
    fn insert(&mut self, value: i32) {
        if value < self.value {
            match self.left {
                Some(ref mut node) => node.insert(value),
                None => self.left = Some(Box::new(TreeNode::new(value))),
            }
        } else {
            match self.right {
                Some(ref mut node) => node.insert(value),
                None => self.right = Some(Box::new(TreeNode::new(value))),
            }
        }
    }
}

fn create_binary_search_tree() {
    let mut root = TreeNode::new(50);
    root.insert(30);
    root.insert(70);
    root.insert(20);
    root.insert(40);
    root.insert(60);
    root.insert(80);
}

use std::rc::Rc;

struct GraphNode {
    value: String,
    neighbors: Vec<Rc<GraphNode>>,
}

impl GraphNode {
    fn new(value: String) -> Rc<Self> {
        Rc::new(GraphNode {
            value,
            neighbors: Vec::new(),
        })
    }
}

fn build_graph() {
    let node_a = GraphNode::new("節點 A".to_string());
    let node_b = GraphNode::new("節點 B".to_string());
    let node_c = GraphNode::new("節點 C".to_string());
    
    println!("節點 A 參照計數: {}", Rc::strong_count(&node_a));
    println!("節點 B 參照計數: {}", Rc::strong_count(&node_b));
}

use std::cell::RefCell;
use std::rc::Rc;

struct SharedCache {
    data: Rc<RefCell<Vec<String>>>,
}

impl SharedCache {
    fn new() -> Self {
        SharedCache {
            data: Rc::new(RefCell::new(Vec::new())),
        }
    }
    
    fn add_entry(&self, entry: String) {
        self.data.borrow_mut().push(entry);
    }
    
    fn get_entries(&self) -> Vec<String> {
        self.data.borrow().clone()
    }
    
    fn clone_cache(&self) -> Self {
        SharedCache {
            data: Rc::clone(&self.data),
        }
    }
}

fn demonstrate_shared_cache() {
    let cache1 = SharedCache::new();
    let cache2 = cache1.clone_cache();
    
    cache1.add_entry("項目 1".to_string());
    cache2.add_entry("項目 2".to_string());
    
    println!("快取內容: {:?}", cache1.get_entries());
}

use std::sync::{Arc, Mutex};
use std::thread;

fn multi_threaded_accumulator() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for i in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                let mut num = counter_clone.lock().unwrap();
                *num += 1;
            }
            println!("執行緒 {} 完成累加", i);
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最終累加結果: {}", *counter.lock().unwrap());
}

fn safe_config_parsing(path: &str) -> Result<Config, ConfigError> {
    let content = std::fs::read_to_string(path)
        .map_err(|e| ConfigError::IoError(e))?;
    
    if content.is_empty() {
        return Err(ConfigError::EmptyContent);
    }
    
    let config = parse_content(&content)
        .map_err(|e| ConfigError::ParseError(e))?;
    
    validate_config(&config)?;
    
    Ok(config)
}

fn load_config_with_fallback(path: &str) -> Config {
    match safe_config_parsing(path) {
        Ok(config) => config,
        Err(e) => {
            eprintln!("載入設定檔失敗: {:?}, 使用預設設定", e);
            Config::default()
        }
    }
}

pub struct SafeBuffer {
    ptr: *mut u8,
    len: usize,
    capacity: usize,
}

impl SafeBuffer {
    pub fn new(capacity: usize) -> Result<Self, String> {
        if capacity == 0 {
            return Err("容量不能為零".to_string());
        }
        
        let ptr = unsafe {
            libc::malloc(capacity) as *mut u8
        };
        
        if ptr.is_null() {
            return Err("記憶體配置失敗".to_string());
        }
        
        Ok(Self { ptr, len: 0, capacity })
    }
    
    pub fn push(&mut self, byte: u8) -> Result<(), String> {
        if self.len >= self.capacity {
            return Err("緩衝區已滿".to_string());
        }
        
        unsafe {
            *self.ptr.add(self.len) = byte;
        }
        self.len += 1;
        Ok(())
    }
    
    pub fn as_slice(&self) -> &[u8] {
        unsafe {
            std::slice::from_raw_parts(self.ptr, self.len)
        }
    }
    
    pub fn clear(&mut self) {
        self.len = 0;
    }
    
    pub fn capacity(&self) -> usize {
        self.capacity
    }
    
    pub fn len(&self) -> usize {
        self.len
    }
    
    pub fn is_empty(&self) -> bool {
        self.len == 0
    }
}

impl Drop for SafeBuffer {
    fn drop(&mut self) {
        unsafe {
            libc::free(self.ptr as *mut libc::c_void);
        }
    }
}

unsafe impl Send for SafeBuffer {}
unsafe impl Sync for SafeBuffer {}

#[derive(Debug)]
enum AllocatorError {
    OutOfMemory,
    InvalidSize,
    InvalidAlignment,
    AllocationFailed(String),
}

impl std::fmt::Display for AllocatorError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            AllocatorError::OutOfMemory => write!(f, "記憶體不足"),
            AllocatorError::InvalidSize => write!(f, "無效的大小參數"),
            AllocatorError::InvalidAlignment => write!(f, "無效的對齊參數"),
            AllocatorError::AllocationFailed(msg) => write!(f, "配置失敗: {}", msg),
        }
    }
}

impl std::error::Error for AllocatorError {}

fn allocate_with_validation(
    size: usize,
    align: usize
) -> Result<*mut u8, AllocatorError> {
    if size == 0 {
        return Err(AllocatorError::InvalidSize);
    }
    
    if !align.is_power_of_two() {
        return Err(AllocatorError::InvalidAlignment);
    }
    
    let ptr = unsafe {
        let mut ptr = std::ptr::null_mut();
        let ret = libc::posix_memalign(
            &mut ptr,
            align,
            size
        );
        
        if ret == libc::ENOMEM {
            return Err(AllocatorError::OutOfMemory);
        } else if ret != 0 {
            return Err(AllocatorError::AllocationFailed(
                format!("posix_memalign 回傳錯誤碼 {}", ret)
            ));
        }
        
        ptr as *mut u8
    };
    
    Ok(ptr)
}