RTOS Mutex 활용 — Recursive·Priority Inheritance 적용

1
SemaphoreHandle_t spi_mutex;
2

3
void spi_xfer_safe(const uint8_t *tx, uint8_t *rx, size_t n) {
4
    if (xSemaphoreTake(spi_mutex, pdMS_TO_TICKS(100)) != pdTRUE) {
5
        log_err("spi busy");
6
        return;
7
    }
8
    spi_xfer(tx, rx, n);
9
    xSemaphoreGive(spi_mutex);
10
}
11

12
int main(void) {
13
    spi_mutex = xSemaphoreCreateMutex();
14
}

1
class mutex_guard {
2
public:
3
    explicit mutex_guard(SemaphoreHandle_t m) : m_(m) {
4
        xSemaphoreTake(m_, portMAX_DELAY);
5
    }
6
    ~mutex_guard() { xSemaphoreGive(m_); }
7
private:
8
    SemaphoreHandle_t m_;
9
};
10

11
void do_spi(void) {
12
    mutex_guard g(spi_mutex);
13
    spi_write(buf, len);
14
    /* return 또는 exception 어디서든 자동 release */
15
}

1
static StaticSemaphore_t spi_mutex_buf;
2
SemaphoreHandle_t spi_mutex;
3

4
void init(void) {
5
    spi_mutex = xSemaphoreCreateMutexStatic(&spi_mutex_buf);
6
}

1
SemaphoreHandle_t log_mtx;
2

3
void log_line(const char *s);
4
void log_with_prefix(const char *p, const char *s) {
5
    xSemaphoreTakeRecursive(log_mtx, portMAX_DELAY);
6
    write_raw(p);
7
    log_line(s);    /* 내부에서 또 take */
8
    xSemaphoreGiveRecursive(log_mtx);
9
}
10

11
void log_line(const char *s) {
12
    xSemaphoreTakeRecursive(log_mtx, portMAX_DELAY);
13
    write_raw(s);
14
    xSemaphoreGiveRecursive(log_mtx);
15
}
16

17
int main(void) {
18
    log_mtx = xSemaphoreCreateRecursiveMutex();
19
}

1
void task_low(void *arg) {       /* priority 1 */
2
    for (;;) {
3
        xSemaphoreTake(m, portMAX_DELAY);
4
        busy_work(50);            /* High가 들어오면 PI로 priority 5 boost */
5
        xSemaphoreGive(m);
6
        vTaskDelay(pdMS_TO_TICKS(10));
7
    }
8
}
9

10
void task_med(void *arg) {       /* priority 3 */
11
    for (;;) {
12
        busy_work(100);           /* PI 없으면 Low를 영원히 preempt */
13
        vTaskDelay(pdMS_TO_TICKS(1));
14
    }
15
}
16

17
void task_high(void *arg) {      /* priority 5 */
18
    for (;;) {
19
        xSemaphoreTake(m, portMAX_DELAY);
20
        do_critical();
21
        xSemaphoreGive(m);
22
    }
23
}

1
if (xSemaphoreTake(m, pdMS_TO_TICKS(200)) != pdTRUE) {
2
    log_err("possible deadlock");
3
    /* recovery — abort transaction */
4
    return ERR_BUSY;
5
}

1
/* 항상 address 오름차순으로 lock */
2
void transfer(account_t *a, account_t *b, int amount) {
3
    account_t *first  = (a < b) ? a : b;
4
    account_t *second = (a < b) ? b : a;
5
    xSemaphoreTake(first->mtx,  portMAX_DELAY);
6
    xSemaphoreTake(second->mtx, portMAX_DELAY);
7
    /* ... */
8
    xSemaphoreGive(second->mtx);
9
    xSemaphoreGive(first->mtx);
10
}

1
연산                             시간 (Cortex-M4 72 MHz)
2
mutex take (uncontended)         0.9 µs
3
mutex give (no waiter)           0.7 µs
4
mutex take (PI boost 발생)       3.1 µs
5
recursive take                   1.1 µs
6
mutex contended → 다음 깨움      6.4 µs

1
PI on vs off (Mars Pathfinder 재현, Med busy_work 100 ms)
2
PI on              High wait  = 50 ms
3
PI off             High wait  = 영구 굶음

1
void IRQ(void) {
2
    xSemaphoreTakeFromISR(m, ...);   /* 존재하지 않음 */
3
}

1
/* task A가 take, task B가 give */
2
xSemaphoreGive(spi_mutex);   /* error 반환 — 풀리지 않음 */

1
xSemaphoreTake(m, ...);
2
printf_to_uart(big);    /* 수십 ms */
3
xSemaphoreGive(m);

1
SemaphoreHandle_t m = xSemaphoreCreateRecursiveMutex();   /* 무조건 recursive */

1
xSemaphoreTake(m, portMAX_DELAY);   /* 모든 곳에서 무한 대기 */