Embedded C++ for Real Systems · 20/41

Custom Allocator 기초 — std::allocator 인터페이스 분석

2026년 4월 30일 · Hawk · 5분 읽기

cpp embedded allocator custom-allocator stl

#한 줄 요약

“Allocator는 메모리 출처를 STL에 알려줍니다.” std::vector<int, MyAllocator> 형태로 내가 지정한 메모리를 사용합니다.

#어떤 문제를 푸는가

std::vector<int>의 기본 allocator는 std::allocator<int>이며 heap(new/malloc)을 사용합니다. 임베디드에서는 heap 회피가 원칙이지만 표준 컨테이너의 편리함을 포기하기는 어렵습니다.

1
std::vector<int> v;
2
v.push_back(1);   // new 호출 — heap

Custom allocator는 STL과 호환되는 메모리 인터페이스입니다. pool, stack arena, 특정 메모리 영역에서 할당하도록 만들 수 있습니다.

1
std::vector<int, MyPoolAllocator<int>> v;
2
v.push_back(1);   // pool에서 할당

이 글은 STL allocator concept과 기본 구현을 다룹니다.

#Allocator Concept (C++17 이전)

STL 컨테이너는 allocator concept을 따르는 객체를 사용합니다. C++17 이전의 형태는 이렇습니다.

1
template<typename T>
2
class MyAllocator {
3
public:
4
    using value_type = T;
5

6
    MyAllocator() noexcept = default;
7

8
    template<typename U>
9
    MyAllocator(const MyAllocator<U>&) noexcept {}
10

11
    T* allocate(std::size_t n) {
12
        // 메모리 할당 (n * sizeof(T) 바이트)
13
        return static_cast<T*>(::operator new(n * sizeof(T)));
14
    }
15

16
    void deallocate(T* p, std::size_t /*n*/) noexcept {
17
        ::operator delete(p);
18
    }
19
};
20

21
template<typename T, typename U>
22
bool operator==(const MyAllocator<T>&, const MyAllocator<U>&) { return true; }
23

24
template<typename T, typename U>
25
bool operator!=(const MyAllocator<T>&, const MyAllocator<U>&) { return false; }

핵심 요구사항은 이렇습니다.

value_type typedef를 제공합니다.
allocate(n)이 n * sizeof(T) 바이트를 반환합니다.
deallocate(p, n)으로 메모리를 돌려줍니다.
operator==, operator!=로 컨테이너끼리 비교가 가능합니다.

C++20에서는 concept으로 강제됩니다(std::allocator_traits).

#가장 단순한 예 — Pool Allocator

고정 크기 pool에서 할당하는 기본형입니다.

1
template<typename T, size_t N>
2
class PoolAllocator {
3
public:
4
    using value_type = T;
5

6
    PoolAllocator() noexcept = default;
7

8
    template<typename U>
9
    PoolAllocator(const PoolAllocator<U, N>&) noexcept {}
10

11
    T* allocate(std::size_t n) {
12
        if (n != 1) throw std::bad_alloc();   // 한 번에 1개만
13
        for (size_t i = 0; i < N; ++i) {
14
            if (!in_use_[i]) {
15
                in_use_.set(i);
16
                return reinterpret_cast<T*>(&storage_[sizeof(T) * i]);
17
            }
18
        }
19
        throw std::bad_alloc();
20
    }
21

22
    void deallocate(T* p, std::size_t /*n*/) noexcept {
23
        size_t i = (reinterpret_cast<std::byte*>(p) - storage_) / sizeof(T);
24
        if (i < N) in_use_.reset(i);
25
    }
26

27
private:
28
    static inline alignas(T) std::byte storage_[sizeof(T) * N]{};
29
    static inline std::bitset<N> in_use_{};
30
};

문제는 throw입니다. -fno-exceptions 환경에서는 다른 패턴이 필요합니다.

#No-exception allocator — abort 사용

-fno-exceptions에서는 throw 대신 abort 또는 null을 사용합니다.

1
template<typename T, size_t N>
2
class NoExceptPoolAllocator {
3
public:
4
    using value_type = T;
5

6
    T* allocate(std::size_t n) noexcept {
7
        if (n != 1) std::abort();
8
        for (size_t i = 0; i < N; ++i) {
9
            if (!in_use_[i]) {
10
                in_use_.set(i);
11
                return reinterpret_cast<T*>(&storage_[sizeof(T) * i]);
12
            }
13
        }
14
        std::abort();   // 또는 다른 fail 메커니즘
15
    }
16

17
    void deallocate(T* p, std::size_t) noexcept {
18
        size_t i = (reinterpret_cast<std::byte*>(p) - storage_) / sizeof(T);
19
        if (i < N) in_use_.reset(i);
20
    }
21
    // ...
22
};

표준 STL은 allocate가 throw하거나 정상 반환하는 것을 가정합니다. abort나 null을 쓰면 STL 호환이 깨지므로 ETL이나 직접 구현한 컨테이너를 권장합니다.

#C++17 — `std::pmr::polymorphic_allocator`

C++17이 polymorphic allocator를 도입하면서 런타임에 allocator를 바꿀 수 있게 됐습니다.

1
#include <memory_resource>
2

3
std::pmr::vector<int> v(&my_pool);
4
// 같은 std::pmr::vector<int> 타입이지만
5
// 런타임에 다른 pool 사용 가능

자세한 내용은 Part 3-04: std::pmr 활용.

#Stateful allocator

allocator가 pool 포인터나 arena 같은 상태를 가지는 경우입니다.

1
template<typename T>
2
class ArenaAllocator {
3
    Arena* arena_;
4
public:
5
    using value_type = T;
6

7
    explicit ArenaAllocator(Arena* arena) : arena_(arena) {}
8

9
    template<typename U>
10
    ArenaAllocator(const ArenaAllocator<U>& other) : arena_(other.arena()) {}
11

12
    Arena* arena() const { return arena_; }
13

14
    T* allocate(std::size_t n) {
15
        return static_cast<T*>(arena_->allocate(n * sizeof(T), alignof(T)));
16
    }
17

18
    void deallocate(T* p, std::size_t /*n*/) noexcept {
19
        // arena는 한 번에 해제 — 개별 deallocate 무의미
20
    }
21
};
22

23
template<typename T, typename U>
24
bool operator==(const ArenaAllocator<T>& a, const ArenaAllocator<U>& b) {
25
    return a.arena() == b.arena();
26
}

상태 있는 allocator는 컨테이너 간 비교가 의미를 가집니다. 같은 arena를 사용하는 두 vector만 동등합니다.

#Arena allocator — bump pointer

가장 단순한 stateful allocator입니다. 포인터를 증가시키며 할당하므로 개별 해제는 불가합니다.

1
class Arena {
2
    std::byte* base_;
3
    std::byte* current_;
4
    std::byte* end_;
5

6
public:
7
    Arena(std::byte* buffer, size_t size)
8
        : base_(buffer), current_(buffer), end_(buffer + size) {}
9

10
    void* allocate(size_t bytes, size_t alignment) {
11
        // align 맞추기
12
        auto* aligned = reinterpret_cast<std::byte*>(
13
            (reinterpret_cast<uintptr_t>(current_) + alignment - 1) & ~(alignment - 1));
14

15
        if (aligned + bytes > end_) return nullptr;   // 부족
16

17
        current_ = aligned + bytes;
18
        return aligned;
19
    }
20

21
    void reset() { current_ = base_; }   // 한 번에 모두 해제
22

23
    size_t used() const { return current_ - base_; }
24
};
25

26
std::array<std::byte, 4096> buffer;
27
Arena arena(buffer.data(), buffer.size());

포인터 산술만으로 끝나므로 할당이 매우 빠르고 fragmentation은 0입니다. 단점은 개별 해제가 불가하다는 점입니다. frame allocator나 transient 객체에 적합합니다.

#임베디드 — Static memory pool

전역 또는 .bss의 고정 메모리 영역을 pool로 활용합니다.

1
// 한 task의 transient allocation 용
2
template<typename T>
3
class TaskArenaAllocator {
4
    static inline std::array<std::byte, 4096> arena_storage_{};
5
    static inline Arena arena_{arena_storage_.data(), arena_storage_.size()};
6

7
public:
8
    using value_type = T;
9

10
    TaskArenaAllocator() = default;
11
    template<typename U> TaskArenaAllocator(const TaskArenaAllocator<U>&) {}
12

13
    T* allocate(std::size_t n) noexcept {
14
        auto* p = arena_.allocate(n * sizeof(T), alignof(T));
15
        if (!p) std::abort();
16
        return static_cast<T*>(p);
17
    }
18

19
    void deallocate(T*, std::size_t) noexcept {
20
        // no-op (arena가 reset으로 일괄 해제)
21
    }
22

23
    static void reset() { arena_.reset(); }
24
};
25

26
// 사용
27
void process_frame() {
28
    std::vector<int, TaskArenaAllocator<int>> v;
29
    v.push_back(1);   // arena에서
30
    v.push_back(2);
31
    // 함수 끝
32
    TaskArenaAllocator<int>::reset();   // 한 번에 해제
33
}

프레임 단위로 할당과 해제를 처리합니다. 매 프레임 시작 시점에 reset합니다.

#Allocator로 STL 컨테이너 사용

1
// 정수 vector — pool에서 할당
2
std::vector<int, PoolAllocator<int, 32>> v;
3
v.push_back(1);
4
v.push_back(2);
5
// v가 사라지면 pool 자리 회수
6

7
// map — pool에서
8
std::map<int, Order, std::less<>, PoolAllocator<std::pair<const int, Order>, 16>> m;
9
m[1] = Order{};
10

11
// string — pool에서
12
std::basic_string<char, std::char_traits<char>, PoolAllocator<char, 256>> s;
13
s = "hello";

STL 인터페이스를 그대로 쓰면서 메모리를 제어할 수 있습니다. 단점은 컨테이너 타입이 길어진다는 점입니다.

C++17의 std::pmr가 훨씬 깔끔합니다. 같은 타입(std::pmr::vector<int>)으로 두고 런타임에 분기합니다.

#C++20 allocator concept

std::allocator_traits가 모든 기본 정의를 제공합니다. 최소 구현은 이렇습니다.

1
template<typename T>
2
struct MinimalAllocator {
3
    using value_type = T;
4

5
    T* allocate(std::size_t n) { /* */ }
6
    void deallocate(T* p, std::size_t n) { /* */ }
7

8
    // 나머지는 allocator_traits가 default
9
};
10

11
// 사용
12
std::vector<int, MinimalAllocator<int>> v;

C++17 이전에는 수많은 typedef가 필요했지만 이제 value_type, allocate, deallocate 셋이면 충분합니다.

#자주 보는 함정과 안티패턴

#1. rebind 누락

1
std::list<int, MyAllocator<int>> l;
2
// list 내부에 ListNode<int> 할당 필요
3
// rebind로 MyAllocator<ListNode<int>> 만들어야

allocator_traits가 자동으로 rebind해 주므로 C++17 이후로는 보통 신경 쓰지 않아도 됩니다.

#2. allocator 비교 잘못

1
bool operator==(const MyAlloc&, const MyAlloc&) { return true; }   // 다른 pool도 같다고?

상태 있는 allocator는 상태 자체를 비교해야 합니다. 잘못된 비교는 컨테이너 move/swap을 망칩니다.

#3. deallocate에서 size 무시

1
void deallocate(T* p, size_t n) {
2
    free(p);   // n 무시 — array는 어떻게?
3
}

allocator에 따라 size가 필요합니다. pool은 무시해도 되지만 다른 경우엔 꼭 활용합니다.

#4. throw 사용

-fno-exceptions 환경에서 throw가 발생하면 abort로 떨어집니다. abort를 명시하거나 예외를 활성화합니다.

#5. thread safety 가정

multi-thread에서 같은 pool을 동시에 접근하면 race가 발생합니다. mutex나 thread-local pool을 씁니다.

#6. 복잡한 allocator

간단한 pool로 충분한데 generic allocator를 만드는 경우가 많습니다. 프로젝트 요구에 맞게 단순하게 유지합니다.

#측정 — Pool vs heap allocator

같은 std::vector<int>로 10000회 push_back을 비교합니다.

1
# heap (std::allocator)
2
allocation: 변동 (realloc 시점)
3
total time: 1.2 ms
4
fragmentation: 시간에 따라 증가
5

6
# pool (fixed size)
7
allocation: 일정 (pool slot 1개)
8
total time: 0.4 ms
9
fragmentation: 0

Pool이 약 3배 빠르고 결정적입니다. 임베디드 real-time에서 중요한 차이입니다.

#정리

Custom allocator는 STL의 메모리 출처를 제어하며 value_type, allocate, deallocate 세 가지만 구현하면 됩니다.
Stateful allocator는 pool/arena 포인터를 보유하므로 컨테이너 간 비교에 의미가 있습니다.
Arena allocator는 bump pointer 방식이라 개별 해제는 불가하지만 일괄 reset이 가능해 transient 객체에 적합합니다.
-fno-exceptions 환경에서는 throw 대신 abort를 사용하며 STL 표준 호환이 깨질 수 있습니다.
C++17 std::pmr이 훨씬 단순하며 다음 chapter에서 다룹니다.

#관련 항목

#다음 글

Part 3-03: Pool Allocator 구현 — 임베디드의 대표적 allocator로, 고정 크기 블록과 free list 관리를 다룹니다.

Embedded C++ for Real Systems · 21 of 41

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

범용 HAL 구조 — 벤더 종속성 격리, 다중 보드/MCU 지원, 시리즈 마무리.

2026년 5월 2일·cpp

Peripheral 추상화 — UART·SPI·I2C 공통 인터페이스 설계

UART, SPI, I2C — peripheral을 type-safe class로. Blocking, interrupt, DMA 패턴.

2026년 5월 2일·cpp

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

GPIO pin = type — 컴파일 타임에 핀 설정 검증, runtime 비용 0.

2026년 5월 2일·cpp

Custom Allocator 기초 — std::allocator 인터페이스 분석

#한 줄 요약

#어떤 문제를 푸는가

#Allocator Concept (C++17 이전)

#가장 단순한 예 — Pool Allocator

#No-exception allocator — abort 사용

#C++17 — `std::pmr::polymorphic_allocator`

#Stateful allocator

#Arena allocator — bump pointer

#임베디드 — Static memory pool

#Allocator로 STL 컨테이너 사용

#C++20 allocator concept

#자주 보는 함정과 안티패턴

#1. rebind 누락

#2. allocator 비교 잘못

#3. deallocate에서 size 무시

#4. throw 사용

#5. thread safety 가정

#6. 복잡한 allocator

#측정 — Pool vs heap allocator

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 21 of 41

관련 글

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

Peripheral 추상화 — UART·SPI·I2C 공통 인터페이스 설계

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

이 글을 참조하는 글 (3)

#한 줄 요약

#어떤 문제를 푸는가

#Allocator Concept (C++17 이전)

#가장 단순한 예 — Pool Allocator

#No-exception allocator — abort 사용

#C++17 — std::pmr::polymorphic_allocator

#Stateful allocator

#Arena allocator — bump pointer

#임베디드 — Static memory pool

#Allocator로 STL 컨테이너 사용

#C++20 allocator concept

#자주 보는 함정과 안티패턴

#1. rebind 누락

#2. allocator 비교 잘못

#3. deallocate에서 size 무시

#4. throw 사용

#5. thread safety 가정

#6. 복잡한 allocator

#측정 — Pool vs heap allocator

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 21 of 41

관련 글

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

Peripheral 추상화 — UART·SPI·I2C 공통 인터페이스 설계

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

이 글을 참조하는 글 (3)

#C++17 — `std::pmr::polymorphic_allocator`