michaelh/zephyr
1
0
Fork 0
Code Releases Activity

nano_sema: Simplify nano_xxx_sem_take() API family

Browse source 
Changes the nanokernel semaphore API so that the timeout parameter must be
specified when invoking nano_isr_sem_take(), nano_fiber_sem_take(),
nano_task_sem_take() and nano_sem_take().

This obsoletes the following APIs:
	nano_fiber_sem_take_wait()
	nano_fiber_sem_take_wait_timeout()
	nano_task_sem_take_wait()
	nano_task_sem_take_wait_timeout()
	nano_sem_take_wait()
	nano_sem_take_wait_timeout()

Change-Id: If7a4bce1bd8ec8d6410d04f3c16ff1922ff0910e
Signed-off-by: Peter Mitsis <peter.mitsis@windriver.com>
This commit is contained in:
Peter Mitsis 2015-12-18 15:36:34 -05:00 • committed by Anas Nashif
commit 54b782a88b
39 changed files with 199 additions and 378 deletions
Download patch file Download diff file Expand all files Collapse all files

2
arch/arm/core/cpu_idle.S
View file

@ -139,7 +139,7 @@ SECTION_FUNC(TEXT, nano_cpu_idle)
* @brief Atomically re-enable interrupts and enter low power mode
*
* This function is utilized by the nanokernel object "wait" APIs for tasks,
* e.g. nano_task_lifo_get_wait(), nano_task_sem_take_wait(),
* e.g. nano_task_lifo_get_wait(), nano_task_sem_take(),
* nano_task_stack_pop_wait(), and nano_task_fifo_get().
*
* INTERNAL

2
arch/x86/core/cpuhalt.c
View file

@ -71,7 +71,7 @@ void nano_cpu_idle(void)
* @brief Atomically re-enable interrupts and enter low power mode
*
* This function is utilized by the nanokernel object "wait" APIs for tasks,
* e.g. nano_task_lifo_get_wait(), nano_task_sem_take_wait(),
* e.g. nano_task_lifo_get_wait(), nano_task_sem_take(),
* nano_task_stack_pop_wait(), and nano_task_fifo_get().
*
* INTERNAL

4
doc/collaboration/code/doxygen/hello_commented.c
View file

@ -145,7 +145,7 @@ void fiberEntry(void) {
while (1) {
nano_fiber_sem_take_wait(&nanoSemFiber); /* Action 3 */
nano_fiber_sem_take(&nanoSemFiber, TICKS_UNLIMITED); /* Action 3 */
PRINT("%s: Hello World!\n", __FUNCTION__); /* Action 4 */
@ -181,7 +181,7 @@ void main(void) {
nano_task_timer_wait(&timer);
nano_task_sem_give(&nanoSemFiber);
nano_task_sem_take_wait(&nanoSemTask); /* Action 3 */
nano_task_sem_take(&nanoSemTask, TICKS_UNLIMITED); /* Action 3 */
}
}

2
doc/collaboration/code/doxygen/phil_fiber_commented.c
View file

@ -33,7 +33,7 @@
#ifdef CONFIG_NANOKERNEL
/* For the nanokernel. */
#define FORK(x) &forks[x]
#define TAKE(x) nano_fiber_sem_take_wait(x)
#define TAKE(x) nano_fiber_sem_take(x, TICKS_UNLIMITED)
#define GIVE(x) nano_fiber_sem_give(x)
#define RANDDELAY(x) myDelay(((sys_tick_get_32() * ((x) + 1)) & 0x1f) + 1)
#else

8
doc/kernel/nanokernel/nanokernel_example.rst
View file

@ -41,7 +41,7 @@ Example Code
while (1)
{
/* wait for task to let us have a turn */
nano_fiber_sem_take_wait (&nanoSemFiber);
nano_fiber_sem_take(&nanoSemFiber, TICKS_UNLIMITED);
/* say "hello" */
PRINT ("%s: Hello World!\n", __FUNCTION__);
@ -77,7 +77,7 @@ Example Code
nano_task_sem_give (&nanoSemFiber);
/* now wait for fiber to let us have a turn */
nano_task_sem_take_wait (&nanoSemTask);
nano_task_sem_take (&nanoSemTask, TICKS_UNLIMITED);
}
}
@ -124,7 +124,7 @@ The following steps repeat endlessly:
#. The fiber, now marked as runnable, pre-empts the background
task, allowing execution to jump to the fiber.
nano_fiber_sem_take_wait.
nano_fiber_sem_take.
#. The fiber then prints, “fiberEntry: Hello World!” It starts a time
for SLEEPTICKS in the future and waits for that timer to expire. The
@ -143,5 +143,5 @@ The following steps repeat endlessly:
background task is scheduled.
#. The background task execution picks up after the call to
:c:func:`nano_task_sem_take_wait()`. It jumps to the top of the
:c:func:`nano_task_sem_take()`. It jumps to the top of the
while loop.

12
doc/kernel/nanokernel/nanokernel_synchronization.rst
View file

@ -103,7 +103,7 @@ and gives warning if it is not obtained in that time.
{
...
if (nano_fiber_sem_take_wait_timeout(&input_sem, 500) != 1) {
if (nano_fiber_sem_take(&input_sem, 500) != 1) {
printk("Input data not available!");
} else {
/* fetch available data */
@ -127,14 +127,4 @@ by :file:`nanokernel.h`:
:cpp:func:`nano_task_sem_take()`, :cpp:func:`nano_fiber_sem_take()`,
:cpp:func:`nano_isr_sem_take()`, :cpp:func:`nano_sem_take()`
Test a semaphore.
:cpp:func:`nano_task_sem_take_wait()`,
:cpp:func:`nano_fiber_sem_take_wait()`,
:cpp:func:`nano_sem_take_wait()`
Wait on a semaphore.
:cpp:func:`nano_task_sem_take_wait_timeout()`,
:cpp:func:`nano_fiber_sem_take_wait_timeout()`,
:cpp:func:`nano_sem_take_wait_timeout()`
Wait on a semaphore for a specified time period.

2
drivers/console/ipm_console_receiver.c
View file

@ -41,7 +41,7 @@ static void ipm_console_fiber(int arg1, int arg2)
pos = 0;
while (1) {
nano_fiber_sem_take_wait(&driver_data->sem);
nano_fiber_sem_take(&driver_data->sem, TICKS_UNLIMITED);
ret = sys_ring_buf_get(&driver_data->rb, &type,
(uint8_t *)&config_info->line_buf[pos],

4
include/device.h
View file

@ -144,7 +144,7 @@ static inline void synchronous_call_wait(device_sync_call_t *sync)
task_sem_take(sync->t_sem, TICKS_UNLIMITED);
} else {
sync->caller_is_task = false;
nano_sem_take_wait(&sync->f_sem);
nano_sem_take(&sync->f_sem, TICKS_NONE);
}
}
@ -174,7 +174,7 @@ static inline void synchronous_call_complete(device_sync_call_t *sync)
*/
static inline void synchronous_call_wait(device_sync_call_t *sync)
{
nano_sem_take_wait(&sync->f_sem);
nano_sem_take(&sync->f_sem, TICKS_UNLIMITED);
}
/**

136
include/nanokernel.h
View file

@ -839,20 +839,6 @@ extern void nano_sem_init(struct nano_sem *sem);
*/
extern void nano_sem_give(struct nano_sem *sem);
/**
*
* @brief Take a nanokernel semaphore
*
* This is a convenience wrapper for the execution context-specific APIs. This
* is helpful whenever the exact execution context is not known, but should be
* avoided when the context is known up-front (to avoid unnecessary overhead).
*
* @param sem Pointer to a nano_sem structure.
*
* @return N/A
*/
extern int nano_sem_take(struct nano_sem *sem);
/**
*
* @brief Take a nanokernel semaphore, poll/pend if not available
@ -861,30 +847,18 @@ extern int nano_sem_take(struct nano_sem *sem);
* is helpful whenever the exact execution context is not known, but should be
* avoided when the context is known up-front (to avoid unnecessary overhead).
*
* @warning It's only valid to call this API from a fiber or a task.
*
* @param sem Pointer to a nano_sem structure.
* @param timeout_in_ticks Affects the action taken should the LIFO be empty.
* If TICKS_NONE, then return immediately. If TICKS_UNLIMITED, then wait as
* long as necesssary. Otherwise wait up to the specified number of ticks
* before timing out.
*
* @return N/A
* @warning If it is to be called from the context of an ISR, then @a
* timeout_in_ticks must be set to TICKS_NONE.
*
* @return 1 if semaphore is available, 0 otherwise
*/
extern void nano_sem_take_wait(struct nano_sem *sem);
/**
*
* @brief Take a nanokernel semaphore, poll/pend with timeout if not available
*
* This is a convenience wrapper for the execution context-specific APIs. This
* is helpful whenever the exact execution context is not known, but should be
* avoided when the context is known up-front (to avoid unnecessary overhead).
*
* @warning It's only valid to call this API from a fiber or a task.
*
* @param sem Pointer to a nano_sem structure.
* @param timeout Time to wait in ticks
*
* @return N/A
*/
extern void nano_sem_take_wait_timeout(struct nano_sem *sem, int32_t timeout);
extern int nano_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks);
/* methods for ISRs */
@ -914,10 +888,11 @@ extern void nano_isr_sem_give(struct nano_sem *sem);
* a wait (pend) operation will NOT be performed.
*
* @param sem Pointer to a nano_sem structure.
* @param timeout_in_ticks Always use TICKS_NONE.
*
* @return 1 if semaphore is available, 0 otherwise
*/
extern int nano_isr_sem_take(struct nano_sem *sem);
extern int nano_isr_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks);
/* methods for fibers */
@ -938,54 +913,19 @@ extern void nano_fiber_sem_give(struct nano_sem *sem);
/**
*
* @brief Take a nanokernel semaphore, fail if unavailable
* @brief Take a nanokernel semaphore, wait or fail if unavailable
*
* Attempt to take a nanokernel semaphore; it may be called from a fiber.
*
* If the semaphore is not available, this function returns immediately, i.e.
* a wait (pend) operation will NOT be performed.
*
* @param sem Pointer to a nano_sem structure.
* @param timeout_in_ticks Affects the action taken should the LIFO be empty.
* If TICKS_NONE, then return immediately. If TICKS_UNLIMITED, then wait as
* long as necesssary. Otherwise wait up to the specified number of ticks
* before timing out.
*
* @return 1 if semaphore is available, 0 otherwise
*/
extern int nano_fiber_sem_take(struct nano_sem *sem);
/**
*
* @brief Test a nanokernel semaphore, wait if unavailable
*
* Take a nanokernel semaphore; it can only be called from a fiber.
*
* If the nanokernel semaphore is not available, i.e. the event counter
* is 0, the calling fiber will wait (pend) until the semaphore is
* given (via nano_fiber_sem_give/nano_task_sem_give/nano_isr_sem_give).
*
* @param sem Pointer to a nano_sem structure.
*
* @return N/A
*/
extern void nano_fiber_sem_take_wait(struct nano_sem *sem);
#ifdef CONFIG_NANO_TIMEOUTS
/**
* @brief test a nanokernel semaphore, wait with a timeout if unavailable
*
* Take a nanokernel semaphore; it can only be called from a fiber.
*
* If the nanokernel semaphore is not available, i.e. the event counter
* is 0, the calling fiber will wait (pend) until the semaphore is
* given (via nano_fiber_sem_give/nano_task_sem_give/nano_isr_sem_give). A
* timeout can be specified.
*
* @param sem Pointer to the semaphore to take
* @param timeout time to wait in ticks
*
* @return 1 if semaphore is available, 0 if timed out
*/
extern int nano_fiber_sem_take_wait_timeout(struct nano_sem *sem,
int32_t timeout);
#endif
extern int nano_fiber_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks);
/* methods for tasks */
@ -1014,46 +954,14 @@ extern void nano_task_sem_give(struct nano_sem *sem);
* a wait (pend) operation will NOT be performed.
*
* @param sem Pointer to a nano_sem structure.
* @param timeout_in_ticks Affects the action taken should the LIFO be empty.
* If TICKS_NONE, then return immediately. If TICKS_UNLIMITED, then wait as
* long as necesssary. Otherwise wait up to the specified number of ticks
* before timing out.
*
* @return 1 if semaphore is available, 0 otherwise
*/
extern int nano_task_sem_take(struct nano_sem *sem);
/**
*
* @brief Take a nanokernel semaphore, poll if unavailable
*
* Take a nanokernel semaphore; it can only be called from a task.
*
* If the nanokernel semaphore is not available, i.e. the event counter
* is 0, the calling task will poll until the semaphore is given
* (via nano_fiber_sem_give/nano_task_sem_give/nano_isr_sem_give).
*
* @param sem Pointer to a nano_sem structure.
*
* @return N/A
*/
extern void nano_task_sem_take_wait(struct nano_sem *sem);
#ifdef CONFIG_NANO_TIMEOUTS
/**
* @brief test a nanokernel semaphore, poll with a timeout if unavailable
*
* Take a nanokernel semaphore; it can only be called from a task.
*
* If the nanokernel semaphore is not available, i.e. the event counter is 0,
* the calling task will poll until the semaphore is given (via
* nano_fiber_sem_give/nano_task_sem_give/nano_isr_sem_give). A timeout can be
* specified.
*
* @param sem the semaphore to take
* @param timeout time to wait in ticks
*
* @return 1 if semaphore is available, 0 if timed out
*/
extern int nano_task_sem_take_wait_timeout(struct nano_sem *sem,
int32_t timeout);
#endif
extern int nano_task_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks);
/**
* @}

6
kernel/nanokernel/event_logger.c
View file

@ -116,7 +116,7 @@ int sys_event_logger_get(struct event_logger *logger, uint16_t *event_id,
uint8_t *dropped_event_count, uint32_t *buffer,
uint8_t *buffer_size)
{
if (nano_fiber_sem_take(&(logger->sync_sema))) {
if (nano_fiber_sem_take(&(logger->sync_sema), TICKS_NONE)) {
return event_logger_get(logger, event_id, dropped_event_count,
buffer, buffer_size);
}
@ -128,7 +128,7 @@ int sys_event_logger_get_wait(struct event_logger *logger, uint16_t *event_id,
uint8_t *dropped_event_count, uint32_t *buffer,
uint8_t *buffer_size)
{
nano_fiber_sem_take_wait(&(logger->sync_sema));
nano_fiber_sem_take(&(logger->sync_sema), TICKS_UNLIMITED);
return event_logger_get(logger, event_id, dropped_event_count, buffer,
buffer_size);
@ -142,7 +142,7 @@ int sys_event_logger_get_wait_timeout(struct event_logger *logger,
uint32_t *buffer, uint8_t *buffer_size,
uint32_t timeout)
{
if (nano_fiber_sem_take_wait_timeout(&(logger->sync_sema), timeout)) {
if (nano_fiber_sem_take(&(logger->sync_sema), timeout)) {
return event_logger_get(logger, event_id, dropped_event_count,
buffer, buffer_size);
}

142
kernel/nanokernel/nano_sema.c
View file

@ -25,8 +25,8 @@
* nano_sem_init
* nano_fiber_sem_give, nano_task_sem_give, nano_isr_sem_give
* nano_fiber_sem_take, nano_task_sem_take, nano_isr_sem_take
* nano_fiber_sem_take_wait, nano_task_sem_take_wait
* nano_sem_take
*
* The semaphores are of the 'counting' type, i.e. each 'give' operation will
* increment the internal count by 1, if no fiber is pending on it. The 'init'
* call initializes the count to 0. Following multiple 'give' operations, the
@ -123,127 +123,45 @@ void nano_sem_give(struct nano_sem *sem)
FUNC_ALIAS(_sem_take, nano_isr_sem_take, int);
FUNC_ALIAS(_sem_take, nano_fiber_sem_take, int);
FUNC_ALIAS(_sem_take, nano_task_sem_take, int);
FUNC_ALIAS(_sem_take, nano_sem_take, int);
int _sem_take(
struct nano_sem *sem
)
{
unsigned int imask;
int avail;
imask = irq_lock();
avail = (sem->nsig > 0);
sem->nsig -= avail;
irq_unlock(imask);
return avail;
}
/**
* INTERNAL
* There exists a separate nano_task_sem_take_wait() implementation since a
* task cannot pend on a nanokernel object. Instead, tasks will poll the
* sempahore object.
*/
void nano_fiber_sem_take_wait(struct nano_sem *sem)
{
unsigned int imask;
imask = irq_lock();
if (sem->nsig == 0) {
_nano_wait_q_put(&sem->wait_q);
_Swap(imask);
} else {
sem->nsig--;
irq_unlock(imask);
}
}
void nano_task_sem_take_wait(struct nano_sem *sem)
{
unsigned int imask;
/* spin until the sempahore is signaled */
while (1) {
imask = irq_lock();
/*
* Predict that the branch will be taken to break out of the loop.
* There is little cost to a misprediction since that leads to idle.
*/
if (likely(sem->nsig > 0))
break;
/* see explanation in nano_stack.c:nano_task_stack_pop_wait() */
nano_cpu_atomic_idle(imask);
}
sem->nsig--;
irq_unlock(imask);
}
void nano_sem_take_wait(struct nano_sem *sem)
{
static void (*func[3])(struct nano_sem *sem) = {
NULL,
nano_fiber_sem_take_wait,
nano_task_sem_take_wait
};
func[sys_execution_context_type_get()](sem);
}
#ifdef CONFIG_NANO_TIMEOUTS
int nano_fiber_sem_take_wait_timeout(struct nano_sem *sem, int32_t timeout_in_ticks)
int _sem_take(struct nano_sem *sem, int32_t timeout_in_ticks)
{
unsigned int key = irq_lock();
if (sem->nsig == 0) {
if (unlikely(TICKS_NONE == timeout_in_ticks)) {
if (likely(sem->nsig > 0)) {
sem->nsig--;
irq_unlock(key);
return 0;
}
if (likely(timeout_in_ticks != TICKS_UNLIMITED)) {
_nano_timeout_add(_nanokernel.current, &sem->wait_q,
timeout_in_ticks);
return 1;
}
if (timeout_in_ticks != TICKS_NONE) {
_NANO_TIMEOUT_ADD(&sem->wait_q, timeout_in_ticks);
_nano_wait_q_put(&sem->wait_q);
return _Swap(key);
}
sem->nsig--;
irq_unlock(key);
return 1;
return 0;
}
int nano_task_sem_take_wait_timeout(struct nano_sem *sem, int32_t timeout_in_ticks)
/**
* INTERNAL
* Since a task cannot pend on a nanokernel object, they poll the
* sempahore object.
*/
int nano_task_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks)
{
int64_t cur_ticks, limit;
int64_t cur_ticks;
int64_t limit = 0x7fffffffffffffffll;
unsigned int key;
if (unlikely(TICKS_UNLIMITED == timeout_in_ticks)) {
nano_task_sem_take_wait(sem);
return 1;
}
if (unlikely(TICKS_NONE == timeout_in_ticks)) {
return nano_task_sem_take(sem);
}
key = irq_lock();
cur_ticks = sys_tick_get();
cur_ticks = _NANO_TIMEOUT_TICK_GET();
if (timeout_in_ticks != TICKS_UNLIMITED) {
limit = cur_ticks + timeout_in_ticks;
}
while (cur_ticks < limit) {
do {
/*
* Predict that the branch will be taken to break out of the loop.
* There is little cost to a misprediction since that leads to idle.
@ -255,26 +173,26 @@ int nano_task_sem_take_wait_timeout(struct nano_sem *sem, int32_t timeout_in_tic
return 1;
}
if (timeout_in_ticks != TICKS_NONE) {
/* see explanation in nano_stack.c:nano_task_stack_pop_wait() */
nano_cpu_atomic_idle(key);
key = irq_lock();
cur_ticks = sys_tick_get();
cur_ticks = _NANO_TIMEOUT_TICK_GET();
}
} while (cur_ticks < limit);
irq_unlock(key);
return 0;
}
void nano_sem_take_wait_timeout(struct nano_sem *sem, int32_t timeout)
int nano_sem_take(struct nano_sem *sem, int32_t timeout)
{
static int (*func[3])(struct nano_sem *, int32_t) = {
NULL,
nano_fiber_sem_take_wait_timeout,
nano_task_sem_take_wait_timeout
nano_isr_sem_take,
nano_fiber_sem_take,
nano_task_sem_take
};
func[sys_execution_context_type_get()](sem, timeout);
return func[sys_execution_context_type_get()](sem, timeout);
}
#endif /* CONFIG_NANO_TIMEOUTS */

2
net/bluetooth/conn.c
View file

@ -363,7 +363,7 @@ static bool send_frag(struct bt_conn *conn, struct net_buf *buf, uint8_t flags,
flags);
/* Wait until the controller can accept ACL packets */
nano_fiber_sem_take_wait(bt_conn_get_pkts(conn));
nano_fiber_sem_take(bt_conn_get_pkts(conn), TICKS_UNLIMITED);
/* Check for disconnection while waiting for pkts_sem */
if (conn->state != BT_CONN_CONNECTED) {

4
net/bluetooth/hci_core.c
View file

@ -250,7 +250,7 @@ int bt_hci_cmd_send_sync(uint16_t opcode, struct net_buf *buf,
nano_fifo_put(&bt_dev.cmd_tx_queue, buf);
nano_sem_take_wait(&sync_sem);
nano_sem_take(&sync_sem, TICKS_UNLIMITED);
/* Indicate failure if we failed to get the return parameters */
if (!cmd(buf)->sync) {
@ -1725,7 +1725,7 @@ static void hci_cmd_tx_fiber(void)
/* Wait until ncmd > 0 */
BT_DBG("calling sem_take_wait");
nano_fiber_sem_take_wait(&bt_dev.ncmd_sem);
nano_fiber_sem_take(&bt_dev.ncmd_sem, TICKS_UNLIMITED);
/* Get next command - wait if necessary */
BT_DBG("calling fifo_get_wait");

4
net/bluetooth/l2cap.c
View file

@ -869,7 +869,7 @@ static void l2cap_chan_le_recv(struct bt_l2cap_chan *chan, struct net_buf *buf)
{
uint16_t sdu_len;
if (!nano_fiber_sem_take(&chan->rx.credits)) {
if (!nano_fiber_sem_take(&chan->rx.credits, TICKS_NONE)) {
BT_ERR("No credits to receive packet");
bt_l2cap_chan_disconnect(chan);
return;
@ -1213,7 +1213,7 @@ static int l2cap_chan_le_send(struct bt_l2cap_chan *chan, struct net_buf *buf,
uint16_t len)
{
/* Wait for credits */
nano_sem_take_wait(&chan->tx.credits);
nano_sem_take(&chan->tx.credits, TICKS_UNLIMITED);
buf = l2cap_chan_create_seg(chan, buf, len);
if (!buf) {

4
net/ip/net_context.c
View file

@ -129,7 +129,7 @@ struct net_context *net_context_get(enum ip_protocol ip_proto,
}
#endif
nano_sem_take_wait(&contexts_lock);
nano_sem_take(&contexts_lock, TICKS_UNLIMITED);
if (local_port) {
if (context_port_used(ip_proto, local_port, local_addr) < 0) {
@ -171,7 +171,7 @@ struct net_context *net_context_get(enum ip_protocol ip_proto,
void net_context_put(struct net_context *context)
{
nano_sem_take_wait(&contexts_lock);
nano_sem_take(&contexts_lock, TICKS_UNLIMITED);
memset(&context->tuple, 0, sizeof(context->tuple));
memset(&context->udp, 0, sizeof(context->udp));

2
samples/microkernel/apps/kernel_event_logger/src/kernel_event_collector_sample.c
View file

@ -23,7 +23,7 @@
#include <string.h>
#ifdef CONFIG_NANOKERNEL
#define TAKE(x) nano_fiber_sem_take_wait(&x)
#define TAKE(x) nano_fiber_sem_take(&x, TICKS_UNLIMITED)
#define GIVE(x) nano_fiber_sem_give(&x)
#define SLEEP(x) fiber_sleep(x)
#else /* ! CONFIG_NANOKERNEL */

2
samples/microkernel/apps/philosophers/src/phil_fiber.c
View file

@ -20,7 +20,7 @@
#ifdef CONFIG_NANOKERNEL
#define FORK(x) &forks[x]
#define TAKE(x) nano_fiber_sem_take_wait(x)
#define TAKE(x) nano_fiber_sem_take(x, TICKS_UNLIMITED)
#define GIVE(x) nano_fiber_sem_give(x)
#else /* ! CONFIG_NANOKERNEL */
#define FORK(x) forks[x]

2
samples/microkernel/benchmark/latency_measure/src/nano_ctx_switch.c
View file

@ -63,7 +63,7 @@ static volatile int ctxSwitchBalancer = 0;
*/
static void fiberOne(void)
{
nano_fiber_sem_take_wait(&syncSema);
nano_fiber_sem_take(&syncSema, TICKS_UNLIMITED);
timestamp = TIME_STAMP_DELTA_GET(0);
while (ctxSwitchCounter < NCTXSWITCH) {
fiber_yield();

2
samples/microkernel/benchmark/latency_measure/src/nano_int_to_fiber_sem.c
View file

@ -92,7 +92,7 @@ static void fiberInt(void)
*/
static void fiberWaiter(void)
{
nano_fiber_sem_take_wait(&testSema);
nano_fiber_sem_take(&testSema, TICKS_UNLIMITED);
timestamp = TIME_STAMP_DELTA_GET(timestamp);
}

8
samples/microkernel/benchmark/sys_kernel/README.txt
View file

@ -40,7 +40,7 @@ time for one iteration is displayed.
TEST CASE: Semaphore #1
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take_wait
nano_fiber_sem_take(TICKS_UNLIMITED)
nano_fiber_sem_give
Starting test. Please wait...
TEST RESULT: SUCCESSFUL
@ -50,7 +50,7 @@ END TEST CASE
TEST CASE: Semaphore #2
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take
nano_fiber_sem_take(TICKS_NONE)
fiber_yield
nano_fiber_sem_give
Starting test. Please wait...
@ -61,10 +61,10 @@ END TEST CASE
TEST CASE: Semaphore #3
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take_wait
nano_fiber_sem_take(TICKS_UNLIMITED)
nano_fiber_sem_give
nano_task_sem_give
nano_task_sem_take_wait
nano_task_sem_take(TICKS_UNLIMITED)
Starting test. Please wait...
TEST RESULT: SUCCESSFUL
DETAILS: Average time for 1 iteration: NNNN nSec

8
samples/microkernel/test/test_events/src/test_fiber.c
View file

@ -46,21 +46,21 @@ static void testFiberEntry(void)
{
/* signal event for eventWaitTest() */
/* single test */
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_event_send(EVENT_ID);
/* test in cycle */
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_event_send(EVENT_ID);
/* signal event for eventTimeoutTest() */
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_event_send(EVENT_ID);
/*
* Signal two events for fiberEventSignalTest ().
* It has to detect only one
*/
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_event_send(EVENT_ID);
fiber_event_send(EVENT_ID);
}

6
samples/microkernel/test/test_sema/src/test_fiber.c
View file

@ -53,18 +53,18 @@ static void testFiberEntry(void)
{
int i;
/* release semaphore test task is waiting for */
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_sem_give(simpleSem);
/* release the semaphore for N_TESTS times */
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
for (i = 0; i < N_TESTS; i++) {
fiber_sem_give(simpleSem);
}
/* signal each semaphore in the group */
for (i = 0; semList[i] != ENDLIST; i++) {
nano_fiber_sem_take_wait(&fiberSem);
nano_fiber_sem_take(&fiberSem, TICKS_UNLIMITED);
fiber_sem_give(semList[i]);
}
}

2
samples/microkernel/test/test_timer/src/timer.c
View file

@ -356,7 +356,7 @@ void RegressionTaskEntry(void)
}
TC_PRINT("Verifying the nanokernel timer fired\n");
if (!nano_task_sem_take(&test_nano_timers_sem)) {
if (!nano_task_sem_take(&test_nano_timers_sem, TICKS_NONE)) {
tcRC = TC_FAIL;
goto exitRtn;
}

4
samples/nanokernel/apps/synchronization/src/main.c
View file

@ -56,7 +56,7 @@ void fiberEntry(void)
while (1) {
/* wait for task to let us have a turn */
nano_fiber_sem_take_wait(&nanoSemFiber);
nano_fiber_sem_take(&nanoSemFiber, TICKS_UNLIMITED);
/* say "hello" */
PRINT("%s: Hello World!\n", __func__);
@ -89,7 +89,7 @@ void main(void)
nano_task_sem_give(&nanoSemFiber);
/* now wait for fiber to let us have a turn */
nano_task_sem_take_wait(&nanoSemTask);
nano_task_sem_take(&nanoSemTask, TICKS_UNLIMITED);
}
}

2
samples/nanokernel/benchmark/footprint/src/nanokernel_footprint.c
View file

@ -70,7 +70,7 @@ volatile pfunc func_array[] = {
(pfunc)nano_fiber_timer_wait,
/* nano semaphore functions */
(pfunc)nano_sem_init,
(pfunc)nano_fiber_sem_take_wait,
(pfunc)nano_fiber_sem_take,
(pfunc)nano_fiber_sem_give,
#ifdef TEST_max
/* nano LIFO functions */

2
samples/nanokernel/benchmark/object_footprint/src/nanokernel_objects.c
View file

@ -60,7 +60,7 @@ volatile pfunc func_array[] = {
/* nano semaphore functions */
#ifdef CONFIG_OBJECTS_SEMAPHORE
(pfunc)nano_sem_init,
(pfunc)nano_fiber_sem_take_wait,
(pfunc)nano_fiber_sem_take,
(pfunc)nano_fiber_sem_give,
#endif

8
samples/nanokernel/benchmark/sys_kernel/README.txt
View file

@ -40,7 +40,7 @@ time for one iteration is displayed.
TEST CASE: Semaphore #1
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take_wait
nano_fiber_sem_take(TICKS_UNLIMITED)
nano_fiber_sem_give
Starting test. Please wait...
TEST RESULT: SUCCESSFUL
@ -50,7 +50,7 @@ END TEST CASE
TEST CASE: Semaphore #2
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take
nano_fiber_sem_take(TICKS_NONE)
fiber_yield
nano_fiber_sem_give
Starting test. Please wait...
@ -61,10 +61,10 @@ END TEST CASE
TEST CASE: Semaphore #3
TEST COVERAGE:
nano_sem_init
nano_fiber_sem_take_wait
nano_fiber_sem_take(TICKS_UNLIMITED)
nano_fiber_sem_give
nano_task_sem_give
nano_task_sem_take_wait
nano_task_sem_take(TICKS_UNLIMITED)
Starting test. Please wait...
TEST RESULT: SUCCESSFUL
DETAILS: Average time for 1 iteration: NNNN nSec

16
samples/nanokernel/benchmark/sys_kernel/src/sema.c
View file

@ -50,7 +50,7 @@ void sema_fiber1(int par1, int par2)
ARG_UNUSED(par1);
for (i = 0; i < par2; i++) {
nano_fiber_sem_take_wait(&nanoSem1);
nano_fiber_sem_take(&nanoSem1, TICKS_UNLIMITED);
nano_fiber_sem_give(&nanoSem2);
}
}
@ -72,7 +72,7 @@ void sema_fiber2(int par1, int par2)
for (i = 0; i < par2; i++) {
nano_fiber_sem_give(&nanoSem1);
nano_fiber_sem_take_wait(&nanoSem2);
nano_fiber_sem_take(&nanoSem2, TICKS_UNLIMITED);
(*pcounter)++;
}
}
@ -93,7 +93,7 @@ void sema_fiber3(int par1, int par2)
for (i = 0; i < par2; i++) {
nano_fiber_sem_give(&nanoSem1);
while (!nano_fiber_sem_take(&nanoSem2)) {
while (!nano_fiber_sem_take(&nanoSem2, TICKS_NONE)) {
fiber_yield();
}
(*pcounter)++;
@ -117,7 +117,7 @@ int sema_test(void)
"Semaphore #1");
fprintf(output_file, sz_description,
"\n\tnano_sem_init"
"\n\tnano_fiber_sem_take_wait"
"\n\tnano_fiber_sem_take(TICKS_UNLIMITED)"
"\n\tnano_fiber_sem_give");
printf(sz_test_start_fmt);
@ -138,7 +138,7 @@ int sema_test(void)
"Semaphore #2");
fprintf(output_file, sz_description,
"\n\tnano_sem_init"
"\n\tnano_fiber_sem_take"
"\n\tnano_fiber_sem_take(TICKS_NONE)"
"\n\tfiber_yield"
"\n\tnano_fiber_sem_give");
printf(sz_test_start_fmt);
@ -161,10 +161,10 @@ int sema_test(void)
"Semaphore #3");
fprintf(output_file, sz_description,
"\n\tnano_sem_init"
"\n\tnano_fiber_sem_take_wait"
"\n\tnano_fiber_sem_take(TICKS_UNLIMITED)"
"\n\tnano_fiber_sem_give"
"\n\tnano_task_sem_give"
"\n\tnano_task_sem_take_wait");
"\n\tnano_task_sem_take(TICKS_UNLIMITED)");
printf(sz_test_start_fmt);
sema_test_init();
@ -175,7 +175,7 @@ int sema_test(void)
NUMBER_OF_LOOPS, 3, 0);
for (i = 0; i < NUMBER_OF_LOOPS; i++) {
nano_task_sem_give(&nanoSem1);
nano_task_sem_take_wait(&nanoSem2);
nano_task_sem_take(&nanoSem2, TICKS_UNLIMITED);
}
t = TIME_STAMP_DELTA_GET(t);

12
samples/nanokernel/test/test_arm_m3_irq_vector_table/src/main.c
View file

@ -95,9 +95,9 @@ void main(void)
}
int rv;
rv = nano_task_sem_take(&sem[0]) ||
nano_task_sem_take(&sem[1]) ||
nano_task_sem_take(&sem[2]) ? TC_FAIL : TC_PASS;
rv = nano_task_sem_take(&sem[0], TICKS_NONE) ||
nano_task_sem_take(&sem[1], TICKS_NONE) ||
nano_task_sem_take(&sem[2], TICKS_NONE) ? TC_FAIL : TC_PASS;
if (TC_FAIL == rv) {
goto get_out;
@ -107,9 +107,9 @@ void main(void)
_NvicSwInterruptTrigger(ii);
}
rv = nano_task_sem_take(&sem[0]) &&
nano_task_sem_take(&sem[1]) &&
nano_task_sem_take(&sem[2]) ? TC_PASS : TC_FAIL;
rv = nano_task_sem_take(&sem[0], TICKS_NONE) &&
nano_task_sem_take(&sem[1], TICKS_NONE) &&
nano_task_sem_take(&sem[2], TICKS_NONE) ? TC_PASS : TC_FAIL;
get_out:
TC_END_RESULT(rv);

10
samples/nanokernel/test/test_context/src/context.c
View file

@ -543,7 +543,7 @@ int fiber_yieldTest(void)
* The main task will wake this fiber.
*/
nano_fiber_sem_take_wait(&wakeFiber);
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
return TC_PASS;
}
@ -567,7 +567,7 @@ static void fiberEntry(int task_thread_id, int arg1)
ARG_UNUSED(arg1);
fiberEvidence++; /* Prove to the task that the fiber has run */
nano_fiber_sem_take_wait(&wakeFiber);
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
rv = nanoCtxFiberTest((nano_thread_id_t) task_thread_id);
if (rv != TC_PASS) {
@ -575,7 +575,7 @@ static void fiberEntry(int task_thread_id, int arg1)
}
/* Allow the task to print any messages before the next test runs */
nano_fiber_sem_take_wait(&wakeFiber);
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
rv = fiber_yieldTest();
if (rv != TC_PASS) {
@ -690,7 +690,7 @@ static int test_timeout(void)
test_fiber_busy_wait, (int)timeout, 0,
FIBER_PRIORITY, 0);
rv = nano_task_sem_take_wait_timeout(&reply_timeout, timeout + 2);
rv = nano_task_sem_take(&reply_timeout, timeout + 2);
if (!rv) {
rv = TC_FAIL;
TC_ERROR(" *** task timed out waiting for sys_thread_busy_wait()\n");
@ -707,7 +707,7 @@ static int test_timeout(void)
test_fiber_sleep, (int)timeout, 0,
FIBER_PRIORITY, 0);
rv = nano_task_sem_take_wait_timeout(&reply_timeout, timeout + 5);
rv = nano_task_sem_take(&reply_timeout, timeout + 5);
if (!rv) {
rv = TC_FAIL;
TC_ERROR(" *** task timed out waiting for fiber on fiber_sleep().\n");

23
samples/nanokernel/test/test_fifo/src/fifo.c
View file

@ -187,7 +187,7 @@ void fiber1(void)
int count = 0; /* counter */
/* Wait for fiber1 to be activated. */
nano_fiber_sem_take_wait(&nanoSemObj1);
nano_fiber_sem_take(&nanoSemObj1, TICKS_UNLIMITED);
/* Wait for data to be added to <nanoFifoObj> by task */
pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_UNLIMITED);
@ -207,7 +207,8 @@ void fiber1(void)
return;
}
nano_fiber_sem_take_wait(&nanoSemObj1); /* Wait for fiber1 to be reactivated */
/* Wait for fiber1 to be reactivated */
nano_fiber_sem_take(&nanoSemObj1, TICKS_UNLIMITED);
TC_PRINT("Test Fiber FIFO Get\n\n");
/* Get all FIFOs */
@ -420,7 +421,7 @@ void fiber2(void)
/* Wait for fiber2 to be activated */
nano_fiber_sem_take_wait(&nanoSemObj2);
nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED);
/* Wait for data to be added to <nanoFifoObj> */
pData = nano_fiber_fifo_get(&nanoFifoObj, TICKS_UNLIMITED);
@ -440,7 +441,8 @@ void fiber2(void)
return;
}
nano_fiber_sem_take_wait(&nanoSemObj2); /* Wait for fiber2 to be reactivated */
/* Wait for fiber2 to be reactivated */
nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED);
/* Fiber #2 has been reactivated by main task */
for (int i = 0; i < 4; i++) {
@ -454,7 +456,8 @@ void fiber2(void)
}
nano_fiber_sem_give(&nanoSemObjTask); /* Wake main task */
nano_fiber_sem_take_wait(&nanoSemObj2); /* Wait for fiber2 to be reactivated */
/* Wait for fiber2 to be reactivated */
nano_fiber_sem_take(&nanoSemObj2, TICKS_UNLIMITED);
testFiberFifoGetW();
PRINT_LINE;
@ -475,14 +478,14 @@ void fiber3(void)
void *pData;
/* Wait for fiber3 to be activated */
nano_fiber_sem_take_wait(&nanoSemObj3);
nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED);
/* Put two items onto <nanoFifoObj2> to unblock fibers #1 and #2. */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[0]); /* Wake fiber1 */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[1]); /* Wake fiber2 */
/* Wait for fiber3 to be re-activated */
nano_fiber_sem_take_wait(&nanoSemObj3);
nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED);
/* Immediately get the data from <nanoFifoObj2>. */
pData = nano_fiber_fifo_get(&nanoFifoObj2, TICKS_UNLIMITED);
@ -505,7 +508,7 @@ void fiber3(void)
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[3]);
/* Wait for fiber3 to be re-activated (not expected to occur) */
nano_fiber_sem_take_wait(&nanoSemObj3);
nano_fiber_sem_take(&nanoSemObj3, TICKS_UNLIMITED);
}
@ -644,7 +647,7 @@ void main(void)
nano_task_sem_give(&nanoSemObj2); /* Activate fiber #2 */
/* Wait for fibers to finish */
nano_task_sem_take_wait(&nanoSemObjTask);
nano_task_sem_take(&nanoSemObjTask, TICKS_UNLIMITED);
if (retCode == TC_FAIL) {
goto exit;
@ -675,7 +678,7 @@ void main(void)
* Wait for fiber1 to complete execution. (Using a semaphore gives
* the fiber the freedom to do blocking-type operations if it wants to.)
*/
nano_task_sem_take_wait(&nanoSemObjTask);
nano_task_sem_take(&nanoSemObjTask, TICKS_UNLIMITED);
TC_PRINT("Test Task FIFO Get\n");

12
samples/nanokernel/test/test_lifo/src/lifo.c
View file

@ -171,7 +171,7 @@ int fiberLifoWaitTest(void)
return -1;
}
nano_fiber_sem_take_wait(&fiberWaitSem);
nano_fiber_sem_take(&fiberWaitSem, TICKS_UNLIMITED);
data = nano_fiber_lifo_get_wait(&test_lifo);
if (data != &lifoItem[2]) {
fiberDetectedFailure = 1;
@ -199,7 +199,7 @@ int fiberLifoWaitTest(void)
* fiber will wait forever.
*/
nano_fiber_sem_take_wait(&fiberWaitSem);
nano_fiber_sem_take(&fiberWaitSem, TICKS_UNLIMITED);
return 0;
}
@ -251,7 +251,7 @@ int fiberLifoNonWaitTest(void)
* the LIFO.
*/
nano_fiber_sem_take_wait(&fiberWaitSem);
nano_fiber_sem_take(&fiberWaitSem, TICKS_UNLIMITED);
/*
* The task retrieved the two items from the LIFO and then triggered
@ -326,7 +326,7 @@ int taskLifoWaitTest(void)
void *data; /* ptr to data retrieved from LIFO */
/* Wait on <taskWaitSem> in case fiber's print message blocked */
nano_fiber_sem_take_wait(&taskWaitSem);
nano_fiber_sem_take(&taskWaitSem, TICKS_UNLIMITED);
/* The fiber is waiting on the LIFO. Wake it. */
nano_task_lifo_put(&test_lifo, &lifoItem[0]);
@ -399,7 +399,7 @@ int taskLifoNonWaitTest(void)
}
/* Wait for the fiber to be ready */
nano_task_sem_take_wait(&taskWaitSem);
nano_task_sem_take(&taskWaitSem, TICKS_UNLIMITED);
data = nano_task_lifo_get(&test_lifo);
if (data != (void *) &lifoItem[1]) {
@ -535,7 +535,7 @@ static int do_test_multiple_waiters(void)
/* reply_multi_waiters will have been given once for each fiber */
for (ii = 0; ii < NUM_WAITERS; ii++) {
if (!nano_task_sem_take(&reply_multi_waiters)) {
if (!nano_task_sem_take(&reply_multi_waiters, TICKS_NONE)) {
TC_ERROR(" *** Cannot take sem supposedly given by waiters.\n");
return TC_FAIL;
}

6
samples/nanokernel/test/test_sema/README.txt
View file

@ -54,9 +54,9 @@ multiple-waiter fiber 0 acquired semaphore, sending reply
multiple-waiter fiber 1 acquired semaphore, sending reply
multiple-waiter fiber 2 acquired semaphore, sending reply
Task took multi-waiter reply semaphore 3 times, as expected.
test nano_task_sem_take_wait_timeout with timeout > 0
nano_task_sem_take_wait_timeout timed out as expected
nano_task_sem_take_wait_timeout got sem in time, as expected
test nano_task_sem_take() with timeout > 0
nano_task_sem_take() timed out as expected
nano_task_sem_take() got sem in time, as expected
testing timeouts of 5 fibers on same sem
got fiber (q order: 2, t/o: 10, sem: 200001c8) as expected
got fiber (q order: 3, t/o: 15, sem: 200001c8) as expected

4
samples/nanokernel/test/test_sema/src/README
View file

@ -1,10 +1,10 @@
This semaphore test set covers the following scenarios.
nano_fiber_sem_take_wait
nano_fiber_sem_take(TICKS_UNLIMITED)
- Wait for a semaphore to be given
- Take a semaphore without waiting
nano_task_sem_take_wait
nano_task_sem_take(TICKS_UNLIMITED)
- Wait for a semaphore to be given
- Take a semaphore without waiting

69
samples/nanokernel/test/test_sema/src/sema.c
View file

@ -22,10 +22,9 @@
* semaphore routines:
*
* nano_sem_init
* nano_fiber_sem_give, nano_fiber_sem_take, nano_fiber_sem_take_wait
* nano_task_sem_give, nano_task_sem_take, nano_task_sem_take_wait
* nano_fiber_sem_give, nano_fiber_sem_take
* nano_task_sem_give, nano_task_sem_take
* nano_isr_sem_give, nano_isr_sem_take
* nano_fiber_sem_take_wait_timeout, nano_task_sem_take_wait_timeout
*
* Scenario #1:
* A task, fiber or ISR does not wait for the semaphore when taking it.
@ -93,7 +92,7 @@ void isr_sem_take(void *data)
{
ISR_SEM_INFO *pInfo = (ISR_SEM_INFO *) data;
pInfo->data = nano_isr_sem_take(pInfo->sem);
pInfo->data = nano_isr_sem_take(pInfo->sem, TICKS_NONE);
}
static void _trigger_nano_isr_sem_take(void)
@ -152,13 +151,13 @@ int testSemFiberNoWait(void)
}
for (i = 0; i < 32; i++) {
if (nano_fiber_sem_take(&testSem) != 1) {
if (nano_fiber_sem_take(&testSem, TICKS_NONE) != 1) {
TC_ERROR(" *** Expected nano_fiber_sem_take() to succeed, not fail\n");
goto errorReturn;
}
}
if (nano_fiber_sem_take(&testSem) != 0) {
if (nano_fiber_sem_take(&testSem, TICKS_NONE) != 0) {
TC_ERROR(" *** Expected nano_fiber_sem_take() to fail, not succeed\n");
goto errorReturn;
}
@ -200,7 +199,7 @@ static void fiberEntry(int arg1, int arg2)
* available (the main task will give it).
*/
nano_fiber_sem_take_wait(&testSem);
nano_fiber_sem_take(&testSem, TICKS_UNLIMITED);
semTestState = STS_TASK_WOKE_FIBER;
@ -338,13 +337,13 @@ int testSemTaskNoWait(void)
}
for (i = 0; i < 32; i++) {
if (nano_task_sem_take(&testSem) != 1) {
if (nano_task_sem_take(&testSem, TICKS_NONE) != 1) {
TC_ERROR(" *** Expected nano_task_sem_take() to succeed, not fail\n");
goto errorReturn;
}
}
if (nano_task_sem_take(&testSem) != 0) {
if (nano_task_sem_take(&testSem, TICKS_NONE) != 0) {
TC_ERROR(" *** Expected nano_task_sem_take() to fail, not succeed!\n");
goto errorReturn;
}
@ -381,7 +380,7 @@ int testSemWait(void)
TC_PRINT("Semaphore from the task woke the fiber\n");
nano_task_sem_take_wait(&testSem); /* Wait on <testSem> */
nano_task_sem_take(&testSem, TICKS_UNLIMITED); /* Wait on <testSem> */
if (semTestState != STS_FIBER_WOKE_TASK) {
TC_ERROR(" *** Expected fiber to wake task. It did not.\n");
@ -390,7 +389,7 @@ int testSemWait(void)
TC_PRINT("Semaphore from the fiber woke the task\n");
nano_task_sem_take_wait(&testSem); /* Wait on <testSem> again. */
nano_task_sem_take(&testSem, TICKS_UNLIMITED); /* Wait on <testSem> again. */
if (semTestState != STS_ISR_WOKE_TASK) {
TC_ERROR(" *** Expected ISR to wake task. It did not.\n");
@ -423,7 +422,7 @@ static char __stack fiber_multi_waiters_stacks[NUM_WAITERS][FIBER_STACKSIZE];
static void fiber_multi_waiters(int arg1, int arg2)
{
TC_PRINT("multiple-waiter fiber %d trying to get semaphore...\n", arg1);
nano_fiber_sem_take_wait(&multi_waiters);
nano_fiber_sem_take(&multi_waiters, TICKS_UNLIMITED);
TC_PRINT("multiple-waiter fiber %d acquired semaphore, sending reply\n",
arg1);
nano_fiber_sem_give(&reply_multi_waiters);
@ -453,7 +452,7 @@ static int do_test_multiple_waiters(void)
/* reply_multi_waiters will have been given once for each fiber */
for (ii = 0; ii < NUM_WAITERS; ii++) {
if (!nano_task_sem_take(&reply_multi_waiters)) {
if (!nano_task_sem_take(&reply_multi_waiters, TICKS_NONE)) {
TC_ERROR(" *** Cannot take sem supposedly given by waiters.\n");
return TC_FAIL;
}
@ -462,12 +461,12 @@ static int do_test_multiple_waiters(void)
TC_PRINT("Task took multi-waiter reply semaphore %d times, as expected.\n",
NUM_WAITERS);
if (nano_task_sem_take(&multi_waiters)) {
if (nano_task_sem_take(&multi_waiters, TICKS_NONE)) {
TC_ERROR(" *** multi_waiters should have been empty.\n");
return TC_FAIL;
}
if (nano_task_sem_take(&reply_multi_waiters)) {
if (nano_task_sem_take(&reply_multi_waiters, TICKS_NONE)) {
TC_ERROR(" *** reply_multi_waiters should have been empty.\n");
return TC_FAIL;
}
@ -577,7 +576,7 @@ static void test_fiber_pend_and_timeout(int data, int unused)
ARG_UNUSED(unused);
rv = nano_fiber_sem_take_wait_timeout(the_data->sem, the_data->timeout);
rv = nano_fiber_sem_take(the_data->sem, the_data->timeout);
if (rv) {
TC_ERROR(" *** timeout of %d did not time out.\n",
the_data->timeout);
@ -628,7 +627,7 @@ static void test_fiber_pend_and_get_sem(int data, int unused)
ARG_UNUSED(unused);
rv = nano_fiber_sem_take_wait_timeout(the_data->sem, the_data->timeout);
rv = nano_fiber_sem_take(the_data->sem, the_data->timeout);
if (!rv) {
TC_PRINT(" *** fiber (q order: %d, t/o: %d, sem: %p) timed out!\n",
the_data->q_order, the_data->timeout, the_data->sem);
@ -689,7 +688,7 @@ static void test_fiber_ticks_special_values(int packet, int special_value)
struct reply_packet *reply_packet = (void *)packet;
reply_packet->reply =
nano_fiber_sem_take_wait_timeout(&sem_timeout[0], special_value);
nano_fiber_sem_take(&sem_timeout[0], special_value);
nano_fiber_fifo_put(&timeout_order_fifo, reply_packet);
}
@ -706,10 +705,10 @@ static int test_timeout(void)
nano_sem_init(&sem_timeout[1]);
nano_fifo_init(&timeout_order_fifo);
/* test nano_task_sem_take_wait_timeout() with timeout */
/* test nano_task_sem_take() with timeout */
timeout = 10;
orig_ticks = sys_tick_get();
rv = nano_task_sem_take_wait_timeout(&sem_timeout[0], timeout);
rv = nano_task_sem_take(&sem_timeout[0], timeout);
if (rv) {
TC_ERROR(" *** timeout of %d did not time out.\n", timeout);
return TC_FAIL;
@ -720,22 +719,22 @@ static int test_timeout(void)
return TC_FAIL;
}
/* test nano_task_sem_take_wait_timeout with timeout of 0 */
/* test nano_task_sem_take() with timeout of 0 */
rv = nano_task_sem_take_wait_timeout(&sem_timeout[0], 0);
rv = nano_task_sem_take(&sem_timeout[0], 0);
if (rv) {
TC_ERROR(" *** timeout of 0 did not time out.\n");
return TC_FAIL;
}
/* test nano_task_sem_take_wait_timeout with timeout > 0 */
/* test nano_task_sem_take() with timeout > 0 */
TC_PRINT("test nano_task_sem_take_wait_timeout with timeout > 0\n");
TC_PRINT("test nano_task_sem_take() with timeout > 0\n");
timeout = 3;
orig_ticks = sys_tick_get();
rv = nano_task_sem_take_wait_timeout(&sem_timeout[0], timeout);
rv = nano_task_sem_take(&sem_timeout[0], timeout);
if (rv) {
TC_ERROR(" *** timeout of %d did not time out.\n",
@ -747,10 +746,10 @@ static int test_timeout(void)
return TC_FAIL;
}
TC_PRINT("nano_task_sem_take_wait_timeout timed out as expected\n");
TC_PRINT("nano_task_sem_take() timed out as expected\n");
/*
* test nano_task_sem_take_wait_timeout with a timeout and fiber that gives
* test nano_task_sem_take() with a timeout and fiber that gives
* the semaphore on time
*/
@ -762,7 +761,7 @@ static int test_timeout(void)
timeout,
FIBER_PRIORITY, 0);
rv = nano_task_sem_take_wait_timeout(&sem_timeout[0], (int)(timeout + 5));
rv = nano_task_sem_take(&sem_timeout[0], (int)(timeout + 5));
if (!rv) {
TC_ERROR(" *** timed out even if semaphore was given in time.\n");
return TC_FAIL;
@ -772,14 +771,14 @@ static int test_timeout(void)
return TC_FAIL;
}
TC_PRINT("nano_task_sem_take_wait_timeout got sem in time, as expected\n");
TC_PRINT("nano_task_sem_take() got sem in time, as expected\n");
/*
* test nano_task_sem_take_wait_timeout with TICKS_NONE and the
* test nano_task_sem_take() with TICKS_NONE and the
* semaphore unavailable.
*/
if (nano_task_sem_take_wait_timeout(&sem_timeout[0], TICKS_NONE)) {
if (nano_task_sem_take(&sem_timeout[0], TICKS_NONE)) {
TC_ERROR("task with TICKS_NONE got sem, but shouldn't have\n");
return TC_FAIL;
}
@ -787,12 +786,12 @@ static int test_timeout(void)
TC_PRINT("task with TICKS_NONE did not get sem, as expected\n");
/*
* test nano_task_sem_take_wait_timeout with TICKS_NONE and the
* test nano_task_sem_take() with TICKS_NONE and the
* semaphore available.
*/
nano_task_sem_give(&sem_timeout[0]);
if (!nano_task_sem_take_wait_timeout(&sem_timeout[0], TICKS_NONE)) {
if (!nano_task_sem_take(&sem_timeout[0], TICKS_NONE)) {
TC_ERROR("task with TICKS_NONE did not get available sem\n");
return TC_FAIL;
}
@ -800,7 +799,7 @@ static int test_timeout(void)
TC_PRINT("task with TICKS_NONE got available sem, as expected\n");
/*
* test nano_task_sem_take_wait_timeout with TICKS_UNLIMITED and the
* test nano_task_sem_take() with TICKS_UNLIMITED and the
* semaphore available.
*/
@ -808,7 +807,7 @@ static int test_timeout(void)
" will hang the test if it fails.\n");
nano_task_sem_give(&sem_timeout[0]);
if (!nano_task_sem_take_wait_timeout(&sem_timeout[0], TICKS_UNLIMITED)) {
if (!nano_task_sem_take(&sem_timeout[0], TICKS_UNLIMITED)) {
TC_ERROR(" *** This will never be hit!!! .\n");
return TC_FAIL;
}

2
samples/nanokernel/test/test_stack/src/stack.c
View file

@ -540,7 +540,7 @@ void main(void)
* the fiber the freedom to do blocking-type operations if it wants to.)
*
*/
nano_task_sem_take_wait(&nanoSemObj);
nano_task_sem_take(&nanoSemObj, TICKS_UNLIMITED);
TC_PRINT("Test Task STACK Pop\n");
/* Get all data */

19
samples/nanokernel/test/test_timer/src/timer.c
View file

@ -367,7 +367,8 @@ static void fiberEntry(int arg1, int arg2)
fiberDetectedError = 1;
return;
}
nano_fiber_sem_take_wait(&wakeFiber); /* Wait forever - let task run */
/* Wait forever - let task run */
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
/* Check that timers expire in the correct order */
TC_PRINT("Fiber testing timers expire in the correct order\n");
@ -378,7 +379,8 @@ static void fiberEntry(int arg1, int arg2)
fiberDetectedError = 2;
return;
}
nano_fiber_sem_take_wait(&wakeFiber); /* Wait forever - let task run */
/* Wait forever - let task run */
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
/* Check that timers can be stopped */
TC_PRINT("Task testing the stopping of timers\n");
@ -389,7 +391,8 @@ static void fiberEntry(int arg1, int arg2)
fiberDetectedError = 3;
return;
}
nano_fiber_sem_take_wait(&wakeFiber); /* Wait forever - let task run */
/* Wait forever - let task run */
nano_fiber_sem_take(&wakeFiber, TICKS_UNLIMITED);
/* Fiber to wait on a timer that will be stopped by another fiber */
TC_PRINT("Fiber to stop a timer that has a waiting fiber\n");
@ -495,7 +498,7 @@ void main(void)
task_fiber_start(fiberStack, FIBER_STACKSIZE, fiberEntry,
0, 0, FIBER_PRIORITY, 0);
nano_task_sem_take_wait(&wakeTask);
nano_task_sem_take(&wakeTask, TICKS_UNLIMITED);
if (fiberDetectedError == 1) {
TC_ERROR("Fiber-level of waiting for timers failed\n");
@ -504,7 +507,7 @@ void main(void)
}
nano_task_sem_give(&wakeFiber);
nano_task_sem_take_wait(&wakeTask);
nano_task_sem_take(&wakeTask, TICKS_UNLIMITED);
if (fiberDetectedError == 2) {
TC_ERROR("Fiber-level timer expiration order failed\n");
@ -513,7 +516,7 @@ void main(void)
}
nano_task_sem_give(&wakeFiber);
nano_task_sem_take_wait(&wakeTask);
nano_task_sem_take(&wakeTask, TICKS_UNLIMITED);
if (fiberDetectedError == 3) {
TC_ERROR("Fiber-level stopping of timers test failed\n");
@ -522,7 +525,7 @@ void main(void)
}
nano_task_sem_give(&wakeFiber);
nano_task_sem_take_wait(&wakeTask);
nano_task_sem_take(&wakeTask, TICKS_UNLIMITED);
if (fiberDetectedError == 4) {
TC_ERROR("Fiber stopping a timer waited upon by a fiber failed\n");
rv = TC_FAIL;
@ -536,7 +539,7 @@ void main(void)
goto doneTests;
}
nano_task_sem_take_wait(&wakeTask);
nano_task_sem_take(&wakeTask, TICKS_UNLIMITED);
#if 0
/*

4
samples/net/listener/src/listener.c
View file

@ -190,7 +190,7 @@ void fiberEntry(void)
while (1) {
/* wait for task to let us have a turn */
nano_fiber_sem_take_wait (&nanoSemFiber);
nano_fiber_sem_take(&nanoSemFiber, TICKS_UNLIMITED);
buf = net_receive(ctx, TICKS_NONE);
if (buf) {
@ -230,7 +230,7 @@ void main(void)
nano_task_sem_give(&nanoSemFiber);
/* now wait for fiber to let us have a turn */
nano_task_sem_take_wait(&nanoSemTask);
nano_task_sem_take(&nanoSemTask, TICKS_UNLIMITED);
}
}

4
samples/net/loopback_test/src/network.c
View file

@ -112,7 +112,7 @@ void fiberEntry(void)
while (1) {
/* wait for task to let us have a turn */
nano_fiber_sem_take_wait (&nanoSemFiber);
nano_fiber_sem_take(&nanoSemFiber, TICKS_UNLIMITED);
buf = net_receive(ctx, TICKS_NONE);
if (buf) {
@ -194,7 +194,7 @@ void main(void)
nano_task_sem_give(&nanoSemFiber);
/* now wait for fiber to let us have a turn */
nano_task_sem_take_wait(&nanoSemTask);
nano_task_sem_take(&nanoSemTask, TICKS_UNLIMITED);
}
}