rusty_common/memory/

zerocopy_pools.rs

//! Zero-copy memory pools for high-frequency allocations
//!
//! This module provides memory pool implementations that eliminate allocations
//! in critical paths and optimize for sub-microsecond latency in trading systems.

use parking_lot::{Mutex, RwLock};
use quanta::Instant as QuantaInstant;
use simd_aligned::VecSimd;
use std::alloc::{Layout, alloc, dealloc};
use std::ptr::NonNull;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use wide::f64x4;

/// Configuration for zerocopy memory pools
#[derive(Debug, Clone)]
pub struct ZerocopyPoolConfig {
    /// Initial number of buffers to pre-allocate
    pub initial_buffer_count: usize,
    /// Maximum number of buffers the pool can grow to
    pub max_buffer_count: usize,
    /// Size of each buffer in bytes
    pub buffer_size: usize,
    /// Whether buffers should be SIMD-aligned (32-byte alignment)
    pub simd_aligned: bool,
    /// Whether to track detailed statistics
    pub enable_statistics: bool,
}

impl Default for ZerocopyPoolConfig {
    fn default() -> Self {
        Self {
            initial_buffer_count: 64,
            max_buffer_count: 512,
            buffer_size: 64 * 1024, // 64KB
            simd_aligned: true,
            enable_statistics: true,
        }
    }
}

/// Statistics for memory pool usage
#[derive(Debug, Clone, Default)]
pub struct PoolStatistics {
    /// Total number of allocations made from this pool
    pub total_allocations: u64,
    /// Total number of deallocations returned to this pool
    pub total_deallocations: u64,
    /// Current number of buffers allocated and in use
    pub current_allocated: u64,
    /// Peak number of buffers allocated at any point
    pub peak_allocated: u64,
    /// Total bytes allocated throughout the pool's lifetime
    pub total_bytes_allocated: u64,
    /// Number of times a buffer was successfully retrieved from the pool
    pub pool_hits: u64,
    /// Number of times pool was empty and required allocation or growth
    pub pool_misses: u64,
    /// Number of times the pool was grown to accommodate more buffers
    pub grow_operations: u64,
    /// Average allocation time in nanoseconds (exponential moving average)
    pub avg_allocation_time_nanos: u64,
}

/// Raw buffer handle for zero-copy operations
pub struct BufferHandle {
    ptr: NonNull<u8>,
    size: usize,
    pool: Arc<ZerocopyMemoryPool>,
    buffer_id: usize,
    allocation_time: QuantaInstant,
}

impl BufferHandle {
    /// Get buffer as mutable slice
    pub const fn as_slice_mut(&mut self) -> &mut [u8] {
        // SAFETY: This is safe because:
        // 1. self.ptr is guaranteed to be non-null and valid (allocated by pool)
        // 2. self.size reflects the actual allocated size from the pool
        // 3. The buffer is owned exclusively by this handle
        // 4. The memory is properly aligned for u8 access
        // 5. The BufferHandle ensures exclusive access during its lifetime
        unsafe { std::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.size) }
    }

    /// Get buffer as immutable slice
    pub const fn as_slice(&self) -> &[u8] {
        // SAFETY: This is safe because:
        // 1. self.ptr is guaranteed to be non-null and valid (allocated by pool)
        // 2. self.size reflects the actual allocated size from the pool
        // 3. The buffer data is initialized (zero-filled on allocation)
        // 4. The memory is properly aligned for u8 access
        // 5. The shared reference ensures no concurrent mutation
        unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), self.size) }
    }

    /// Get raw pointer to buffer
    pub const fn as_ptr(&self) -> *const u8 {
        self.ptr.as_ptr()
    }

    /// Get mutable raw pointer to buffer
    pub const fn as_mut_ptr(&mut self) -> *mut u8 {
        self.ptr.as_ptr()
    }

    /// Get buffer size
    pub const fn size(&self) -> usize {
        self.size
    }

    /// Clear buffer contents (set to zero)
    pub const fn clear(&mut self) {
        unsafe {
            std::ptr::write_bytes(self.ptr.as_ptr(), 0, self.size);
        }
    }
}

impl Drop for BufferHandle {
    fn drop(&mut self) {
        let elapsed_nanos = self.allocation_time.elapsed().as_nanos() as u64;
        self.pool.return_buffer(self.buffer_id, elapsed_nanos);
    }
}

unsafe impl Send for BufferHandle {}
unsafe impl Sync for BufferHandle {}

/// SIMD-aligned buffer handle for vectorized operations
pub struct SimdBufferHandle {
    simd_data: VecSimd<f64x4>,
    pool: Arc<SimdMemoryPool>,
    buffer_id: usize,
    allocation_time: QuantaInstant,
}

impl SimdBufferHandle {
    /// Get SIMD data as mutable reference
    pub const fn as_simd_mut(&mut self) -> &mut VecSimd<f64x4> {
        &mut self.simd_data
    }

    /// Get SIMD data as immutable reference
    pub const fn as_simd(&self) -> &VecSimd<f64x4> {
        &self.simd_data
    }

    /// Get flat slice for scalar operations
    pub fn as_flat_slice_mut(&mut self) -> &mut [f64] {
        self.simd_data.flat_mut()
    }

    /// Get flat slice for scalar operations (immutable)
    pub fn as_flat_slice(&self) -> &[f64] {
        self.simd_data.flat()
    }

    /// Clear SIMD buffer (set all values to zero)
    pub fn clear(&mut self) {
        for i in 0..self.simd_data.len() {
            self.simd_data[i] = f64x4::splat(0.0);
        }
    }
}

impl Drop for SimdBufferHandle {
    fn drop(&mut self) {
        let elapsed_nanos = self.allocation_time.elapsed().as_nanos() as u64;
        self.pool.return_simd_buffer(self.buffer_id, elapsed_nanos);
    }
}

/// Typed buffer handle for specific data structures
pub struct TypedBufferHandle<T: Default> {
    data: Box<T>,
    pool: Arc<TypedMemoryPool<T>>,
    buffer_id: usize,
    allocation_time: QuantaInstant,
}

impl<T: Default> TypedBufferHandle<T> {
    /// Get mutable reference to typed data
    pub fn data_mut(&mut self) -> &mut T {
        &mut self.data
    }

    /// Get immutable reference to typed data
    pub fn data(&self) -> &T {
        &self.data
    }
}

/// Implement standard AsRef trait for TypedBufferHandle
impl<T: Default> AsRef<T> for TypedBufferHandle<T> {
    fn as_ref(&self) -> &T {
        &self.data
    }
}

/// Implement standard AsMut trait for TypedBufferHandle
impl<T: Default> AsMut<T> for TypedBufferHandle<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.data
    }
}

impl<T: Default> Drop for TypedBufferHandle<T> {
    fn drop(&mut self) {
        let elapsed_nanos = self.allocation_time.elapsed().as_nanos() as u64;
        self.pool.return_typed_buffer(self.buffer_id, elapsed_nanos);
    }
}

/// Main zero-copy memory pool implementation
pub struct ZerocopyMemoryPool {
    config: ZerocopyPoolConfig,
    buffers: RwLock<Vec<Option<NonNull<u8>>>>,
    available_buffers: Mutex<Vec<usize>>,
    statistics: RwLock<PoolStatistics>,
    total_allocations: AtomicU64,
    current_allocated: AtomicUsize,
    peak_allocated: AtomicUsize,
}

impl ZerocopyMemoryPool {
    /// Create a new zero-copy memory pool
    pub fn new(config: ZerocopyPoolConfig) -> Arc<Self> {
        let pool = Arc::new(Self {
            config: config.clone(),
            buffers: RwLock::new(Vec::with_capacity(config.max_buffer_count)),
            available_buffers: Mutex::new(Vec::with_capacity(config.initial_buffer_count)),
            statistics: RwLock::new(PoolStatistics::default()),
            total_allocations: AtomicU64::new(0),
            current_allocated: AtomicUsize::new(0),
            peak_allocated: AtomicUsize::new(0),
        });

        // Pre-allocate initial buffers
        pool.clone().preallocate_buffers();
        pool
    }

    /// Pre-allocate initial buffers
    fn preallocate_buffers(self: Arc<Self>) {
        let layout = if self.config.simd_aligned {
            Layout::from_size_align(self.config.buffer_size, 32).unwrap()
        } else {
            Layout::from_size_align(self.config.buffer_size, 8).unwrap()
        };

        let mut buffers = self.buffers.write();
        let mut available = self.available_buffers.lock();

        for i in 0..self.config.initial_buffer_count {
            unsafe {
                let ptr = alloc(layout);
                if !ptr.is_null() {
                    let non_null_ptr = NonNull::new_unchecked(ptr);
                    buffers.push(Some(non_null_ptr));
                    available.push(i);
                } else {
                    // Allocation failed, reduce initial count
                    break;
                }
            }
        }
    }

    /// Allocate a buffer from the pool
    pub fn allocate_buffer(self: &Arc<Self>) -> Option<BufferHandle> {
        let start_time = QuantaInstant::now();
        self.total_allocations.fetch_add(1, Ordering::Relaxed);

        // Try to get a buffer from the pool
        let buffer_id = {
            let mut available = self.available_buffers.lock();
            available.pop()
        };

        if let Some(id) = buffer_id {
            // Pool hit
            if self.config.enable_statistics {
                let mut stats = self.statistics.write();
                stats.pool_hits += 1;
            }

            let buffers = self.buffers.read();
            if let Some(Some(ptr)) = buffers.get(id) {
                let current = self.current_allocated.fetch_add(1, Ordering::Relaxed) + 1;
                let peak = self.peak_allocated.load(Ordering::Relaxed);
                if current > peak {
                    self.peak_allocated.store(current, Ordering::Relaxed);
                }

                return Some(BufferHandle {
                    ptr: *ptr,
                    size: self.config.buffer_size,
                    pool: self.clone(),
                    buffer_id: id,
                    allocation_time: start_time,
                });
            }
        }

        // Pool miss - try to grow the pool
        if self.config.enable_statistics {
            let mut stats = self.statistics.write();
            stats.pool_misses += 1;
        }

        self.try_grow_pool().map(|id| {
            let buffers = self.buffers.read();
            let ptr = buffers[id].unwrap();

            let current = self.current_allocated.fetch_add(1, Ordering::Relaxed) + 1;
            let peak = self.peak_allocated.load(Ordering::Relaxed);
            if current > peak {
                self.peak_allocated.store(current, Ordering::Relaxed);
            }

            BufferHandle {
                ptr,
                size: self.config.buffer_size,
                pool: self.clone(),
                buffer_id: id,
                allocation_time: start_time,
            }
        })
    }

    /// Try to grow the pool by allocating a new buffer
    fn try_grow_pool(&self) -> Option<usize> {
        let layout = if self.config.simd_aligned {
            Layout::from_size_align(self.config.buffer_size, 32).unwrap()
        } else {
            Layout::from_size_align(self.config.buffer_size, 8).unwrap()
        };

        let mut buffers = self.buffers.write();
        if buffers.len() >= self.config.max_buffer_count {
            return None; // Pool at maximum capacity
        }

        unsafe {
            let ptr = alloc(layout);
            if !ptr.is_null() {
                let non_null_ptr = NonNull::new_unchecked(ptr);
                let id = buffers.len();
                buffers.push(Some(non_null_ptr));

                if self.config.enable_statistics {
                    let mut stats = self.statistics.write();
                    stats.grow_operations += 1;
                }

                Some(id)
            } else {
                None
            }
        }
    }

    /// Return a buffer to the pool
    fn return_buffer(&self, buffer_id: usize, allocation_time_nanos: u64) {
        let mut available = self.available_buffers.lock();
        available.push(buffer_id);

        self.current_allocated.fetch_sub(1, Ordering::Relaxed);

        if self.config.enable_statistics {
            let mut stats = self.statistics.write();
            stats.total_deallocations += 1;
            stats.avg_allocation_time_nanos =
                (stats.avg_allocation_time_nanos * 9 + allocation_time_nanos) / 10;
        }
    }

    /// Get current pool statistics
    pub fn get_statistics(&self) -> PoolStatistics {
        if !self.config.enable_statistics {
            return PoolStatistics::default();
        }

        let mut stats = self.statistics.read().clone();
        stats.total_allocations = self.total_allocations.load(Ordering::Relaxed);
        stats.current_allocated = self.current_allocated.load(Ordering::Relaxed) as u64;
        stats.peak_allocated = self.peak_allocated.load(Ordering::Relaxed) as u64;
        stats.total_bytes_allocated = stats.total_allocations * self.config.buffer_size as u64;
        stats
    }

    /// Get number of available buffers
    pub fn available_count(&self) -> usize {
        self.available_buffers.lock().len()
    }

    /// Get total buffer count
    pub fn buffer_count(&self) -> usize {
        self.buffers.read().len()
    }

    /// Get buffer size
    pub const fn buffer_size(&self) -> usize {
        self.config.buffer_size
    }

    /// Get total memory managed by pool
    pub fn total_memory_bytes(&self) -> usize {
        self.buffer_count() * self.buffer_size()
    }
}

impl Drop for ZerocopyMemoryPool {
    fn drop(&mut self) {
        let layout = if self.config.simd_aligned {
            Layout::from_size_align(self.config.buffer_size, 32).unwrap()
        } else {
            Layout::from_size_align(self.config.buffer_size, 8).unwrap()
        };

        let buffers = self.buffers.write();
        for ptr in buffers.iter().flatten() {
            unsafe {
                dealloc(ptr.as_ptr(), layout);
            }
        }
    }
}

unsafe impl Send for ZerocopyMemoryPool {}
unsafe impl Sync for ZerocopyMemoryPool {}

/// SIMD-aligned memory pool for vectorized operations
pub struct SimdMemoryPool {
    config: ZerocopyPoolConfig,
    simd_buffers: RwLock<Vec<Option<VecSimd<f64x4>>>>,
    available_buffers: Mutex<Vec<usize>>,
    statistics: RwLock<PoolStatistics>,
    total_allocations: AtomicU64,
    current_allocated: AtomicUsize,
    peak_allocated: AtomicUsize,
}

impl SimdMemoryPool {
    /// Create a new SIMD memory pool
    pub fn new(config: ZerocopyPoolConfig) -> Arc<Self> {
        let simd_element_count = config.buffer_size / (4 * std::mem::size_of::<f64>());

        let pool = Arc::new(Self {
            config: config.clone(),
            simd_buffers: RwLock::new(Vec::with_capacity(config.max_buffer_count)),
            available_buffers: Mutex::new(Vec::with_capacity(config.initial_buffer_count)),
            statistics: RwLock::new(PoolStatistics::default()),
            total_allocations: AtomicU64::new(0),
            current_allocated: AtomicUsize::new(0),
            peak_allocated: AtomicUsize::new(0),
        });

        // Pre-allocate initial SIMD buffers
        {
            let mut buffers = pool.simd_buffers.write();
            let mut available = pool.available_buffers.lock();

            for i in 0..config.initial_buffer_count {
                let simd_buffer = VecSimd::<f64x4>::with(0.0, simd_element_count);
                buffers.push(Some(simd_buffer));
                available.push(i);
            }
        }

        pool
    }

    /// Allocate a SIMD buffer from the pool
    pub fn allocate_simd_buffer(self: &Arc<Self>) -> Option<SimdBufferHandle> {
        let start_time = QuantaInstant::now();
        self.total_allocations.fetch_add(1, Ordering::Relaxed);

        let buffer_id = {
            let mut available = self.available_buffers.lock();
            available.pop()
        };

        if let Some(id) = buffer_id {
            let mut buffers = self.simd_buffers.write();
            if let Some(simd_data) = buffers[id].take() {
                let current = self.current_allocated.fetch_add(1, Ordering::Relaxed) + 1;
                let peak = self.peak_allocated.load(Ordering::Relaxed);
                if current > peak {
                    self.peak_allocated.store(current, Ordering::Relaxed);
                }

                return Some(SimdBufferHandle {
                    simd_data,
                    pool: self.clone(),
                    buffer_id: id,
                    allocation_time: start_time,
                });
            }
        }

        None
    }

    /// Return a SIMD buffer to the pool
    fn return_simd_buffer(&self, buffer_id: usize, allocation_time_nanos: u64) {
        // Clear the SIMD buffer before returning
        let simd_element_count = self.config.buffer_size / (4 * std::mem::size_of::<f64>());
        let mut cleared_buffer = VecSimd::<f64x4>::with(0.0, simd_element_count);

        for i in 0..cleared_buffer.len() {
            cleared_buffer[i] = f64x4::splat(0.0);
        }

        {
            let mut buffers = self.simd_buffers.write();
            buffers[buffer_id] = Some(cleared_buffer);
        }

        {
            let mut available = self.available_buffers.lock();
            available.push(buffer_id);
        }

        self.current_allocated.fetch_sub(1, Ordering::Relaxed);

        if self.config.enable_statistics {
            let mut stats = self.statistics.write();
            stats.total_deallocations += 1;
            stats.avg_allocation_time_nanos =
                (stats.avg_allocation_time_nanos * 9 + allocation_time_nanos) / 10;
        }
    }

    /// Get number of available SIMD buffers
    pub fn available_simd_count(&self) -> usize {
        self.available_buffers.lock().len()
    }
}

/// Typed memory pool for specific data structures
pub struct TypedMemoryPool<T> {
    config: ZerocopyPoolConfig,
    typed_buffers: RwLock<Vec<Option<Box<T>>>>,
    available_buffers: Mutex<Vec<usize>>,
    statistics: RwLock<PoolStatistics>,
    total_allocations: AtomicU64,
    current_allocated: AtomicUsize,
    peak_allocated: AtomicUsize,
}

impl<T: Default> TypedMemoryPool<T> {
    /// Create a new typed memory pool
    pub fn new(config: ZerocopyPoolConfig) -> Arc<Self> {
        let pool = Arc::new(Self {
            config: config.clone(),
            typed_buffers: RwLock::new(Vec::with_capacity(config.max_buffer_count)),
            available_buffers: Mutex::new(Vec::with_capacity(config.initial_buffer_count)),
            statistics: RwLock::new(PoolStatistics::default()),
            total_allocations: AtomicU64::new(0),
            current_allocated: AtomicUsize::new(0),
            peak_allocated: AtomicUsize::new(0),
        });

        // Pre-allocate initial typed buffers
        {
            let mut buffers = pool.typed_buffers.write();
            let mut available = pool.available_buffers.lock();

            for i in 0..config.initial_buffer_count {
                let typed_buffer = Box::new(T::default());
                buffers.push(Some(typed_buffer));
                available.push(i);
            }
        }

        pool
    }

    /// Allocate a typed buffer from the pool
    pub fn allocate_typed(self: &Arc<Self>) -> Option<TypedBufferHandle<T>> {
        let start_time = QuantaInstant::now();
        self.total_allocations.fetch_add(1, Ordering::Relaxed);

        let buffer_id = {
            let mut available = self.available_buffers.lock();
            available.pop()
        };

        if let Some(id) = buffer_id {
            let mut buffers = self.typed_buffers.write();
            if let Some(data) = buffers[id].take() {
                let current = self.current_allocated.fetch_add(1, Ordering::Relaxed) + 1;
                let peak = self.peak_allocated.load(Ordering::Relaxed);
                if current > peak {
                    self.peak_allocated.store(current, Ordering::Relaxed);
                }

                return Some(TypedBufferHandle {
                    data,
                    pool: self.clone(),
                    buffer_id: id,
                    allocation_time: start_time,
                });
            }
        }

        None
    }

    /// Return a typed buffer to the pool
    fn return_typed_buffer(&self, buffer_id: usize, allocation_time_nanos: u64) {
        // Reset the typed data to default before returning
        let default_data = Box::new(T::default());

        {
            let mut buffers = self.typed_buffers.write();
            buffers[buffer_id] = Some(default_data);
        }

        {
            let mut available = self.available_buffers.lock();
            available.push(buffer_id);
        }

        self.current_allocated.fetch_sub(1, Ordering::Relaxed);

        if self.config.enable_statistics {
            let mut stats = self.statistics.write();
            stats.total_deallocations += 1;
            stats.avg_allocation_time_nanos =
                (stats.avg_allocation_time_nanos * 9 + allocation_time_nanos) / 10;
        }
    }

    /// Get number of available typed buffers
    pub fn available_count(&self) -> usize {
        self.available_buffers.lock().len()
    }
}

/// Global memory pool manager for the trading system
pub struct GlobalPoolManager {
    general_pool: Arc<ZerocopyMemoryPool>,
    simd_pool: Arc<SimdMemoryPool>,
    large_buffer_pool: Arc<ZerocopyMemoryPool>,
    small_buffer_pool: Arc<ZerocopyMemoryPool>,
}

impl GlobalPoolManager {
    /// Create a new global pool manager with optimized configurations
    pub fn new() -> Self {
        // General purpose pool (64KB buffers)
        let general_config = ZerocopyPoolConfig {
            initial_buffer_count: 128,
            max_buffer_count: 1024,
            buffer_size: 64 * 1024,
            simd_aligned: true,
            enable_statistics: true,
        };

        // SIMD pool for vectorized operations
        let simd_config = ZerocopyPoolConfig {
            initial_buffer_count: 64,
            max_buffer_count: 256,
            buffer_size: 32 * 1024, // 32KB for SIMD operations
            simd_aligned: true,
            enable_statistics: true,
        };

        // Large buffer pool (1MB buffers)
        let large_config = ZerocopyPoolConfig {
            initial_buffer_count: 16,
            max_buffer_count: 64,
            buffer_size: 1024 * 1024,
            simd_aligned: true,
            enable_statistics: true,
        };

        // Small buffer pool (4KB buffers)
        let small_config = ZerocopyPoolConfig {
            initial_buffer_count: 256,
            max_buffer_count: 2048,
            buffer_size: 4 * 1024,
            simd_aligned: false,
            enable_statistics: true,
        };

        Self {
            general_pool: ZerocopyMemoryPool::new(general_config),
            simd_pool: SimdMemoryPool::new(simd_config),
            large_buffer_pool: ZerocopyMemoryPool::new(large_config),
            small_buffer_pool: ZerocopyMemoryPool::new(small_config),
        }
    }

    /// Get the general purpose memory pool
    pub const fn general_pool(&self) -> &Arc<ZerocopyMemoryPool> {
        &self.general_pool
    }

    /// Get the SIMD memory pool
    pub const fn simd_pool(&self) -> &Arc<SimdMemoryPool> {
        &self.simd_pool
    }

    /// Get the large buffer memory pool
    pub const fn large_buffer_pool(&self) -> &Arc<ZerocopyMemoryPool> {
        &self.large_buffer_pool
    }

    /// Get the small buffer memory pool
    pub const fn small_buffer_pool(&self) -> &Arc<ZerocopyMemoryPool> {
        &self.small_buffer_pool
    }

    /// Get comprehensive statistics from all pools
    pub fn get_comprehensive_statistics(&self) -> GlobalPoolStatistics {
        GlobalPoolStatistics {
            general_pool: self.general_pool.get_statistics(),
            simd_pool: self.simd_pool.statistics.read().clone(),
            large_buffer_pool: self.large_buffer_pool.get_statistics(),
            small_buffer_pool: self.small_buffer_pool.get_statistics(),
        }
    }
}

impl Default for GlobalPoolManager {
    fn default() -> Self {
        Self::new()
    }
}

/// Comprehensive statistics from all memory pools
#[derive(Debug, Clone)]
pub struct GlobalPoolStatistics {
    /// Statistics for the general purpose memory pool (64KB buffers)
    pub general_pool: PoolStatistics,
    /// Statistics for the SIMD-optimized memory pool (32KB buffers)
    pub simd_pool: PoolStatistics,
    /// Statistics for the large buffer memory pool (1MB buffers)
    pub large_buffer_pool: PoolStatistics,
    /// Statistics for the small buffer memory pool (4KB buffers)
    pub small_buffer_pool: PoolStatistics,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_zerocopy_memory_pool_basic_operations() {
        let config = ZerocopyPoolConfig {
            initial_buffer_count: 4,
            max_buffer_count: 8,
            buffer_size: 1024,
            simd_aligned: false,
            enable_statistics: true,
        };

        let pool = ZerocopyMemoryPool::new(config);

        assert_eq!(pool.buffer_count(), 4);
        assert_eq!(pool.available_count(), 4);

        // Allocate a buffer
        let mut buffer = pool.allocate_buffer().unwrap();
        assert_eq!(pool.available_count(), 3);

        // Use the buffer
        let slice = buffer.as_slice_mut();
        slice[0] = 0xFF;
        slice[1023] = 0xAA;

        drop(buffer);
        assert_eq!(pool.available_count(), 4);
    }

    #[test]
    fn test_simd_memory_pool() {
        let config = ZerocopyPoolConfig {
            initial_buffer_count: 2,
            max_buffer_count: 4,
            buffer_size: 1024,
            simd_aligned: true,
            enable_statistics: true,
        };

        let pool = SimdMemoryPool::new(config);

        assert_eq!(pool.available_simd_count(), 2);

        let mut simd_buffer = pool.allocate_simd_buffer().unwrap();
        assert_eq!(pool.available_simd_count(), 1);

        // Use SIMD operations
        let simd_data = simd_buffer.as_simd_mut();
        if !simd_data.is_empty() {
            simd_data[0] = f64x4::splat(42.0);
        }

        drop(simd_buffer);
        assert_eq!(pool.available_simd_count(), 2);
    }

    #[test]
    fn test_global_pool_manager() {
        let manager = GlobalPoolManager::new();

        // Test general pool
        let general_buffer = manager.general_pool().allocate_buffer().unwrap();
        assert_eq!(general_buffer.size(), 64 * 1024);

        // Test small buffer pool
        let small_buffer = manager.small_buffer_pool().allocate_buffer().unwrap();
        assert_eq!(small_buffer.size(), 4 * 1024);

        // Test large buffer pool
        let large_buffer = manager.large_buffer_pool().allocate_buffer().unwrap();
        assert_eq!(large_buffer.size(), 1024 * 1024);

        // Test SIMD pool
        let simd_buffer = manager.simd_pool().allocate_simd_buffer().unwrap();
        assert!(!simd_buffer.as_simd().is_empty());

        drop(general_buffer);
        drop(small_buffer);
        drop(large_buffer);
        drop(simd_buffer);

        let stats = manager.get_comprehensive_statistics();
        assert!(stats.general_pool.total_allocations > 0);
        assert!(stats.small_buffer_pool.total_allocations > 0);
        assert!(stats.large_buffer_pool.total_allocations > 0);
    }
}