Merge pull request #1546 from pguyot/w07/gc-memory-fragments

Run GC when there is a memory fragment to copy message data

Fix a bug where an out of memory error could occur if a process received
messages repeatedly but didn't allocate enough memory to cause a GC.
Received messages would accumulate as memory fragments and never be disposed.

The fix consists in forcing a GC if there is a memory fragment, either from a
message or from an allocation when running a GC was prohibited. This ensures
fragments are processed and referred data from fragments are copied to the heap.

This fix has a small performance penalty as the GC is always triggered where
there is a fragment, even if there was no need to run a GC based on available
memory.

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

@@ -50,6 +50,7 @@ bug when handling errors from BIFs used as NIFs (when called with `CALL_EXT` and
 - Fixed call to funs such as fun erlang:'not'/1, that make use of BIFs
 - Fixed potential crashes or memory leaks caused by a mistake in calculation of reference counts
 and a race condition in otp_socket code
+- Fixed an out of memory issue by forcing GC to copy data from message fragments
 
 ## [0.6.5] - 2024-10-15
 

src/libAtomVM/memory.c

@@ -158,7 +158,7 @@ enum MemoryGCResult memory_ensure_free_with_roots(Context *c, size_t size, size_
         // Target heap size depends on:
         // - alloc_mode (MEMORY_FORCE_SHRINK takes precedence)
         // - heap growth strategy
-        bool should_gc = free_space < size || (alloc_mode == MEMORY_FORCE_SHRINK);
+        bool should_gc = free_space < size || (alloc_mode == MEMORY_FORCE_SHRINK) || c->heap.root->next != NULL;
         size_t memory_size = 0;
         if (!should_gc) {
             switch (c->heap_growth_strategy) {

tests/erlang_tests/test_heap_growth.erl

@@ -28,6 +28,7 @@ start() ->
     ok = test_bounded_free_strategy(true),
     ok = test_minimum_strategy(),
     ok = test_fibonacci_strategy(),
+    ok = test_messages_get_gcd(),
     0.
 
 test_grow_beyond_min_heap_size() ->
@@ -214,3 +215,47 @@ allocate_until_heap_size_changes(Heap) ->
             alloc_some_heap_words(100),
             allocate_until_heap_size_changes(Heap)
     end.
+
+% This test ensures that when messages are received, they eventually get gc'd
+test_messages_get_gcd() ->
+    {Pid1, Ref1} = spawn_opt(
+        fun() ->
+            loop([])
+        end,
+        [monitor, {atomvm_heap_growth, minimum}]
+    ),
+    FinalHeapSize = loop_send(Pid1, 20),
+    Pid1 ! quit,
+    ok =
+        receive
+            {'DOWN', Ref1, process, Pid1, normal} -> ok
+        after 500 -> timeout
+        end,
+    ok =
+        if
+            FinalHeapSize < 200 -> ok;
+            true -> {heap_size_too_large, FinalHeapSize}
+        end,
+    ok.
+
+loop(State) when is_list(State) ->
+    NewData =
+        receive
+            {get_data, Pid} ->
+                Pid ! {data, State},
+                State;
+            {data, Data} ->
+                Data;
+            quit ->
+                ok
+        end,
+    loop(NewData);
+loop(_Other) ->
+    ok.
+
+loop_send(Pid, 0) ->
+    {total_heap_size, THS} = process_info(Pid, total_heap_size),
+    THS;
+loop_send(Pid, N) ->
+    Pid ! {data, alloc_some_heap_words(40)},
+    loop_send(Pid, N - 1).