Method return_buffer

src/protocol/buffer_pool.rs:194–252

Return a buffer to the pool for reuse

(&self, buffer: BytesMut)

    
    /// Return a buffer to the pool for reuse
    fn return_buffer(&self, buffer: BytesMut) {
        let mut inner = self.inner.lock();
        
        // Check if we should discard this buffer
        if buffer.capacity() > self.config.max_buffer_capacity {
            inner.stats.buffers_discarded += 1;
            
            // Record deallocation in global memory monitor (skip in tests)
            #[cfg(not(test))]
            global_memory_monitor().record_buffer_deallocation(buffer.capacity() as u64);
            
            if self.config.enable_monitoring {
                debug!("Discarded oversized buffer: capacity={}B > max={}B", 
                       buffer.capacity(), self.config.max_buffer_capacity);
            }
            return;
        }
        
        // Check if pool is full
        if inner.buffers.len() >= self.config.max_pool_size {
            inner.stats.buffers_discarded += 1;
            
            // Record deallocation in global memory monitor (skip in tests)
            #[cfg(not(test))]
            global_memory_monitor().record_buffer_deallocation(buffer.capacity() as u64);
            
            if self.config.enable_monitoring {
                debug!("Discarded buffer: pool full (size={})", inner.buffers.len());
            }
            return;
        }
        
        // Return buffer to pool
        let pooled_buffer = PooledBuffer {
            buffer,
            last_used: Instant::now(),
            allocation_count: 1,
        };
        
        let buffer_capacity = pooled_buffer.buffer.capacity();
        
        inner.buffers.push_back(pooled_buffer);
        inner.stats.buffers_returned += 1;
        inner.stats.current_pool_size = inner.buffers.len();
        
        if inner.stats.current_pool_size > inner.stats.peak_pool_size {
            inner.stats.peak_pool_size = inner.stats.current_pool_size;
        }
        
        if self.config.enable_monitoring {
            debug!("Returned buffer to pool: capacity={}B, pool_size={}", 
                   buffer_capacity, inner.buffers.len());
        }
        
        // Perform cleanup if needed
        if inner.last_cleanup.elapsed() > self.config.cleanup_interval {
            self.cleanup_old_buffers(&mut inner);
        }