Modern Embedded Recipes · 66/152

RTOS Semaphore 활용 — Binary·Counting·ISR Give

2026년 4월 15일 · Hawk · 4분 읽기

#한 줄 요약

“Semaphore는 count를 가진 신호입니다.” Binary는 0/1 한 비트, counting은 N개의 자원을 한 줄로 관리합니다. Mutex와 달리 owner가 없어서 ISR이 자유롭게 give 할 수 있습니다.

#어떤 상황에서 쓰나

ADC 변환이 끝났음을 task에 알리고 싶을 때, EXTI button 한 번 눌렸음을 task에 전달할 때, UART RX FIFO에 byte가 들어왔음을 신호할 때처럼 ISR에서 task로 가는 흐름에 가장 자주 등장합니다. Mutex는 task와 task 사이인 데 반해, semaphore는 한쪽 방향 신호이기 때문에 ISR에서도 자연스럽게 쓸 수 있습니다.

또 하나는 동시에 N개만 허용하는 자원 풀입니다. DMA channel 4개, BLE connection slot 6개처럼 갯수가 정해진 자원은 counting semaphore가 가장 단순한 답입니다.

#핵심 개념

종류	값	용도
Binary semaphore	0 또는 1	ISR 신호
Counting semaphore	0 ~ N	자원 풀
Mutex	0 또는 1 + owner	mutual exclusion

Semaphore의 두 가지 핵심 동작입니다.

1
take    count > 0이면 count--, 아니면 block (timeout 가능)
2
give    count++, wait중인 task가 있으면 가장 높은 priority를 깨움

Mutex와 달리 어떤 task든 give 할 수 있고, ISR에서도 *FromISR 변종으로 give 할 수 있습니다. 대신 priority inheritance가 없어 long hold가 우선순위 역전을 일으킵니다.

#코드 / 실제 사용 예

#Binary semaphore — ISR signaling

1
SemaphoreHandle_t adc_done;
2

3
void ADC_IRQHandler(void) {
4
    ADC1->SR &= ~ADC_SR_EOC;
5
    BaseType_t hp = pdFALSE;
6
    xSemaphoreGiveFromISR(adc_done, &hp);
7
    portYIELD_FROM_ISR(hp);
8
}
9

10
void task_processor(void *arg) {
11
    for (;;) {
12
        if (xSemaphoreTake(adc_done, pdMS_TO_TICKS(100)) == pdTRUE) {
13
            process_samples();
14
        } else {
15
            log_warn("ADC timeout");
16
        }
17
    }
18
}
19

20
int main(void) {
21
    adc_done = xSemaphoreCreateBinary();
22
    /* ... */
23
}

ISR에서 한 줄, task에서 한 줄이면 polling이 사라집니다. CPU usage가 0%에 가깝게 떨어지고 latency도 한 자릿수 µs입니다.

#Counting semaphore — resource pool

1
SemaphoreHandle_t dma_slots;    /* DMA channel 4개 */
2

3
void task_xfer(void *arg) {
4
    for (;;) {
5
        xSemaphoreTake(dma_slots, portMAX_DELAY);     /* 빈 channel 대기 */
6
        int ch = alloc_dma_channel();
7
        start_transfer(ch);
8
        wait_complete(ch);
9
        free_dma_channel(ch);
10
        xSemaphoreGive(dma_slots);
11
    }
12
}
13

14
int main(void) {
15
    dma_slots = xSemaphoreCreateCounting(4, 4);    /* max=4, initial=4 */
16
}

자원이 모두 사용 중이면 take에서 block 합니다. 자원이 풀리는 순간 가장 높은 priority의 대기 task부터 깨워줍니다.

#Counting semaphore — event count

1
SemaphoreHandle_t pkt_count;
2

3
void RADIO_IRQHandler(void) {
4
    BaseType_t hp = pdFALSE;
5
    for (int n = pending_packets(); n > 0; n--)
6
        xSemaphoreGiveFromISR(pkt_count, &hp);
7
    portYIELD_FROM_ISR(hp);
8
}
9

10
void task_parser(void *arg) {
11
    for (;;) {
12
        xSemaphoreTake(pkt_count, portMAX_DELAY);   /* packet 1개 처리 */
13
        parse_one();
14
    }
15
}
16

17
int main(void) {
18
    pkt_count = xSemaphoreCreateCounting(64, 0);   /* max=64, initial=0 */
19
}

ISR이 몇 개 들어왔는지 count에 누적해두면 task가 놓치지 않고 처리할 수 있습니다. Binary 한 비트로는 이런 누적이 불가능합니다.

#Notification — 더 가벼운 대안

1
TaskHandle_t target;
2

3
void EXTI_IRQHandler(void) {
4
    BaseType_t hp = pdFALSE;
5
    vTaskNotifyGiveFromISR(target, &hp);
6
    portYIELD_FROM_ISR(hp);
7
}
8

9
void task_btn(void *arg) {
10
    target = xTaskGetCurrentTaskHandle();
11
    for (;;) {
12
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
13
        handle_button();
14
    }
15
}

Target task가 정확히 하나일 때는 task notification이 semaphore보다 빠르고 RAM도 적게 씁니다. 4 byte 정도 절약됩니다.

#Synchronization barrier

1
SemaphoreHandle_t s1, s2;     /* 둘 다 binary */
2

3
void task_a(void *arg) {
4
    for (;;) {
5
        do_part_a();
6
        xSemaphoreGive(s1);
7
        xSemaphoreTake(s2, portMAX_DELAY);
8
    }
9
}
10

11
void task_b(void *arg) {
12
    for (;;) {
13
        xSemaphoreTake(s1, portMAX_DELAY);
14
        do_part_b();
15
        xSemaphoreGive(s2);
16
    }
17
}

두 task가 매 cycle 만나도록 하는 단순한 rendezvous입니다. Event group을 쓰면 더 깔끔하지만, 2-way라면 semaphore 두 개로 충분합니다.

#Static semaphore

1
static StaticSemaphore_t sem_buf;
2
SemaphoreHandle_t s;
3

4
void init(void) {
5
    s = xSemaphoreCreateBinaryStatic(&sem_buf);   /* heap 사용 0 */
6
}

양산 firmware에서는 가급적 *Static 변종을 써서 heap fragmentation을 원천 차단합니다.

#측정 / 성능 비교

Cortex-M4 72 MHz에서 측정한 latency입니다.

1
패턴                              latency
2
ISR → semaphore give → task wake   5.8 µs
3
ISR → task notification → wake     3.2 µs
4
mutex take/give (uncontended)      0.9 µs
5
counting semaphore take (count>0)  1.1 µs

Notification이 semaphore보다 약 두 배 빠릅니다. 1

신호라면 거의 항상 notification이 더 낫습니다.

RAM 사용량:

종류	크기
binary semaphore (dynamic)	80 B
binary semaphore (static)	80 B (heap 0)
task notification	4 B (TCB 내장)

자원이 빠듯한 MCU에서는 notification으로 모아 두면 RAM이 분명히 줄어듭니다.

#자주 보는 함정

ISR에서 Take 호출

1
void IRQ(void) {
2
    xSemaphoreTakeFromISR(s, &hp);   /* 안 됨 */
3
}

ISR은 block 할 수 없으니 take는 의미가 없습니다. ISR에서는 give만 합니다.

*FromISR 변종을 빼먹음

1
void IRQ(void) {
2
    xSemaphoreGive(s);    /* 보통 crash 또는 race */
3
}

ISR 전용 API를 안 쓰면 internal critical section이 어긋납니다. 컴파일 에러가 안 나니 주의해야 합니다.

Counting semaphore의 초기값을 max로

1
xSemaphoreCreateCounting(64, 64);   /* 모든 packet을 받았다고 거짓 신호 */

event count 용도라면 initial은 0이어야 합니다. Resource pool 용도라면 max와 같게 둡니다.

Semaphore로 mutual exclusion

1
xSemaphoreCreateBinary();   /* mutex 대신 사용 */

Owner가 없으니 priority inheritance가 없습니다. SPI bus 같은 자원 보호에는 mutex를 써야 합니다.

Stale signal

1
xSemaphoreGive(s);
2
xSemaphoreGive(s);   /* binary는 두 번째가 무시됨 */

Binary semaphore는 count가 0 또는 1이므로 두 번 give 해도 1로 유지됩니다. 이벤트가 누적되어야 하면 counting을 씁니다.

#정리

Semaphore는 count 있는 신호로, ISR이 자유롭게 give 할 수 있습니다.
Binary는 1
신호, counting은 자원 풀과 event count에 씁니다.
*FromISR을 항상 ISR에서 사용하고, portYIELD_FROM_ISR을 잊지 않습니다.
1
신호는 task notification이 더 빠르고 가볍습니다.
Mutual exclusion에는 semaphore가 아니라 mutex를 쓰는 것이 안전합니다.
양산은 *Static 변종으로 heap을 0으로 만듭니다.

다음 편은 Mutex 활용입니다. Priority inheritance와 recursive lock을 다룹니다.

#관련 항목

이 글을 참조하는 글 (1)

RTOS Event Group 활용 — Bit Wait·Sync·Notify— Modern Embedded Recipes