ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
genode/repos/base-hw/src/core/kernel/timer.h

115 lines
2.0 KiB
C
Raw Normal View History

hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
/*
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
* \brief A timer manages a continuous time and timeouts on it
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
* \author Martin Stein
* \date 2016-03-23
*/
/*
Adjust file headers to refer to the AGPLv3
2017-02-20 13:23:52 +01:00
* Copyright (C) 2016-2017 Genode Labs GmbH
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
*
* This file is part of the Genode OS framework, which is distributed
Adjust file headers to refer to the AGPLv3
2017-02-20 13:23:52 +01:00
* under the terms of the GNU Affero General Public License version 3.
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
*/
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
#ifndef _CORE__KERNEL__TIMER_H_
#define _CORE__KERNEL__TIMER_H_
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
/* base-hw includes */
#include <kernel/types.h>
hw: schedule on demand (Fix #3157)
2019-02-20 15:26:56 +01:00
#include <kernel/irq.h>
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
/* Genode includes */
#include <util/list.h>
hw: move timer into board.h Unify the generic timer implementation for ARMv7 and ARMv8. Ref #3445
2019-07-10 16:12:21 +02:00
#include <board.h>
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
namespace Kernel
{
hw: schedule on demand (Fix #3157)
2019-02-20 15:26:56 +01:00
class Cpu;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
class Timeout;
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
class Timer;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
}
/**
* A timeout causes a kernel pass and the call of a timeout specific handle
*/
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
class Kernel::Timeout : Genode::List<Timeout>::Element
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
{
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
friend class Timer;
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
friend class Genode::List<Timeout>;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
private:
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
bool _listed = false;
time_t _end = 0;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
public:
/**
* Callback handle
*/
virtual void timeout_triggered() { }
virtual ~Timeout() { }
};
/**
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
* A timer manages a continuous time and timeouts on it
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
*/
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
class Kernel::Timer
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
{
private:
hw: schedule on demand (Fix #3157)
2019-02-20 15:26:56 +01:00
class Irq : private Kernel::Irq
{
private:
Cpu & _cpu;
public:
Irq(unsigned id, Cpu & cpu);
void occurred() override;
};
hw: move timer into board.h Unify the generic timer implementation for ARMv7 and ARMv8. Ref #3445
2019-07-10 16:12:21 +02:00
Board::Timer _device;
hw: schedule on demand (Fix #3157)
2019-02-20 15:26:56 +01:00
Irq _irq;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
time_t _time = 0;
hw: increase timing accuracy of kernel (fix #3081) * Introduce 64-bit tick counter * Let the timer always count when possible, also if it already fired * Simplify the kernel syscall API to have one current time call, which returns the elapsed microseconds since boot
2019-02-21 17:23:10 +01:00
time_t _last_timeout_duration;
Genode::List<Timeout> _timeout_list {};
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
void _start_one_shot(time_t const ticks);
time_t _value();
time_t _max_value() const;
hw: increase timing accuracy of kernel (fix #3081) * Introduce 64-bit tick counter * Let the timer always count when possible, also if it already fired * Simplify the kernel syscall API to have one current time call, which returns the elapsed microseconds since boot
2019-02-21 17:23:10 +01:00
time_t _duration() const;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
public:
hw: schedule on demand (Fix #3157)
2019-02-20 15:26:56 +01:00
Timer(Cpu & cpu);
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
base-hw: add trace execution time support This enables the 'top' program on base-hw for debugging issue #3247 on rpi. Fixes #3572
2019-04-09 11:34:32 +02:00
/**
* Return duration from last call of this function
*/
time_t schedule_timeout();
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
void process_timeouts();
void set_timeout(Timeout * const timeout, time_t const duration);
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
time_t us_to_ticks(time_t const us) const;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
hw: increase timing accuracy of kernel (fix #3081) * Introduce 64-bit tick counter * Let the timer always count when possible, also if it already fired * Simplify the kernel syscall API to have one current time call, which returns the elapsed microseconds since boot
2019-02-21 17:23:10 +01:00
time_t ticks_to_us(time_t const ticks) const;
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
time_t timeout_max_us() const;
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
unsigned interrupt_id() const;
hw: increase timing accuracy of kernel (fix #3081) * Introduce 64-bit tick counter * Let the timer always count when possible, also if it already fired * Simplify the kernel syscall API to have one current time call, which returns the elapsed microseconds since boot
2019-02-21 17:23:10 +01:00
time_t time() const { return _time + _duration(); }
hw: use kernel timer for timer driver * Adds public timeout syscalls to kernel API * Kernel::timeout installs a timeout and binds a signal context to it that shall trigger once the timeout expired * With Kernel::timeout_max_us, one can get the maximum installable timeout * Kernel::timeout_age_us returns the time that has passed since the calling threads last timeout installation * Removes all device specific back-ends for the base-hw timer driver and implements a generic back-end taht uses the kernel timeout API * Adds assertions about the kernel timer frequency that originate from the requirements of the the kernel timeout API and adjusts all timers accordingly by using the their internal dividers * Introduces the Kernel::Clock class. As member of each Kernel::Cpu object it combines the management of the timer of the CPU with a timeout scheduler. Not only the timeout API uses the timeout scheduler but also the CPUs job scheduler for installing scheduling timeouts. * Introduces the Kernel::time_t type for timer tic values and values inherited from timer tics (like microseconds). Fixes #1972
2016-05-18 12:20:04 +02:00
};
hw core: merge Kernel::Clock and Kernel::Timer With this, we get rid of platform specific timer interfaces. The new Timer class does the same as the old Clock class and has a generic interface. The old Timer class was merely used by the old Clock class. Also, we get rid of having only one timer instance which we tell with each method call for which CPU it shall be done. Instead now each Cpu object has its own Timer member that knows the CPU it works for. Also, rename all "tics" to "ticks". Fixes #2347
2017-03-23 03:06:53 +01:00
#endif /* _CORE__KERNEL__TIMER_H_ */