rt 0.17.0

A real-time operating system capable of full preemption
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include <rt/cond.h>

#include <rt/atomic.h>
#include <rt/mutex.h>
#include <rt/syscall.h>
#include <rt/task.h>
#include <rt/tick.h>
#include <rt/trace.h>

#include <limits.h>

void rt_cond_signal(struct rt_cond *cond)
{
    rt_sem_post(&cond->sem);
}

void rt_cond_broadcast(struct rt_cond *cond)
{
    rt_sem_post_n(&cond->sem, INT_MAX);
}

void rt_cond_wait(struct rt_cond *cond, struct rt_mutex *mutex)
{
    /* Decrement the semaphore while still holding the mutex so that
     * signals from higher priority tasks on the same monitor can see
     * there is a waiter. */
    const int value =
        rt_atomic_fetch_sub(&cond->sem.value, 1, RT_ATOMIC_ACQUIRE);
    rt_trace_sem_update(&cond->sem, value, value - 1);
    if (value > 0)
    {
        /* The condition was signaled after the caller evaluated the predicate,
         * so let the caller re-evaluate it without releasing the mutex. */
        return;
    }
    rt_mutex_unlock(mutex);
    rt_syscall_sem_wait(&cond->sem);
    rt_mutex_lock(mutex);
}

bool rt_cond_timedwait(struct rt_cond *cond, struct rt_mutex *mutex,
                       unsigned long ticks)
{
    unsigned long start_tick = rt_tick_count();
    const int value =
        rt_atomic_fetch_sub(&cond->sem.value, 1, RT_ATOMIC_ACQUIRE);
    rt_trace_sem_update(&cond->sem, value, value - 1);
    if (value > 0)
    {
        return true;
    }
    rt_mutex_unlock(mutex);
    if ((ticks == 0) || !rt_syscall_sem_timedwait(&cond->sem, ticks))
    {
        return false;
    }
    rt_tick_elapse(&ticks, &start_tick);
    return rt_mutex_timedlock(mutex, ticks);
}