Skip to content

Commit f593b3a

Browse files
pguyotpguyot
committed
Add condition variables to pico_sync (fix #1093)
1 parent efe2103 commit f593b3a

File tree

7 files changed

+452
-1
lines changed

7 files changed

+452
-1
lines changed

‎src/common/pico_sync/CMakeLists.txt‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ endif()
88
if (NOT TARGET pico_sync)
99
pico_add_impl_library(pico_sync)
1010
target_include_directories(pico_sync_headers SYSTEM INTERFACE ${CMAKE_CURRENT_LIST_DIR}/include)
11-
pico_mirrored_target_link_libraries(pico_sync INTERFACE pico_sync_sem pico_sync_mutex pico_sync_critical_section pico_time hardware_sync)
11+
pico_mirrored_target_link_libraries(pico_sync INTERFACE pico_sync_cond pico_sync_sem pico_sync_mutex pico_sync_critical_section pico_time hardware_sync)
1212
endif()
1313

1414

@@ -19,6 +19,14 @@ if (NOT TARGET pico_sync_core)
1919
)
2020
endif()
2121

22+
if (NOT TARGET pico_sync_cond)
23+
pico_add_library(pico_sync_cond)
24+
target_sources(pico_sync_cond INTERFACE
25+
${CMAKE_CURRENT_LIST_DIR}/cond.c
26+
)
27+
pico_mirrored_target_link_libraries(pico_sync_cond INTERFACE pico_sync_core)
28+
endif()
29+
2230
if (NOT TARGET pico_sync_sem)
2331
pico_add_library(pico_sync_sem)
2432
target_sources(pico_sync_sem INTERFACE

‎src/common/pico_sync/cond.c‎

Lines changed: 177 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,177 @@
1+
/*
2+
* Copyright (c) 2022-2023 Paul Guyot <[email protected]>
3+
*
4+
* SPDX-License-Identifier: BSD-3-Clause
5+
*/
6+
7+
#include "pico/cond.h"
8+
9+
void cond_init(cond_t *cond) {
10+
lock_init(&cond->core, next_striped_spin_lock_num());
11+
cond->waiter = LOCK_INVALID_OWNER_ID;
12+
cond->broadcast_count = 0;
13+
cond->signaled = false;
14+
__mem_fence_release();
15+
}
16+
17+
bool __time_critical_func(cond_wait_until)(cond_t *cond, mutex_t *mtx, absolute_time_t until) {
18+
bool success = true;
19+
lock_owner_id_t caller = lock_get_caller_owner_id();
20+
uint32_t save = save_and_disable_interrupts();
21+
// Acquire the mutex spin lock
22+
spin_lock_unsafe_blocking(mtx->core.spin_lock);
23+
assert(lock_is_owner_id_valid(mtx->owner));
24+
assert(caller == mtx->owner);
25+
26+
// Mutex and cond spin locks can be the same as spin locks are attributed
27+
// using `next_striped_spin_lock_num()`. To avoid any deadlock, we only
28+
// acquire the condition variable spin lock if it is different from the
29+
// mutex spin lock
30+
bool same_spinlock = mtx->core.spin_lock == cond->core.spin_lock;
31+
32+
// Acquire the condition variable spin_lock
33+
if (!same_spinlock) {
34+
spin_lock_unsafe_blocking(cond->core.spin_lock);
35+
}
36+
37+
mtx->owner = LOCK_INVALID_OWNER_ID;
38+
39+
uint64_t current_broadcast = cond->broadcast_count;
40+
41+
if (lock_is_owner_id_valid(cond->waiter)) {
42+
// Release the mutex but without restoring interrupts and notify.
43+
if (!same_spinlock) {
44+
spin_unlock_unsafe(mtx->core.spin_lock);
45+
}
46+
47+
// There is a valid owner of the condition variable: we are not the
48+
// first waiter.
49+
// First iteration: notify
50+
lock_internal_spin_unlock_with_notify(&cond->core, save);
51+
save = spin_lock_blocking(cond->core.spin_lock);
52+
// Further iterations: wait
53+
do {
54+
if (!lock_is_owner_id_valid(cond->waiter)) {
55+
break;
56+
}
57+
if (cond->broadcast_count != current_broadcast) {
58+
break;
59+
}
60+
if (is_at_the_end_of_time(until)) {
61+
lock_internal_spin_unlock_with_wait(&cond->core, save);
62+
} else {
63+
if (lock_internal_spin_unlock_with_best_effort_wait_or_timeout(&cond->core, save, until)) {
64+
// timed out
65+
success = false;
66+
break;
67+
}
68+
}
69+
save = spin_lock_blocking(cond->core.spin_lock);
70+
} while (true);
71+
} else {
72+
// Release the mutex but without restoring interrupts
73+
if (!same_spinlock) {
74+
uint32_t disabled_ints = save_and_disable_interrupts();
75+
lock_internal_spin_unlock_with_notify(&mtx->core, disabled_ints);
76+
}
77+
}
78+
79+
if (success && cond->broadcast_count == current_broadcast) {
80+
cond->waiter = caller;
81+
82+
// Wait for the signal
83+
do {
84+
if (cond->signaled) {
85+
cond->waiter = LOCK_INVALID_OWNER_ID;
86+
cond->signaled = false;
87+
break;
88+
}
89+
if (is_at_the_end_of_time(until)) {
90+
lock_internal_spin_unlock_with_wait(&cond->core, save);
91+
} else {
92+
if (lock_internal_spin_unlock_with_best_effort_wait_or_timeout(&cond->core, save, until)) {
93+
// timed out
94+
cond->waiter = LOCK_INVALID_OWNER_ID;
95+
success = false;
96+
break;
97+
}
98+
}
99+
save = spin_lock_blocking(cond->core.spin_lock);
100+
} while (true);
101+
}
102+
103+
// We got the signal (or timed out)
104+
105+
if (lock_is_owner_id_valid(mtx->owner)) {
106+
// Acquire the mutex spin lock and release the core spin lock.
107+
if (!same_spinlock) {
108+
spin_lock_unsafe_blocking(mtx->core.spin_lock);
109+
spin_unlock_unsafe(cond->core.spin_lock);
110+
}
111+
112+
// Another core holds the mutex.
113+
// First iteration: notify
114+
lock_internal_spin_unlock_with_notify(&mtx->core, save);
115+
save = spin_lock_blocking(mtx->core.spin_lock);
116+
// Further iterations: wait
117+
do {
118+
if (!lock_is_owner_id_valid(mtx->owner)) {
119+
break;
120+
}
121+
// We always wait for the mutex.
122+
lock_internal_spin_unlock_with_wait(&mtx->core, save);
123+
save = spin_lock_blocking(mtx->core.spin_lock);
124+
} while (true);
125+
} else {
126+
// Acquire the mutex spin lock and release the core spin lock
127+
// with notify but without restoring interrupts
128+
if (!same_spinlock) {
129+
spin_lock_unsafe_blocking(mtx->core.spin_lock);
130+
uint32_t disabled_ints = save_and_disable_interrupts();
131+
lock_internal_spin_unlock_with_notify(&cond->core, disabled_ints);
132+
}
133+
}
134+
135+
// Eventually hold the mutex.
136+
mtx->owner = caller;
137+
138+
// Restore the interrupts now
139+
spin_unlock(mtx->core.spin_lock, save);
140+
141+
return success;
142+
}
143+
144+
bool __time_critical_func(cond_wait_timeout_ms)(cond_t *cond, mutex_t *mtx, uint32_t timeout_ms) {
145+
return cond_wait_until(cond, mtx, make_timeout_time_ms(timeout_ms));
146+
}
147+
148+
bool __time_critical_func(cond_wait_timeout_us)(cond_t *cond, mutex_t *mtx, uint32_t timeout_us) {
149+
return cond_wait_until(cond, mtx, make_timeout_time_us(timeout_us));
150+
}
151+
152+
void __time_critical_func(cond_wait)(cond_t *cond, mutex_t *mtx) {
153+
cond_wait_until(cond, mtx, at_the_end_of_time);
154+
}
155+
156+
void __time_critical_func(cond_signal)(cond_t *cond) {
157+
uint32_t save = spin_lock_blocking(cond->core.spin_lock);
158+
if (lock_is_owner_id_valid(cond->waiter)) {
159+
// We have a waiter, we can signal.
160+
cond->signaled = true;
161+
lock_internal_spin_unlock_with_notify(&cond->core, save);
162+
} else {
163+
spin_unlock(cond->core.spin_lock, save);
164+
}
165+
}
166+
167+
void __time_critical_func(cond_broadcast)(cond_t *cond) {
168+
uint32_t save = spin_lock_blocking(cond->core.spin_lock);
169+
if (lock_is_owner_id_valid(cond->waiter)) {
170+
// We have a waiter, we can broadcast.
171+
cond->signaled = true;
172+
cond->broadcast_count++;
173+
lock_internal_spin_unlock_with_notify(&cond->core, save);
174+
} else {
175+
spin_unlock(cond->core.spin_lock, save);
176+
}
177+
}

‎src/common/pico_sync/include/pico/cond.h‎

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
/*
2+
* Copyright (c) 2022-2023 Paul Guyot <[email protected]>
3+
*
4+
* SPDX-License-Identifier: BSD-3-Clause
5+
*/
6+
7+
#ifndef _PLATFORM_COND_H
8+
#define _PLATFORM_COND_H
9+
10+
#include "pico/mutex.h"
11+
12+
#ifdef __cplusplus
13+
extern "C" {
14+
#endif
15+
16+
/** \file cond.h
17+
* \defgroup cond cond
18+
* \ingroup pico_sync
19+
* \brief Condition variable API for non IRQ mutual exclusion between cores
20+
*
21+
* Condition variables complement mutexes by providing a way to atomically
22+
* wait and release a held mutex. Then, the task on the other core can signal
23+
* the variable, which ends the wait. Often, the other core would also hold
24+
* the shared mutex, so the signaled task waits until the mutex is released.
25+
*
26+
* Condition variables can also be broadcast.
27+
*
28+
* In this implementation, it is not mandatory. The condition variables only
29+
* work with non-recursive mutexes.
30+
*
31+
* Limitations of mutexes also apply to condition variables. See \ref mutex.h
32+
*/
33+
34+
typedef struct __packed_aligned
35+
{
36+
lock_core_t core;
37+
lock_owner_id_t waiter;
38+
uint32_t broadcast_count; // Overflow is unlikely
39+
bool signaled;
40+
} cond_t;
41+
42+
/*! \brief Initialize a condition variable structure
43+
* \ingroup cond
44+
*
45+
* \param cv Pointer to condition variable structure
46+
*/
47+
void cond_init(cond_t *cv);
48+
49+
/*! \brief Wait on a condition variable
50+
* \ingroup cond
51+
*
52+
* Wait until a condition variable is signaled or broadcast. The mutex should
53+
* be owned and is released atomically. It is reacquired when this function
54+
* returns.
55+
*
56+
* \param cv Condition variable to wait on
57+
* \param mtx Currently held mutex
58+
*/
59+
void cond_wait(cond_t *cv, mutex_t *mtx);
60+
61+
/*! \brief Wait on a condition variable with a timeout.
62+
* \ingroup cond
63+
*
64+
* Wait until a condition variable is signaled or broadcast until a given
65+
* time. The mutex is released atomically and reacquired even if the wait
66+
* timed out.
67+
*
68+
* \param cv Condition variable to wait on
69+
* \param mtx Currently held mutex
70+
* \param until The time after which to return if the condition variable was
71+
* not signaled.
72+
* \return true if the condition variable was signaled, false otherwise
73+
*/
74+
bool cond_wait_until(cond_t *cv, mutex_t *mtx, absolute_time_t until);
75+
76+
/*! \brief Wait on a condition variable with a timeout.
77+
* \ingroup cond
78+
*
79+
* Wait until a condition variable is signaled or broadcast until a given
80+
* time. The mutex is released atomically and reacquired even if the wait
81+
* timed out.
82+
*
83+
* \param cv Condition variable to wait on
84+
* \param mtx Currently held mutex
85+
* \param timeout_ms The timeout in milliseconds.
86+
* \return true if the condition variable was signaled, false otherwise
87+
*/
88+
bool cond_wait_timeout_ms(cond_t *cv, mutex_t *mtx, uint32_t timeout_ms);
89+
90+
/*! \brief Wait on a condition variable with a timeout.
91+
* \ingroup cond
92+
*
93+
* Wait until a condition variable is signaled or broadcast until a given
94+
* time. The mutex is released atomically and reacquired even if the wait
95+
* timed out.
96+
*
97+
* \param cv Condition variable to wait on
98+
* \param mtx Currently held mutex
99+
* \param timeout_ms The timeout in microseconds.
100+
* \return true if the condition variable was signaled, false otherwise
101+
*/
102+
bool cond_wait_timeout_us(cond_t *cv, mutex_t *mtx, uint32_t timeout_us);
103+
104+
/*! \brief Signal on a condition variable and wake the waiter
105+
* \ingroup cond
106+
*
107+
* \param cv Condition variable to signal
108+
*/
109+
void cond_signal(cond_t *cv);
110+
111+
/*! \brief Broadcast a condition variable and wake every waiters
112+
* \ingroup cond
113+
*
114+
* \param cv Condition variable to signal
115+
*/
116+
void cond_broadcast(cond_t *cv);
117+
118+
#ifdef __cplusplus
119+
}
120+
#endif
121+
#endif

‎src/common/pico_sync/include/pico/sync.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,5 +15,6 @@
1515
#include "pico/sem.h"
1616
#include "pico/mutex.h"
1717
#include "pico/critical_section.h"
18+
#include "pico/cond.h"
1819

1920
#endif

‎test/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,4 +13,5 @@ if (PICO_ON_DEVICE)
1313
add_subdirectory(cmsis_test)
1414
add_subdirectory(pico_sem_test)
1515
add_subdirectory(pico_sha256_test)
16+
add_subdirectory(pico_cond_test)
1617
endif()

‎test/pico_cond_test/CMakeLists.txt‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
add_executable(pico_cond_test pico_cond_test.c)
2+
3+
target_link_libraries(pico_cond_test PRIVATE pico_test pico_sync pico_multicore pico_stdlib )
4+
pico_add_extra_outputs(pico_cond_test)

0 commit comments

Comments
 (0)