2015-04-11 01:44:37 +02:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2014-2015 Wind River Systems, Inc.
|
|
|
|
|
*
|
2017-01-19 02:01:01 +01:00
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
2015-04-11 01:44:37 +02:00
|
|
|
*/
|
|
|
|
|
|
2015-12-04 16:09:39 +01:00
|
|
|
/**
|
|
|
|
|
* @file
|
|
|
|
|
* @brief Variables needed needed for system clock
|
|
|
|
|
*
|
2015-10-20 18:42:33 +02:00
|
|
|
*
|
|
|
|
|
* Declare variables used by both system timer device driver and kernel
|
|
|
|
|
* components that use timer functionality.
|
2015-07-01 23:22:39 +02:00
|
|
|
*/
|
2015-04-11 01:44:37 +02:00
|
|
|
|
2018-09-14 19:43:44 +02:00
|
|
|
#ifndef ZEPHYR_INCLUDE_SYS_CLOCK_H_
|
|
|
|
|
#define ZEPHYR_INCLUDE_SYS_CLOCK_H_
|
2015-04-11 01:44:37 +02:00
|
|
|
|
2019-06-26 16:33:55 +02:00
|
|
|
#include <sys/util.h>
|
2019-06-26 16:33:41 +02:00
|
|
|
#include <sys/dlist.h>
|
2018-09-19 18:35:43 +02:00
|
|
|
|
2019-08-12 19:54:52 +02:00
|
|
|
#include <toolchain.h>
|
|
|
|
|
#include <zephyr/types.h>
|
|
|
|
|
|
2019-10-31 12:16:00 +01:00
|
|
|
#include <sys/time_units.h>
|
2019-06-28 20:16:50 +02:00
|
|
|
|
2016-01-22 18:38:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
/**
|
|
|
|
|
* @addtogroup clock_apis
|
|
|
|
|
* @{
|
|
|
|
|
*/
|
|
|
|
|
|
2020-03-06 06:14:02 +01:00
|
|
|
/**
|
|
|
|
|
* @brief Tick precision used in timeout APIs
|
|
|
|
|
*
|
|
|
|
|
* This type defines the word size of the timeout values used in
|
|
|
|
|
* k_timeout_t objects, and thus defines an upper bound on maximum
|
|
|
|
|
* timeout length (or equivalently minimum tick duration). Note that
|
|
|
|
|
* this does not affect the size of the system uptime counter, which
|
|
|
|
|
* is always a 64 bit count of ticks.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_TIMEOUT_64BIT
|
2020-05-27 18:26:57 +02:00
|
|
|
typedef int64_t k_ticks_t;
|
2020-03-06 06:14:02 +01:00
|
|
|
#else
|
2020-05-27 18:26:57 +02:00
|
|
|
typedef uint32_t k_ticks_t;
|
2020-03-06 06:14:02 +01:00
|
|
|
#endif
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
|
|
|
|
|
#define K_TICKS_FOREVER ((k_ticks_t) -1)
|
|
|
|
|
|
|
|
|
|
#ifndef CONFIG_LEGACY_TIMEOUT_API
|
|
|
|
|
|
2020-03-19 18:30:33 +01:00
|
|
|
/**
|
|
|
|
|
* @brief Kernel timeout type
|
|
|
|
|
*
|
|
|
|
|
* Timeout arguments presented to kernel APIs are stored in this
|
|
|
|
|
* opaque type, which is capable of representing times in various
|
|
|
|
|
* formats and units. It should be constructed from application data
|
|
|
|
|
* using one of the macros defined for this purpose (e.g. `K_MSEC()`,
|
|
|
|
|
* `K_TIMEOUT_ABS_TICKS()`, etc...), or be one of the two constants
|
|
|
|
|
* K_NO_WAIT or K_FOREVER. Applications should not inspect the
|
|
|
|
|
* internal data once constructed. Timeout values may be compared for
|
|
|
|
|
* equality with the `K_TIMEOUT_EQ()` macro.
|
|
|
|
|
*/
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
typedef struct {
|
|
|
|
|
k_ticks_t ticks;
|
|
|
|
|
} k_timeout_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief Compare timeouts for equality
|
|
|
|
|
*
|
|
|
|
|
* The k_timeout_t object is an opaque struct that should not be
|
|
|
|
|
* inspected by application code. This macro exists so that users can
|
|
|
|
|
* test timeout objects for equality with known constants
|
|
|
|
|
* (e.g. K_NO_WAIT and K_FOREVER) when implementing their own APIs in
|
|
|
|
|
* terms of Zephyr timeout constants.
|
|
|
|
|
*
|
|
|
|
|
* @return True if the timeout objects are identical
|
|
|
|
|
*/
|
|
|
|
|
#define K_TIMEOUT_EQ(a, b) ((a).ticks == (b).ticks)
|
|
|
|
|
|
|
|
|
|
#define Z_TIMEOUT_NO_WAIT ((k_timeout_t) {})
|
|
|
|
|
#define Z_TIMEOUT_TICKS(t) ((k_timeout_t) { .ticks = (t) })
|
|
|
|
|
#define Z_FOREVER Z_TIMEOUT_TICKS(K_TICKS_FOREVER)
|
2020-06-17 17:56:40 +02:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_TIMEOUT_64BIT
|
2020-06-29 08:48:54 +02:00
|
|
|
# define Z_TIMEOUT_MS(t) Z_TIMEOUT_TICKS((k_ticks_t)k_ms_to_ticks_ceil64(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_US(t) Z_TIMEOUT_TICKS((k_ticks_t)k_us_to_ticks_ceil64(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_NS(t) Z_TIMEOUT_TICKS((k_ticks_t)k_ns_to_ticks_ceil64(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_CYC(t) Z_TIMEOUT_TICKS((k_ticks_t)k_cyc_to_ticks_ceil64(MAX(t, 0)))
|
2020-06-17 17:56:40 +02:00
|
|
|
#else
|
2020-06-29 08:48:54 +02:00
|
|
|
# define Z_TIMEOUT_MS(t) Z_TIMEOUT_TICKS((k_ticks_t)k_ms_to_ticks_ceil32(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_US(t) Z_TIMEOUT_TICKS((k_ticks_t)k_us_to_ticks_ceil32(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_NS(t) Z_TIMEOUT_TICKS((k_ticks_t)k_ns_to_ticks_ceil32(MAX(t, 0)))
|
|
|
|
|
# define Z_TIMEOUT_CYC(t) Z_TIMEOUT_TICKS((k_ticks_t)k_cyc_to_ticks_ceil32(MAX(t, 0)))
|
2020-06-17 17:56:40 +02:00
|
|
|
#endif
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
|
2020-03-09 17:35:35 +01:00
|
|
|
/* Converts between absolute timeout expiration values (packed into
|
|
|
|
|
* the negative space below K_TICKS_FOREVER) and (non-negative) delta
|
|
|
|
|
* timeout values. If the result of Z_TICK_ABS(t) is >= 0, then the
|
|
|
|
|
* value was an absolute timeout with the returend expiration time.
|
|
|
|
|
* Note that this macro is bidirectional: Z_TICK_ABS(Z_TICK_ABS(t)) ==
|
|
|
|
|
* t for all inputs, and that the representation of K_TICKS_FOREVER is
|
|
|
|
|
* the same value in both spaces! Clever, huh?
|
|
|
|
|
*/
|
|
|
|
|
#define Z_TICK_ABS(t) (K_TICKS_FOREVER - 1 - (t))
|
|
|
|
|
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
/* Legacy timeout API */
|
2020-05-27 18:26:57 +02:00
|
|
|
typedef int32_t k_timeout_t;
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
#define K_TIMEOUT_EQ(a, b) ((a) == (b))
|
|
|
|
|
#define Z_TIMEOUT_NO_WAIT 0
|
|
|
|
|
#define Z_TIMEOUT_TICKS(t) k_ticks_to_ms_ceil32(t)
|
|
|
|
|
#define Z_FOREVER K_TICKS_FOREVER
|
|
|
|
|
#define Z_TIMEOUT_MS(t) (t)
|
2020-06-02 00:44:03 +02:00
|
|
|
#define Z_TIMEOUT_US(t) ((999 + (t)) / 1000)
|
|
|
|
|
#define Z_TIMEOUT_NS(t) ((999999 + (t)) / 1000000)
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
#define Z_TIMEOUT_CYC(t) k_cyc_to_ms_ceil32(MAX((t), 0))
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/** @} */
|
|
|
|
|
|
kernel: tickless: Add tickless kernel support
Adds event based scheduling logic to the kernel. Updates
management of timeouts, timers, idling etc. based on
time tracked at events rather than periodic ticks. Provides
interfaces for timers to announce and get next timer expiry
based on kernel scheduling decisions involving time slicing
of threads, timeouts and idling. Uses wall time units instead
of ticks in all scheduling activities.
The implementation involves changes in the following areas
1. Management of time in wall units like ms/us instead of ticks
The existing implementation already had an option to configure
number of ticks in a second. The new implementation builds on
top of that feature and provides option to set the size of the
scheduling granurality to mili seconds or micro seconds. This
allows most of the current implementation to be reused. Due to
this re-use and co-existence with tick based kernel, the names
of variables may contain the word "tick". However, in the
tickless kernel implementation, it represents the currently
configured time unit, which would be be mili seconds or
micro seconds. The APIs that take time as a parameter are not
impacted and they continue to pass time in mili seconds.
2. Timers would not be programmed in periodic mode
generating ticks. Instead they would be programmed in one
shot mode to generate events at the time the kernel scheduler
needs to gain control for its scheduling activities like
timers, timeouts, time slicing, idling etc.
3. The scheduler provides interfaces that the timer drivers
use to announce elapsed time and get the next time the scheduler
needs a timer event. It is possible that the scheduler may not
need another timer event, in which case the system would wait
for a non-timer event to wake it up if it is idling.
4. New APIs are defined to be implemented by timer drivers. Also
they need to handler timer events differently. These changes
have been done in the HPET timer driver. In future other timers
that support tickles kernel should implement these APIs as well.
These APIs are to re-program the timer, update and announce
elapsed time.
5. Philosopher and timer_api applications have been enabled to
test tickless kernel. Separate configuration files are created
which define the necessary CONFIG flags. Run these apps using
following command
make pristine && make BOARD=qemu_x86 CONF_FILE=prj_tickless.conf qemu
Jira: ZEP-339 ZEP-1946 ZEP-948
Change-Id: I7d950c31bf1ff929a9066fad42c2f0559a2e5983
Signed-off-by: Ramesh Thomas <ramesh.thomas@intel.com>
2017-02-06 04:37:19 +01:00
|
|
|
#ifdef CONFIG_TICKLESS_KERNEL
|
|
|
|
|
extern int _sys_clock_always_on;
|
2019-03-08 22:19:05 +01:00
|
|
|
extern void z_enable_sys_clock(void);
|
kernel: tickless: Add tickless kernel support
Adds event based scheduling logic to the kernel. Updates
management of timeouts, timers, idling etc. based on
time tracked at events rather than periodic ticks. Provides
interfaces for timers to announce and get next timer expiry
based on kernel scheduling decisions involving time slicing
of threads, timeouts and idling. Uses wall time units instead
of ticks in all scheduling activities.
The implementation involves changes in the following areas
1. Management of time in wall units like ms/us instead of ticks
The existing implementation already had an option to configure
number of ticks in a second. The new implementation builds on
top of that feature and provides option to set the size of the
scheduling granurality to mili seconds or micro seconds. This
allows most of the current implementation to be reused. Due to
this re-use and co-existence with tick based kernel, the names
of variables may contain the word "tick". However, in the
tickless kernel implementation, it represents the currently
configured time unit, which would be be mili seconds or
micro seconds. The APIs that take time as a parameter are not
impacted and they continue to pass time in mili seconds.
2. Timers would not be programmed in periodic mode
generating ticks. Instead they would be programmed in one
shot mode to generate events at the time the kernel scheduler
needs to gain control for its scheduling activities like
timers, timeouts, time slicing, idling etc.
3. The scheduler provides interfaces that the timer drivers
use to announce elapsed time and get the next time the scheduler
needs a timer event. It is possible that the scheduler may not
need another timer event, in which case the system would wait
for a non-timer event to wake it up if it is idling.
4. New APIs are defined to be implemented by timer drivers. Also
they need to handler timer events differently. These changes
have been done in the HPET timer driver. In future other timers
that support tickles kernel should implement these APIs as well.
These APIs are to re-program the timer, update and announce
elapsed time.
5. Philosopher and timer_api applications have been enabled to
test tickless kernel. Separate configuration files are created
which define the necessary CONFIG flags. Run these apps using
following command
make pristine && make BOARD=qemu_x86 CONF_FILE=prj_tickless.conf qemu
Jira: ZEP-339 ZEP-1946 ZEP-948
Change-Id: I7d950c31bf1ff929a9066fad42c2f0559a2e5983
Signed-off-by: Ramesh Thomas <ramesh.thomas@intel.com>
2017-02-06 04:37:19 +01:00
|
|
|
#endif
|
2015-11-20 22:26:25 +01:00
|
|
|
|
2018-09-19 18:35:43 +02:00
|
|
|
#if defined(CONFIG_SYS_CLOCK_EXISTS) && \
|
|
|
|
|
(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC == 0)
|
|
|
|
|
#error "SYS_CLOCK_HW_CYCLES_PER_SEC must be non-zero!"
|
|
|
|
|
#endif
|
2015-04-11 01:44:37 +02:00
|
|
|
|
2015-04-10 23:16:14 +02:00
|
|
|
/* number of nsec per usec */
|
2018-12-05 00:13:27 +01:00
|
|
|
#define NSEC_PER_USEC 1000U
|
2015-04-10 23:16:14 +02:00
|
|
|
|
2015-08-20 21:59:19 +02:00
|
|
|
/* number of microseconds per millisecond */
|
2018-12-05 00:13:27 +01:00
|
|
|
#define USEC_PER_MSEC 1000U
|
2015-08-20 21:59:19 +02:00
|
|
|
|
|
|
|
|
/* number of milliseconds per second */
|
2018-12-05 00:13:27 +01:00
|
|
|
#define MSEC_PER_SEC 1000U
|
2015-08-20 21:59:19 +02:00
|
|
|
|
2015-10-01 23:24:49 +02:00
|
|
|
/* number of microseconds per second */
|
|
|
|
|
#define USEC_PER_SEC ((USEC_PER_MSEC) * (MSEC_PER_SEC))
|
|
|
|
|
|
|
|
|
|
/* number of nanoseconds per second */
|
|
|
|
|
#define NSEC_PER_SEC ((NSEC_PER_USEC) * (USEC_PER_MSEC) * (MSEC_PER_SEC))
|
|
|
|
|
|
|
|
|
|
|
2018-09-19 18:35:43 +02:00
|
|
|
/* kernel clocks */
|
|
|
|
|
|
|
|
|
|
/*
|
2019-05-08 00:53:51 +02:00
|
|
|
* We default to using 64-bit intermediates in timescale conversions,
|
|
|
|
|
* but if the HW timer cycles/sec, ticks/sec and ms/sec are all known
|
|
|
|
|
* to be nicely related, then we can cheat with 32 bits instead.
|
2018-09-19 18:35:43 +02:00
|
|
|
*/
|
|
|
|
|
|
2019-05-08 00:53:51 +02:00
|
|
|
#ifdef CONFIG_SYS_CLOCK_EXISTS
|
2018-09-19 18:35:43 +02:00
|
|
|
|
2019-05-08 00:53:51 +02:00
|
|
|
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) || \
|
|
|
|
|
(MSEC_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC) || \
|
|
|
|
|
(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC)
|
|
|
|
|
#define _NEED_PRECISE_TICK_MS_CONVERSION
|
2018-09-19 18:35:43 +02:00
|
|
|
#endif
|
2019-05-08 00:53:51 +02:00
|
|
|
|
2018-09-19 18:35:43 +02:00
|
|
|
#endif
|
|
|
|
|
|
2019-10-03 20:43:10 +02:00
|
|
|
#define __ticks_to_ms(t) __DEPRECATED_MACRO \
|
2020-05-27 18:26:57 +02:00
|
|
|
k_ticks_to_ms_floor64((uint64_t)(t))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define z_ms_to_ticks(t) \
|
2020-05-27 18:26:57 +02:00
|
|
|
((int32_t)k_ms_to_ticks_ceil32((uint32_t)(t)))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define __ticks_to_us(t) __DEPRECATED_MACRO \
|
2020-05-27 18:26:57 +02:00
|
|
|
((int32_t)k_ticks_to_us_floor32((uint32_t)(t)))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define z_us_to_ticks(t) __DEPRECATED_MACRO \
|
2020-05-27 18:26:57 +02:00
|
|
|
((int32_t)k_us_to_ticks_ceil32((uint32_t)(t)))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define sys_clock_hw_cycles_per_tick() __DEPRECATED_MACRO \
|
2019-10-31 12:36:10 +01:00
|
|
|
((int)k_ticks_to_cyc_floor32(1U))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define SYS_CLOCK_HW_CYCLES_TO_NS64(t) __DEPRECATED_MACRO \
|
2020-05-27 18:26:57 +02:00
|
|
|
k_cyc_to_ns_floor64((uint64_t)(t))
|
2019-10-03 20:43:10 +02:00
|
|
|
#define SYS_CLOCK_HW_CYCLES_TO_NS(t) __DEPRECATED_MACRO \
|
2020-05-27 18:26:57 +02:00
|
|
|
((uint32_t)k_cyc_to_ns_floor64(t))
|
2019-05-10 01:46:46 +02:00
|
|
|
|
2018-09-19 18:35:43 +02:00
|
|
|
/* added tick needed to account for tick in progress */
|
|
|
|
|
#define _TICK_ALIGN 1
|
|
|
|
|
|
2015-04-10 23:16:14 +02:00
|
|
|
/*
|
|
|
|
|
* SYS_CLOCK_HW_CYCLES_TO_NS_AVG converts CPU clock cycles to nanoseconds
|
|
|
|
|
* and calculates the average cycle time
|
|
|
|
|
*/
|
|
|
|
|
#define SYS_CLOCK_HW_CYCLES_TO_NS_AVG(X, NCYCLES) \
|
2020-05-27 18:26:57 +02:00
|
|
|
(uint32_t)(k_cyc_to_ns_floor64(X) / NCYCLES)
|
2015-04-10 23:16:14 +02:00
|
|
|
|
2016-11-17 18:24:22 +01:00
|
|
|
/**
|
|
|
|
|
* @defgroup clock_apis Kernel Clock APIs
|
|
|
|
|
* @ingroup kernel_apis
|
|
|
|
|
* @{
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @} end defgroup clock_apis
|
|
|
|
|
*/
|
|
|
|
|
|
2018-09-19 23:17:00 +02:00
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @brief Return the lower part of the current system tick count
|
|
|
|
|
*
|
|
|
|
|
* @return the current system tick count
|
|
|
|
|
*
|
|
|
|
|
*/
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t z_tick_get_32(void);
|
2018-09-19 23:17:00 +02:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @brief Return the current system tick count
|
|
|
|
|
*
|
|
|
|
|
* @return the current system tick count
|
|
|
|
|
*
|
|
|
|
|
*/
|
2020-05-27 18:26:57 +02:00
|
|
|
int64_t z_tick_get(void);
|
2018-09-19 23:17:00 +02:00
|
|
|
|
2018-09-28 01:50:00 +02:00
|
|
|
#ifndef CONFIG_SYS_CLOCK_EXISTS
|
|
|
|
|
#define z_tick_get() (0)
|
|
|
|
|
#define z_tick_get_32() (0)
|
|
|
|
|
#endif
|
2015-04-11 01:44:37 +02:00
|
|
|
|
2020-05-27 18:26:57 +02:00
|
|
|
uint64_t z_timeout_end_calc(k_timeout_t timeout);
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
|
2016-01-22 18:38:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-09-14 19:43:44 +02:00
|
|
|
#endif /* ZEPHYR_INCLUDE_SYS_CLOCK_H_ */
|
