PooledByteBufAllocator — 메모리 풀

jemalloc 구조 (Netty가 차용한 핵심)

Thread 1 ──→ Arena 0 ──→ Chunk ──→ Page ──→ Subpage
Thread 2 ──→ Arena 1 ──→ Chunk ──→ Page ──→ Subpage
Thread 3 ──→ Arena 0 ──→ ...   (Arena 수보다 스레드가 많으면 공유)

// PooledByteBufAllocator 내부 (개념적 구조)
PoolArena<byte[]>[] heapArenas;      // Heap 버퍼용 Arena 배열
PoolArena<ByteBuffer>[] directArenas; // Direct 버퍼용 Arena 배열

// 스레드 → Arena 바인딩 과정 (개념적 흐름)
// 1. 스레드가 처음 buffer() 호출
// 2. PoolThreadLocalCache에서 이 스레드에 할당된 Arena 조회
// 3. 없으면 → 가장 적게 사용된 Arena를 선택해서 바인딩
// 4. 이후 이 스레드는 항상 같은 Arena 사용

할당 흐름:
1. PoolThreadCache에 맞는 크기가 있는가? → 있으면 즉시 반환 (락 없음)
2. 없으면 → PoolArena에서 할당 (Arena 내부 동기화)
3. Arena에도 여유가 없으면 → 새 PoolChunk 할당

PoolChunk (16MB) — 이진 트리 구조

                    [16MB]              depth 0
                   /      \
              [8MB]        [8MB]        depth 1
             /    \       /    \
          [4MB] [4MB]  [4MB] [4MB]     depth 2
           ...    ...    ...    ...
          /  \
       [8KB][8KB]                      depth 11 (리프 = Page)

PoolSubpage (하나의 8KB 페이지를 분할)

요청 크기: 512바이트
→ 8KB / 512B = 16개의 슬롯

+------+------+------+------+------+------+--- ... ---+------+
| 512B | 512B | 512B | 512B | 512B | 512B |           | 512B |
|  #0  |  #1  |  #2  |  #3  |  #4  |  #5  |           | #15  |
+------+------+------+------+------+------+--- ... ---+------+

비트맵으로 사용 중/빈 슬롯을 추적
bitmap: [1, 1, 0, 0, 1, 0, ..., 0]  (1=사용 중, 0=비어 있음)

// Pooled — 기본 allocator (네티 4.x 이후)
ByteBufAllocator pooled = PooledByteBufAllocator.DEFAULT;
ByteBuf buf1 = pooled.buffer(256);     // 풀에서 빌려옴
buf1.release();                         // 풀로 반환 (재사용 가능)

// Unpooled — 매번 새로 할당
ByteBufAllocator unpooled = UnpooledByteBufAllocator.DEFAULT;
ByteBuf buf2 = unpooled.buffer(256);   // 새로 할당
buf2.release();                         // 메모리 해제 (재사용 안 됨)

// 성능 비교 (개념적 벤치마크)
ByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;

for (int i = 0; i < 1_000_000; i++) {
    ByteBuf buf = allocator.buffer(256);
    // 데이터 처리...
    buf.release(); // 풀로 반환 → 다음 루프에서 재사용
}
// Pooled: 대부분 스레드 캐시에서 즉시 반환 → 락 없음, GC 없음
// Unpooled: 매번 malloc + free (또는 new byte[] + GC)

// Bootstrap에서 allocator 변경
ServerBootstrap b = new ServerBootstrap();
b.childOption(ChannelOption.ALLOCATOR, UnpooledByteBufAllocator.DEFAULT);

# Arena 수 조정
-Dio.netty.allocator.numHeapArenas=8
-Dio.netty.allocator.numDirectArenas=8

# 페이지 크기 변경 (2의 거듭제곱이어야 함)
-Dio.netty.allocator.pageSize=16384

# maxOrder 변경 (Chunk 크기에 영향)
-Dio.netty.allocator.maxOrder=9
# → Chunk 크기 = 16384 × 2^9 = 8MB

// 커스텀 PooledByteBufAllocator 생성
PooledByteBufAllocator customAllocator = new PooledByteBufAllocator(
    true,   // preferDirect — Direct 버퍼 우선 사용
    8,      // nHeapArena
    8,      // nDirectArena
    8192,   // pageSize (8KB)
    11      // maxOrder (Chunk = 8KB × 2^11 = 16MB)
);

// Bootstrap에 적용
ServerBootstrap b = new ServerBootstrap();
b.childOption(ChannelOption.ALLOCATOR, customAllocator);

PooledByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;
PooledByteBufAllocatorMetric metric = allocator.metric();

// 현재 사용 중인 Direct 메모리 (바이트)
long usedDirect = metric.usedDirectMemory();

// 현재 사용 중인 Heap 메모리 (바이트)
long usedHeap = metric.usedHeapMemory();

// Arena별 상세 메트릭
List<PoolArenaMetric> arenaMetrics = metric.directArenas();
for (PoolArenaMetric arena : arenaMetrics) {
    // 이 Arena의 활성 할당 수
    long activeAllocations = arena.numActiveAllocations();
    // 이 Arena가 관리하는 Chunk 수
    int numChunkLists = arena.chunkLists().size();

    System.out.printf("활성 할당: %d, ChunkList 수: %d%n",
        activeAllocations, numChunkLists);
}

// 스케줄러를 이용한 주기적 메트릭 수집
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
scheduler.scheduleAtFixedRate(() -> {
    PooledByteBufAllocatorMetric metric =
        PooledByteBufAllocator.DEFAULT.metric();

    long directMB = metric.usedDirectMemory() / 1024 / 1024;
    long heapMB = metric.usedHeapMemory() / 1024 / 1024;

    log.info("메모리 풀 상태 — Direct: {}MB, Heap: {}MB", directMB, heapMB);

    // 임계치 초과 시 경고
    if (directMB > 512) {
        log.warn("Direct 메모리 사용량이 512MB를 초과했습니다. 누수를 점검하세요.");
    }
}, 0, 30, TimeUnit.SECONDS);

# 리소스 누수 감지 레벨 설정
-Dio.netty.leakDetection.level=PARANOID

PooledByteBufAllocator
├── PoolArena[0] (Direct)
│   ├── PoolChunk (16MB)
│   │   ├── Page 0 (8KB) → PoolSubpage (작은 크기 분할)
│   │   ├── Page 1 (8KB)
│   │   ├── ...
│   │   └── Page 2047 (8KB)
│   ├── PoolChunk (16MB)
│   └── ...
├── PoolArena[1] (Direct)
│   └── ...
├── ...
└── PoolArena[N-1] (Direct)

스레드 바인딩:
Thread-1 → PoolThreadCache → PoolArena[0]
Thread-2 → PoolThreadCache → PoolArena[1]
Thread-3 → PoolThreadCache → PoolArena[0]  (Arena 수 < 스레드 수일 때 공유)