michaelh/zephyr
1
0
Fork 0
Code Releases Activity

semaphore: Simplify task_sem_take() API family

Browse source 
Changes the semaphore API so that the timeout parameter must be specified
when invoking task_sem_take() thereby obsoleting the following APIs:
	task_sem_take_wait()
	task_sem_take_wait_timeout()
	_task_sem_take()

Change-Id: I746d5c966a3b81ffe014333af51aa10ea8a63263
Signed-off-by: Peter Mitsis <peter.mitsis@windriver.com>
This commit is contained in:
Peter Mitsis 2015-12-07 13:44:11 -05:00 • committed by Anas Nashif
commit 40eba989e2
30 changed files with 139 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -71,7 +71,7 @@ void helloLoop(const char *taskname, ksem_t mySem, ksem_t otherSem)
{
while (1)
{
task_sem_take_wait (mySem);
task_sem_take (mySem, TICKS_UNLIMITED);
PRINT ("%s: Hello World!\n", taskname); /* Action 1 */
@ -185,4 +185,4 @@ void main(void) {
}
}
#endif
#endif

2
doc/kernel/microkernel/microkernel_mailboxes.rst
View file

@ -562,7 +562,7 @@ to keep up.
/* until the previous message has been received by the consumer */
do {
memcpy(send_msg.tx_block.pointer_to_data, hw_buffer, 4096);
} while (task_sem_take(MY_SEMA) != RC_OK);
} while (task_sem_take(MY_SEMA, TICKS_NONE) != RC_OK);
/* finish preparing to send message */
send_msg.size = 4096;

12
doc/kernel/microkernel/microkernel_semaphores.rst
View file

@ -139,7 +139,7 @@ and gives a warning if it is not obtained in that time.
{
...
if (task_sem_take_wait_timeout(INPUT_DATA, 500) == RC_TIME) {
if (task_sem_take(INPUT_DATA, 500) == RC_TIME) {
printf("Input data not available!");
} else {
/* extract saved data item from buffer and process it */
@ -207,13 +207,7 @@ The following APIs for an individual semaphore are provided by
Gives a semaphore.
:c:func:`task_sem_take()`
Takes a semaphore, or fails if not given.
:c:func:`task_sem_take_wait()`
Takes a semaphore, or waits until it is given.
:c:func:`task_sem_take_wait_timeout()`
Takes a semaphore, or waits for a specified time period.
Takes a semaphore, with time limited waiting.
:cpp:func:`task_sem_reset()`
Sets the semaphore count to zero.
@ -233,4 +227,4 @@ The following APIs for semaphore groups are provided by microkernel.h.
Takes a semaphore from a group. or waits for a specified time period.
:cpp:func:`task_sem_group_reset()`
Sets the count to zero for each semaphore in a group.
Sets the count to zero for each semaphore in a group.

8
doc/kernel/microkernel/microkernel_timers.rst
View file

@ -121,7 +121,7 @@ a period of zero, it stops automatically once it expires.
/* gather data until timer expires */
do {
...
} while (task_sem_take(my_sem) != RC_OK);
} while (task_sem_take(my_sem, TICKS_NONE) != RC_OK);
/* process the new data */
...
@ -147,7 +147,7 @@ reactivate the timer.
/* gather data until timer expires */
do {
...
} while (task_sem_take(my_sem) != RC_OK);
} while (task_sem_take(my_sem, TICKS_NONE) != RC_OK);
/* process the new data, then loop around to get more */
...
@ -174,7 +174,7 @@ This code illustrates how an active timer can be stopped prematurely.
task_timer_stop(timer_id);
/* check to see if the timer expired before it was stopped */
if (task_sem_take(my_sem) == RC_OK) {
if (task_sem_take(my_sem, TICKS_NONE) == RC_OK) {
printf("Warning: Input took too long to arrive!");
}
@ -206,4 +206,4 @@ The following microkernel timer APIs are provided by :file:`microkernel.h`:
Cancels a timer.
:cpp:func:`task_timer_free()`
Marks timer as unused.
Marks timer as unused.

2
include/device.h
View file

@ -141,7 +141,7 @@ static inline void synchronous_call_wait(device_sync_call_t *sync)
if ((sys_execution_context_type_get() == NANO_CTX_TASK) &&
(task_priority_get() < CONFIG_NUM_TASK_PRIORITIES - 1)) {
sync->caller_is_task = true;
task_sem_take_wait(sync->t_sem);
task_sem_take(sync->t_sem, TICKS_UNLIMITED);
} else {
sync->caller_is_task = false;
nano_sem_take_wait(&sync->f_sem);

45
include/microkernel/semaphore.h
View file

@ -37,7 +37,6 @@ extern "C" {
#include <microkernel/base_api.h>
extern void _k_sem_struct_value_update(int n, struct _k_sem_struct *S);
extern int _task_sem_take(ksem_t sema, int32_t ticks);
extern ksem_t _task_sem_group_take(ksemg_t semagroup, int32_t ticks);
/*
@ -142,27 +141,21 @@ extern void task_sem_group_reset(ksemg_t semagroup);
*
* @brief Take semaphore or fail.
*
* This routine takes semaphore @a s. If the semaphore's count is zero the
* This routine takes semaphore @a sema. If the semaphore's count is zero the
* routine immediately returns a failure indication.
*
* @param s Semaphore name.
* @param sema Semaphore name.
* @param timeout Affects the action taken should the semaphore be unavailable.
* If TICKS_NONE, then return immediately. If TICKS_UNLIMITED, then wait as
* long as necessary. Otherwise wait up to the specified number of ticks before
* timing out.
*
* @return RC_OK on success, or RC_FAIL on failure.
* @retval RC_OK Successfully took semaphore
* @retval RC_TIME Timed out while waiting for semaphore
* @retval RC_FAIL Failed to immediately take semaphore when
* @a timeout = TICKS_NONE
*/
#define task_sem_take(s) _task_sem_take(s, TICKS_NONE)
/**
*
* @brief Take semaphore or wait.
*
* This routine takes semaphore @a s. If the semaphore's count is zero the
* routine waits until it is given.
*
* @param s Semaphore name.
*
* @return RC_OK.
*/
#define task_sem_take_wait(s) _task_sem_take(s, TICKS_UNLIMITED)
extern int task_sem_take(ksem_t sema, int32_t timeout);
/**
*
@ -179,22 +172,6 @@ extern void task_sem_group_reset(ksemg_t semagroup);
#define task_sem_group_take_wait(g) _task_sem_group_take(g, TICKS_UNLIMITED)
#ifdef CONFIG_SYS_CLOCK_EXISTS
/**
*
* @brief Take semaphore or timeout.
*
* This routine takes semaphore @a s. If the semaphore's count is zero the
* routine waits until it is given, or until the specified time limit
* is reached.
*
* @param s Semaphore name.
* @param t Maximum number of ticks to wait.
*
* @return RC_OK on success, or RC_TIME on timeout.
*/
#define task_sem_take_wait_timeout(s, t) _task_sem_take(s, t)
/**
*
* @brief Take semaphore from group or timeout.

4
kernel/microkernel/k_semaphore.c
View file

@ -349,12 +349,12 @@ void _k_sem_wait_request(struct k_args *A)
}
}
int _task_sem_take(ksem_t sema, int32_t time)
int task_sem_take(ksem_t sema, int32_t timeout)
{
struct k_args A;
A.Comm = _K_SVC_SEM_WAIT_REQUEST;
A.Time.ticks = time;
A.Time.ticks = timeout;
A.args.s1.sema = sema;
KERNEL_ENTRY(&A);
return A.Time.rcode;

2
samples/microkernel/apps/hello_world/src/hello.c
View file

@ -50,7 +50,7 @@
void helloLoop(const char *taskname, ksem_t mySem, ksem_t otherSem)
{
while (1) {
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
/* say "hello" */
PRINT("%s: Hello World!\n", taskname);

2
samples/microkernel/benchmark/app_kernel/src/mailbox_r.c
View file

@ -86,7 +86,7 @@ int mailbox_get(kmbox_t mailbox, int size, int count, unsigned int* time)
Message.size = size;
/* sync with the sender */
task_sem_take_wait(SEM0);
task_sem_take(SEM0, TICKS_UNLIMITED);
t = BENCH_START();
for (i = 0; i < count; i++) {
task_mbox_get(mailbox, &Message, TICKS_UNLIMITED);

2
samples/microkernel/benchmark/app_kernel/src/pipe_r.c
View file

@ -102,7 +102,7 @@ int pipeget(kpipe_t pipe, K_PIPE_OPTION option, int size, int count,
int size2xfer_total = size * count;
/* sync with the sender */
task_sem_take_wait(SEM0);
task_sem_take(SEM0, TICKS_UNLIMITED);
t = BENCH_START();
for (i = 0; _1_TO_N == option || (i < count); i++) {
int sizexferd = 0;

8
samples/microkernel/benchmark/app_kernel/src/receiver.c
View file

@ -44,19 +44,19 @@ void recvtask(void)
{
/* order must be compatible with master.c ! */
#ifdef FIFO_BENCH
task_sem_take_wait(STARTRCV);
task_sem_take(STARTRCV, TICKS_UNLIMITED);
dequtask();
#endif
#ifdef SEMA_BENCH
task_sem_take_wait(STARTRCV);
task_sem_take(STARTRCV, TICKS_UNLIMITED);
waittask();
#endif
#ifdef MAILBOX_BENCH
task_sem_take_wait(STARTRCV);
task_sem_take(STARTRCV, TICKS_UNLIMITED);
mailrecvtask();
#endif
#ifdef PIPE_BENCH
task_sem_take_wait(STARTRCV);
task_sem_take(STARTRCV, TICKS_UNLIMITED);
piperecvtask();
#endif
}

4
samples/microkernel/benchmark/app_kernel/src/sema_r.c
View file

@ -42,10 +42,10 @@ void waittask(void)
slist[4] = ENDLIST;
for (i = 0; i < NR_OF_SEMA_RUNS; i++) {
task_sem_take_wait(SEM1);
task_sem_take(SEM1, TICKS_UNLIMITED);
}
for (i = 0; i < NR_OF_SEMA_RUNS; i++) {
task_sem_take_wait_timeout(SEM1, SEMA_WAIT_TIME);
task_sem_take(SEM1, SEMA_WAIT_TIME);
}
for (i = 0; i < NR_OF_SEMA_RUNS; i++) {

2
samples/microkernel/benchmark/footprint/src/microkernel_footprint.c
View file

@ -86,7 +86,7 @@ static pfunc func_array[] = {
(pfunc)task_sem_count_get,
(pfunc)task_sem_reset,
(pfunc)task_sem_group_reset,
(pfunc)_task_sem_take,
(pfunc)task_sem_take,
(pfunc)_task_sem_group_take,
/* pipe functions */
(pfunc)task_pipe_put,

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

@ -63,7 +63,7 @@ static void latencyTestIsr(void *unused)
*/
void microInt(void)
{
task_sem_take_wait(INTSEMA);
task_sem_take(INTSEMA, TICKS_UNLIMITED);
irq_offload(latencyTestIsr, NULL);
task_suspend(task_id_get());
}

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

@ -72,7 +72,7 @@ int microSemaLockUnlock(void)
bench_test_start();
timestamp = TIME_STAMP_DELTA_GET(0);
for (i = SEMASTART; i <= SEMAEND; i++) {
task_sem_take_wait(i);
task_sem_take(i, TICKS_UNLIMITED);
}
timestamp = TIME_STAMP_DELTA_GET(timestamp);
if (bench_test_end() == 0) {

8
samples/microkernel/test/test_critical/src/critical.c
View file

@ -83,13 +83,13 @@ uint32_t criticalLoop(uint32_t count)
void AlternateTask(void)
{
task_sem_take_wait(ALT_SEM); /* Wait to be activated */
task_sem_take(ALT_SEM, TICKS_UNLIMITED); /* Wait to be activated */
altTaskIterations = criticalLoop(altTaskIterations);
task_sem_give(REGRESS_SEM);
task_sem_take_wait(ALT_SEM); /* Wait to be re-activated */
task_sem_take(ALT_SEM, TICKS_UNLIMITED); /* Wait to be re-activated */
altTaskIterations = criticalLoop(altTaskIterations);
@ -119,7 +119,7 @@ void RegressionTask(void)
nCalls = criticalLoop(nCalls);
/* Wait for AlternateTask() to complete */
status = task_sem_take_wait_timeout(REGRESS_SEM, TEST_TIMEOUT);
status = task_sem_take(REGRESS_SEM, TEST_TIMEOUT);
if (status != RC_OK) {
TC_ERROR("Timed out waiting for REGRESS_SEM\n");
goto errorReturn;
@ -141,7 +141,7 @@ void RegressionTask(void)
nCalls = criticalLoop(nCalls);
/* Wait for AlternateTask() to finish */
status = task_sem_take_wait_timeout(REGRESS_SEM, TEST_TIMEOUT);
status = task_sem_take(REGRESS_SEM, TEST_TIMEOUT);
if (status != RC_OK) {
TC_ERROR("Timed out waiting for REGRESS_SEM\n");
goto errorReturn;

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

@ -502,13 +502,13 @@ int eventSignalHandlerTest(void)
void AlternateTask(void)
{
/* Wait for eventWaitTest() to run. */
task_sem_take_wait(ALTERNATE_SEM);
task_sem_take(ALTERNATE_SEM, TICKS_UNLIMITED);
task_event_send(EVENT_ID);
releaseTestFiber();
_trigger_isrEventSignal();
/* Wait for eventTimeoutTest() to run. */
task_sem_take_wait(ALTERNATE_SEM);
task_sem_take(ALTERNATE_SEM, TICKS_UNLIMITED);
task_event_send(EVENT_ID);
releaseTestFiber();
_trigger_isrEventSignal();
@ -521,11 +521,11 @@ void AlternateTask(void)
* waiting task will get woken up after the event handler for EVENT_ID runs.
*/
task_sem_take_wait(ALTERNATE_SEM);
task_sem_take(ALTERNATE_SEM, TICKS_UNLIMITED);
handlerRetVal = 0;
task_event_send(EVENT_ID);
task_sem_take_wait(ALTERNATE_SEM);
task_sem_take(ALTERNATE_SEM, TICKS_UNLIMITED);
handlerRetVal = 1;
task_event_send(EVENT_ID);
}

8
samples/microkernel/test/test_fifo/src/fifo.c
View file

@ -192,7 +192,7 @@ void MicroTestFifoTask(void)
int locData = SPECIAL_DATA; /* variable to pass data to and from queue */
/* (1) Wait for semaphore: put element test */
task_sem_take_wait(SEMSIG_MicroTestFifoTask);
task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
TC_PRINT("Starts %s\n", __func__);
/* Put one element */
@ -215,7 +215,7 @@ void MicroTestFifoTask(void)
* task is in task_fifo_put_wait. This is to test return value of the
* task_fifo_put_wait interface.
*/
task_sem_take_wait(SEMSIG_MicroTestFifoTask);
task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
/*
* RegressionTask is waiting to put data into FIFO queue, which is
* full. We purge the queue here and the task_fifo_put_wait interface
@ -237,7 +237,7 @@ void MicroTestFifoTask(void)
}
/* (3) Wait for semaphore: get element test */
task_sem_take_wait(SEMSIG_MicroTestFifoTask);
task_sem_take(SEMSIG_MicroTestFifoTask, TICKS_UNLIMITED);
TC_PRINT("%s: About to dequeue 1 element\n", __func__);
retValue = task_fifo_get(FIFOQ, &locData);
/*
@ -618,7 +618,7 @@ void RegressionTask(void)
TC_PRINT("%s: queue is empty. Test Done!\n", __func__);
}
task_sem_take_wait(SEM_TestDone);
task_sem_take(SEM_TestDone, TICKS_UNLIMITED);
exitTest:

10
samples/microkernel/test/test_mail/src/mail.c
View file

@ -193,7 +193,7 @@ int MsgSenderTask(void)
/* Wait for Receiver Task to finish using myMbox */
(void) task_sem_take_wait(semSync1);
(void) task_sem_take(semSync1, TICKS_UNLIMITED);
/* Send message (no wait) to specified task that is waiting for it */
@ -220,7 +220,7 @@ int MsgSenderTask(void)
/* Wait for Receiver Task to start sleeping */
(void) task_sem_take_wait(semSync2);
(void) task_sem_take(semSync2, TICKS_UNLIMITED);
/* Send message to any task that is not yet waiting for it */
@ -255,7 +255,7 @@ int MsgSenderTask(void)
/* Sync with Receiver Task, since we're about to use a timeout */
task_sem_take_wait(semSync1);
task_sem_take(semSync1, TICKS_UNLIMITED);
/* Send message used in 2 part receive test */
@ -331,7 +331,7 @@ int MsgSenderTask(void)
/* Sync with Receiver Task, since we're about to use a timeout */
task_sem_take_wait(semSync1);
task_sem_take(semSync1, TICKS_UNLIMITED);
/* Send message used in long-duration receive test */
@ -516,7 +516,7 @@ int MsgRcvrTask(void)
/* Sync with Sender Task, since we're about to use a timeout */
(void) task_sem_take_wait(semSync2);
(void) task_sem_take(semSync2, TICKS_UNLIMITED);
/* Receive message header for cancelled receive test */

17
samples/microkernel/test/test_map/src/map.c
View file

@ -84,7 +84,8 @@ void HelperTask(void)
{
void *ptr[NUMBLOCKS]; /* Pointer to memory block */
task_sem_take_wait(SEM_REGRESSDONE); /* Wait for part 1 to complete */
/* Wait for part 1 to complete */
task_sem_take(SEM_REGRESSDONE, TICKS_UNLIMITED);
/* Part 2 of test */
@ -98,7 +99,8 @@ void HelperTask(void)
}
task_sem_give(SEM_HELPERDONE); /* Indicate part 2 is complete */
task_sem_take_wait(SEM_REGRESSDONE); /* Wait for part 3 to complete */
/* Wait for part 3 to complete */
task_sem_take(SEM_REGRESSDONE, TICKS_UNLIMITED);
/*
* Part 4 of test.
@ -112,7 +114,7 @@ void HelperTask(void)
task_sem_give(SEM_HELPERDONE);
/* Part 5 of test */
task_sem_take_wait(SEM_REGRESSDONE);
task_sem_take(SEM_REGRESSDONE, TICKS_UNLIMITED);
TC_PRINT("%s: About to free another memory block\n", __func__);
task_mem_map_free(MAP_LgBlks, &ptr[1]);
@ -329,7 +331,8 @@ void RegressionTask(void)
printPointers(ptr);
task_sem_give(SEM_REGRESSDONE); /* Allow HelperTask to run */
task_sem_take_wait(SEM_HELPERDONE); /* Wait for HelperTask to finish */
/* Wait for HelperTask to finish */
task_sem_take(SEM_HELPERDONE, TICKS_UNLIMITED);
/*
* Part 3 of test.
@ -360,7 +363,8 @@ void RegressionTask(void)
goto exitTest; /* terminate test */
}
task_sem_take_wait(SEM_HELPERDONE); /* Wait for HelperTask to complete */
/* Wait for HelperTask to complete */
task_sem_take(SEM_HELPERDONE, TICKS_UNLIMITED);
TC_PRINT("%s: start to wait for block\n", __func__);
task_sem_give(SEM_REGRESSDONE); /* Allow HelperTask to run part 5 */
@ -374,7 +378,8 @@ void RegressionTask(void)
goto exitTest; /* terminate test */
}
task_sem_take_wait(SEM_HELPERDONE); /* Wait for HelperTask to complete */
/* Wait for HelperTask to complete */
task_sem_take(SEM_HELPERDONE, TICKS_UNLIMITED);
/* Free memory block */

20
samples/microkernel/test/test_pipe/src/pipe.c
View file

@ -201,7 +201,7 @@ int pipePutHelperWork(SIZE_EXPECT *singleItems, int nSingles,
int bytesReceived; /* number of bytes received */
for (i = 0; i < nSingles; i++) {
(void)task_sem_take_wait(altSem);
(void)task_sem_take(altSem, TICKS_UNLIMITED);
for (j = 0; j < sizeof(rxBuffer); j++) {
rxBuffer[j] = 0;
}
@ -240,7 +240,7 @@ int pipePutHelperWork(SIZE_EXPECT *singleItems, int nSingles,
* stored in it.
*/
(void)task_sem_take_wait(altSem);
(void)task_sem_take(altSem, TICKS_UNLIMITED);
for (i = 0; i < nMany; i++) {
for (j = 0; j < sizeof(rxBuffer); j++) {
@ -360,7 +360,7 @@ int pipePutTestWork(SIZE_EXPECT *singleItems, int nSingles,
}
task_sem_give(altSem);
(void)task_sem_take_wait(regSem);
(void)task_sem_take(regSem, TICKS_UNLIMITED);
nitem = task_sem_count_get(counterSem) - 1;
if (nitem != i) {
@ -395,7 +395,7 @@ int pipePutTestWork(SIZE_EXPECT *singleItems, int nSingles,
task_sem_give(altSem); /* Wake the alternate task */
/* wait for other task reading all the items from pipe */
(void)task_sem_take_wait(regSem);
(void)task_sem_take(regSem, TICKS_UNLIMITED);
if (task_sem_count_get(counterSem) != nMany) {
TC_ERROR("Expected number of items %d, not %d\n",
@ -456,7 +456,8 @@ int pipePutWaitHelper(void)
int rv; /* return value from task_pipe_get*/
int bytesRead; /* # of bytes read from task_pipe_get() */
(void)task_sem_take_wait(altSem); /* Wait until test is ready */
/* Wait until test is ready */
(void)task_sem_take(altSem, TICKS_UNLIMITED);
/*
* 1. task_pipe_get(TICKS_UNLIMITED) will force a context
@ -568,7 +569,7 @@ int pipePutWaitTest(void)
}
/* Wait for AlternateTask()'s pipePutWaitHelper() to finish */
(void)task_sem_take_wait(regSem);
(void)task_sem_take(regSem, TICKS_UNLIMITED);
return TC_PASS;
}
@ -586,7 +587,8 @@ int pipePutTimeoutHelper(void)
int rv; /* return value from task_pipe_get() */
int bytesRead; /* # of bytes read from task_pipe_get() */
(void)task_sem_take_wait(altSem); /* Wait until test is ready */
/* Wait until test is ready */
(void)task_sem_take(altSem, TICKS_UNLIMITED);
/*
* 1. task_pipe_get(timeout) will force a context
@ -718,7 +720,7 @@ int pipePutTimeoutTest(void)
}
/* Wait for AlternateTask()'s pipePutWaitHelper() to finish */
(void)task_sem_take_wait(regSem);
(void)task_sem_take(regSem, TICKS_UNLIMITED);
return TC_PASS;
}
@ -821,7 +823,7 @@ int pipeGetWaitHelper(void)
{
int rv; /* return coded form pipeGetWaitHelperWork() */
(void)task_sem_take_wait(altSem);
(void)task_sem_take(altSem, TICKS_UNLIMITED);
rv = pipeGetWaitHelperWork(wait_all_N, ARRAY_SIZE(wait_all_N));
if (rv != TC_PASS) {

10
samples/microkernel/test/test_pool/src/pool.c
View file

@ -249,7 +249,7 @@ int poolBlockGetTest(void)
void HelperTask(void)
{
task_sem_take_wait(HELPER_SEM);
task_sem_take(HELPER_SEM, TICKS_UNLIMITED);
task_sem_give(REGRESS_SEM);
task_mem_pool_free(&helperBlock);
@ -297,7 +297,7 @@ int poolBlockGetTimeoutTest(void)
return TC_FAIL;
}
rv = task_sem_take(REGRESS_SEM);
rv = task_sem_take(REGRESS_SEM, TICKS_NONE);
if (rv != RC_OK) {
TC_ERROR("Failed to get size 3148 byte block within 20 ticks\n");
return TC_FAIL;
@ -359,7 +359,7 @@ int poolBlockGetWaitTest(void)
void DefragTask(void)
{
task_sem_take_wait(DEFRAG_SEM); /* Wait to be activated */
task_sem_take(DEFRAG_SEM, TICKS_UNLIMITED); /* Wait to be activated */
task_mem_pool_defragment(POOL_ID);
@ -402,7 +402,7 @@ int poolDefragTest(void)
return TC_FAIL;
}
rv = task_sem_take(REGRESS_SEM);
rv = task_sem_take(REGRESS_SEM, TICKS_NONE);
if (rv != RC_OK) {
TC_ERROR("DefragTask did not finish in allotted time!\n");
return TC_FAIL;
@ -426,7 +426,7 @@ int poolDefragTest(void)
void AlternateTask(void)
{
task_sem_take_wait(ALTERNATE_SEM);
task_sem_take(ALTERNATE_SEM, TICKS_UNLIMITED);
evidence = 1;

54
samples/microkernel/test/test_sema/src/sema.c
View file

@ -28,8 +28,6 @@
* task_sem_give()
* task_sem_count_get()
* task_sem_take()
* task_sem_take_wait()
* task_sem_take_wait_timeout()
* isr_sem_give()
* fiber_sem_give()
*/
@ -113,7 +111,7 @@ int simpleSemaTest(void)
*/
for (i = 9; i >= 4; i--) {
status = task_sem_take(simpleSem);
status = task_sem_take(simpleSem, TICKS_NONE);
if (status != RC_OK) {
TC_ERROR("task_sem_take(SIMPLE_SEM) error. Expected %d, not %d.\n",
RC_OK, status);
@ -136,7 +134,7 @@ int simpleSemaTest(void)
*/
for (i = 0; i < 10; i++) {
status = task_sem_take(simpleSem);
status = task_sem_take(simpleSem, TICKS_NONE);
if (status != RC_FAIL) {
TC_ERROR("task_sem_take(SIMPLE_SEM) error. Expected %d, got %d.\n",
RC_FAIL, status);
@ -168,9 +166,9 @@ int simpleSemaWaitTest(void)
for (i = 0; i < 5; i++) {
/* Wait one second for SIMPLE_SEM. Timeout is expected. */
status = task_sem_take_wait_timeout(simpleSem, OBJ_TIMEOUT);
status = task_sem_take(simpleSem, OBJ_TIMEOUT);
if (status != RC_TIME) {
TC_ERROR("task_sem_take_wait_timeout() error. Expected %d, got %d\n",
TC_ERROR("task_sem_take() error. Expected %d, got %d\n",
RC_TIME, status);
return TC_FAIL;
}
@ -184,27 +182,27 @@ int simpleSemaWaitTest(void)
task_sem_give(altSem);
status = task_sem_take_wait_timeout(simpleSem, OBJ_TIMEOUT);
status = task_sem_take(simpleSem, OBJ_TIMEOUT);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait_timeout() error. Expected %d, got %d\n",
TC_ERROR("task_sem_take() error. Expected %d, got %d\n",
RC_OK, status);
return TC_FAIL;
}
/*
* Note that task_sem_take_wait() has been tested when waking up the alternate
* task. Since previous tests had this task waiting, the alternate task
* must have had the time to enter the state where it is waiting for the
* ALTTASK_SEM semaphore to be given. Thus, we do not need to test for
* it here.
* Note that task_sem_take(TICKS_UNLIMITED) has been tested when waking up
* the alternate task. Since previous tests had this task waiting, the
* alternate task must have had the time to enter the state where it is
* waiting for the ALTTASK_SEM semaphore to be given. Thus, we do not need
* to test for it here.
*
* Now wait on SIMPLE_SEM again. This time it will be woken up by an
* ISR signalling the semaphore.
*/
status = task_sem_take_wait_timeout(simpleSem, OBJ_TIMEOUT);
status = task_sem_take(simpleSem, OBJ_TIMEOUT);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait_timeout() error. Expected %d, got %d\n",
TC_ERROR("task_sem_take() error. Expected %d, got %d\n",
RC_OK, status);
return TC_FAIL;
}
@ -381,9 +379,9 @@ static int simpleFiberSemTest(void)
/* let the fiber signal the semaphore and wait on it */
releaseTestFiber();
status = task_sem_take_wait_timeout(simpleSem, OBJ_TIMEOUT);
status = task_sem_take(simpleSem, OBJ_TIMEOUT);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait_timeout() error. Expected %d, got %d\n",
TC_ERROR("task_sem_take() error. Expected %d, got %d\n",
RC_OK, status);
return TC_FAIL;
}
@ -422,7 +420,7 @@ int HighPriTask(void)
int status;
/* Wait until task is activated */
status = task_sem_take_wait(hpSem);
status = task_sem_take(hpSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("%s priority task failed to wait on %s: %d\n",
"High", "HIGH_PRI_SEM", status);
@ -430,7 +428,7 @@ int HighPriTask(void)
}
/* Wait on a semaphore along with other tasks */
status = task_sem_take_wait(manyBlockSem);
status = task_sem_take(manyBlockSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("%s priority task failed to wait on %s: %d\n",
"High", "MANY_BLOCKED_SEM", status);
@ -456,7 +454,7 @@ int LowPriTask(void)
int status;
/* Wait on a semaphore along with other tasks */
status = task_sem_take_wait(manyBlockSem);
status = task_sem_take(manyBlockSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("%s priority task failed to wait on %s: %d\n",
"Low", "MANY_BLOCKED_SEM", status);
@ -484,9 +482,9 @@ int AlternateTask(void)
int i;
/* Wait until it is time to continue */
status = task_sem_take_wait(altSem);
status = task_sem_take(altSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait() error. Expected %d, got %d\n",
TC_ERROR("task_sem_take() error. Expected %d, got %d\n",
RC_OK, status);
return TC_FAIL;
}
@ -506,17 +504,17 @@ int AlternateTask(void)
trigger_isrSemaSignal(simpleSem);
/* Wait for RegressionTask to wake this task up */
status = task_sem_take_wait(altSem);
status = task_sem_take(altSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait() error. Expected %d, got %d",
TC_ERROR("task_sem_take() error. Expected %d, got %d",
RC_OK, status);
return TC_FAIL;
}
/* Wait on a semaphore that will have many waiters */
status = task_sem_take_wait(manyBlockSem);
status = task_sem_take(manyBlockSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait() error. Expected %d, got %d",
TC_ERROR("task_sem_take() error. Expected %d, got %d",
RC_OK, status);
return TC_FAIL;
}
@ -525,9 +523,9 @@ int AlternateTask(void)
task_sem_give(blockMpSem);
/* Wait until the alternate task is needed again */
status = task_sem_take_wait(altSem);
status = task_sem_take(altSem, TICKS_UNLIMITED);
if (status != RC_OK) {
TC_ERROR("task_sem_take_wait() error. Expected %d, got %d",
TC_ERROR("task_sem_take() error. Expected %d, got %d",
RC_OK, status);
return TC_FAIL;
}

30
samples/microkernel/test/test_task/src/task.c
View file

@ -151,15 +151,15 @@ int taskMacrosTest(int taskId, int taskPrio)
void helperTaskSetPrioTest(void)
{
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
helperData = task_priority_get(); /* Helper task priority lowered by 5 */
task_sem_give(RT_SEM);
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
helperData = task_priority_get(); /* Helper task prioirty raised by 10 */
task_sem_give(RT_SEM);
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
helperData = task_priority_get(); /* Helper task prioirty restored */
task_sem_give(RT_SEM);
}
@ -207,7 +207,7 @@ int taskSetPrioTest(void)
/* Lower the priority of the helper task (HelperTask) */
task_priority_set(HT_TASKID, HT_PRIO + 5);
task_sem_give(HT_SEM);
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
if (helperData != HT_PRIO + 5) {
TC_ERROR("Expected priority to be changed to %d, not %d\n",
HT_PRIO + 5, helperData);
@ -217,7 +217,7 @@ int taskSetPrioTest(void)
/* Raise the priority of the helper task (HelperTask) */
task_priority_set(HT_TASKID, HT_PRIO - 5);
task_sem_give(HT_SEM);
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
if (helperData != HT_PRIO - 5) {
TC_ERROR("Expected priority to be changed to %d, not %d\n",
HT_PRIO - 5, helperData);
@ -228,7 +228,7 @@ int taskSetPrioTest(void)
/* Restore the priority of the helper task (HelperTask) */
task_priority_set(HT_TASKID, HT_PRIO);
task_sem_give(HT_SEM);
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
if (helperData != HT_PRIO) {
TC_ERROR("Expected priority to be changed to %d, not %d\n",
HT_PRIO, helperData);
@ -249,7 +249,7 @@ void helperTaskSleepTest(void)
{
int32_t firstTick;
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
firstTick = sys_tick_get_32();
while (!is_main_task_ready) {
@ -286,7 +286,7 @@ int taskSleepTest(void)
tick = sys_tick_get_32() - tick;
is_main_task_ready = 1;
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
if (tick != SLEEP_TIME) {
TC_ERROR("task_sleep() slept for %d ticks, not %d\n", tick, SLEEP_TIME);
@ -322,7 +322,7 @@ int taskSleepTest(void)
void helperTaskYieldTest(void)
{
int i;
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
for (i = 0; i < 5; i++) {
helperData++;
@ -365,7 +365,7 @@ int taskYieldTest(void)
task_priority_set(HT_TASKID, HT_PRIO);
/* Ensure that the helper task finishes */
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
return TC_PASS;
}
@ -382,7 +382,7 @@ void helperTaskSuspendTest(void)
{
helperData++;
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
}
/**
@ -435,7 +435,7 @@ void HelperTask(void)
{
int rv;
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
rv = isrAPIsTest(HT_TASKID, HT_PRIO);
if (rv != TC_PASS) {
tcRC = TC_FAIL;
@ -443,7 +443,7 @@ void HelperTask(void)
}
task_sem_give(RT_SEM);
task_sem_take_wait(HT_SEM);
task_sem_take(HT_SEM, TICKS_UNLIMITED);
rv = taskMacrosTest(HT_TASKID, HT_PRIO);
if (rv != TC_PASS) {
tcRC = TC_FAIL;
@ -485,7 +485,7 @@ void RegressionTask(void)
}
task_sem_give(HT_SEM);
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
TC_PRINT("Testing task_id_get() and task_priority_get()\n");
rv = taskMacrosTest(RT_TASKID, RT_PRIO);
@ -495,7 +495,7 @@ void RegressionTask(void)
}
task_sem_give(HT_SEM);
task_sem_take_wait(RT_SEM);
task_sem_take(RT_SEM, TICKS_UNLIMITED);
TC_PRINT("Testing task_priority_set()\n");
if (taskSetPrioTest() != TC_PASS) {

2
samples/microkernel/test/test_task_irq/src/main.c
View file

@ -89,7 +89,7 @@ void registerWait(void)
/* Wait for the 2 tasks to finish registering their IRQ objects*/
for (tasksDone = 0; tasksDone < NUM_TEST_TASKS - 1; tasksDone++) {
if (task_sem_take_wait_timeout(SEM_RDY, TIMEOUT) != RC_OK) {
if (task_sem_take(SEM_RDY, TIMEOUT) != RC_OK) {
TC_ERROR("Monitor task timed out\n");
task_sem_give(resultSems[TC_FAIL]);
return;

4
samples/microkernel/test/test_task_irq/src/test_device.c
View file

@ -101,7 +101,7 @@ int taskA(ksem_t semRdy)
/* Wait for other task to receive its events */
(void)task_sem_take_wait(semRdy);
(void)task_sem_take(semRdy, TICKS_UNLIMITED);
TC_PRINT("\nAttempt to allocate an IRQ object that\n");
TC_PRINT("is already allocated by another task...\n");
@ -181,7 +181,7 @@ int taskB(ksem_t semRdy)
* will thus consume the signal first.
*/
(void)task_sem_take_wait(semRdy);
(void)task_sem_take(semRdy, TICKS_UNLIMITED);
TC_PRINT("Attempt to free an IRQ object...\n");
task_irq_free(DEV3_ID);

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

@ -57,9 +57,9 @@ int testLowTimerStop(void)
task_timer_stop(pTimer[0]);
status = task_sem_take_wait_timeout(TIMER_SEM, 20);
status = task_sem_take(TIMER_SEM, 20);
if (status != RC_TIME) {
TC_ERROR("** task_sem_take_wait_timeout() returned %d, not %d\n", status, RC_TIME);
TC_ERROR("** task_sem_take() returned %d, not %d\n", status, RC_TIME);
return TC_FAIL; /* Return failure, do not "clean up" */
}
@ -93,7 +93,7 @@ int testLowTimerPeriodicity(void)
task_timer_start(pTimer[0], 100, 50, TIMER_SEM);
for (i = 0; i < 5; i++) {
status = task_sem_take_wait_timeout(TIMER_SEM, 200);
status = task_sem_take(TIMER_SEM, 200);
ticks = sys_tick_delta(&refTime);
if (status != RC_OK) {
@ -118,7 +118,7 @@ int testLowTimerPeriodicity(void)
/* Use task_timer_restart() to change the periodicity */
task_timer_restart(pTimer[0], 60, 60);
for (i = 0; i < 6; i++) {
status = task_sem_take_wait_timeout(TIMER_SEM, 100);
status = task_sem_take(TIMER_SEM, 100);
ticks_32 = sys_tick_delta_32(&refTime);
if (status != RC_OK) {
@ -164,7 +164,7 @@ int testLowTimerDoesNotStart(void)
}
task_timer_start(pTimer[0], Ti[i], Tr[i], TIMER_SEM);
status = task_sem_take_wait_timeout(TIMER_SEM, 200);
status = task_sem_take(TIMER_SEM, 200);
if (status != RC_TIME) {
TC_ERROR("** Timer appears to have fired unexpectedly\n");
return TC_FAIL; /* Return failure, do not "clean up" */
@ -199,14 +199,14 @@ int testLowTimerOneShot(void)
/* Timer to fire once only in 100 ticks */
(void) sys_tick_delta(&refTime);
task_timer_start(pTimer[0], 100, 0, TIMER_SEM);
status = task_sem_take_wait(TIMER_SEM);
status = task_sem_take(TIMER_SEM, TICKS_UNLIMITED);
ticks = sys_tick_delta(&refTime);
if (!WITHIN_ERROR(ticks, 100, 1)) {
TC_ERROR("** Expected %d ticks to elapse, got %d\n", 100, ticks);
return TC_FAIL; /* Return failure, do not "clean up" */
}
if (status != RC_OK) {
TC_ERROR("** task_sem_take_wait() unexpectedly failed\n");
TC_ERROR("** task_sem_take() unexpectedly failed\n");
return TC_FAIL; /* Return failure, do not "clean up" */
}
@ -214,9 +214,9 @@ int testLowTimerOneShot(void)
* Wait up to 200 more ticks for another timer signalling
* that should not occur.
*/
status = task_sem_take_wait_timeout(TIMER_SEM, 200);
status = task_sem_take(TIMER_SEM, 200);
if (status != RC_TIME) {
TC_ERROR("** task_sem_take_wait_timeout() expected timeout, got %d\n", status);
TC_ERROR("** task_sem_take() expected timeout, got %d\n", status);
return TC_FAIL; /* Return failure, do not "clean up" */
}
@ -362,7 +362,7 @@ void RegressionTaskEntry(void)
}
TC_PRINT("Verifying the nanokernel timeouts worked\n");
tcRC = task_sem_take_wait_timeout(test_nano_timeouts_sem, SECONDS(5));
tcRC = task_sem_take(test_nano_timeouts_sem, SECONDS(5));
tcRC = tcRC == RC_OK ? TC_PASS : TC_FAIL;
exitRtn:

4
samples/net/echo_client/src/echo-client.c
View file

@ -331,7 +331,7 @@ void sending_loop(const char *taskname, ksem_t mySem, ksem_t otherSem)
bool send_unicast = true;
while (1) {
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
PRINT("%s: Sending packet\n", __func__);
@ -362,7 +362,7 @@ void sending_loop(const char *taskname, ksem_t mySem, ksem_t otherSem)
void receiving_loop(const char *taskname, ksem_t mySem, ksem_t otherSem)
{
while (1) {
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
PRINT("%s: Waiting packet\n", __func__);

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

@ -119,7 +119,7 @@ void helloLoop(const char *taskname, ksem_t mySem, ksem_t otherSem)
}
while (1) {
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
buf = net_receive(ctx, TICKS_NONE);
if (buf) {

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

@ -238,7 +238,7 @@ static void listen(const char *taskname, ksem_t mySem, ksem_t otherSem,
int i = 0;
while (1) {
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
receive_data(taskname, ctx);
@ -286,7 +286,7 @@ static void send(const char *taskname, ksem_t mySem, ksem_t otherSem,
return;
}
task_sem_take_wait(mySem);
task_sem_take(mySem, TICKS_UNLIMITED);
send_data(taskname, ctx);