Merge pull request #1597 from bettio/continue-unique-integer-avm

See also #1519

These changes are made under both the "Apache 2.0" and the "GNU Lesser General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

Author: bettio

CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added `lists:dropwhile/2`.
 - Support for `float/1` BIF.
 - Added `erlang:get/0` and `erlang:erase/0`.
+- Added `erlang:unique_integer/0` and `erlang:unique_integer/1`
 
 ### Fixed
 - ESP32: improved sntp sync speed from a cold boot.

libs/estdlib/src/erlang.erl

@@ -112,7 +112,9 @@
     term_to_binary/1,
     timestamp/0,
     universaltime/0,
-    localtime/0
+    localtime/0,
+    unique_integer/0,
+    unique_integer/1
 ]).
 
 -export_type([
@@ -1314,3 +1316,24 @@ universaltime() ->
 -spec localtime() -> calendar:datetime().
 localtime() ->
     erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @returns A unique integer
+%% @doc     Same as erlang:unique_integer([]).
+%% @end
+%%-----------------------------------------------------------------------------
+-spec unique_integer() -> integer().
+unique_integer() ->
+    erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @param   Options list of options.
+%% @returns a unique integer
+%% @doc     Return a unique integer. If positive is passed, returned integer is
+%%          positive. If monotonic is passed, returned integer is monotonically increasing
+%%          across all processes.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec unique_integer([monotonic | positive]) -> integer().
+unique_integer(_Options) ->
+    erlang:nif_error(undefined).

src/libAtomVM/bif.c

@@ -29,6 +29,7 @@
 #include "dictionary.h"
 #include "interop.h"
 #include "overflow_helpers.h"
+#include "smp.h"
 #include "term.h"
 #include "trace.h"
 #include "unicode.h"
@@ -387,6 +388,33 @@ term bif_erlang_map_get_2(Context *ctx, uint32_t fail_label, term arg1, term arg
     return term_get_map_value(arg2, pos);
 }
 
+term bif_erlang_unique_integer_0(Context *ctx)
+{
+    int64_t value = globalcontext_get_ref_ticks(ctx->global);
+    return term_make_maybe_boxed_int64(value, &ctx->heap);
+}
+
+term bif_erlang_unique_integer_1(Context *ctx, uint32_t fail_label, term arg1)
+{
+    int proper = 0;
+    if (UNLIKELY(!term_is_list(arg1))) {
+        RAISE_ERROR_BIF(fail_label, BADARG_ATOM);
+    }
+    size_t _len = term_list_length(arg1, &proper);
+    UNUSED(_len);
+    if (UNLIKELY(!proper)) {
+        RAISE_ERROR_BIF(fail_label, BADARG_ATOM);
+    }
+
+    // List is checked only for correctness if in the future
+    // we would like to handle monotonic and positive integers separately.
+    //
+    // Right now the implementation is backed by increasing counter
+    // that always covers both options
+    int64_t value = globalcontext_get_ref_ticks(ctx->global);
+    return term_make_maybe_boxed_int64(value, &ctx->heap);
+}
+
 static inline term make_boxed_int(Context *ctx, uint32_t fail_label, uint32_t live, avm_int_t value)
 {
     if (UNLIKELY(memory_ensure_free_with_roots(ctx, BOXED_INT_SIZE, live, ctx->x, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {

src/libAtomVM/bif.h

@@ -70,6 +70,9 @@ term bif_erlang_tuple_size_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_map_size_1(Context *ctx, uint32_t fail_label, int live, term arg1);
 term bif_erlang_map_get_2(Context *ctx, uint32_t fail_label, term arg1, term arg2);
 
+term bif_erlang_unique_integer_0(Context *ctx);
+term bif_erlang_unique_integer_1(Context *ctx, uint32_t fail_label, term arg1);
+
 term bif_erlang_add_2(Context *ctx, uint32_t fail_label, int live, term arg1, term arg2);
 term bif_erlang_plus_1(Context *ctx, uint32_t fail_label, int live, term arg1);
 term bif_erlang_sub_2(Context *ctx, uint32_t fail_label, int live, term arg1, term arg2);

src/libAtomVM/bifs.gperf

@@ -92,6 +92,8 @@ erlang:element/2, {.bif.base.type = BIFFunctionType, .bif.bif2_ptr = bif_erlang_
 erlang:tuple_size/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_tuple_size_1}
 erlang:map_size/1, {.gcbif.base.type = GCBIFFunctionType, .gcbif.gcbif1_ptr = bif_erlang_map_size_1}
 erlang:map_get/2, {.bif.base.type = BIFFunctionType, .bif.bif2_ptr = bif_erlang_map_get_2}
+erlang:unique_integer/0, {.bif.base.type = BIFFunctionType, .bif.bif0_ptr = bif_erlang_unique_integer_0}
+erlang:unique_integer/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_unique_integer_1}
 erlang:min/2, {.bif.base.type = BIFFunctionType, .bif.bif2_ptr = bif_erlang_min_2}
 erlang:max/2, {.bif.base.type = BIFFunctionType, .bif.bif2_ptr = bif_erlang_max_2}
 erlang:size/1, {.gcbif.base.type = GCBIFFunctionType, .gcbif.gcbif1_ptr = bif_erlang_size_1}

tests/erlang_tests/CMakeLists.txt

@@ -510,6 +510,7 @@ compile_erlang(float_decode)
 compile_erlang(test_utf8_atoms)
 
 compile_erlang(twentyone_param_function)
+compile_erlang(unique)
 compile_erlang(complex_list_match_xregs)
 compile_erlang(twentyone_param_fun)
 compile_erlang(gc_safe_x_reg_write)
@@ -997,6 +998,7 @@ add_custom_target(erlang_test_modules DEPENDS
     test_utf8_atoms.beam
 
     twentyone_param_function.beam
+    unique.beam
     complex_list_match_xregs.beam
     twentyone_param_fun.beam
     gc_safe_x_reg_write.beam

tests/erlang_tests/unique.erl

@@ -0,0 +1,130 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2024 Jakub Gonet <jakub.gonet@swmansion.com>
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%    http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+%
+% SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+%
+
+-module(unique).
+
+-export([start/0, id/1, check_error/3]).
+
+start() ->
+    ok = unique_0(),
+    ok = unique_positive(),
+    ok = unique_monotonic(),
+    ok = unique_positive_monotonic(),
+    ok = unique_monotonic_processes(),
+
+    Self = self(),
+    N = length([
+        spawn_opt(fun() -> Self ! {ok, unique_0()} end, []),
+        spawn_opt(fun() -> Self ! {ok, unique_positive()} end, []),
+        spawn_opt(fun() -> Self ! {ok, unique_monotonic()} end, []),
+        spawn_opt(fun() -> Self ! {ok, unique_positive_monotonic()} end, [])
+    ]),
+    receive_messages(N),
+    0.
+
+test_invalid() ->
+    ok = ?MODULE:check_error(fun() -> erlang:unique_integer(?MODULE:id(5)) end),
+    ok = ?MODULE:check_error(fun() -> erlang:unique_integer(?MODULE:id([positive | monotonic])) end).
+
+check_error(F, A, B) ->
+    try F() of
+        Result -> {unexpected, Result}
+    catch
+        A:B -> ok
+    end.
+
+id(X) ->
+    X.
+
+unique_0() ->
+    A = erlang:unique_integer(),
+    B = erlang:unique_integer(),
+    C = erlang:unique_integer(),
+    Valid = (A =/= B) and (A =/= C),
+    true = Valid,
+    ok.
+
+unique_positive() ->
+    A = erlang:unique_integer([positive]),
+    B = erlang:unique_integer([positive]),
+    C = erlang:unique_integer([positive]),
+    Valid = (A > 0) and (B > 0) and (C > 0) and (A =/= B) and (B =/= C),
+    true = Valid,
+    ok.
+
+unique_monotonic() ->
+    A = erlang:unique_integer([monotonic]),
+    B = erlang:unique_integer([monotonic]),
+    C = erlang:unique_integer([monotonic]),
+    Valid = (A < B) and (B < C),
+    true = Valid,
+    ok.
+
+unique_positive_monotonic() ->
+    A = erlang:unique_integer([positive, monotonic]),
+    B = erlang:unique_integer([positive, monotonic]),
+    C = erlang:unique_integer([positive, monotonic]),
+    Valid = (A > 0) and (A < B) and (B < C),
+    true = Valid,
+    ok.
+
+unique_monotonic_processes() ->
+    Self = self(),
+    spawn_opt(
+        fun() ->
+            n_times(50, fun() -> Self ! {a, erlang:unique_integer([monotonic])} end)
+        end,
+        []
+    ),
+    spawn_opt(
+        fun() ->
+            n_times(100, fun() -> Self ! {b, erlang:unique_integer([monotonic])} end)
+        end,
+        []
+    ),
+    Msgs = receive_messages(150),
+    NumA = [Num || {a, Num} <- Msgs],
+    NumB = [Num || {b, Num} <- Msgs],
+    true = increasing(NumA),
+    true = increasing(NumB),
+    ok.
+
+receive_messages(N) ->
+    receive_messages(N, []).
+receive_messages(0, Msgs) ->
+    reverse(Msgs);
+receive_messages(N, Msgs) ->
+    receive
+        Msg -> receive_messages(N - 1, [Msg | Msgs])
+    end.
+
+reverse(List) -> reverse(List, []).
+reverse([], Acc) -> Acc;
+reverse([H | T], Acc) -> reverse(T, [H | Acc]).
+
+n_times(0, _F) ->
+    ok;
+n_times(N, F) ->
+    F(),
+    n_times(N - 1, F).
+
+increasing([_]) -> true;
+increasing([A, B | T]) when A < B -> increasing([B | T]);
+increasing(_) -> false.

tests/test.c

@@ -569,6 +569,7 @@ struct Test tests[] = {
     TEST_CASE(test_utf8_atoms),
 
     TEST_CASE(twentyone_param_function),
+    TEST_CASE(unique),
     TEST_CASE(complex_list_match_xregs),
     TEST_CASE(twentyone_param_fun),
     TEST_CASE(gc_safe_x_reg_write),