std::pmr 임베디드 활용 — Polymorphic Memory Resource 분석

1
std::vector<int, PoolAllocator<int, 16>> v1;     // pool 16
2
std::vector<int, PoolAllocator<int, 32>> v2;     // pool 32 — 다른 타입
3
// v1과 v2는 *다른 타입* — 호환 안 됨

1
std::pmr::vector<int> v1(&pool1);     // pool1에서
2
std::pmr::vector<int> v2(&pool2);     // pool2에서
3
// v1과 v2는 *같은 타입* — 호환
4

5
void process(std::pmr::vector<int>& v) {
6
    // 어떤 pool 위 vector든 받음
7
}

1
class memory_resource {
2
public:
3
    virtual ~memory_resource() = default;
4

5
    void* allocate(size_t bytes, size_t alignment) {
6
        return do_allocate(bytes, alignment);
7
    }
8

9
    void deallocate(void* p, size_t bytes, size_t alignment) {
10
        do_deallocate(p, bytes, alignment);
11
    }
12

13
    bool is_equal(const memory_resource& other) const {
14
        return do_is_equal(other);
15
    }
16

17
protected:
18
    virtual void* do_allocate(size_t, size_t) = 0;
19
    virtual void do_deallocate(void*, size_t, size_t) = 0;
20
    virtual bool do_is_equal(const memory_resource&) const noexcept = 0;
21
};

1
auto* mr = std::pmr::new_delete_resource();
2
std::pmr::vector<int> v(mr);   // heap에서

1
auto* mr = std::pmr::null_memory_resource();
2
std::pmr::vector<int> v(mr);
3
v.push_back(1);   // throws std::bad_alloc

1
std::array<std::byte, 4096> buffer;
2
std::pmr::monotonic_buffer_resource mr(buffer.data(), buffer.size());
3

4
std::pmr::vector<int> v(&mr);
5
v.reserve(100);
6
for (int i = 0; i < 100; ++i) v.push_back(i);
7
// 모든 메모리는 stack buffer에서
8
// mr 소멸 또는 release() 호출 시 일괄 reset

1
// 전역 static buffer
2
constexpr size_t kPoolSize = 8192;
3
alignas(std::max_align_t) std::byte g_pool_buffer[kPoolSize];
4
std::pmr::monotonic_buffer_resource g_pool(g_pool_buffer, kPoolSize);
5

6
void process_request() {
7
    std::pmr::vector<Order> orders(&g_pool);
8
    orders.reserve(10);
9

10
    for (auto& req : input_requests) {
11
        orders.push_back(Order{req});
12
    }
13

14
    process_orders(orders);
15

16
    // 함수 끝 — orders는 소멸하지만 buffer는 안 비워짐
17
    // 다음 호출에 release 또는 reset 필요
18
}
19

20
void reset_pool() {
21
    g_pool.release();   // 또는 buffer 재할당
22
}

1
std::pmr::pool_options opts{
2
    .max_blocks_per_chunk = 16,
3
    .largest_required_pool_block = 256
4
};
5

6
std::pmr::unsynchronized_pool_resource pool(opts);
7
std::pmr::vector<int> v(&pool);

1
class PoolMemoryResource : public std::pmr::memory_resource {
2
    Pool* pool_;
3

4
public:
5
    explicit PoolMemoryResource(Pool* pool) : pool_(pool) {}
6

7
protected:
8
    void* do_allocate(size_t bytes, size_t alignment) override {
9
        return pool_->allocate(bytes, alignment);
10
    }
11

12
    void do_deallocate(void* p, size_t /*bytes*/, size_t /*align*/) override {
13
        pool_->deallocate(p);
14
    }
15

16
    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
17
        auto* o = dynamic_cast<const PoolMemoryResource*>(&other);
18
        return o && o->pool_ == pool_;
19
    }
20
};
21

22
// 사용
23
Pool my_pool;
24
PoolMemoryResource mr(&my_pool);
25

26
std::pmr::vector<int> v(&mr);

1
class PoolMemoryResource : public std::pmr::memory_resource {
2
    Pool* pool_;
3
    static inline int s_type_id;   // unique tag
4

5
public:
6
    static const void* type_id() { return &s_type_id; }
7

8
    explicit PoolMemoryResource(Pool* pool) : pool_(pool) {}
9

10
    virtual const void* get_type_id() const { return &s_type_id; }
11

12
protected:
13
    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
14
        auto* o = static_cast<const PoolMemoryResource*>(&other);
15
        if (o->get_type_id() != &s_type_id) return false;
16
        return o->pool_ == pool_;
17
    }
18
};

1
// 어떤 pmr vector든 받음
2
void process(std::pmr::vector<int>& v) {
3
    v.push_back(1);
4
}
5

6
std::pmr::vector<int> v1(&pool1);
7
std::pmr::vector<int> v2(&pool2);
8

9
process(v1);   // OK
10
process(v2);   // OK — 같은 함수, 다른 메모리

1
template<typename Alloc>
2
void process(std::vector<int, Alloc>& v) {   // 매 호출마다 인스턴스화
3
    v.push_back(1);
4
}

1
constexpr size_t kFrameBufferSize = 16 * 1024;
2
alignas(std::max_align_t) static std::byte frame_buffer[kFrameBufferSize];
3
static std::pmr::monotonic_buffer_resource frame_pool(
4
    frame_buffer, kFrameBufferSize);
5

6
void process_frame() {
7
    // 매 frame 시작 시 reset
8
    frame_pool.release();
9

10
    std::pmr::vector<Object> objects(&frame_pool);
11
    std::pmr::string log_buffer(&frame_pool);
12

13
    // 처리
14
    for (auto& obj : input) {
15
        objects.push_back(process_one(obj));
16
        log_buffer += format_log(obj);
17
    }
18

19
    // 함수 끝 — 객체들이 소멸하지만 메모리는 reset에서 회수
20
}

1
std::pmr::vector<T>
2
std::pmr::string
3
std::pmr::list<T>
4
std::pmr::map<K, V>
5
std::pmr::set<T>
6
std::pmr::unordered_map<K, V>
7
std::pmr::unordered_set<T>
8
std::pmr::deque<T>

1
std::pmr::vector<int> v;   // default resource = heap

1
void process() {
2
    std::pmr::vector<int> v(&pool);
3
    v.push_back(1);
4
    // 함수 끝 — v 소멸, 그러나 pool 메모리는 안 비워짐
5
}
6
// pool이 계속 차오름

1
std::pmr::vector<int>* make() {
2
    std::pmr::monotonic_buffer_resource pool(...);   // local
3
    return new std::pmr::vector<int>(&pool);   // pool 소멸 → dangling
4
}

1
void do_deallocate(void* p, size_t, size_t) {
2
    free(p);   // bytes 무시 — pool은 어떻게 알지?
3
}

1
# std::vector<int, MyAlloc> (3 allocator 인스턴스)
2
.text       : +2.4 KB  (3개 vector specialization)
3
runtime alloc: 직접 호출, ~10 cycles
4

5
# std::pmr::vector<int> (3 resource)
6
.text       : +0.8 KB  (한 vector specialization)
7
runtime alloc: virtual 호출, ~15 cycles