feat(server): introduce ByteBufferPool and integrate into connection handlers for reduced allocation overhead

- Added ByteBufferPool for efficient buffer reuse across server components
  - Supports configurable small(2KB), medium(8KB), and large(32KB) buffer pools
  - Thread-safe via ConcurrentLinkedQueue and capacity-limited to prevent leaks
  - Tracks allocation, acquisition, and release statistics for profiling
- Integrated ByteBufferPool into DefaultConnectionManager
  - Replaced per-connection temporary buffer allocation with pooled buffer
  - Reduced GC pressure from high-frequency accept operations
- Integrated ByteBufferPool into HttpConnectionHandler
  - Pooled 8KB read buffers per connection, released on close
  - Planned for pooled write buffer support via HttpUtils
- Updated HttpUtils to provide overload of createResponseBuffer(ResponseEntity, ByteBufferPool)
  - Enables response buffer creation using pooled ByteBuffer
  - Preserves backward compatibility with existing static utility calls
- Overall: significant reduction of ByteBuffer allocation rate and GC churn under high load

Author: yyubin

profile_gatling.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Sprout 서버 부하테스트 + Async Profiler 통합 스크립트
+# Sprout 서버 부하테스트 + Async Profiler 통합 스크립트 (CPU / Alloc / Wall)
 
 SERVER_PORT=8080
 DURATION=30
@@ -20,19 +20,35 @@ if [ ! -f "$ASPROF" ]; then
 fi
 
 echo "1) Gatling 부하테스트 시작..."
-./gradlew gatlingRun --simulation=benchmark.HelloWorldSimulation &
+./gradlew gatlingRun --simulation=$SIMULATION_CLASS &
 GATLING_PID=$!
 
 sleep 3
 
 echo "2) Async Profiler로 $DURATION초간 프로파일링..."
-env DYLD_LIBRARY_PATH=$ASYNC_PROFILER_HOME/lib $ASPROF -d $DURATION -e cpu   -o flamegraph -f cpu-flamegraph.html   $PID
-env DYLD_LIBRARY_PATH=$ASYNC_PROFILER_HOME/lib $ASPROF -d $DURATION -e alloc -o flamegraph -f alloc-flamegraph.html $PID
+
+# CPU
+env DYLD_LIBRARY_PATH=$ASYNC_PROFILER_HOME/lib $ASPROF \
+  -d $DURATION -e cpu -o flamegraph -f cpu-flamegraph.html $PID
+
+# Allocation
+env DYLD_LIBRARY_PATH=$ASYNC_PROFILER_HOME/lib $ASPROF \
+  -d $DURATION -e alloc -o flamegraph -f alloc-flamegraph.html $PID
+
+# Wall-clock
+env DYLD_LIBRARY_PATH=$ASYNC_PROFILER_HOME/lib $ASPROF \
+  -d $DURATION -e wall -o flamegraph -f wall-flamegraph.html $PID
 
 wait $GATLING_PID
 
-echo "완료! 결과 파일"
-echo " - cpu-flamegraph.html"
-echo " - alloc-flamegraph.html"
+echo ""
+echo "프로파일링 완료!"
+echo "생성된 결과 파일:"
+echo " - cpu-flamegraph.html   (CPU 사용 분석)"
+echo " - alloc-flamegraph.html (힙 메모리 할당 분석)"
+echo " - wall-flamegraph.html  (실제 wall-clock 병목 분석)"
+echo ""
+
 open cpu-flamegraph.html
 open alloc-flamegraph.html
+open wall-flamegraph.html

src/main/java/sprout/server/ByteBufferPool.java

@@ -0,0 +1,192 @@
+package sprout.server;
+
+import sprout.beans.InfrastructureBean;
+import sprout.beans.annotation.Component;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicLong;
+
+@Component
+public class ByteBufferPool implements InfrastructureBean {
+
+    private static class PoolConfig {
+        final int bufferSize;
+        final int maxPoolSize;
+        final ConcurrentLinkedQueue<ByteBuffer> pool;
+        final AtomicLong acquireCount = new AtomicLong(0);
+        final AtomicLong releaseCount = new AtomicLong(0);
+        final AtomicLong allocateCount = new AtomicLong(0);
+
+        PoolConfig(int bufferSize, int maxPoolSize) {
+            this.bufferSize = bufferSize;
+            this.maxPoolSize = maxPoolSize;
+            this.pool = new ConcurrentLinkedQueue<>();
+        }
+    }
+
+    // Predefined buffer sizes
+    public static final int SMALL_BUFFER_SIZE = 2048;      // 2KB for protocol detection
+    public static final int MEDIUM_BUFFER_SIZE = 8192;     // 8KB for read operations
+    public static final int LARGE_BUFFER_SIZE = 32768;     // 32KB for large responses
+
+    private static final int DEFAULT_MAX_POOL_SIZE = 500;
+
+    private final ConcurrentHashMap<Integer, PoolConfig> pools;
+    private final boolean useDirect;
+
+    public ByteBufferPool() {
+        this(false);
+    }
+
+    public ByteBufferPool(boolean useDirect) {
+        this.useDirect = useDirect;
+        this.pools = new ConcurrentHashMap<>();
+
+        // Initialize default pools
+        initializePool(SMALL_BUFFER_SIZE, DEFAULT_MAX_POOL_SIZE);
+        initializePool(MEDIUM_BUFFER_SIZE, DEFAULT_MAX_POOL_SIZE);
+        initializePool(LARGE_BUFFER_SIZE, DEFAULT_MAX_POOL_SIZE / 5); // Fewer large buffers
+    }
+
+    public void initializePool(int bufferSize, int maxPoolSize) {
+        pools.put(bufferSize, new PoolConfig(bufferSize, maxPoolSize));
+    }
+
+    public ByteBuffer acquire(int size) {
+        int poolSize = findPoolSize(size);
+        PoolConfig config = pools.get(poolSize);
+
+        if (config == null) {
+            // No pool for this size, allocate directly
+            return allocateBuffer(size);
+        }
+
+        config.acquireCount.incrementAndGet();
+
+        ByteBuffer buffer = config.pool.poll();
+        if (buffer != null) {
+            // Got buffer from pool, reset it
+            buffer.clear();
+            return buffer;
+        }
+
+        // Pool is empty, allocate new buffer
+        config.allocateCount.incrementAndGet();
+        return allocateBuffer(poolSize);
+    }
+
+    public void release(ByteBuffer buffer) {
+        if (buffer == null) {
+            return;
+        }
+
+        int capacity = buffer.capacity();
+        PoolConfig config = pools.get(capacity);
+
+        if (config == null) {
+            // Not a pooled size, let it be GC'd
+            return;
+        }
+
+        config.releaseCount.incrementAndGet();
+
+        // Check if pool is full
+        if (config.pool.size() >= config.maxPoolSize) {
+            // Pool is full, discard buffer (will be GC'd)
+            return;
+        }
+
+        // Clear buffer and return to pool
+        buffer.clear();
+        config.pool.offer(buffer);
+    }
+
+    private int findPoolSize(int requestedSize) {
+        if (requestedSize <= SMALL_BUFFER_SIZE) {
+            return SMALL_BUFFER_SIZE;
+        } else if (requestedSize <= MEDIUM_BUFFER_SIZE) {
+            return MEDIUM_BUFFER_SIZE;
+        } else if (requestedSize <= LARGE_BUFFER_SIZE) {
+            return LARGE_BUFFER_SIZE;
+        }
+        // For very large buffers, return the requested size (no pooling)
+        return requestedSize;
+    }
+
+    private ByteBuffer allocateBuffer(int size) {
+        return useDirect ? ByteBuffer.allocateDirect(size) : ByteBuffer.allocate(size);
+    }
+
+    public PoolStats getStats(int bufferSize) {
+        PoolConfig config = pools.get(bufferSize);
+        if (config == null) {
+            return null;
+        }
+
+        return new PoolStats(
+            bufferSize,
+            config.pool.size(),
+            config.maxPoolSize,
+            config.acquireCount.get(),
+            config.releaseCount.get(),
+            config.allocateCount.get()
+        );
+    }
+
+    public static class PoolStats {
+        public final int bufferSize;
+        public final int currentPoolSize;
+        public final int maxPoolSize;
+        public final long acquireCount;
+        public final long releaseCount;
+        public final long allocateCount;
+
+        public PoolStats(int bufferSize, int currentPoolSize, int maxPoolSize,
+                         long acquireCount, long releaseCount, long allocateCount) {
+            this.bufferSize = bufferSize;
+            this.currentPoolSize = currentPoolSize;
+            this.maxPoolSize = maxPoolSize;
+            this.acquireCount = acquireCount;
+            this.releaseCount = releaseCount;
+            this.allocateCount = allocateCount;
+        }
+
+        public double getHitRate() {
+            if (acquireCount == 0) {
+                return 0.0;
+            }
+            long hits = acquireCount - allocateCount;
+            return (hits * 100.0) / acquireCount;
+        }
+
+        public double getUtilization() {
+            if (maxPoolSize == 0) {
+                return 0.0;
+            }
+            return (currentPoolSize * 100.0) / maxPoolSize;
+        }
+
+        @Override
+        public String toString() {
+            return String.format(
+                "PoolStats{size=%d, pool=%d/%d, acquires=%d, releases=%d, allocations=%d, hitRate=%.2f%%, utilization=%.2f%%}",
+                bufferSize, currentPoolSize, maxPoolSize, acquireCount, releaseCount,
+                allocateCount, getHitRate(), getUtilization()
+            );
+        }
+    }
+
+    public void clear() {
+        for (PoolConfig config : pools.values()) {
+            config.pool.clear();
+        }
+    }
+
+    public int getTotalBuffersInPool() {
+        return pools.values().stream()
+                .mapToInt(config -> config.pool.size())
+                .sum();
+    }
+}

src/main/java/sprout/server/ServerAutoConfigurationRegistrar.java

@@ -46,7 +46,7 @@ private Collection<BeanDefinition> registerHybridServerBeans(Collection<BeanDefi
     }
 
     private Collection<BeanDefinition> registerNioServerBeans(Collection<BeanDefinition> existingDefs) throws NoSuchMethodException {
-        Constructor<?> constructor = NioHttpProtocolHandler.class.getConstructor(RequestDispatcher.class, HttpRequestParser.class, RequestExecutorService.class);
+        Constructor<?> constructor = NioHttpProtocolHandler.class.getConstructor(RequestDispatcher.class, HttpRequestParser.class, RequestExecutorService.class, ByteBufferPool.class);
         return List.of(registerThreadTypeBean(existingDefs), createBeanDefinition("httpProtocolHandler", NioHttpProtocolHandler.class, constructor));
     }
 

src/main/java/sprout/server/ServerConfiguration.java

@@ -28,13 +28,13 @@ public RequestExecutorService executorService(AppConfig appConfig, List<ContextP
     }
 
     @Bean
-    public AcceptableProtocolHandler httpProtocolHandler(AppConfig appConfig, RequestDispatcher requestDispatcher, HttpRequestParser httpRequestParser, RequestExecutorService executorService) {
+    public AcceptableProtocolHandler httpProtocolHandler(AppConfig appConfig, RequestDispatcher requestDispatcher, HttpRequestParser httpRequestParser, RequestExecutorService executorService, ByteBufferPool byteBufferPool) {
         String executionMode = appConfig.getStringProperty("server.execution-mode", "hybrid");
         if (executionMode.equals("hybrid")) {
             System.out.println("Execution mode is hybrid");
             return new BioHttpProtocolHandler(requestDispatcher, httpRequestParser, executorService);
         }
         System.out.println("Execution mode is NIO");
-        return new NioHttpProtocolHandler(requestDispatcher, httpRequestParser, executorService);
+        return new NioHttpProtocolHandler(requestDispatcher, httpRequestParser, executorService, byteBufferPool);
     }
 }

src/main/java/sprout/server/builtins/HttpConnectionHandler.java

@@ -41,7 +41,6 @@ public HttpConnectionHandler(SocketChannel channel, Selector selector, RequestDi
             this.readBuffer.put(initialBuffer);
         }
 
-        System.out.println("connection established from " + channel.socket() + " with initial buffer size: " + readBuffer.remaining() + " bytes");
     }
 
     @Override

src/main/java/sprout/server/builtins/NioHttpProtocolHandler.java

@@ -3,6 +3,7 @@
 import sprout.mvc.dispatcher.RequestDispatcher;
 import sprout.mvc.http.parser.HttpRequestParser;
 import sprout.server.AcceptableProtocolHandler;
+import sprout.server.ByteBufferPool;
 import sprout.server.RequestExecutorService;
 
 import java.nio.ByteBuffer;
@@ -14,18 +15,20 @@ public class NioHttpProtocolHandler implements AcceptableProtocolHandler {
     private final RequestDispatcher dispatcher;
     private final HttpRequestParser parser;
     private final RequestExecutorService requestExecutorService;
+    private final ByteBufferPool bufferPool;
 
 
-    public NioHttpProtocolHandler(RequestDispatcher dispatcher, HttpRequestParser parser, RequestExecutorService requestExecutorService) {
+    public NioHttpProtocolHandler(RequestDispatcher dispatcher, HttpRequestParser parser, RequestExecutorService requestExecutorService, ByteBufferPool bufferPool) {
         this.dispatcher = dispatcher;
         this.parser = parser;
         this.requestExecutorService = requestExecutorService;
+        this.bufferPool = bufferPool;
     }
 
     @Override
     public void accept(SocketChannel channel, Selector selector, ByteBuffer byteBuffer) throws Exception {
         System.out.println( "Accepted connection from " + channel.socket());
-        HttpConnectionHandler handler = new HttpConnectionHandler(channel, selector, dispatcher, parser, requestExecutorService, byteBuffer);
+        HttpConnectionHandler handler = new HttpConnectionHandler(channel, selector, dispatcher, parser, requestExecutorService, bufferPool, byteBuffer);
         channel.register(selector, SelectionKey.OP_READ, handler);
         handler.read(channel.keyFor(selector));
     }