NIF: Add erlang/os system_time/0 and monotonic_time/0

Add zero-arity NIF implementations for erlang:system_time/0, erlang:monotonic_time/0, and os:system_time/0,1, returning time in native units.

erlang:system_time/0 and erlang:monotonic_time/0 delegate to their /1 counterparts with native
os:system_time/0,1 reuse the erlang:system_time NIF directly to avoid code duplication
Added Erlang stubs/exports in erlang.erl and os.erl
Added Elixir wrappers: System.monotonic_time/0, System.system_time/0, System.os_time/0,1
Added tests for all new functions

Signed-off-by: Peter M <petermm@gmail.com>

Author: petermm

CHANGELOG.md

@@ -81,6 +81,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added missing `inet` functions: `ntoa/1`, `parse_address/1`, `parse_ipv4_address/1`,
 `parse_ipv4strict_address/1`
 - Added `nanosecond` and `native` time unit support to `erlang:system_time/1`, `erlang:monotonic_time/1`, and `calendar:system_time_to_universal_time/2`
+- Added `erlang:system_time/0`, `erlang:monotonic_time/0`, and `os:system_time/0,1` NIFs
 
 ### Changed
 

libs/estdlib/src/erlang.erl

@@ -40,6 +40,7 @@
     is_record/2,
     map_size/1,
     map_get/2,
+    monotonic_time/0,
     monotonic_time/1,
     min/2,
     max/2,
@@ -104,6 +105,7 @@
     exit/1,
     exit/2,
     open_port/2,
+    system_time/0,
     system_time/1,
     group_leader/0,
     group_leader/2,
@@ -568,6 +570,10 @@ memory(_Type) ->
 %% systems the value may vary among UNIX systems (e.g., Linux, macOS, FreeBSD).
 %% @end
 %%-----------------------------------------------------------------------------
+-spec monotonic_time() -> integer().
+monotonic_time() ->
+    erlang:nif_error(undefined).
+
 -spec monotonic_time(Unit :: time_unit()) -> integer().
 monotonic_time(_Unit) ->
     erlang:nif_error(undefined).
@@ -1250,6 +1256,15 @@ exit(_Process, _Reason) ->
 open_port(_PortName, _Options) ->
     erlang:nif_error(undefined).
 
+%%-----------------------------------------------------------------------------
+%% @returns An integer representing system time.
+%% @doc     Returns the current Erlang system time in native time unit.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec system_time() -> integer().
+system_time() ->
+    erlang:nif_error(undefined).
+
 %%-----------------------------------------------------------------------------
 %% @param   Unit    Unit to return system time in
 %% @returns An integer representing system time

libs/estdlib/src/os.erl

@@ -19,7 +19,7 @@
 %
 -module(os).
 
--export([getenv/1]).
+-export([getenv/1, system_time/0, system_time/1]).
 
 %%-----------------------------------------------------------------------------
 %% @param   Name name of the environment variable
@@ -30,3 +30,21 @@
 -spec getenv(Name :: nonempty_string()) -> nonempty_string() | false.
 getenv(_VarName) ->
     erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @returns An integer representing system time.
+%% @doc     Returns the current OS system time in native time unit.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec system_time() -> integer().
+system_time() ->
+    erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @returns An integer representing system time.
+%% @doc     Returns the current OS system time in the time unit.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec system_time(TimeUnit :: erlang:time_unit()) -> integer().
+system_time(TimeUnit) ->
+    erlang:nif_error(undefined).

libs/exavmlib/lib/System.ex

@@ -25,6 +25,21 @@ defmodule System do
           :second
           | :millisecond
           | :microsecond
+          | :nanosecond
+
+  @doc """
+  Returns the current monotonic time in the `:native` time unit.
+
+  This time is monotonically increasing and starts in an unspecified
+  point in time. This is not strictly monotonically increasing. Multiple
+  sequential calls of the function may return the same value.
+
+  Inlined by the compiler.
+  """
+  @spec monotonic_time() :: integer
+  def monotonic_time do
+    :erlang.monotonic_time()
+  end
 
   @doc """
   Returns the current monotonic time in the given time unit.
@@ -37,6 +52,20 @@ defmodule System do
     :erlang.monotonic_time(unit)
   end
 
+  @doc """
+  Returns the current system time in the `:native` time unit.
+
+  It is the VM view of the `os_time/0`. They may not match in
+  case of time warps although the VM works towards aligning
+  them. This time is not monotonic.
+
+  Inlined by the compiler.
+  """
+  @spec system_time() :: integer
+  def system_time do
+    :erlang.system_time()
+  end
+
   @doc """
   Returns the current system time in the given time unit.
 
@@ -48,4 +77,30 @@ defmodule System do
   def system_time(unit) do
     :erlang.system_time(unit)
   end
+
+  @doc """
+  Returns the current operating system (OS) time.
+
+  The result is returned in the `:native` time unit.
+
+  This time may be adjusted forwards or backwards in time
+  with no limitation and is not monotonic.
+
+  Inlined by the compiler.
+  """
+  @spec os_time() :: integer
+  def os_time do
+    :os.system_time()
+  end
+
+  @doc """
+  Returns the current operating system (OS) time in the given time `unit`.
+
+  This time may be adjusted forwards or backwards in time
+  with no limitation and is not monotonic.
+  """
+  @spec os_time(time_unit | :native) :: integer
+  def os_time(unit) do
+    :os.system_time(unit)
+  end
 end

src/libAtomVM/nifs.c

@@ -187,6 +187,7 @@ static term nif_erlang_float_to_list(Context *ctx, int argc, term argv[]);
 static term nif_erlang_list_to_binary_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_list_to_integer(Context *ctx, int argc, term argv[]);
 static term nif_erlang_list_to_float_1(Context *ctx, int argc, term argv[]);
+static term nif_erlang_monotonic_time_0(Context *ctx, int argc, term argv[]);
 static term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_iolist_size_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_iolist_to_binary_1(Context *ctx, int argc, term argv[]);
@@ -198,7 +199,9 @@ static term nif_erlang_setelement_3(Context *ctx, int argc, term argv[]);
 // static term nif_erlang_spawn_opt(Context *ctx, int argc, term argv[]);
 static term nif_erlang_spawn_fun_opt(Context *ctx, int argc, term argv[]);
 static term nif_erlang_whereis_1(Context *ctx, int argc, term argv[]);
+static term nif_erlang_system_time_0(Context *ctx, int argc, term argv[]);
 static term nif_erlang_system_time_1(Context *ctx, int argc, term argv[]);
+
 static term nif_erlang_tuple_to_list_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_list_to_tuple_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[]);
@@ -533,11 +536,21 @@ static const struct Nif concat_nif = {
     .nif_ptr = nif_erlang_concat_2
 };
 
+static const struct Nif monotonic_time_0_nif = {
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_erlang_monotonic_time_0
+};
+
 static const struct Nif monotonic_time_nif = {
     .base.type = NIFFunctionType,
     .nif_ptr = nif_erlang_monotonic_time_1
 };
 
+static const struct Nif system_time_0_nif = {
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_erlang_system_time_0
+};
+
 static const struct Nif system_time_nif = {
     .base.type = NIFFunctionType,
     .nif_ptr = nif_erlang_system_time_1
@@ -1709,6 +1722,14 @@ term nif_erlang_make_ref_0(Context *ctx, int argc, term argv[])
     return term_from_ref_ticks(ref_ticks, &ctx->heap);
 }
 
+static term nif_erlang_monotonic_time_0(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+    term native_argv[] = { NATIVE_ATOM };
+    return nif_erlang_monotonic_time_1(ctx, 1, native_argv);
+}
+
 term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[])
 {
     UNUSED(ctx);
@@ -1734,6 +1755,14 @@ term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[])
     }
 }
 
+static term nif_erlang_system_time_0(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+    term native_argv[] = { NATIVE_ATOM };
+    return nif_erlang_system_time_1(ctx, 1, native_argv);
+}
+
 term nif_erlang_system_time_1(Context *ctx, int argc, term argv[])
 {
     UNUSED(ctx);

src/libAtomVM/nifs.gperf

@@ -45,6 +45,8 @@ binary:match/2, &binary_match_nif
 binary:match/3, &binary_match_nif
 calendar:system_time_to_universal_time/2, &system_time_to_universal_time_nif
 os:getenv/1, &os_getenv_nif
+os:system_time/0, &system_time_0_nif
+os:system_time/1, &system_time_nif
 erlang:atom_to_binary/1, &atom_to_binary_nif
 erlang:atom_to_binary/2, &atom_to_binary_nif
 erlang:atom_to_list/1, &atom_to_list_nif
@@ -101,7 +103,9 @@ erlang:system_flag/2, &system_flag_nif
 erlang:whereis/1, &whereis_nif
 erlang:++/2, &concat_nif
 erlang:--/2, &erlang_lists_subtract_nif
+erlang:monotonic_time/0, &monotonic_time_0_nif
 erlang:monotonic_time/1, &monotonic_time_nif
+erlang:system_time/0, &system_time_0_nif
 erlang:system_time/1, &system_time_nif
 erlang:tuple_to_list/1, &tuple_to_list_nif
 erlang:universaltime/0, &universaltime_nif

src/platforms/esp32/test/main/test_erl_sources/test_monotonic_time.erl

@@ -50,7 +50,7 @@ test_monotonic_time_native() ->
     ok.
 
 % Readings coarsest-to-finest: finer value is always taken later so
-% finer >= coarser * scale.  Upper bound allows 1 ms between calls.
+% finer >= coarser * scale.  Upper bound allows 1 s between calls.
 test_time_unit_ratios() ->
     S = erlang:monotonic_time(second),
     Ms = erlang:monotonic_time(millisecond),

src/platforms/rp2/tests/test_erl_sources/test_clocks.erl

@@ -66,7 +66,7 @@ start() ->
     ok.
 
 % Readings coarsest-to-finest: finer value is always taken later so
-% finer >= coarser * scale.  Upper bound allows 1 ms between calls.
+% finer >= coarser * scale.  Upper bound allows 1 s between calls.
 test_time_unit_ratios(Case, Fun) ->
     S = Fun(second),
     Ms = Fun(millisecond),

tests/erlang_tests/test_system_time.erl

@@ -26,9 +26,12 @@ start() ->
     ok = test_system_time(second, 1001),
     ok = test_system_time(millisecond, 10),
     ok = test_system_time(microsecond, 1),
-    ok = test_system_time(nanosecond, 1),
+    ok = test_nanosecond_system_time(),
     ok = test_native_system_time(),
 
+    ok = test_erlang_monotonic_time_0(),
+    ok = test_erlang_system_time_0(),
+    ok = test_os_system_time(),
     ok = test_time_unit_ratios(),
 
     ok = expect(fun() -> erlang:system_time(not_a_time_unit) end, badarg),
@@ -44,31 +47,47 @@ test_system_time(Unit, SleepMs) ->
     true = (After > Before),
     ok.
 
+test_erlang_monotonic_time_0() ->
+    T = erlang:monotonic_time(),
+    true = is_integer(T),
+    ok.
+
+test_erlang_system_time_0() ->
+    T = erlang:system_time(),
+    true = is_integer(T) andalso T > 0,
+    ok.
+
+test_os_system_time() ->
+    T0 = os:system_time(),
+    true = is_integer(T0) andalso T0 > 0,
+    ok = test_system_time_unit(os_system_time_second, fun() -> os:system_time(second) end),
+    ok = test_system_time_unit(os_system_time_millisecond, fun() -> os:system_time(millisecond) end),
+    ok = test_system_time_unit(os_system_time_microsecond, fun() -> os:system_time(microsecond) end),
+    ok = test_os_system_time_native(),
+    ok.
+
 test_system_time_unit(_Name, Fun) ->
     T = Fun(),
     true = is_integer(T) andalso T > 0,
     ok.
 
 % Readings are taken coarsest-to-finest so the finer value is always >= the
-% coarser value * its scale factor.  The upper-bound allows for at most 1 ms
+% coarser value * its scale factor.  The upper-bound allows for at most 1 s
 % of wall-clock time between consecutive calls.
 test_time_unit_ratios() ->
     S = erlang:system_time(second),
     Ms = erlang:system_time(millisecond),
     Us = erlang:system_time(microsecond),
-    Ns = erlang:system_time(nanosecond),
 
     true = Ms >= S * 1000,
-    % within 1 s of each other
+    % within 1 s
     true = Ms < S * 1000 + 1000,
 
     true = Us >= Ms * 1000,
-    % within 1 ms
+    % within 1 s
     true = Us < Ms * 1000 + 1000000,
 
-    true = Ns >= Us * 1000,
-    % within 1 ms
-    true = Ns < Us * 1000 + 1000000,
+    ok = test_ns_ratio(),
 
     ok.
 
@@ -95,7 +114,7 @@ test_system_time_to_universal_time() ->
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1, second),
 
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, millisecond),
-    {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, millisecond),
+    {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(1, millisecond),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1000, millisecond),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1001, millisecond),
 
@@ -108,27 +127,50 @@ test_system_time_to_universal_time() ->
 
     {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, second),
 
+    ok = test_nanosecond_universal_time(),
+    ok = test_native_universal_time(),
+
+    ok.
+
+-if(?OTP_RELEASE >= 22).
+test_nanosecond_system_time() ->
+    ok = test_system_time(nanosecond, 1).
+
+test_native_system_time() ->
+    ok = test_system_time(native, 1).
+
+test_os_system_time_native() ->
+    ok = test_system_time_unit(os_system_time_nanosecond, fun() -> os:system_time(nanosecond) end),
+    ok = test_system_time_unit(os_system_time_native, fun() -> os:system_time(native) end),
+    ok.
+
+test_ns_ratio() ->
+    Us = erlang:system_time(microsecond),
+    Ns = erlang:system_time(nanosecond),
+    true = Ns >= Us * 1000,
+    % within 1 ms
+    true = Ns < Us * 1000 + 1000000,
+    ok.
+
+test_nanosecond_universal_time() ->
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, nanosecond),
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(1, nanosecond),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1000000000, nanosecond),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1001000000, nanosecond),
     {{2023, 7, 8}, {20, 19, 39}} = calendar:system_time_to_universal_time(
         1688847579000000000, nanosecond
     ),
-
-    ok = test_native_universal_time(),
-
     ok.
 
--if(?OTP_RELEASE >= 22).
-test_native_system_time() ->
-    ok = test_system_time(native, 1).
-
 test_native_universal_time() ->
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, native),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1000000000, native),
     ok.
 -else.
+test_nanosecond_system_time() -> ok.
 test_native_system_time() -> ok.
+test_os_system_time_native() -> ok.
+test_ns_ratio() -> ok.
+test_nanosecond_universal_time() -> ok.
 test_native_universal_time() -> ok.
 -endif.