michaelh/zephyr
1
0
Fork 0
Code Releases Activity
zephyr/include/zephyr/wait_q.h

64 lines
1.3 KiB
C
Raw Permalink Normal View History

kernel: remove nano/micro wording and usage Also remove some old cflags referencing directories that do not exist anymore. Also replace references to legacy APIs in doxygen documentation of various functions. Change-Id: I8fce3d1fe0f4defc44e6eb0ae09a4863e33a39db Signed-off-by: Anas Nashif <anas.nashif@intel.com>
2016-12-18 15:42:55 +01:00
/* wait queue for multiple threads on kernel objects */
unified: initial unified kernel implementation Summary of what this includes: initialization: Copy from nano_init.c, with the following changes: - the main thread is the continuation of the init thread, but an idle thread is created as well - _main() initializes threads in groups and starts the EXE group - the ready queues are initialized - the main thread is marked as non-essential once the system init is done - a weak main() symbol is provided if the application does not provide a main() function scheduler: Not an exhaustive list, but basically provide primitives for: - adding/removing a thread to/from a wait queue - adding/removing a thread to/from the ready queue - marking thread as ready - locking/unlocking the scheduler - instead of locking interrupts - getting/setting thread priority - checking what state (coop/preempt) a thread is currenlty running in - rescheduling threads - finding what thread is the next to run - yielding/sleeping/aborting sleep - finding the current thread threads: - Add operationns on threads, such as creating and starting them. standardized handling of kernel object return codes: - Kernel objects now cause _Swap() to return the following values: 0 => operation successful -EAGAIN => operation timed out -Exxxxx => operation failed for another reason - The thread's swap_data field can be used to return any additional information required to complete the operation, such as the actual result of a successful operation. timeouts: - same as nano timeouts, renamed to simply 'timeouts' - the kernel is still tick-based, but objects take timeout values in ms for forward compatibility with a tickless kernel. semaphores: - Port of the nanokernel semaphores, which have the same basic behaviour as the microkernel ones. Semaphore groups are not yet implemented. - These semaphores are enhanced in that they accept an initial count and a count limit. This allows configuring them as binary semaphores, and also provisioning them without having to "give" the semaphore multiple times before using them. mutexes: - Straight port of the microkernel mutexes. An init function is added to allow defining them at runtime. pipes: - straight port timers: - amalgamation of nano and micro timers, with all functionalities intact. events: - re-implementation, using semaphores and workqueues. mailboxes: - straight port message queues: - straight port of microkernel FIFOs memory maps: - straight port workqueues: - Basically, have all APIs follow the k_ naming rule, and use the _timeout subsystem from the unified kernel directory, and not the _nano_timeout one. stacks: - Port of the nanokernel stacks. They can now have multiple threads pending on them and threads can wait with a timeout. LIFOs: - Straight port of the nanokernel LIFOs. FIFOs: - Straight port of the nanokernel FIFOs. Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com> Peter Mitsis <peter.mitsis@windriver.com> Allan Stephens <allan.stephens@windriver.com> Benjamin Walsh <benjamin.walsh@windriver.com> Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-09-03 00:55:39 +02:00
/*
* Copyright (c) 2015 Wind River Systems, Inc.
*
license: Replace Apache boilerplate with SPDX tag Replace the existing Apache 2.0 boilerplate header with an SPDX tag throughout the zephyr code tree. This patch was generated via a script run over the master branch. Also updated doc/porting/application.rst that had a dependency on line numbers in a literal include. Manually updated subsys/logging/sys_log.c that had a malformed header in the original file. Also cleanup several cases that already had a SPDX tag and we either got a duplicate or missed updating. Jira: ZEP-1457 Change-Id: I6131a1d4ee0e58f5b938300c2d2fc77d2e69572c Signed-off-by: David B. Kinder <david.b.kinder@intel.com> Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2017-01-19 02:01:01 +01:00
* SPDX-License-Identifier: Apache-2.0
unified: initial unified kernel implementation Summary of what this includes: initialization: Copy from nano_init.c, with the following changes: - the main thread is the continuation of the init thread, but an idle thread is created as well - _main() initializes threads in groups and starts the EXE group - the ready queues are initialized - the main thread is marked as non-essential once the system init is done - a weak main() symbol is provided if the application does not provide a main() function scheduler: Not an exhaustive list, but basically provide primitives for: - adding/removing a thread to/from a wait queue - adding/removing a thread to/from the ready queue - marking thread as ready - locking/unlocking the scheduler - instead of locking interrupts - getting/setting thread priority - checking what state (coop/preempt) a thread is currenlty running in - rescheduling threads - finding what thread is the next to run - yielding/sleeping/aborting sleep - finding the current thread threads: - Add operationns on threads, such as creating and starting them. standardized handling of kernel object return codes: - Kernel objects now cause _Swap() to return the following values: 0 => operation successful -EAGAIN => operation timed out -Exxxxx => operation failed for another reason - The thread's swap_data field can be used to return any additional information required to complete the operation, such as the actual result of a successful operation. timeouts: - same as nano timeouts, renamed to simply 'timeouts' - the kernel is still tick-based, but objects take timeout values in ms for forward compatibility with a tickless kernel. semaphores: - Port of the nanokernel semaphores, which have the same basic behaviour as the microkernel ones. Semaphore groups are not yet implemented. - These semaphores are enhanced in that they accept an initial count and a count limit. This allows configuring them as binary semaphores, and also provisioning them without having to "give" the semaphore multiple times before using them. mutexes: - Straight port of the microkernel mutexes. An init function is added to allow defining them at runtime. pipes: - straight port timers: - amalgamation of nano and micro timers, with all functionalities intact. events: - re-implementation, using semaphores and workqueues. mailboxes: - straight port message queues: - straight port of microkernel FIFOs memory maps: - straight port workqueues: - Basically, have all APIs follow the k_ naming rule, and use the _timeout subsystem from the unified kernel directory, and not the _nano_timeout one. stacks: - Port of the nanokernel stacks. They can now have multiple threads pending on them and threads can wait with a timeout. LIFOs: - Straight port of the nanokernel LIFOs. FIFOs: - Straight port of the nanokernel FIFOs. Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com> Peter Mitsis <peter.mitsis@windriver.com> Allan Stephens <allan.stephens@windriver.com> Benjamin Walsh <benjamin.walsh@windriver.com> Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-09-03 00:55:39 +02:00
*/
headers: Fix headers guards Any word started with underscore followed by and uppercase letter or a second underscore is a reserved word according with C99. With have *many* violations on Zephyr's code, this commit is tackling only the violations caused by headers guards. It also takes the opportunity to normalize them using the filename in uppercase and replacing dot with underscore. e.g file.h -> FILE_H Signed-off-by: Flavio Ceolin <flavio.ceolin@intel.com>
2018-09-14 00:06:35 +02:00
#ifndef ZEPHYR_KERNEL_INCLUDE_WAIT_Q_H_
#define ZEPHYR_KERNEL_INCLUDE_WAIT_Q_H_
unified: initial unified kernel implementation Summary of what this includes: initialization: Copy from nano_init.c, with the following changes: - the main thread is the continuation of the init thread, but an idle thread is created as well - _main() initializes threads in groups and starts the EXE group - the ready queues are initialized - the main thread is marked as non-essential once the system init is done - a weak main() symbol is provided if the application does not provide a main() function scheduler: Not an exhaustive list, but basically provide primitives for: - adding/removing a thread to/from a wait queue - adding/removing a thread to/from the ready queue - marking thread as ready - locking/unlocking the scheduler - instead of locking interrupts - getting/setting thread priority - checking what state (coop/preempt) a thread is currenlty running in - rescheduling threads - finding what thread is the next to run - yielding/sleeping/aborting sleep - finding the current thread threads: - Add operationns on threads, such as creating and starting them. standardized handling of kernel object return codes: - Kernel objects now cause _Swap() to return the following values: 0 => operation successful -EAGAIN => operation timed out -Exxxxx => operation failed for another reason - The thread's swap_data field can be used to return any additional information required to complete the operation, such as the actual result of a successful operation. timeouts: - same as nano timeouts, renamed to simply 'timeouts' - the kernel is still tick-based, but objects take timeout values in ms for forward compatibility with a tickless kernel. semaphores: - Port of the nanokernel semaphores, which have the same basic behaviour as the microkernel ones. Semaphore groups are not yet implemented. - These semaphores are enhanced in that they accept an initial count and a count limit. This allows configuring them as binary semaphores, and also provisioning them without having to "give" the semaphore multiple times before using them. mutexes: - Straight port of the microkernel mutexes. An init function is added to allow defining them at runtime. pipes: - straight port timers: - amalgamation of nano and micro timers, with all functionalities intact. events: - re-implementation, using semaphores and workqueues. mailboxes: - straight port message queues: - straight port of microkernel FIFOs memory maps: - straight port workqueues: - Basically, have all APIs follow the k_ naming rule, and use the _timeout subsystem from the unified kernel directory, and not the _nano_timeout one. stacks: - Port of the nanokernel stacks. They can now have multiple threads pending on them and threads can wait with a timeout. LIFOs: - Straight port of the nanokernel LIFOs. FIFOs: - Straight port of the nanokernel FIFOs. Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com> Peter Mitsis <peter.mitsis@windriver.com> Allan Stephens <allan.stephens@windriver.com> Benjamin Walsh <benjamin.walsh@windriver.com> Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-09-03 00:55:39 +02:00
include: migrate includes to <zephyr/...> In order to bring consistency in-tree, migrate all includes within include directory to the new prefix <zephyr/...>. Note that the conversion has been scripted, refer to zephyrproject-rtos#45388 for more details. Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
2022-05-06 10:30:42 +02:00
#include <zephyr/kernel_structs.h>
#include <zephyr/sys/dlist.h>
#include <zephyr/sys/rb.h>
#include <zephyr/kernel/sched_priq.h>
#include <zephyr/timeout_q.h>
unified: initial unified kernel implementation Summary of what this includes: initialization: Copy from nano_init.c, with the following changes: - the main thread is the continuation of the init thread, but an idle thread is created as well - _main() initializes threads in groups and starts the EXE group - the ready queues are initialized - the main thread is marked as non-essential once the system init is done - a weak main() symbol is provided if the application does not provide a main() function scheduler: Not an exhaustive list, but basically provide primitives for: - adding/removing a thread to/from a wait queue - adding/removing a thread to/from the ready queue - marking thread as ready - locking/unlocking the scheduler - instead of locking interrupts - getting/setting thread priority - checking what state (coop/preempt) a thread is currenlty running in - rescheduling threads - finding what thread is the next to run - yielding/sleeping/aborting sleep - finding the current thread threads: - Add operationns on threads, such as creating and starting them. standardized handling of kernel object return codes: - Kernel objects now cause _Swap() to return the following values: 0 => operation successful -EAGAIN => operation timed out -Exxxxx => operation failed for another reason - The thread's swap_data field can be used to return any additional information required to complete the operation, such as the actual result of a successful operation. timeouts: - same as nano timeouts, renamed to simply 'timeouts' - the kernel is still tick-based, but objects take timeout values in ms for forward compatibility with a tickless kernel. semaphores: - Port of the nanokernel semaphores, which have the same basic behaviour as the microkernel ones. Semaphore groups are not yet implemented. - These semaphores are enhanced in that they accept an initial count and a count limit. This allows configuring them as binary semaphores, and also provisioning them without having to "give" the semaphore multiple times before using them. mutexes: - Straight port of the microkernel mutexes. An init function is added to allow defining them at runtime. pipes: - straight port timers: - amalgamation of nano and micro timers, with all functionalities intact. events: - re-implementation, using semaphores and workqueues. mailboxes: - straight port message queues: - straight port of microkernel FIFOs memory maps: - straight port workqueues: - Basically, have all APIs follow the k_ naming rule, and use the _timeout subsystem from the unified kernel directory, and not the _nano_timeout one. stacks: - Port of the nanokernel stacks. They can now have multiple threads pending on them and threads can wait with a timeout. LIFOs: - Straight port of the nanokernel LIFOs. FIFOs: - Straight port of the nanokernel FIFOs. Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com> Peter Mitsis <peter.mitsis@windriver.com> Allan Stephens <allan.stephens@windriver.com> Benjamin Walsh <benjamin.walsh@windriver.com> Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-09-03 00:55:39 +02:00
#ifdef __cplusplus
extern "C" {
#endif
kernel/Kconfig: Reorgnize wait_q and sched algorithm choices Make these "choice" items instead of a single boolean that implies the element unset. Also renames WAITQ_FAST to WAITQ_SCALABLE, as the rbtree is really only "fast" for large queue sizes (it's constant factor overhead is bigger than a list's!) Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-06-27 20:20:50 +02:00
#ifdef CONFIG_WAITQ_SCALABLE
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
kernel: Fix sloppy wait queue API There were multiple spots where code was using the _wait_q_t abstraction as a synonym for a dlist and doing direct list management on them with the dlist APIs. Refactor _wait_q_t into a proper opaque struct (not a typedef for sys_dlist_t) and write a simple wrapper API for the existing usages. Now replacement of wait_q with a different data structure is much cleaner. Note that there were some SYS_DLIST_FOR_EACH_SAFE loops in mailbox.c that got replaced by the normal/non-safe macro. While these loops do mutate the list in the code body, they always do an early return in those circumstances instead of returning into the macro'd for() loop, so the _SAFE usage was needless. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-10 20:10:34 +02:00
#define _WAIT_Q_FOR_EACH(wq, thread_ptr) \
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
RB_FOR_EACH_CONTAINER(&(wq)->waitq.tree, thread_ptr, base.qnode_rb)
all: Update reserved function names Update reserved function names starting with one underscore, replacing them as follows: '_k_' with 'z_' '_K_' with 'Z_' '_handler_' with 'z_handl_' '_Cstart' with 'z_cstart' '_Swap' with 'z_swap' This renaming is done on both global and those static function names in kernel/include and include/. Other static function names in kernel/ are renamed by removing the leading underscore. Other function names not starting with any prefix listed above are renamed starting with a 'z_' or 'Z_' prefix. Function names starting with two or three leading underscores are not automatcally renamed since these names will collide with the variants with two or three leading underscores. Various generator scripts have also been updated as well as perf, linker and usb files. These are drivers/serial/uart_handlers.c include/linker/kobject-text.ld kernel/include/syscall_handler.h scripts/gen_kobject_list.py scripts/gen_syscall_header.py Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-08 22:19:05 +01:00
static inline void z_waitq_init(_wait_q_t *w)
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
{
w->waitq = (struct _priq_rb) {
.tree = {
all: Update reserved function names Update reserved function names starting with one underscore, replacing them as follows: '_k_' with 'z_' '_K_' with 'Z_' '_handler_' with 'z_handl_' '_Cstart' with 'z_cstart' '_Swap' with 'z_swap' This renaming is done on both global and those static function names in kernel/include and include/. Other static function names in kernel/ are renamed by removing the leading underscore. Other function names not starting with any prefix listed above are renamed starting with a 'z_' or 'Z_' prefix. Function names starting with two or three leading underscores are not automatcally renamed since these names will collide with the variants with two or three leading underscores. Various generator scripts have also been updated as well as perf, linker and usb files. These are drivers/serial/uart_handlers.c include/linker/kobject-text.ld kernel/include/syscall_handler.h scripts/gen_kobject_list.py scripts/gen_syscall_header.py Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-08 22:19:05 +01:00
.lessthan_fn = z_priq_rb_lessthan
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
}
};
}
all: Update reserved function names Update reserved function names starting with one underscore, replacing them as follows: '_k_' with 'z_' '_K_' with 'Z_' '_handler_' with 'z_handl_' '_Cstart' with 'z_cstart' '_Swap' with 'z_swap' This renaming is done on both global and those static function names in kernel/include and include/. Other static function names in kernel/ are renamed by removing the leading underscore. Other function names not starting with any prefix listed above are renamed starting with a 'z_' or 'Z_' prefix. Function names starting with two or three leading underscores are not automatcally renamed since these names will collide with the variants with two or three leading underscores. Various generator scripts have also been updated as well as perf, linker and usb files. These are drivers/serial/uart_handlers.c include/linker/kobject-text.ld kernel/include/syscall_handler.h scripts/gen_kobject_list.py scripts/gen_syscall_header.py Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-08 22:19:05 +01:00
static inline struct k_thread *z_waitq_head(_wait_q_t *w)
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
{
C++: Fix compilation error "invalid conversion" When some header are included into C++ source file, this kind of compilations errors are generated: error: invalid conversion from 'void*' to 'u32_t*' {aka 'unsigned int*'} [-fpermissive] Signed-off-by: Benoit Leforestier <benoit.leforestier@gmail.com>
2019-04-25 14:46:55 +02:00
return (struct k_thread *)rb_get_min(&w->waitq.tree);
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
}
kernel/Kconfig: Reorgnize wait_q and sched algorithm choices Make these "choice" items instead of a single boolean that implies the element unset. Also renames WAITQ_FAST to WAITQ_SCALABLE, as the rbtree is really only "fast" for large queue sizes (it's constant factor overhead is bigger than a list's!) Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-06-27 20:20:50 +02:00
#else /* !CONFIG_WAITQ_SCALABLE: */
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
#define _WAIT_Q_FOR_EACH(wq, thread_ptr) \
SYS_DLIST_FOR_EACH_CONTAINER(&((wq)->waitq), thread_ptr, \
base.qnode_dlist)
kernel: Fix sloppy wait queue API There were multiple spots where code was using the _wait_q_t abstraction as a synonym for a dlist and doing direct list management on them with the dlist APIs. Refactor _wait_q_t into a proper opaque struct (not a typedef for sys_dlist_t) and write a simple wrapper API for the existing usages. Now replacement of wait_q with a different data structure is much cleaner. Note that there were some SYS_DLIST_FOR_EACH_SAFE loops in mailbox.c that got replaced by the normal/non-safe macro. While these loops do mutate the list in the code body, they always do an early return in those circumstances instead of returning into the macro'd for() loop, so the _SAFE usage was needless. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-10 20:10:34 +02:00
all: Update reserved function names Update reserved function names starting with one underscore, replacing them as follows: '_k_' with 'z_' '_K_' with 'Z_' '_handler_' with 'z_handl_' '_Cstart' with 'z_cstart' '_Swap' with 'z_swap' This renaming is done on both global and those static function names in kernel/include and include/. Other static function names in kernel/ are renamed by removing the leading underscore. Other function names not starting with any prefix listed above are renamed starting with a 'z_' or 'Z_' prefix. Function names starting with two or three leading underscores are not automatcally renamed since these names will collide with the variants with two or three leading underscores. Various generator scripts have also been updated as well as perf, linker and usb files. These are drivers/serial/uart_handlers.c include/linker/kobject-text.ld kernel/include/syscall_handler.h scripts/gen_kobject_list.py scripts/gen_syscall_header.py Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-08 22:19:05 +01:00
static inline void z_waitq_init(_wait_q_t *w)
kernel: Fix sloppy wait queue API There were multiple spots where code was using the _wait_q_t abstraction as a synonym for a dlist and doing direct list management on them with the dlist APIs. Refactor _wait_q_t into a proper opaque struct (not a typedef for sys_dlist_t) and write a simple wrapper API for the existing usages. Now replacement of wait_q with a different data structure is much cleaner. Note that there were some SYS_DLIST_FOR_EACH_SAFE loops in mailbox.c that got replaced by the normal/non-safe macro. While these loops do mutate the list in the code body, they always do an early return in those circumstances instead of returning into the macro'd for() loop, so the _SAFE usage was needless. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-10 20:10:34 +02:00
{
sys_dlist_init(&w->waitq);
}
all: Update reserved function names Update reserved function names starting with one underscore, replacing them as follows: '_k_' with 'z_' '_K_' with 'Z_' '_handler_' with 'z_handl_' '_Cstart' with 'z_cstart' '_Swap' with 'z_swap' This renaming is done on both global and those static function names in kernel/include and include/. Other static function names in kernel/ are renamed by removing the leading underscore. Other function names not starting with any prefix listed above are renamed starting with a 'z_' or 'Z_' prefix. Function names starting with two or three leading underscores are not automatcally renamed since these names will collide with the variants with two or three leading underscores. Various generator scripts have also been updated as well as perf, linker and usb files. These are drivers/serial/uart_handlers.c include/linker/kobject-text.ld kernel/include/syscall_handler.h scripts/gen_kobject_list.py scripts/gen_syscall_header.py Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-08 22:19:05 +01:00
static inline struct k_thread *z_waitq_head(_wait_q_t *w)
kernel: Fix sloppy wait queue API There were multiple spots where code was using the _wait_q_t abstraction as a synonym for a dlist and doing direct list management on them with the dlist APIs. Refactor _wait_q_t into a proper opaque struct (not a typedef for sys_dlist_t) and write a simple wrapper API for the existing usages. Now replacement of wait_q with a different data structure is much cleaner. Note that there were some SYS_DLIST_FOR_EACH_SAFE loops in mailbox.c that got replaced by the normal/non-safe macro. While these loops do mutate the list in the code body, they always do an early return in those circumstances instead of returning into the macro'd for() loop, so the _SAFE usage was needless. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-10 20:10:34 +02:00
{
C++: Fix compilation error "invalid conversion" When some header are included into C++ source file, this kind of compilations errors are generated: error: invalid conversion from 'void*' to 'u32_t*' {aka 'unsigned int*'} [-fpermissive] Signed-off-by: Benoit Leforestier <benoit.leforestier@gmail.com>
2019-04-25 14:46:55 +02:00
return (struct k_thread *)sys_dlist_peek_head(&w->waitq);
kernel: Fix sloppy wait queue API There were multiple spots where code was using the _wait_q_t abstraction as a synonym for a dlist and doing direct list management on them with the dlist APIs. Refactor _wait_q_t into a proper opaque struct (not a typedef for sys_dlist_t) and write a simple wrapper API for the existing usages. Now replacement of wait_q with a different data structure is much cleaner. Note that there were some SYS_DLIST_FOR_EACH_SAFE loops in mailbox.c that got replaced by the normal/non-safe macro. While these loops do mutate the list in the code body, they always do an early return in those circumstances instead of returning into the macro'd for() loop, so the _SAFE usage was needless. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-10 20:10:34 +02:00
}
kernel: add _WAIT_Q_INIT() Dissociate wait queue initialization from doubly-linked lists if the underlying implementation is to be abstracted. Change-Id: Id7544c6ac506643437f9c4f0ae97e7eecab8d06d Signed-off-by: Benjamin Walsh <walsh.benj@gmail.com>
2017-01-28 22:56:18 +01:00
kernel/Kconfig: Reorgnize wait_q and sched algorithm choices Make these "choice" items instead of a single boolean that implies the element unset. Also renames WAITQ_FAST to WAITQ_SCALABLE, as the rbtree is really only "fast" for large queue sizes (it's constant factor overhead is bigger than a list's!) Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-06-27 20:20:50 +02:00
#endif /* !CONFIG_WAITQ_SCALABLE */
kernel: Scheduler rewrite This replaces the existing scheduler (but not priority handling) implementation with a somewhat simpler one. Behavior as to thread selection does not change. New features: + Unifies SMP and uniprocessing selection code (with the sole exception of the "cache" trick not being possible in SMP). + The old static multi-queue implementation is gone and has been replaced with a build-time choice of either a "dumb" list implementation (faster and significantly smaller for apps with only a few threads) or a balanced tree queue which scales well to arbitrary numbers of threads and priority levels. This is controlled via the CONFIG_SCHED_DUMB kconfig variable. + The balanced tree implementation is usable symmetrically for the wait_q abstraction, fixing a scalability glitch Zephyr had when many threads were waiting on a single object. This can be selected via CONFIG_WAITQ_FAST. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-05-03 23:51:49 +02:00
unified: initial unified kernel implementation Summary of what this includes: initialization: Copy from nano_init.c, with the following changes: - the main thread is the continuation of the init thread, but an idle thread is created as well - _main() initializes threads in groups and starts the EXE group - the ready queues are initialized - the main thread is marked as non-essential once the system init is done - a weak main() symbol is provided if the application does not provide a main() function scheduler: Not an exhaustive list, but basically provide primitives for: - adding/removing a thread to/from a wait queue - adding/removing a thread to/from the ready queue - marking thread as ready - locking/unlocking the scheduler - instead of locking interrupts - getting/setting thread priority - checking what state (coop/preempt) a thread is currenlty running in - rescheduling threads - finding what thread is the next to run - yielding/sleeping/aborting sleep - finding the current thread threads: - Add operationns on threads, such as creating and starting them. standardized handling of kernel object return codes: - Kernel objects now cause _Swap() to return the following values: 0 => operation successful -EAGAIN => operation timed out -Exxxxx => operation failed for another reason - The thread's swap_data field can be used to return any additional information required to complete the operation, such as the actual result of a successful operation. timeouts: - same as nano timeouts, renamed to simply 'timeouts' - the kernel is still tick-based, but objects take timeout values in ms for forward compatibility with a tickless kernel. semaphores: - Port of the nanokernel semaphores, which have the same basic behaviour as the microkernel ones. Semaphore groups are not yet implemented. - These semaphores are enhanced in that they accept an initial count and a count limit. This allows configuring them as binary semaphores, and also provisioning them without having to "give" the semaphore multiple times before using them. mutexes: - Straight port of the microkernel mutexes. An init function is added to allow defining them at runtime. pipes: - straight port timers: - amalgamation of nano and micro timers, with all functionalities intact. events: - re-implementation, using semaphores and workqueues. mailboxes: - straight port message queues: - straight port of microkernel FIFOs memory maps: - straight port workqueues: - Basically, have all APIs follow the k_ naming rule, and use the _timeout subsystem from the unified kernel directory, and not the _nano_timeout one. stacks: - Port of the nanokernel stacks. They can now have multiple threads pending on them and threads can wait with a timeout. LIFOs: - Straight port of the nanokernel LIFOs. FIFOs: - Straight port of the nanokernel FIFOs. Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com> Peter Mitsis <peter.mitsis@windriver.com> Allan Stephens <allan.stephens@windriver.com> Benjamin Walsh <benjamin.walsh@windriver.com> Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
2016-09-03 00:55:39 +02:00
#ifdef __cplusplus
}
#endif
headers: Fix headers guards Any word started with underscore followed by and uppercase letter or a second underscore is a reserved word according with C99. With have *many* violations on Zephyr's code, this commit is tackling only the violations caused by headers guards. It also takes the opportunity to normalize them using the filename in uppercase and replacing dot with underscore. e.g file.h -> FILE_H Signed-off-by: Flavio Ceolin <flavio.ceolin@intel.com>
2018-09-14 00:06:35 +02:00
#endif /* ZEPHYR_KERNEL_INCLUDE_WAIT_Q_H_ */
Copy permalink