Memory Pool — Fixed-Size Block Allocator의 단순함과 강력함

1
#define POOL_BLOCKS  32
2
#define BLOCK_SIZE   64
3

4
typedef struct block { struct block *next; } block_t;
5

6
static uint8_t  pool_memory[POOL_BLOCKS * BLOCK_SIZE];
7
static block_t *free_list;
8
static mutex_t  pool_lock;
9

10
void pool_init(void) {
11
    free_list = (block_t*)pool_memory;
12
    block_t *cur = free_list;
13
    for (int i = 0; i < POOL_BLOCKS - 1; i++) {
14
        cur->next = (block_t*)(pool_memory + (i + 1) * BLOCK_SIZE);
15
        cur = cur->next;
16
    }
17
    cur->next = NULL;
18
}
19

20
void *pool_alloc(void) {
21
    mutex_take(&pool_lock);
22
    block_t *b = free_list;
23
    if (b) free_list = b->next;
24
    mutex_give(&pool_lock);
25
    return b;
26
}
27

28
void pool_free(void *ptr) {
29
    if (!ptr) return;
30
    mutex_take(&pool_lock);
31
    block_t *b = (block_t*)ptr;
32
    b->next = free_list;
33
    free_list = b;
34
    mutex_give(&pool_lock);
35
}

1
static pool_t packet_pool;     /* 64 byte network packets */
2
static pool_t message_pool;    /* 256 byte MQTT messages */
3
static pool_t large_pool;      /* 4 KB transfer buffers */
4

5
void pool_setup(void) {
6
    pool_create(&packet_pool,  64,   128);
7
    pool_create(&message_pool, 256,   32);
8
    pool_create(&large_pool,   4096,   8);
9
}
10

11
packet_t *p   = pool_alloc(&packet_pool);
12
message_t *m  = pool_alloc(&message_pool);

1
osMemoryPoolId_t   packet_pool;
2
osMemoryPoolAttr_t attr = { .name = "packet" };
3

4
void init(void) {
5
    packet_pool = osMemoryPoolNew(32, sizeof(packet_t), &attr);
6
}
7

8
void *p = osMemoryPoolAlloc(packet_pool, osWaitForever);
9
/* ... use ... */
10
osMemoryPoolFree(packet_pool, p);

1
static StaticQueue_t pool_q_buf;
2
static uint8_t       pool_q_storage[32 * sizeof(packet_t*)];
3
static packet_t      packets[32];  /* 실제 block storage */
4
QueueHandle_t        packet_pool_q;
5

6
void init(void) {
7
    packet_pool_q = xQueueCreateStatic(
8
        32, sizeof(packet_t*), pool_q_storage, &pool_q_buf);
9
    for (int i = 0; i < 32; i++) {
10
        packet_t *p = &packets[i];
11
        xQueueSend(packet_pool_q, &p, 0);
12
    }
13
}
14

15
packet_t *get_packet(void) {
16
    packet_t *p;
17
    if (xQueueReceive(packet_pool_q, &p, 0) == pdTRUE) return p;
18
    return NULL;
19
}
20

21
void put_packet(packet_t *p) {
22
    xQueueSend(packet_pool_q, &p, 0);
23
}

1
struct mbuf {
2
    struct mbuf *next;
3
    uint16_t     len;
4
    uint8_t      data[MBUF_DATA];
5
};
6

7
#define MBUF_POOL_SIZE 256
8
static struct mbuf mbuf_storage[MBUF_POOL_SIZE];
9
static pool_t      mbuf_pool;
10

11
/* ISR — RX */
12
void eth_rx_isr(uint8_t *bytes, int len) {
13
    struct mbuf *m = pool_alloc(&mbuf_pool);
14
    if (!m) { drop_counter++; return; }
15
    memcpy(m->data, bytes, len);
16
    m->len = len;
17
    queue_for_processing(m);
18
}
19

20
/* Task — process */
21
void net_task(void) {
22
    struct mbuf *m;
23
    while (dequeue(&m)) {
24
        process_packet(m);
25
        pool_free(&mbuf_pool, m);
26
    }
27
}

1
#include <stdatomic.h>
2

3
static _Atomic(block_t*) free_list_head;
4

5
void *pool_alloc_lf(void) {
6
    block_t *old, *next;
7
    do {
8
        old = atomic_load_explicit(&free_list_head, memory_order_acquire);
9
        if (!old) return NULL;
10
        next = old->next;
11
    } while (!atomic_compare_exchange_weak_explicit(
12
                 &free_list_head, &old, next,
13
                 memory_order_acq_rel, memory_order_acquire));
14
    return old;
15
}
16

17
void pool_free_lf(void *ptr) {
18
    block_t *b = (block_t*)ptr;
19
    block_t *old;
20
    do {
21
        old = atomic_load_explicit(&free_list_head, memory_order_relaxed);
22
        b->next = old;
23
    } while (!atomic_compare_exchange_weak_explicit(
24
                 &free_list_head, &old, b,
25
                 memory_order_release, memory_order_relaxed));
26
}

1
struct kmem_cache *packet_cache;
2

3
void init(void) {
4
    packet_cache = kmem_cache_create("packet",
5
                                     sizeof(struct packet),
6
                                     0, SLAB_HWCACHE_ALIGN, NULL);
7
}
8

9
struct packet *p = kmem_cache_alloc(packet_cache, GFP_KERNEL);
10
kmem_cache_free(packet_cache, p);

1
워크로드 분석 예시:
2
  - peak RX burst : 64 packet / 1 ms
3
  - 평균 처리 시간 : 200 µs
4
  - in-flight     : 64 × 200µs / 1ms = 12.8 → round up 16
5
  - margin (25%)  : 4
6
  pool size       = 20 block

1
typedef struct {
2
    _Atomic int allocated;
3
    _Atomic int peak_use;
4
    _Atomic int alloc_fail;
5
} pool_stats_t;
6

7
void *pool_alloc_inst(pool_t *p) {
8
    block_t *b = pool_alloc(p);
9
    if (b) {
10
        int n = atomic_fetch_add(&p->stats.allocated, 1) + 1;
11
        int peak = atomic_load(&p->stats.peak_use);
12
        while (n > peak &&
13
               !atomic_compare_exchange_weak(&p->stats.peak_use, &peak, n));
14
    } else {
15
        atomic_fetch_add(&p->stats.alloc_fail, 1);
16
    }
17
    return b;
18
}

1
struct __attribute__((aligned(64))) block_aligned {
2
    block_t hdr;
3
    uint8_t data[60];
4
};

1
struct multi_pool {
2
    pool_t p64, p256, p1024, p4096;
3
};
4

5
void *multi_alloc(struct multi_pool *mp, size_t size) {
6
    if (size <=   64) return pool_alloc(&mp->p64);
7
    if (size <=  256) return pool_alloc(&mp->p256);
8
    if (size <= 1024) return pool_alloc(&mp->p1024);
9
    if (size <= 4096) return pool_alloc(&mp->p4096);
10
    return NULL;
11
}