Rust 할당자 시스템

pub unsafe trait GlobalAlloc {
    // 필수 구현
    unsafe fn alloc(&self, layout: Layout) -> *mut u8;
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);

    // 기본 구현 있음 (오버라이드 가능)
    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
        // 기본: alloc 후 memset(0)
        let ptr = self.alloc(layout);
        if !ptr.is_null() {
            ptr::write_bytes(ptr, 0, layout.size());
        }
        ptr
    }

    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
        // 기본: 새로 alloc → memcpy → dealloc (비효율적)
        // 실제 할당자는 이걸 직접 구현해서 제자리 확장을 시도함
        let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
        let new_ptr = self.alloc(new_layout);
        if !new_ptr.is_null() {
            ptr::copy_nonoverlapping(ptr, new_ptr, layout.size().min(new_size));
            self.dealloc(ptr, layout);
        }
        new_ptr
    }
}

# Cargo.toml
[dependencies]
tikv-jemallocator = "0.6"

// main.rs 맨 위에 한 줄
#[global_allocator]
static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;

// 이후 모든 Box, Vec, String, HashMap...이 jemalloc을 씀
// 코드는 한 줄도 안 바꿔도 됨
fn main() {
    let v: Vec = vec![1, 2, 3];  // 이미 jemalloc 사용
}

pub struct BumpAllocator {
    start: *mut u8,
    end:   *mut u8,
    bump:  Cell<*mut u8>,  // Cell: 내부 가변성 (할당자는 &self로 호출됨)
}

impl BumpAllocator {
    pub fn new(size: usize) -> Self {
        // 내부적으로 큰 블록 하나를 미리 할당
        let layout = Layout::from_size_align(size, 16).unwrap();
        let start  = unsafe { alloc(layout) };
        let end    = unsafe { start.add(size) };
        Self { start, end, bump: Cell::new(start) }
    }

    pub fn alloc_t<T>(&self) -> *mut T {
        let bump   = self.bump.get();
        // 정렬 맞추기
        let align  = mem::align_of::<T>();
        let offset = bump.align_offset(align);
        let ptr    = unsafe { bump.add(offset) };
        let next   = unsafe { ptr.add(mem::size_of::<T>()) };

        if next > self.end {
            panic!("BumpAllocator: OOM");
        }
        self.bump.set(next);
        ptr as *mut T
    }

    // 전부 한 번에 해제 — O(1)
    pub fn reset(&self) {
        self.bump.set(self.start);
    }
}

#![feature(allocator_api)]
use std::alloc::Allocator;

// Vec에 bump allocator 붙이기
let arena = BumpAllocator::new(1024 * 1024);  // 1MB

let mut names: Vec<&str, &BumpAllocator> = Vec::new_in(&arena);
let mut scores: Vec<u32, &BumpAllocator>  = Vec::new_in(&arena);

names.push("alice");
scores.push(100);

// HTTP 요청 끝 → arena 하나만 drop → 안의 Vec 전부 O(1) 해제
// free()를 수백 번 호출하는 대신 블록 하나 반환
drop(arena);

// bumpalo — stable Rust에서 arena 쓰기
use bumpalo::Bump;

let arena = Bump::new();

// 아래 세 할당은 전부 같은 연속 블록에서 나옴
let x: &mut i32   = arena.alloc(42);
let s: &mut str    = arena.alloc_str("hello");
let v: &mut [u8]  = arena.alloc_slice_fill_copy(16, 0);

// arena drop → x, s, v 전부 한 번에 해제
// 각각 drop() 호출 없음

use std::alloc::{GlobalAlloc, Layout};
use std::sync::atomic::{AtomicUsize, Ordering};

// 간단한 통계 할당자 — malloc에 감싸서 카운트만 추적
struct TrackingAllocator {
    allocated: AtomicUsize,
    freed:     AtomicUsize,
}

unsafe impl GlobalAlloc for TrackingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        self.allocated.fetch_add(layout.size(), Ordering::Relaxed);
        std::alloc::System.alloc(layout)  // 실제 할당은 System에 위임
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        self.freed.fetch_add(layout.size(), Ordering::Relaxed);
        std::alloc::System.dealloc(ptr, layout)
    }
}

#[global_allocator]
static ALLOC: TrackingAllocator = TrackingAllocator {
    allocated: AtomicUsize::new(0),
    freed:     AtomicUsize::new(0),
};

fn memory_stats() {
    let a = ALLOC.allocated.load(Ordering::Relaxed);
    let f = ALLOC.freed.load(Ordering::Relaxed);
    println!("할당: {} bytes, 해제: {} bytes, 현재 사용: {} bytes", a, f, a - f);
}