clock: Avoid #include <drivers/clockevent.hh>

Several source files include <drivers/clockevent.hh>, though this is a
very low-level feature which they don't actually use.

sched.cc does use <drivers/clockevent.hh>, but already gets it through
sched.hh, so also doesn't need to include it explicitly.

This patch removes the unnecessary includes.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: relative-time clock_event::set()

OSv's timer mechanism hinges on the Local APIC's (per-cpu) one-shot timer,
which delivers an interrupt after the requested number of nanoseconds.

The API to set this timer, clock_event::set(), took the absolute time of
the next interrupt. However, what it really needs is the duration in
nanoseconds until the next interrupt.

So this patch we change the basic clock_event::set() API to take a
duration, and implement the original clock_event::set(s64) - taking an s64
absolute wall-clock time - as a simple wrapper.  The next patch will add
more wrappers for set() taking absolute times from different clocks.
Later patches in this series will stop using the old set(s64) version,
until it is dropped in the end of the series.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: add clock_event::set(timepoint)

In the previous patch we built clock_event::set(s64) on top of
set(duration). In this patch we add set(timepoint), for absolute time
in any clock supporting the now() static method. In the following patches,
we'll convert our timers to using the monotonic clock osv::clock::uptime,
and use timepoints of that clock in calls to clock_event::set().

By temporarily having both s64 and std::chrono:time_point versions
of set(), we make this patch series bisectable. At the end of this series,
the s64 variant will be removed.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Add clock::boot_time() function

Currently, OSv's sched::timer mechanism supports only the wall clock
clock::get()->time(). In the following patches, we intend to support both
wall-clock and monotonic clock in timers, but only keep a single list of
timers (using the monotonic clock).

For this, we need a way to convert wall-clock time to monotonic uptime.
This patch adds to the clock driver a function clock::boot_time() which
returns the current offset between the wall time and the uptime, i.e., the
current estimate of the wall time at boot. Note that this estimate can
change if the wall time is adjusted (in the host, since OSv currently has
no mechanism for adjusting the clock from within).

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: temporary alias osv::clock::get() for clock::get()

Unfortunately, sched.cc uses "using namespace osv" causing a big mixup
between ::clock (from <drivers/clock.hh>) and osv::clock (from
<osv/clock.hh>). In the next patch, we want to start using <osv/clock.hh>
in sched.cc, so we need to first clear this mixup by temporarily adding
an alias osv::clock::get(), to resolve the clock::get() used throughout
sched.cc.

In later patches in this series, we'll remove all the calls to clock::get(),
from sched.cc, so at the end of the series we revert this patch.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: base timers on monotonic clock

sched::timer_base, used to implement all forms of timeouts in OSv, is
currently based on the wall-clock time in s64 form. This is problematic
for two reasons:

1. The type s64 doesn't say which units should be used, whether the time
is absolute or relative or what is its epoch.

2. wall-clock time is a bad choice for short-term timers: If a thread
intends to sleep for a millisecond, and the wall-clock goes back a minute,
the thread will end up sleeping a whole minute.

So this patch changes the basis of sched::timer_base to strongly-typed
time points from a monotonic clock, osv::clock::uptime::time_point.

We also allow setting timers using the wall-clock time, but with a big
caveat: The expiration time is converted from wall to uptime clocks at
the moment of timer_base::set(), so if the wall-clock is adjusted later,
the wall time at expiration may not be exactly the one intended.

So that we don't have to change all timer users in this one patch, we
also temporarily implement the old weakly-typed timer_base::set(s64)
using the new mechanism. This variant will be removed in a later patch
in this series, when it is no longer used.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Allow comparison of std::chrono::duration with 0

Durations cannot be compared with unit-less integers: one cannot just
check d < 7: One needs to do something like d < 7_ms.

Unfortunately, this rule also applies to zero: d < 0 won't work, and users
need to add a unit to the zero. Of course, any unit would work: d < 0_ms,
or d < 0_ns, or any other time unit. For physicists, this requirement
makes perfect sense (even zero has units), but for most programmers, the
extra units would seem surprising and redundant.

This patch makes it possible to compare a std::chrono::duration to
0 without needing to add a unit, while still leaving comparison with a
non-zero integer an error.

This is convenient for us because existing code which compared s64
durations to unit-less 0, will continue to work unmodified after we
switch from s64 to std::chrono::duration.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use monotonic clock in the thread scheduler

Switch the thread scheduler from using the s64 type for durations and
the wall time, to the osv::clock::uptime::duration type (which is
std::chrono::nanoseconds) and monotonic clock.

Also, now that the per-thread CPU-time clock (thread::thread_clock())
returns an std::chrono::duration instead of s64, we no longer need the
fill_ts(s64) variant in libc/time.cc (if we leave it unused, we'll get a
compilation warning).

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Support monotonic clock in timerfd

Switch the timerfd to use std::chrono types, and add support also for the
monotonic clock.

Fixes #142.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Test timerfd's support for monotonic clock

In tst-timerfd, test timerfd with monotonic clock, in addition to the
existing test with the realtime clock.

This patch also changes this test to only use Linux APIs, not anything
OSv-specific, so it can also be run on Linux.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Allow various functions to take duration

C++11's std::chrono allows clearly differentiating between absolute times
(std::chrono::time_point) and relative times (std::chrono::duration),
and we are no longer at risk of confusing absolute and relative time.

This patch allows various functions to also take relative times (duration)
instead of absolute times (time_point), making them easier to use.
All of them use the monotonic clock's current time (osv::clock::uptime::now)
to convert relative to absolute times:

1. Shortcut tmr.set(10_ms) for tmr.set(osv::clock::uptime::now() + 10_ms)

2. Similarly, we add a duration version of condvar::wait(), which can now
be used as condvar::wait(mutex, 10_ms).

3. Add a new function sched::thread::sleep(10_ms).

These new variants are not only shorter, they also make it unnecessary for
the caller to understand what clock it should use for relative waits,
or mistakenly use the wrong clock.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Drop sched::thread::sleep_until()

Delete the sched::thread::sleep_until() function. All users of this
function actually wanted a relative time, not absolute time, and can
use the simpler new sched::thread::sleep() instead.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in alarm() implementation

Change alarm() implementation to use the new <osv/clock.hh> APIs and the
monotonic clock.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in callout implementation

Change callout implementation to use the new <osv/clock.hh> APIs and the
monotonic clock.

Since _callout.h now uses the C++ type osv::clock::uptime::time_point,
it can only be used from C++ code. All the relevant code is already C++.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in msleep implementation

Fix msleep implementation to use the new <osv/clock.hh> APIs and the
monotonic clock.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in BSD time functions

Reimplement the BSD functions getmicrotime(9), getmicrouptime(9)
and variable "ticks", using the new clock APIs.

getmicrotime() returns the system time ("wall clock"), while getmicrouptime
and ticks return the time since boot.

I believe this is the correct implementation according to the FreeBSD
documentation, but our previous implementation didn't quite do this and
it also worked ;-) The previous implementation pretended, according to
getmicrouptime() and get_ticks(), that the system is up since 1970,
and yet the variable "time_uptime" (which FreeBSD has) is never updated,
and is fixed at 1 second :-)

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in sbwait implementation

Fix sbwait implementation to use the new <osv/clock.hh> APIs and the
monotonic clock.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Use new clock APIs in tst-wait-for.cc

Fix tst-wait-for.cc to use the new <osv/clock.hh> APIs.

This test uses std::abs on a time duration, and unfortunately C++11 fails
to implement std::abs on an std::chrono::duration. This patch also adds
support for this (in the form of a trivial template function) to
<osv/clock.hh>.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Remove old type-less time literals

Drop the s64 literals _ms, _ns, etc., from <drivers/clock.hh>.
Fix a few places which still use the old literals.

The std:chrono::duration version from <osv/clock.hh> remains -
but remember you need to "using namespace osv::clock::literals"
to use them.

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>
clock: Drop nanotime() function

Drop the nanotime() function.

Change the few remaining callers to use the appropriate osv::clock or
std::chrono replacements.

We already got rid in previous patches of most references to nanotime()
by switching from absolute times to relative times.

The direct equivalent of the old nanotime() function, where we actually
need the number of nanoseconds since the UNIX epoch, is the rather
verbose expression osv::clock::wall::now().time_since_epoch().count(),
or the shorter clock::get()->time().

Reviewed-by: Glauber Costa <glommer@cloudius-systems.com>
Signed-off-by: Nadav Har'El <nyh@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>