Refactor time-unit conversion into shared helpers

Extract time_unit_to_parts_per_second, nanoseconds_to_parts_per_second,
timespec_to_parts_per_second, and make_time_in_unit helpers to eliminate
code duplication between monotonic_time and system_time BIFs.

The new timespec_to_parts_per_second correctly handles negative
timestamps with non-zero tv_nsec by using an adjusted-seconds approach
that avoids rejecting valid results whose intermediate sec*pps would
overflow but whose final floored value fits in int64.

Calendar function now reuses time_unit_to_parts_per_second for unit
dispatch.

Add tests for non-power-of-10 integer units (256, 48000), boundary
floor-division cases, and additional badarg coverage.

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

Author: petermm

CHANGELOG.md

@@ -25,7 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added Thumb-2 support to armv6m JIT backend, optimizing code for ARMv7-M and later cores
 - Added support for `binary:split/2,3` list patterns and `trim` / `trim_all` options
 - Added `timer:send_after/2`, `timer:send_after/3` and `timer:apply_after/4`
-- Added support for integer parts-per-second timeunit
+- Added support for integer parts-per-second timeunit, with `badarg` raised on int64 overflow
 
 ### Changed
 - ~10% binary size reduction by rewriting module loading logic

src/libAtomVM/nifs.c

@@ -1841,114 +1841,142 @@ term nif_erlang_make_ref_0(Context *ctx, int argc, term argv[])
     return term_from_ref_ticks(ref_ticks, &ctx->heap);
 }
 
-term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[])
+static bool time_unit_to_parts_per_second(term unit, avm_int64_t *parts_per_second)
 {
-    UNUSED(ctx);
-
-    term unit;
-    if (argc == 0) {
-        unit = NATIVE_ATOM;
+    if (unit == SECOND_ATOM) {
+        *parts_per_second = 1;
+    } else if (unit == MILLISECOND_ATOM) {
+        *parts_per_second = 1000;
+    } else if (unit == MICROSECOND_ATOM) {
+        *parts_per_second = INT64_C(1000000);
+    } else if (unit == NANOSECOND_ATOM || unit == NATIVE_ATOM) {
+        *parts_per_second = INT64_C(1000000000);
+    } else if (term_is_int64(unit)) {
+        *parts_per_second = term_maybe_unbox_int64(unit);
+        if (UNLIKELY(*parts_per_second <= 0)) {
+            return false;
+        }
     } else {
-        unit = argv[0];
+        return false;
     }
 
-    struct timespec ts;
-    sys_monotonic_time(&ts);
+    return true;
+}
 
-    if (unit == SECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ts.tv_sec);
+// Convert nanoseconds to parts using: parts = nanoseconds * pps / 1e9
+// Splits into high/low to avoid intermediate overflow.
+// Caller must ensure 0 <= nanoseconds < 1e9 and pps > 0.
+static bool nanoseconds_to_parts_per_second(
+    avm_int64_t nanoseconds, avm_int64_t parts_per_second, bool round_up, avm_int64_t *parts)
+{
+    avm_int64_t quotient = parts_per_second / INT64_C(1000000000);
+    avm_int64_t remainder = parts_per_second % INT64_C(1000000000);
+    avm_int64_t fractional_high = nanoseconds * quotient;
+    avm_int64_t remainder_product = nanoseconds * remainder;
+    avm_int64_t fractional_low = remainder_product / INT64_C(1000000000);
 
-    } else if (unit == MILLISECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * 1000UL + ts.tv_nsec / 1000000UL);
+    if (round_up && (remainder_product % INT64_C(1000000000)) != 0) {
+        fractional_low += 1;
+    }
 
-    } else if (unit == MICROSECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * 1000000UL + ts.tv_nsec / 1000UL);
+    if (UNLIKELY(fractional_high > INT64_MAX - fractional_low)) {
+        return false;
+    }
 
-    } else if (unit == NANOSECOND_ATOM || unit == NATIVE_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * INT64_C(1000000000) + ts.tv_nsec);
+    *parts = fractional_high + fractional_low;
+    return true;
+}
 
-    } else if (term_is_int64(unit)) {
-        avm_int64_t parts_per_second = term_maybe_unbox_int64(unit);
-        if (UNLIKELY(parts_per_second <= 0)) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
+// Convert a normalized timespec (0 <= tv_nsec < 1e9) to integer parts.
+// Uses floor semantics for negative timestamps with non-zero tv_nsec.
+static bool timespec_to_parts_per_second(
+    const struct timespec *ts, avm_int64_t parts_per_second, avm_int64_t *parts)
+{
+    avm_int64_t seconds = (avm_int64_t) ts->tv_sec;
+    avm_int64_t fractional_part;
+
+    if (ts->tv_nsec == 0 || seconds >= 0) {
         if (UNLIKELY(
-                ((ts.tv_sec > 0) && ((avm_int64_t) ts.tv_sec > INT64_MAX / parts_per_second))
-                || ((ts.tv_sec < 0) && ((avm_int64_t) ts.tv_sec < INT64_MIN / parts_per_second)))) {
-            RAISE_ERROR(BADARG_ATOM);
+                ((seconds > 0) && (seconds > INT64_MAX / parts_per_second))
+                || ((seconds < 0) && (seconds < INT64_MIN / parts_per_second)))) {
+            return false;
         }
-        avm_int64_t second_part = (avm_int64_t) ts.tv_sec * parts_per_second;
-        avm_int64_t quotient = parts_per_second / INT64_C(1000000000);
-        avm_int64_t remainder = parts_per_second % INT64_C(1000000000);
-        avm_int64_t fractional_high = (avm_int64_t) ts.tv_nsec * quotient;
-        avm_int64_t fractional_low = ((avm_int64_t) ts.tv_nsec * remainder) / INT64_C(1000000000);
-        if (UNLIKELY(fractional_high > INT64_MAX - fractional_low)) {
-            RAISE_ERROR(BADARG_ATOM);
+
+        if (UNLIKELY(!nanoseconds_to_parts_per_second(
+                (avm_int64_t) ts->tv_nsec, parts_per_second, false, &fractional_part))) {
+            return false;
         }
-        avm_int64_t fractional_part = fractional_high + fractional_low;
+
+        avm_int64_t second_part = seconds * parts_per_second;
         if (UNLIKELY(second_part > INT64_MAX - fractional_part)) {
-            RAISE_ERROR(BADARG_ATOM);
+            return false;
         }
-        return make_maybe_boxed_int64(ctx, second_part + fractional_part);
 
-    } else {
-        RAISE_ERROR(BADARG_ATOM);
+        *parts = second_part + fractional_part;
+        return true;
+    }
+
+    // Preserve floor semantics for normalized negative timespecs such as {-2, 999999999}.
+    avm_int64_t adjusted_seconds = seconds + 1;
+    if (UNLIKELY(adjusted_seconds < INT64_MIN / parts_per_second)) {
+        return false;
+    }
+
+    if (UNLIKELY(!nanoseconds_to_parts_per_second(
+            INT64_C(1000000000) - (avm_int64_t) ts->tv_nsec, parts_per_second, true,
+            &fractional_part))) {
+        return false;
     }
+
+    avm_int64_t second_part = adjusted_seconds * parts_per_second;
+    if (UNLIKELY(second_part < INT64_MIN + fractional_part)) {
+        return false;
+    }
+
+    *parts = second_part - fractional_part;
+    return true;
 }
 
-term nif_erlang_system_time_1(Context *ctx, int argc, term argv[])
+static term make_time_in_unit(Context *ctx, term unit, void (*time_fun)(struct timespec *))
 {
-    UNUSED(ctx);
+    avm_int64_t parts_per_second;
+    if (UNLIKELY(!time_unit_to_parts_per_second(unit, &parts_per_second))) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
 
+    struct timespec ts;
+    time_fun(&ts);
+
+    avm_int64_t value;
+    if (UNLIKELY(!timespec_to_parts_per_second(&ts, parts_per_second, &value))) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
+
+    return make_maybe_boxed_int64(ctx, value);
+}
+
+term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[])
+{
     term unit;
     if (argc == 0) {
         unit = NATIVE_ATOM;
     } else {
         unit = argv[0];
     }
 
-    struct timespec ts;
-    sys_time(&ts);
-
-    if (unit == SECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ts.tv_sec);
-
-    } else if (unit == MILLISECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * 1000UL + ts.tv_nsec / 1000000UL);
-
-    } else if (unit == MICROSECOND_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * 1000000UL + ts.tv_nsec / 1000UL);
-
-    } else if (unit == NANOSECOND_ATOM || unit == NATIVE_ATOM) {
-        return make_maybe_boxed_int64(ctx, ((int64_t) ts.tv_sec) * INT64_C(1000000000) + ts.tv_nsec);
-
-    } else if (term_is_int64(unit)) {
-        avm_int64_t parts_per_second = term_maybe_unbox_int64(unit);
-        if (UNLIKELY(parts_per_second <= 0)) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
-        if (UNLIKELY(
-                ((ts.tv_sec > 0) && ((avm_int64_t) ts.tv_sec > INT64_MAX / parts_per_second))
-                || ((ts.tv_sec < 0) && ((avm_int64_t) ts.tv_sec < INT64_MIN / parts_per_second)))) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
-        avm_int64_t second_part = (avm_int64_t) ts.tv_sec * parts_per_second;
-        avm_int64_t quotient = parts_per_second / INT64_C(1000000000);
-        avm_int64_t remainder = parts_per_second % INT64_C(1000000000);
-        avm_int64_t fractional_high = (avm_int64_t) ts.tv_nsec * quotient;
-        avm_int64_t fractional_low = ((avm_int64_t) ts.tv_nsec * remainder) / INT64_C(1000000000);
-        if (UNLIKELY(fractional_high > INT64_MAX - fractional_low)) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
-        avm_int64_t fractional_part = fractional_high + fractional_low;
-        if (UNLIKELY(second_part > INT64_MAX - fractional_part)) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
-        return make_maybe_boxed_int64(ctx, second_part + fractional_part);
+    return make_time_in_unit(ctx, unit, sys_monotonic_time);
+}
 
+term nif_erlang_system_time_1(Context *ctx, int argc, term argv[])
+{
+    term unit;
+    if (argc == 0) {
+        unit = NATIVE_ATOM;
     } else {
-        RAISE_ERROR(BADARG_ATOM);
+        unit = argv[0];
     }
+
+    return make_time_in_unit(ctx, unit, sys_time);
 }
 
 static term build_datetime_from_tm(Context *ctx, struct tm *broken_down_time)
@@ -2062,27 +2090,14 @@ term nif_calendar_system_time_to_universal_time_2(Context *ctx, int argc, term a
     }
     avm_int64_t value = term_maybe_unbox_int64(argv[0]);
 
-    avm_int64_t divisor;
-    if (argv[1] == SECOND_ATOM) {
-        divisor = 1;
-    } else if (argv[1] == MILLISECOND_ATOM) {
-        divisor = 1000;
-    } else if (argv[1] == MICROSECOND_ATOM) {
-        divisor = INT64_C(1000000);
-    } else if (argv[1] == NANOSECOND_ATOM || argv[1] == NATIVE_ATOM) {
-        divisor = INT64_C(1000000000);
-    } else if (term_is_int64(argv[1])) {
-        divisor = term_maybe_unbox_int64(argv[1]);
-        if (UNLIKELY(divisor <= 0)) {
-            RAISE_ERROR(BADARG_ATOM);
-        }
-    } else {
+    avm_int64_t parts_per_second;
+    if (UNLIKELY(!time_unit_to_parts_per_second(argv[1], &parts_per_second))) {
         RAISE_ERROR(BADARG_ATOM);
     }
 
     // Floor division: round negative fractional seconds toward negative infinity
-    avm_int64_t quotient = value / divisor;
-    avm_int64_t remainder = value % divisor;
+    avm_int64_t quotient = value / parts_per_second;
+    avm_int64_t remainder = value % parts_per_second;
     struct timespec ts = {
         .tv_sec = (time_t) (quotient - (remainder < 0)),
         .tv_nsec = 0

tests/erlang_tests/test_monotonic_time.erl

@@ -39,6 +39,7 @@ start() ->
 
     ok = test_native_monotonic_time(),
     ok = test_integer_time_unit(),
+    ok = test_non_power_of_10_integer_time_unit(),
     ok = test_bad_integer_time_unit(),
 
     1.
@@ -97,7 +98,23 @@ test_integer_time_unit() ->
 
     ok.
 
+test_non_power_of_10_integer_time_unit() ->
+    ok = test_integer_time_unit_monotonicity(256),
+    ok = test_integer_time_unit_monotonicity(48000),
+    ok.
+
 test_bad_integer_time_unit() ->
     ok = expect(fun() -> erlang:monotonic_time(0) end, badarg),
     ok = expect(fun() -> erlang:monotonic_time(-1) end, badarg),
     ok.
+
+test_integer_time_unit_monotonicity(PartsPerSecond) ->
+    T1 = erlang:monotonic_time(PartsPerSecond),
+    receive
+    after 1 -> ok
+    end,
+    T2 = erlang:monotonic_time(PartsPerSecond),
+    true = is_integer(T1),
+    true = is_integer(T2),
+    true = T2 >= T1,
+    ok.

tests/erlang_tests/test_system_time.erl

@@ -35,6 +35,7 @@ start() ->
     ok = test_time_unit_ratios(),
 
     ok = test_integer_time_unit(),
+    ok = test_non_power_of_10_integer_time_unit(),
     ok = test_bad_integer_time_unit(),
 
     ok = expect(fun() -> erlang:system_time(not_a_time_unit) end, badarg),
@@ -137,7 +138,9 @@ test_system_time_to_universal_time() ->
     {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, nanosecond),
     {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, native),
 
-    ok = expect(fun() -> calendar:system_time_to_universal_time(not_an_integer, second) end, badarg),
+    ok = expect(
+        fun() -> calendar:system_time_to_universal_time(not_an_integer, second) end, badarg
+    ),
 
     ok = test_nanosecond_universal_time(),
     ok = test_native_universal_time(),
@@ -207,6 +210,11 @@ test_integer_time_unit() ->
 
     ok.
 
+test_non_power_of_10_integer_time_unit() ->
+    ok = test_integer_parts_per_second_ratio(256),
+    ok = test_integer_parts_per_second_ratio(48000),
+    ok.
+
 test_integer_unit_universal_time() ->
     %% integer 1 = seconds
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, 1),
@@ -218,12 +226,21 @@ test_integer_unit_universal_time() ->
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1000, 1000),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1001, 1000),
     {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, 1000),
+    {{1969, 12, 31}, {23, 59, 58}} = calendar:system_time_to_universal_time(-1001, 1000),
 
     %% integer 1000000 = microseconds
     {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(0, 1000000),
     {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(1000000, 1000000),
     {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, 1000000),
 
+    %% integer 256 and 48000 = arbitrary parts per second
+    {{1970, 1, 1}, {0, 0, 0}} = calendar:system_time_to_universal_time(255, 256),
+    {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(256, 256),
+    {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, 256),
+    {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-255, 256),
+    {{1970, 1, 1}, {0, 0, 1}} = calendar:system_time_to_universal_time(48000, 48000),
+    {{1969, 12, 31}, {23, 59, 59}} = calendar:system_time_to_universal_time(-1, 48000),
+
     ok.
 
 test_bad_integer_time_unit() ->
@@ -232,5 +249,18 @@ test_bad_integer_time_unit() ->
     ok.
 
 test_bad_integer_unit_universal_time() ->
+    ok = expect(
+        fun() -> calendar:system_time_to_universal_time(not_an_integer, second) end, badarg
+    ),
+    ok = expect(fun() -> calendar:system_time_to_universal_time(not_an_integer, 1000) end, badarg),
     ok = expect(fun() -> calendar:system_time_to_universal_time(0, 0) end, badarg),
+    ok = expect(fun() -> calendar:system_time_to_universal_time(0, -1) end, badarg),
+    ok.
+
+test_integer_parts_per_second_ratio(PartsPerSecond) ->
+    Seconds = erlang:system_time(second),
+    Parts = erlang:system_time(PartsPerSecond),
+    true = is_integer(Parts) andalso Parts > 0,
+    true = Parts >= Seconds * PartsPerSecond,
+    true = Parts < Seconds * PartsPerSecond + (PartsPerSecond * 2),
     ok.