Merge pull request #1202 from pguyot/w25/code-all_loaded-all_available

Add code:all_loaded/0 and code:all_available/0

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

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Added a limited implementation of the OTP `ets` interface
+- Added `code:all_loaded/0` and `code:all_available/0`
 
 ## [0.6.3] - Unreleased
 

libs/estdlib/src/code.erl

@@ -24,7 +24,37 @@
 %%-----------------------------------------------------------------------------
 -module(code).
 
--export([load_abs/1, load_binary/3]).
+-export([
+    all_available/0,
+    all_loaded/0,
+    load_abs/1,
+    load_binary/3
+]).
+
+%%-----------------------------------------------------------------------------
+%% @returns A list of available modules, including loaded modules
+%% @doc     Return all modules available from loaded avm packs, in addition
+%%          to loaded modules. List of available modules may be incomplete if
+%%          this function is called while a module is loaded.
+%%          Result type differs from Erlang/OTP: names of modules is a binary
+%%          (and not a string), and second term of tuples is currently
+%%          unspecified
+%% @end
+%%-----------------------------------------------------------------------------
+-spec all_available() -> [{unicode:unicode_binary(), term(), boolean()}].
+all_available() ->
+    erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @returns A list of all loaded modules
+%% @doc     Return a list of all loaded modules.
+%%          Result type differs from Erlang/OTP: second term of tuples is
+%%          currently unspecified
+%% @end
+%%-----------------------------------------------------------------------------
+-spec all_loaded() -> [{atom(), term()}].
+all_loaded() ->
+    erlang:nif_error(undefined).
 
 %%-----------------------------------------------------------------------------
 %% @param   Filename    path to the beam to open, without .beams suffix

src/libAtomVM/globalcontext.h

@@ -118,7 +118,7 @@ struct GlobalContext
     RWLock *modules_lock;
 #endif
     Module **modules_by_index;
-    int loaded_modules_count;
+    int ATOMIC loaded_modules_count;
 
     struct SyncList avmpack_data;
 

src/libAtomVM/nifs.c

@@ -177,6 +177,8 @@ static term nif_base64_encode(Context *ctx, int argc, term argv[]);
 static term nif_base64_decode(Context *ctx, int argc, term argv[]);
 static term nif_base64_encode_to_string(Context *ctx, int argc, term argv[]);
 static term nif_base64_decode_to_string(Context *ctx, int argc, term argv[]);
+static term nif_code_all_available(Context *ctx, int argc, term argv[]);
+static term nif_code_all_loaded(Context *ctx, int argc, term argv[]);
 static term nif_code_load_abs(Context *ctx, int argc, term argv[]);
 static term nif_code_load_binary(Context *ctx, int argc, term argv[]);
 static term nif_lists_reverse(Context *ctx, int argc, term argv[]);
@@ -728,6 +730,16 @@ static const struct Nif base64_decode_to_string_nif =
     .base.type = NIFFunctionType,
     .nif_ptr = nif_base64_decode_to_string
 };
+static const struct Nif code_all_available_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_code_all_available
+};
+static const struct Nif code_all_loaded_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_code_all_loaded
+};
 static const struct Nif code_load_abs_nif =
 {
     .base.type = NIFFunctionType,
@@ -4435,6 +4447,121 @@ static term nif_base64_decode_to_string(Context *ctx, int argc, term argv[])
     return base64_decode(ctx, argc, argv, false);
 }
 
+static term nif_code_all_loaded(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+
+    term result = term_nil();
+    int loaded_modules_count = ctx->global->loaded_modules_count;
+    if (UNLIKELY(memory_ensure_free(ctx, LIST_SIZE(loaded_modules_count, TUPLE_SIZE(2))) != MEMORY_GC_OK)) {
+        RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    }
+
+    for (int ix = 0; ix < loaded_modules_count; ix++) {
+        Module *module = globalcontext_get_module_by_index(ctx->global, ix);
+        term module_tuple = term_alloc_tuple(2, &ctx->heap);
+        term_put_tuple_element(module_tuple, 0, module_get_name(module));
+        term_put_tuple_element(module_tuple, 1, UNDEFINED_ATOM);
+        result = term_list_prepend(module_tuple, result, &ctx->heap);
+    }
+
+    return result;
+}
+
+struct CodeAllAvailableAcc {
+    Context *ctx;
+    struct AVMPackData *avmpack_data;
+    term result;
+    size_t acc_count;
+};
+
+static void *nif_code_all_available_fold(void *accum, const void *section_ptr, uint32_t section_size, const void *beam_ptr, uint32_t flags, const char *section_name)
+{
+    UNUSED(section_ptr);
+    UNUSED(section_size);
+    UNUSED(beam_ptr);
+    UNUSED(flags);
+
+    struct CodeAllAvailableAcc *acc = (struct CodeAllAvailableAcc *) accum;
+    size_t section_name_len = strlen(section_name);
+    if (section_name_len < 260) {
+        if (memcmp(".beam", section_name + section_name_len - 5, 5) == 0) {
+            bool loaded;
+            if (acc->avmpack_data->in_use) {
+                // Check if module is loaded
+                char atom_str[section_name_len - 5];
+                atom_str[0] = section_name_len - 5;
+                memcpy(atom_str + 1, section_name, atom_str[0]);
+                Module *loaded_module = globalcontext_get_module(acc->ctx->global, (AtomString) &atom_str);
+                loaded = loaded_module != NULL;
+            } else {
+                loaded = false;
+            }
+            if (!loaded) {
+                acc->acc_count++;
+                if (!term_is_invalid_term(acc->result)) {
+                    term module_tuple = term_alloc_tuple(3, &acc->ctx->heap);
+                    term_put_tuple_element(module_tuple, 0, term_from_const_binary(section_name, section_name_len - 5, &acc->ctx->heap, acc->ctx->global));
+                    term_put_tuple_element(module_tuple, 1, UNDEFINED_ATOM);
+                    term_put_tuple_element(module_tuple, 2, FALSE_ATOM);
+                    acc->result = term_list_prepend(module_tuple, acc->result, &acc->ctx->heap);
+                }
+            }
+        }
+    }
+    return accum;
+}
+
+static term nif_code_all_available(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+
+    // We return the list of loaded modules and all modules that are
+    // found in loaded avm packs.
+    struct ListHead *item;
+    struct ListHead *avmpack_data = synclist_rdlock(&ctx->global->avmpack_data);
+    struct CodeAllAvailableAcc acc;
+    acc.ctx = ctx;
+    acc.result = term_invalid_term();
+    acc.acc_count = 0;
+    LIST_FOR_EACH (item, avmpack_data) {
+        struct AVMPackData *avmpack_data = GET_LIST_ENTRY(item, struct AVMPackData, avmpack_head);
+        acc.avmpack_data = avmpack_data;
+        avmpack_fold(&acc, avmpack_data->data, nif_code_all_available_fold);
+    }
+
+    size_t available_count = acc.acc_count + ctx->global->loaded_modules_count;
+
+    if (UNLIKELY(memory_ensure_free(ctx, LIST_SIZE(available_count, TUPLE_SIZE(3) + TERM_BOXED_REFC_BINARY_SIZE)) != MEMORY_GC_OK)) {
+        synclist_unlock(&ctx->global->avmpack_data);
+        RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    }
+
+    // List may be incomplete if modules are loaded while we are iterating on them
+    acc.acc_count = 0;
+    acc.result = term_nil();
+    LIST_FOR_EACH (item, avmpack_data) {
+        struct AVMPackData *avmpack_data = GET_LIST_ENTRY(item, struct AVMPackData, avmpack_head);
+        acc.avmpack_data = avmpack_data;
+        avmpack_fold(&acc, avmpack_data->data, nif_code_all_available_fold);
+    }
+    synclist_unlock(&ctx->global->avmpack_data);
+
+    for (size_t ix = 0; ix < available_count - acc.acc_count; ix++) {
+        Module *module = globalcontext_get_module_by_index(ctx->global, ix);
+        term module_tuple = term_alloc_tuple(3, &ctx->heap);
+        AtomString module_atom_str = globalcontext_atomstring_from_term(ctx->global, module_get_name(module));
+        term_put_tuple_element(module_tuple, 0, term_from_const_binary(((const char *) module_atom_str) + 1, ((const char *) module_atom_str)[0], &ctx->heap, ctx->global));
+        term_put_tuple_element(module_tuple, 1, UNDEFINED_ATOM);
+        term_put_tuple_element(module_tuple, 2, TRUE_ATOM);
+        acc.result = term_list_prepend(module_tuple, acc.result, &ctx->heap);
+    }
+
+    return acc.result;
+}
+
 static term nif_code_load_abs(Context *ctx, int argc, term argv[])
 {
     UNUSED(argc);

src/libAtomVM/nifs.gperf

@@ -143,6 +143,8 @@ atomvm:posix_unlink/1, IF_HAVE_UNLINK(&atomvm_posix_unlink_nif)
 atomvm:posix_clock_settime/2, IF_HAVE_CLOCK_SETTIME_OR_SETTIMEOFDAY(&atomvm_posix_clock_settime_nif)
 code:load_abs/1, &code_load_abs_nif
 code:load_binary/3, &code_load_binary_nif
+code:all_available/0, &code_all_available_nif
+code:all_loaded/0, &code_all_loaded_nif
 console:print/1, &console_print_nif
 base64:encode/1, &base64_encode_nif
 base64:decode/1, &base64_decode_nif

tests/erlang_tests/CMakeLists.txt

@@ -476,6 +476,7 @@ compile_erlang(test_stacktrace)
 compile_erlang(small_big_ext)
 compile_erlang(test_crypto)
 
+compile_erlang(test_code_all_available_loaded)
 compile_erlang(test_code_load_binary)
 compile_erlang(test_code_load_abs)
 compile_erlang(test_add_avm_pack_binary)
@@ -939,6 +940,7 @@ add_custom_target(erlang_test_modules DEPENDS
     small_big_ext.beam
     test_crypto.beam
 
+    test_code_all_available_loaded.beam
     test_code_load_binary.beam
     test_code_load_abs.beam
     test_add_avm_pack_binary.beam

tests/erlang_tests/test_code_all_available_loaded.erl

@@ -0,0 +1,70 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2024 Paul Guyot <pguyot@kallisys.net>
+%
+% 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(test_code_all_available_loaded).
+
+-export([start/0]).
+
+start() ->
+    ok = test_all_loaded(),
+    ok = test_all_available(),
+    0.
+
+test_all_loaded() ->
+    Loaded = code:all_loaded(),
+    true = length(Loaded) > 0,
+    true = has_key(?MODULE, Loaded),
+    ok.
+
+test_all_available() ->
+    FunctionExists =
+        case erlang:system_info(machine) of
+            "BEAM" ->
+                erlang:system_info(version) >= "11.";
+            "ATOM" ->
+                true
+        end,
+    test_all_available0(FunctionExists).
+
+test_all_available0(false) ->
+    ok;
+test_all_available0(true) ->
+    Loaded = code:all_loaded(),
+    Available = code:all_available(),
+    true = length(Available) >= length(Loaded),
+    AvailableLoaded = [
+        {binary_to_atom(iolist_to_binary(Module), utf8), File}
+     || {Module, File, true} <- Available
+    ],
+    true = set_equal(Loaded, AvailableLoaded),
+    ok.
+
+has_key(_Module, []) -> false;
+has_key(Module, [{Module, _} | _]) -> true;
+has_key(Module, [_H | Tail]) -> has_key(Module, Tail).
+
+set_equal(L1, L2) ->
+    set_equal0(L1, L2, []).
+
+set_equal0([], [], []) -> true;
+set_equal0([H | T1], [H | T2], Acc) -> set_equal0(T1, T2 ++ Acc, []);
+set_equal0([_H1 | _T1] = L1, [H2 | T2], Acc) -> set_equal0(L1, T2, [H2 | Acc]);
+set_equal0(_L1, [], _Acc) -> false;
+set_equal0([], _L2, _Acc) -> false.

tests/test.c

@@ -487,6 +487,7 @@ struct Test tests[] = {
     TEST_CASE_ATOMVM_ONLY(test_regecho_driver, 11),
     TEST_CASE_ATOMVM_ONLY(test_send_nif_and_echo, 22),
 
+    TEST_CASE(test_code_all_available_loaded),
     TEST_CASE_EXPECTED(test_code_load_binary, 24),
     TEST_CASE_EXPECTED(test_code_load_abs, 24),
     TEST_CASE_ATOMVM_ONLY(test_add_avm_pack_binary, 24),