Embedded C++ for Real Systems · 30/41

ETL 라이브러리 분석 — Embedded Template Library의 STL 대체

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

cpp embedded etl library stl-alternative fsm

#한 줄 요약

“ETL은 STL의 임베디드 친화 대체입니다.” 모든 컨테이너가 고정 크기이고 heap을 쓰지 않으며, FSM과 message router와 factory도 함께 제공합니다.

#어떤 문제를 푸는가

C++ STL은 대부분 heap을 사용하지만, 임베디드에서는 heap을 회피해야 합니다. ETL은 STL과 비슷한 인터페이스를 fixed-size + zero heap으로 제공합니다.

1
#include <etl/vector.h>
2

3
etl::vector<int, 32> v;   // 최대 32개
4
v.push_back(1);
5
if (v.full()) { /* */ }

추가로 다음을 제공합니다.

Fixed-size FSM
Fixed-size message router
etl::delegate (std::function 대체)
etl::observer (Observer 패턴)
etl::string (fixed-size)

홈은 etlcpp.com이며 MIT 라이선스의 header-only 라이브러리입니다.

#기본 컨테이너

#`etl::vector<T, N>`

1
#include <etl/vector.h>
2

3
etl::vector<int, 32> v;
4

5
v.push_back(1);
6
v.push_back(2);
7

8
for (auto x : v) { /* */ }
9

10
if (v.full()) { /* 32 도달 */ }
11
if (v.empty()) { /* */ }
12

13
v.erase(v.begin());
14
v.clear();

내부적으로는 T storage[N]과 size만 갖고 있어 heap을 쓰지 않습니다.

#`etl::string<N>`

1
#include <etl/string.h>
2

3
etl::string<64> s = "hello";
4
s += " world";
5

6
if (s.size() > 64) { /* truncated */ }
7

8
const char* cstr = s.c_str();

고정 크기 char array이며 길이가 초과되면 잘립니다.

#`etl::list<T, N>`

1
#include <etl/list.h>
2

3
etl::list<Order, 16> orders;
4

5
orders.push_back(o);
6
orders.pop_front();
7

8
for (auto& o : orders) { /* */ }

doubly linked list이며 고정 크기 pool을 내부에 두므로 heap을 쓰지 않습니다.

#`etl::map<K, V, N>`

1
#include <etl/map.h>
2

3
etl::map<int, Order, 16> m;
4
m.insert({1, Order{}});
5
m[5] = Order{};
6

7
auto it = m.find(1);
8
if (it != m.end()) { /* */ }

RB-tree 기반이며 노드 pool도 고정 크기입니다.

#`etl::queue<T, N>`

1
#include <etl/queue.h>
2

3
etl::queue<int, 8> q;
4
q.push(1);
5
int v = q.front();
6
q.pop();

ring buffer 기반입니다.

#etl::delegate — std::function 대체

std::function은 내부에서 heap을 쓸 수 있지만, etl::delegate는 fixed-size입니다.

1
#include <etl/delegate.h>
2

3
class Handler {
4
public:
5
    void on_event(int e) { /* */ }
6
};
7

8
Handler h;
9

10
etl::delegate<void(int)> d;
11
d = etl::delegate<void(int)>::create<Handler, &Handler::on_event>(h);
12

13
d(42);   // h.on_event(42) 호출

크기는 object와 method 두 pointer만큼이며 heap을 쓰지 않습니다.

함수와 lambda도 받을 수 있습니다.

1
auto d1 = etl::delegate<int(int, int)>::create<add_function>();
2
auto d2 = etl::delegate<void()>::create<&Class::static_method>();

#etl::observer — Observer 패턴

1
#include <etl/observer.h>
2

3
struct TempEvent { float celsius; };
4

5
class TempObserver : public etl::observer<TempEvent> {
6
public:
7
    void notification(TempEvent e) override {
8
        if (e.celsius > 80) alarm();
9
    }
10
};
11

12
class TempSensor : public etl::observable<TempObserver, 4> {   // 최대 4 observer
13
public:
14
    void update() {
15
        notify_observers(TempEvent{read_temperature()});
16
    }
17
};
18

19
TempSensor sensor;
20
TempObserver obs;
21
sensor.add_observer(obs);
22

23
sensor.update();   // obs.notification 호출

heap 없는 pub/sub이며 최대 observer 수가 고정되어 있습니다.

#etl::fsm — Finite State Machine

ETL의 대표 기능으로 fixed-size FSM을 제공합니다.

1
#include <etl/fsm.h>
2

3
// Event 정의
4
struct events {
5
    enum {
6
        start,
7
        stop,
8
        error,
9
    };
10
};
11

12
class StartEvent : public etl::message<events::start> {};
13
class StopEvent : public etl::message<events::stop> {};
14

15
// State 정의
16
enum class StateId : etl::fsm_state_id_t {
17
    idle,
18
    running,
19
    error,
20
};
21

22
class MyFsm : public etl::fsm {
23
public:
24
    MyFsm() : fsm(0) {}
25
};
26

27
class IdleState : public etl::fsm_state<MyFsm, IdleState, (etl::fsm_state_id_t)StateId::idle,
28
                                          StartEvent> {
29
public:
30
    etl::fsm_state_id_t on_event(const StartEvent&) {
31
        log("starting");
32
        return (etl::fsm_state_id_t)StateId::running;
33
    }
34

35
    etl::fsm_state_id_t on_event_unknown(const etl::imessage&) {
36
        return STATE_ID;   // 무시
37
    }
38
};
39

40
class RunningState : public etl::fsm_state<MyFsm, RunningState, (etl::fsm_state_id_t)StateId::running,
41
                                            StopEvent> {
42
public:
43
    etl::fsm_state_id_t on_event(const StopEvent&) {
44
        log("stopping");
45
        return (etl::fsm_state_id_t)StateId::idle;
46
    }
47
    // ...
48
};
49

50
// 사용
51
IdleState idle;
52
RunningState running;
53
etl::ifsm_state* states[] = {&idle, &running};
54

55
MyFsm fsm;
56
fsm.set_states(states, etl::size(states));
57
fsm.start();
58

59
fsm.receive(StartEvent{});   // idle → running
60
fsm.receive(StopEvent{});    // running → idle

heap을 쓰지 않고, type-safe event dispatch가 가능하며, 상태 전이가 명확합니다.

자세한 FSM 패턴은 Part 4-06에서 다룹니다.

#etl::message_router — Type-safe routing

1
#include <etl/message_router.h>
2

3
struct TempMessage : public etl::message<1> { float celsius; };
4
struct PressureMessage : public etl::message<2> { float kpa; };
5

6
class SensorRouter : public etl::message_router<SensorRouter,
7
                                                  TempMessage,
8
                                                  PressureMessage> {
9
public:
10
    void on_receive(const TempMessage& m) {
11
        log_temp(m.celsius);
12
    }
13

14
    void on_receive(const PressureMessage& m) {
15
        log_pressure(m.kpa);
16
    }
17

18
    void on_receive_unknown(const etl::imessage&) {
19
        // 무시
20
    }
21
};
22

23
SensorRouter router;
24
router.receive(TempMessage{25.0f});
25
router.receive(PressureMessage{101.3f});

message type별 dispatch가 컴파일 타임에 결정되며 RTTI를 쓰지 않습니다.

#etl::array vs std::array

ETL은 etl::array도 제공합니다. 차이는 주로 예외 환경에서 드러납니다.

1
etl::array<int, 8> a = {1, 2, 3};
2
// std::array와 거의 동일 API
3
// 단 -fno-exceptions에서 .at() 동작이 차이

대부분의 경우 std::array로 충분합니다.

#etl::optional

1
#include <etl/optional.h>
2

3
etl::optional<int> x;
4
if (x) { /* */ }
5
x = 42;
6
*x = 10;

C++17 이전 환경에서 std::optional의 대체로 쓰며, C++17 이상에서는 표준을 사용합니다.

#설정 매크로

ETL은 컴파일러와 플랫폼 설정이 필요합니다.

1
#define ETL_NO_STL                        // STL 의존 끔
2
#define ETL_NO_LARGE_CHAR_SUPPORT
3
#define ETL_LOG_ERRORS                    // 로깅
4
#define ETL_VERBOSE_ERRORS                // 상세 에러
5
#define ETL_DEBUG_COUNT                   // 디버깅 통계

1
// 또는 컴파일러 플래그
2
CXXFLAGS += -DETL_NO_STL -DETL_LOG_ERRORS

#에러 처리

ETL은 예외 또는 abort를 선택할 수 있습니다.

1
// 예외 모드 (기본)
2
etl::vector<int, 4> v;
3
v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4);
4
v.push_back(5);   // throws etl::vector_full
5

6
// no-exception 모드
7
#define ETL_NO_EXCEPTIONS
8

9
// → push_back에 5번째는 그냥 *무시* 또는 ETL_ASSERT trigger

ETL_ASSERT 매크로를 정의해 fail 동작을 직접 통제할 수 있습니다.

1
#define ETL_ASSERT(condition, error) \
2
    if (!(condition)) { fatal_error(error.what()); }

#측정 — ETL vs STL

같은 코드를 STL과 ETL로 비교한 결과입니다 (STM32F4).

1
std::vector<int> + 16 elements:
2
  .text:  6.2 KB (vector + heap)
3
  .heap usage: ~64 B
4
  alloc cost: 변동 (realloc 가능)
5

6
etl::vector<int, 16>:
7
  .text:  0.4 KB (간단한 wrapper)
8
  .heap usage: 0
9
  alloc cost: 0 (compile-time fixed)

코드 크기가 15배 작고 heap도 쓰지 않습니다.

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

#1. fixed-size 초과

1
etl::vector<int, 4> v;
2
for (int i = 0; i < 10; ++i) v.push_back(i);   // 4 이후 fail

full()을 먼저 체크하거나 capacity를 늘립니다.

#2. STL과 혼용

1
std::vector<etl::string<32>> v;   // STL vector는 heap

완전히 ETL을 쓰거나, STL이 허용되는 환경에서만 섞습니다.

#3. exception 가정

ETL은 기본적으로 exception을 던집니다. -fno-exceptions 환경에서는 abort합니다. 이때는 ETL_NO_EXCEPTIONS를 정의합니다.

#4. 큰 N으로 .bss 폭증

1
etl::vector<HugeStruct, 1000> v;

sizeof(HugeStruct) * 1000이 그대로 .bss에 잡힙니다. 측정 후 적정 N을 선택합니다.

#5. Boost.Intrusive와 비교하지 않음

ETL은 가볍고 Boost는 더 강력합니다. 프로젝트의 요구에 맞게 선택합니다.

#6. Header-only 의존

ETL은 header-only라서 컴파일 시간이 늘어납니다. PCH를 활용합니다.

#ETL의 장점 vs 단점

장점	단점
Heap 0	API가 STL과 일부 다름
인증 친화 (MISRA 가까움)	C++11/14 위주 (C++20 일부)
Header-only	컴파일 시간
Fixed-size 명시	동적 크기 불가
FSM, router 포함	학습 곡선
Active maintenance	Boost만큼 풍부하진 않음

#정리

ETL은 임베디드용 STL 대체 라이브러리로, 모두 fixed-size이며 heap을 쓰지 않습니다.
기본 컨테이너로 etl::vector, etl::string, etl::list, etl::map, etl::queue를 제공합니다.
특수 도구로 etl::delegate(std::function 대체), etl::observer, etl::fsm, etl::message_router가 있습니다.
-fno-exceptions 환경에서는 ETL_NO_EXCEPTIONS 매크로를 정의합니다.
측정 가능한 fixed-size이므로 .bss 영향을 추적할 수 있습니다.
MIT 라이선스이며 header-only로 배포됩니다.

#관련 항목

#다음 글

Part 4-03: Lock-free 기초 — mutex 없이 동시성. atomic, CAS, memory order.

Embedded C++ for Real Systems · 31 of 41

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

타입 안전한 상태 머신 — enum + switch부터 std::variant, etl::fsm까지.

2026년 5월 1일·cpp

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

constexpr state machine — 컴파일 타임에 전이 검증, runtime 코드 0.

2026년 5월 1일·cpp

동적 할당 없는 임베디드 C++ — placement new·정적 객체·풀

임베디드의 첫 번째 원칙 — new/malloc 없이 modern C++의 STL 같은 컨테이너 활용.

2026년 4월 30일·cpp

ETL 라이브러리 분석 — Embedded Template Library의 STL 대체

#한 줄 요약

#어떤 문제를 푸는가

#기본 컨테이너

#`etl::vector<T, N>`

#`etl::string<N>`

#`etl::list<T, N>`

#`etl::map<K, V, N>`

#`etl::queue<T, N>`

#etl::delegate — std::function 대체

#etl::observer — Observer 패턴

#etl::fsm — Finite State Machine

#etl::message_router — Type-safe routing

#etl::array vs std::array

#etl::optional

#설정 매크로

#에러 처리

#측정 — ETL vs STL

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

#1. fixed-size 초과

#2. STL과 혼용

#3. exception 가정

#4. 큰 N으로 .bss 폭증

#5. Boost.Intrusive와 비교하지 않음

#6. Header-only 의존

#ETL의 장점 vs 단점

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 31 of 41

관련 글

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

동적 할당 없는 임베디드 C++ — placement new·정적 객체·풀

이 글을 참조하는 글 (7)

#한 줄 요약

#어떤 문제를 푸는가

#기본 컨테이너

#etl::vector<T, N>

#etl::string<N>

#etl::list<T, N>

#etl::map<K, V, N>

#etl::queue<T, N>

#etl::delegate — std::function 대체

#etl::observer — Observer 패턴

#etl::fsm — Finite State Machine

#etl::message_router — Type-safe routing

#etl::array vs std::array

#etl::optional

#설정 매크로

#에러 처리

#측정 — ETL vs STL

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

#1. fixed-size 초과

#2. STL과 혼용

#3. exception 가정

#4. 큰 N으로 .bss 폭증

#5. Boost.Intrusive와 비교하지 않음

#6. Header-only 의존

#ETL의 장점 vs 단점

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 31 of 41

관련 글

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

동적 할당 없는 임베디드 C++ — placement new·정적 객체·풀

이 글을 참조하는 글 (7)

#`etl::vector<T, N>`

#`etl::string<N>`

#`etl::list<T, N>`

#`etl::map<K, V, N>`

#`etl::queue<T, N>`