Merge pull request #1654 from pguyot/w19/reduce-line-ref-memory-footprint

Reduce memory footprint of line refs

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

src/libAtomVM/module.c

@@ -57,6 +57,12 @@ static void module_add_label(Module *mod, int index, const uint8_t *ptr);
 static enum ModuleLoadResult module_build_imported_functions_table(Module *this_module, uint8_t *table_data, GlobalContext *glb);
 static void module_parse_line_table(Module *mod, const uint8_t *data, size_t len);
 
+struct LineRefOffset
+{
+    struct ListHead head;
+    unsigned int offset;
+};
+
 #define IMPL_CODE_LOADER 1
 #include "opcodesswitch.h"
 #undef TRACE
@@ -276,7 +282,6 @@ Module *module_new_from_iff_binary(GlobalContext *global, const void *iff_binary
     }
 
     module_parse_line_table(mod, beam_file + offsets[LINT] + 8, sizes[LINT]);
-    list_init(&mod->line_ref_offsets);
 
     if (offsets[LITT]) {
         #ifdef WITH_ZLIB
@@ -305,7 +310,40 @@ Module *module_new_from_iff_binary(GlobalContext *global, const void *iff_binary
         mod->free_literals_data = 0;
     }
 
-    mod->end_instruction_ii = read_core_chunk(mod);
+    struct ListHead line_refs;
+    list_init(&line_refs);
+    mod->end_instruction_ii = read_core_chunk(mod, &line_refs);
+
+    // Create the list of offsets if the module has line informations.
+    if (mod->line_refs_table != NULL) {
+        // Compute the size of the list
+        size_t num_offsets = 0;
+        struct ListHead *item = line_refs.next;
+        while (item != &line_refs) {
+            num_offsets++;
+            item = item->next;
+        }
+        mod->line_refs_offsets = malloc(num_offsets * sizeof(unsigned int));
+        if (IS_NULL_PTR(mod->line_refs_offsets)) {
+            fprintf(stderr, "Warning: Unable to allocate space for line refs offset, module has %zu offsets.  Line information in stacktraces may be missing\n", num_offsets);
+        } else {
+            size_t index = 0;
+            item = line_refs.next;
+            while (item != &line_refs) {
+                struct LineRefOffset *offset = CONTAINER_OF(item, struct LineRefOffset, head);
+                mod->line_refs_offsets[index] = offset->offset;
+                index++;
+                item = item->next;
+            }
+            mod->line_refs_offsets_count = num_offsets;
+        }
+    }
+    // Empty the list
+    while (!list_is_empty(&line_refs)) {
+        struct ListHead *item = line_refs.next;
+        list_remove(item);
+        free(item);
+    }
 
     return mod;
 }
@@ -316,6 +354,7 @@ COLD_FUNC void module_destroy(Module *module)
     free(module->imported_funcs);
     free(module->literals_table);
     free(module->local_atoms_to_global_table);
+    free(module->line_refs_offsets);
     if (module->free_literals_data) {
         free(module->literals_data);
     }
@@ -697,19 +736,28 @@ static void module_parse_line_table(Module *mod, const uint8_t *data, size_t len
     }
 }
 
-void module_insert_line_ref_offset(Module *mod, int line_ref, int offset)
+void module_insert_line_ref_offset(Module *mod, struct ListHead *line_refs, uint32_t line_ref, int offset)
 {
     if (IS_NULL_PTR(mod->line_refs_table) || line_ref == 0) {
         return;
     }
     struct LineRefOffset *ref_offset = malloc(sizeof(struct LineRefOffset));
     if (IS_NULL_PTR(ref_offset)) {
-        fprintf(stderr, "Warning: Unable to allocate space for line ref offset.  Line information in stacktraces may be missing\n");
+        size_t num_refs = 0;
+        // Empty the list
+        while (!list_is_empty(line_refs)) {
+            struct ListHead *item = line_refs->next;
+            list_remove(item);
+            free(item);
+            num_refs++;
+        }
+        fprintf(stderr, "Warning: Unable to allocate space for an additional line ref offset (we had %zu).  Line information in stacktraces may be missing\n", num_refs);
+        // Give up having line numbers for this module.
+        mod->line_refs_table = NULL;
         return;
     }
-    ref_offset->line_ref = line_ref;
     ref_offset->offset = offset;
-    list_append(&mod->line_ref_offsets, &ref_offset->head);
+    list_append(line_refs, &ref_offset->head);
 }
 
 static bool module_find_line_ref(Module *mod, uint16_t line_ref, uint32_t *line, size_t *filename_len, const uint8_t **filename)
@@ -723,30 +771,30 @@ static bool module_find_line_ref(Module *mod, uint16_t line_ref, uint32_t *line,
 
 bool module_find_line(Module *mod, unsigned int offset, uint32_t *line, size_t *filename_len, const uint8_t **filename)
 {
-    int i = 0;
-    struct LineRefOffset *head = GET_LIST_ENTRY(&mod->line_ref_offsets, struct LineRefOffset, head);
-    struct ListHead *item;
-    LIST_FOR_EACH (item, &mod->line_ref_offsets) {
-        struct LineRefOffset *ref_offset = GET_LIST_ENTRY(item, struct LineRefOffset, head);
-
-        if (offset == ref_offset->offset) {
-            return module_find_line_ref(mod, ref_offset->line_ref, line, filename_len, filename);
-        } else if (i == 0 && offset < ref_offset->offset) {
+    size_t i;
+    unsigned int ref_offset;
+    uint32_t line_ref;
+    const uint8_t *ref_pc;
+    if (IS_NULL_PTR(mod->line_refs_offsets)) {
+        return false;
+    }
+    for (i = 0; i < mod->line_refs_offsets_count; i++) {
+        ref_offset = mod->line_refs_offsets[i];
+        if (offset == ref_offset) {
+            ref_pc = &mod->code->code[ref_offset];
+            DECODE_LITERAL(line_ref, ref_pc);
+            return module_find_line_ref(mod, line_ref, line, filename_len, filename);
+        } else if (i == 0 && offset < ref_offset) {
             return false;
-        } else {
-
-            struct LineRefOffset *prev_ref_offset = GET_LIST_ENTRY(ref_offset->head.prev, struct LineRefOffset, head);
-            if (prev_ref_offset->offset <= offset && offset < ref_offset->offset) {
-                return module_find_line_ref(mod, prev_ref_offset->line_ref, line, filename_len, filename);
-            }
-
-            struct LineRefOffset *next_ref_offset = GET_LIST_ENTRY(ref_offset->head.next, struct LineRefOffset, head);
-            if (next_ref_offset == head && ref_offset->offset <= offset) {
-                return module_find_line_ref(mod, ref_offset->line_ref, line, filename_len, filename);
-            }
+        } else if (offset < ref_offset) {
+            ref_offset = mod->line_refs_offsets[i - 1];
+            ref_pc = &mod->code->code[ref_offset];
+            DECODE_LITERAL(line_ref, ref_pc);
+            return module_find_line_ref(mod, line_ref, line, filename_len, filename);
         }
-
-        ++i;
     }
-    return false;
+    ref_offset = mod->line_refs_offsets[i - 1];
+    ref_pc = &mod->code->code[ref_offset];
+    DECODE_LITERAL(line_ref, ref_pc);
+    return module_find_line_ref(mod, line_ref, line, filename_len, filename);
 }

src/libAtomVM/module.h

@@ -88,13 +88,6 @@ struct ModuleFilename
     size_t len;
 };
 
-struct LineRefOffset
-{
-    struct ListHead head;
-    unsigned int offset;
-    uint16_t line_ref;
-};
-
 struct Module
 {
 #ifdef ENABLE_ADVANCED_TRACE
@@ -113,7 +106,8 @@ struct Module
     size_t locations_count;
     const uint8_t *locations_table;
 
-    struct ListHead line_ref_offsets;
+    unsigned int *line_refs_offsets;
+    size_t line_refs_offsets_count;
 
     const struct ExportedFunction **imported_funcs;
 
@@ -390,10 +384,11 @@ bool module_get_function_from_label(Module *this_module, int label, AtomString *
  * is a no-op.
  *
  * @param mod the module
+ * @param line_refs the list of line references to append to
  * @param line_ref the line reference (index)
  * @param offset the instruction offset at which the line instruction occurred.
  */
-void module_insert_line_ref_offset(Module *mod, int line_ref, int offset);
+void module_insert_line_ref_offset(Module *mod, struct ListHead *line_refs, uint32_t line_ref, int offset);
 
 /*
  * @brief Find the latest line reference (index) before or at which the instruction offset

src/libAtomVM/opcodesswitch.h

@@ -1809,9 +1809,9 @@ static bool maybe_call_native(Context *ctx, AtomString module_name, AtomString f
 #endif
 
 #ifdef IMPL_CODE_LOADER
-    int read_core_chunk0(Module *mod);
+    int read_core_chunk0(Module *mod, struct ListHead *line_refs);
 
-    int read_core_chunk(Module *mod)
+    int read_core_chunk(Module *mod, struct ListHead *line_refs)
 #else
     #ifdef IMPL_EXECUTE_LOOP
         int context_execute_loop(Context *ctx, Module *mod, const char *function_name, int arity)
@@ -1848,7 +1848,7 @@ static bool maybe_call_native(Context *ctx, AtomString module_name, AtomString f
     #endif
 
 #ifdef IMPL_CODE_LOADER
-    return read_core_chunk0(mod);
+    return read_core_chunk0(mod, line_refs);
 #endif
 #ifdef IMPL_EXECUTE_LOOP
     // This process is the first scheduler process
@@ -1860,7 +1860,7 @@ static bool maybe_call_native(Context *ctx, AtomString module_name, AtomString f
 }
 
 #ifdef IMPL_CODE_LOADER
-int read_core_chunk0(Module *mod)
+int read_core_chunk0(Module *mod, struct ListHead *line_refs)
 #else
 #ifdef IMPL_EXECUTE_LOOP
 HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
@@ -5675,15 +5675,16 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
 
             case OP_LINE: {
                 #ifdef IMPL_CODE_LOADER
-                    const uint8_t *saved_pc = pc -1;
+                    unsigned int offset = pc - code;
                 #endif
                 uint32_t line_number;
+                // This decode increments pc and ensures we can decode it
                 DECODE_LITERAL(line_number, pc);
 
                 TRACE("line/1: %i\n", line_number);
 
                 #ifdef IMPL_CODE_LOADER
-                    module_insert_line_ref_offset(mod, line_number, saved_pc - code);
+                    module_insert_line_ref_offset(mod, line_refs, line_number, offset);
                 #endif
                 break;
             }