c70fed29f7
Previously, the Genode::Timer::curr_time always used the Timer_session::elapsed_ms RPC as back end. Now, Genode::Timer reads this remote time only in a periodic fashion independently from the calls to Genode::Timer::curr_time. If now one calls Genode::Timer::curr_time, the function takes the last read remote time value and adapts it using the timestamp difference since the remote-time read. The conversion factor from timestamps to time is estimated on every remote-time read using the last read remote-time value and the timestamp difference since the last remote time read. This commit also re-works the timeout test. The test now has two stages. In the first stage, it tests fast polling of the Genode::Timer::curr_time. This stage checks the error between locally interpolated and timer-driver time as well as wether the locally interpolated time is monotone and sufficiently homogeneous. In the second stage several periodic and one-shot timeouts are scheduled at once. This stage checks if the timeouts trigger sufficiently precise. This commit adds the new Kernel::time syscall to base-hw. The syscall is solely used by the Genode::Timer on base-hw as substitute for the timestamp. This is because on ARM, the timestamp function uses the ARM performance counter that stops counting when the WFI (wait for interrupt) instruction is active. This instruction, however is used by the base-hw idle contexts that get active when no user thread needs to be scheduled. Thus, the ARM performance counter is not a good choice for time interpolation and we use the kernel internal time instead. With this commit, the timeout library becomes a basic library. That means that it is linked against the LDSO which then provides it to the program it serves. Furthermore, you can't use the timeout library anymore without the LDSO because through the kernel-dependent LDSO make-files we can achieve a kernel-dependent timeout implementation. This commit introduces a structured Duration type that shall successively replace the use of Microseconds, Milliseconds, and integer types for duration values. Open issues: * The timeout test fails on Raspberry PI because of precision errors in the first stage. However, this does not render the framework unusable in general on the RPI but merely is an issue when speaking of microseconds precision. * If we run on ARM with another Kernel than HW the timestamp speed may continuously vary from almost 0 up to CPU speed. The Timer, however, only uses interpolation if the timestamp speed remained stable (12.5% tolerance) for at least 3 observation periods. Currently, one period is 100ms, so its 300ms. As long as this is not the case, Timer_session::elapsed_ms is called instead. Anyway, it might happen that the CPU load was stable for some time so interpolation becomes active and now the timestamp speed drops. In the worst case, we would now have 100ms of slowed down time. The bad thing about it would be, that this also affects the timeout of the period. Thus, it might "freeze" the local time for more than 100ms. On the other hand, if the timestamp speed suddenly raises after some stable time, interpolated time can get too fast. This would shorten the period but nonetheless may result in drifting away into the far future. Now we would have the problem that we can't deliver the real time anymore until it has caught up because the output of Timer::curr_time shall be monotone. So, effectively local time might "freeze" again for more than 100ms. It would be a solution to not use the Trace::timestamp on ARM w/o HW but a function whose return value causes the Timer to never use interpolation because of its stability policy. Fixes #2400
70 lines
1.8 KiB
C++
70 lines
1.8 KiB
C++
/*
|
|
* \brief Libc-internal kernel API
|
|
* \author Christian Helmuth
|
|
* \author Emery Hemingway
|
|
* \date 2016-12-14
|
|
*
|
|
* TODO document libc tasking including
|
|
* - the initial thread (which is neither component nor pthread)
|
|
* - processes incoming signals and forwards to entrypoint
|
|
* - the main thread (which is the kernel and the main user context)
|
|
* - pthreads (which are pthread user contexts only)
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2016-2017 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU Affero General Public License version 3.
|
|
*/
|
|
|
|
#ifndef _LIBC__TASK_H_
|
|
#define _LIBC__TASK_H_
|
|
|
|
namespace Libc {
|
|
|
|
/**
|
|
* Resume all user contexts
|
|
*
|
|
* This resumes the main user context as well as any pthread context.
|
|
*/
|
|
void resume_all();
|
|
|
|
/**
|
|
* Suspend the execution of the calling user context
|
|
*
|
|
* \param timeout_ms maximum time to stay suspended in milliseconds,
|
|
* 0 for infinite suspend
|
|
*
|
|
* \return remaining duration until timeout,
|
|
* 0 if the timeout expired
|
|
*
|
|
* The context could be running on the component entrypoint as main context
|
|
* or as separate pthread. This function returns after the libc kernel
|
|
* resumed the user context execution.
|
|
*/
|
|
struct Suspend_functor { virtual bool suspend() = 0; };
|
|
unsigned long suspend(Suspend_functor &, unsigned long timeout_ms = 0UL);
|
|
|
|
/**
|
|
* Get time since startup in ms
|
|
*/
|
|
unsigned long current_time();
|
|
|
|
/**
|
|
* Suspend main user context and the component entrypoint
|
|
*
|
|
* This interface is solely used by the implementation of fork().
|
|
*/
|
|
void schedule_suspend(void (*suspended) ());
|
|
|
|
struct Select_handler_base;
|
|
|
|
/**
|
|
* Schedule select handler that is deblocked by ready fd sets
|
|
*/
|
|
void schedule_select(Select_handler_base *);
|
|
}
|
|
|
|
#endif /* _LIBC__TASK_H_ */
|