임베디드 동적 메모리 — malloc 위험·결정성·대안 분석

1
malloc 문제
2
- 비결정성     free list scan, coalesce, fragmentation 처리
3
- fragmentation 사용 가능 메모리가 작은 hole로 흩어짐
4
- 실패 처리    NULL 반환을 모든 호출자가 처리해야 함
5

6
대안
7
- static       모든 자원을 컴파일 시 결정 — 0 byte heap
8
- pool         같은 크기 N개 — fragmentation 0
9
- arena        한 lifetime에 묶인 군집 — 한 번에 reset
10
- slab         OS 커널식 — 같은 size 캐싱

1
#define POOL_N    16
2
#define BLOCK_SZ  256
3

4
static uint8_t pool_buf[POOL_N][BLOCK_SZ];
5
static uint8_t pool_used[POOL_N];
6
static portMUX_TYPE pool_lock = portMUX_INITIALIZER_UNLOCKED;
7

8
void *pool_alloc(void) {
9
    void *p = NULL;
10
    portENTER_CRITICAL(&pool_lock);
11
    for (int i = 0; i < POOL_N; i++) {
12
        if (!pool_used[i]) {
13
            pool_used[i] = 1;
14
            p = pool_buf[i];
15
            break;
16
        }
17
    }
18
    portEXIT_CRITICAL(&pool_lock);
19
    return p;
20
}
21

22
void pool_free(void *p) {
23
    int idx = ((uint8_t *)p - (uint8_t *)pool_buf) / BLOCK_SZ;
24
    portENTER_CRITICAL(&pool_lock);
25
    pool_used[idx] = 0;
26
    portEXIT_CRITICAL(&pool_lock);
27
}

1
typedef struct {
2
    uint8_t *base;
3
    size_t   cap;
4
    size_t   off;
5
} arena_t;
6

7
void *arena_alloc(arena_t *a, size_t n) {
8
    n = (n + 7) & ~7;       /* 8-byte 정렬 */
9
    if (a->off + n > a->cap) return NULL;
10
    void *p = a->base + a->off;
11
    a->off += n;
12
    return p;
13
}
14

15
void arena_reset(arena_t *a) { a->off = 0; }

1
static StaticQueue_t  q_buf;
2
static uint8_t        q_storage[64 * sizeof(item_t)];
3
QueueHandle_t q;
4

5
void init(void) {
6
    q = xQueueCreateStatic(64, sizeof(item_t), q_storage, &q_buf);
7
}

1
typedef struct slab {
2
    void *free_list;
3
    void *blocks;
4
    size_t block_sz, n;
5
} slab_t;
6

7
void slab_init(slab_t *s, void *mem, size_t n, size_t sz) {
8
    s->blocks = mem;
9
    s->free_list = mem;
10
    s->block_sz = sz;
11
    s->n = n;
12
    for (size_t i = 0; i < n - 1; i++)
13
        *(void **)((char *)mem + i * sz) = (char *)mem + (i + 1) * sz;
14
    *(void **)((char *)mem + (n - 1) * sz) = NULL;
15
}
16

17
void *slab_alloc(slab_t *s) {
18
    void *p = s->free_list;
19
    if (p) s->free_list = *(void **)p;
20
    return p;
21
}
22

23
void slab_free(slab_t *s, void *p) {
24
    *(void **)p = s->free_list;
25
    s->free_list = p;
26
}

1
/* general-purpose 실시간 allocator
2
   alloc/free O(1) worst-case, fragmentation 매우 낮음
3
   embedded에서 heap_4를 대체하는 가장 인기 있는 선택 */
4

5
#include "tlsf.h"
6
static uint8_t pool_buf[64 * 1024];
7
tlsf_t tlsf;
8

9
void init(void) {
10
    tlsf = tlsf_create_with_pool(pool_buf, sizeof(pool_buf));
11
}
12

13
void *my_malloc(size_t n) { return tlsf_malloc(tlsf, n); }
14
void  my_free(void *p)    { tlsf_free(tlsf, p); }

1
typedef struct { size_t used, peak, fail; } heap_stats_t;
2
heap_stats_t g_heap;
3

4
void *tracked_malloc(size_t n) {
5
    void *p = malloc(n);
6
    if (!p) { g_heap.fail++; return NULL; }
7
    g_heap.used += n;
8
    if (g_heap.used > g_heap.peak) g_heap.peak = g_heap.used;
9
    return p;
10
}

1
RAM 사용량
2
heap_4 overhead per block    ~16 B
3
TLSF overhead per block      ~8~16 B
4
pool overhead per block      0 (free list 외 자체 없음)

1
malloc failed: free=12 KB but no contiguous 1 KB

1
buf = malloc(...);
2
if (err) return -1;     /* buf leak */

1
void IRQ(void) { p = malloc(64); }

1
p = malloc(N);    /* N이 0 또는 음수 cast 결과인 경우 */

1
QueueHandle_t q = xQueueCreate(64, sizeof(item_t));   /* heap에서 */