Merge branch 'main' into feature/distributed-erlang

Author: bettio

.github/workflows/build-and-test-on-freebsd.yaml

@@ -34,10 +34,17 @@ concurrency:
 
 jobs:
   build-and-test-on-freebsd:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     name: Build and test AtomVM on FreeBSD
     env:
       ATOMVM_EXAMPLE: "atomvm-example"
+
+    strategy:
+      fail-fast: false
+
+      matrix:
+        os_release: ["13.4", "14.2"]
+
     steps:
 
     - uses: actions/checkout@v4
@@ -47,17 +54,17 @@ jobs:
       uses: vmactions/freebsd-vm@v1
       timeout-minutes: 20
       with:
-        release: 13.2
+        release: ${{ matrix.os_release }}
         envs: 'ATOMVM_EXAMPLE'
         usesh: true
         sync: rsync
         copyback: false
 
         prepare: |
-          pkg install -y curl cmake gperf erlang elixir mbedtls
+          pkg install -y curl cmake gperf erlang elixir rebar3 mbedtls
 
         run: |
-
+          set -e
           echo "%%"
           echo "%% System Info"
           echo "%%"

.github/workflows/build-and-test-other.yaml

@@ -107,7 +107,7 @@ jobs:
         # Required for testing big endian archs
         - arch: "s390x"
           platform: "s390x"
-          tag: "bullseye"
+          tag: "bookworm"
           cflags: "-O2"
           cmake_opts: "-DAVM_WARNINGS_ARE_ERRORS=ON"
 

.github/workflows/esp32-simtest.yaml

@@ -55,6 +55,12 @@ jobs:
     runs-on: ubuntu-24.04
     if: needs.cli_token.outputs.token_check == 'true'
     container: espressif/idf:${{ matrix.idf-version }}
+    services:
+      wokwi-ci-server:
+        image: wokwi/wokwi-ci-server
+        ports:
+          - 3000:3000
+
     strategy:
       fail-fast: false
       # focus on device diversity.
@@ -120,6 +126,10 @@ jobs:
           idf.py -DSDKCONFIG_DEFAULTS='sdkconfig.ci.wokwi' set-target ${{matrix.esp-idf-target}}
           idf.py build
 
+      - name: Configure Wokwi environment
+        run: |
+          echo "WOKWI_CLI_SERVER=ws://wokwi-ci-server:3000" >> $GITHUB_ENV
+
       - name: Run ESP32-sim tests using Wokwi CI
         working-directory: ./src/platforms/esp32/test/
         env:

CHANGELOG.md

@@ -66,6 +66,8 @@ certain VM instructions are used.
 - Fixed a double free when esp32 uart driver was closed, yielding an assert abort
 - Fixed compilation with latest debian gcc-arm-none-eabi
 - Fix `network:stop/0` on ESP32 so the network can be started again
+- Fix matching of binaries on unaligned boundaries for code compiled with older versions of OTP
+- Fix a memory corruption caused by `binary:split/2,3`
 
 ## [0.6.5] - 2024-10-15
 

doc/src/build-instructions.md

@@ -315,6 +315,63 @@ $ pytest --embedded-services=idf,qemu -s
 
 ESP32 tests are erlang modules located in `src/platforms/esp32/test/main/test_erl_sources/` and executed from `src/platforms/esp32/test/main/test_main.c`.
 
+### Performance and Power
+
+AtomVM comes with conservative defaults for broad compatibility with different ESP32 boards, and a reasonable performance/power/longevity tradeoff.
+
+You may want to change these settings to optimize for your specific application's performance and power needs.
+
+Factors like heat dissipation should also be considered, and the effect on overall longevity of components.
+
+#### CPU frequency
+
+Use `idf.py menuconfig` in `src/platforms/esp32`
+`Component config ---> ESP System Settings  ---> CPU frequency (160 MHz)  --->`
+
+You can increase or decrease the CPU frequency, this is a tradeoff against power usage.
+Eg. 160 MHz is the conservative default for the ESP32, but you can increase it to 240 MHz or decrease it to 80 MHz. The higher the frequency, the more power is consumed. The lower the frequency, the less power is consumed.
+
+#### Flash mode and speed
+
+Use `idf.py menuconfig` in `src/platforms/esp32`
+`Serial flasher config  ---> Flash SPI mode (DIO)  --->`
+You can change the mode of the SPI flash. QIO is the fastest mode, but not all flash chips support it.
+
+`Serial flasher config  ---> Flash SPI speed (40 MHz)  --->`
+You can change the speed of the SPI flash. The higher the speed, the faster the flash will be, at the cost of higher power usage, but not all flash chips support higher speeds.
+
+See external docs: [ESP-IDF flash modes](https://docs.espressif.com/projects/esptool/en/latest/esp32/advanced-topics/spi-flash-modes.html)
+
+#### PSRAM speed
+
+Use `idf.py menuconfig` in `src/platforms/esp32`
+`Component config ---> ESP PSRAM  ---> SPI RAM config  --->`
+
+If your board has PSRAM and it's enabled, you can configure the SPI RAM settings here.
+`Set RAM clock speed (40MHz clock speed)  --->`
+You can increase or decrease the clock speed of the PSRAM.
+
+```{warning}
+You may have to increase "Flash SPI speed" (see above) before you can increase PSRAM speed.
+```
+
+The higher the speed, the faster the PSRAM will be, at the cost of higher power usage, but not all PSRAM chips support higher speeds.
+
+#### Sleep mode - Deep sleep
+
+For low power applications, you should use the [deep sleep functionality](./programmers-guide.md#restart-and-deep-sleep) of the ESP32.
+
+This will put the ESP32 into a very low power state, and it will consume very little power.
+You can wake the ESP32 from deep sleep using a timer, or an interrupt etc.
+
+Make sure your board is suitable for low power deep sleep, some boards have voltage regulators and/or LEDs constantly draining power, also make sure sensors are powered down or in low power mode when the ESP32 is in deep sleep.
+
+For persisting small amounts of data during deep sleep, you can use the [RTC memory](./programmers-guide.md#rtc-memory) of the ESP32, which is preserved during deep sleep.
+
+#### Sleep mode - Light sleep
+
+Usage of light sleep is untested, and no support for controlling light sleep is currently implemented. Reach out if you do any experiments and measurements.
+
 ### Flash Layout
 
 The AtomVM Flash memory is partitioned to include areas for the above binary artifacts created from the build, as well areas for runtime information used by the ESP32 and compiled Erlang/Elixir code.

src/libAtomVM/nifs.c

@@ -3278,15 +3278,19 @@ static term nif_binary_split(Context *ctx, int argc, term argv[])
     size_t num_segments = 1;
     const char *temp_bin_data = bin_data;
     int temp_bin_size = bin_size;
+    size_t heap_size = 0;
     do {
         const char *found = (const char *) memmem(temp_bin_data, temp_bin_size, pattern_data, pattern_size);
         if (!found) break;
         num_segments++;
+        heap_size += CONS_SIZE + term_sub_binary_heap_size(argv[0], found - temp_bin_data);
         int next_search_offset = found - temp_bin_data + pattern_size;
         temp_bin_data += next_search_offset;
         temp_bin_size -= next_search_offset;
     } while (global && temp_bin_size >= pattern_size);
 
+    heap_size += CONS_SIZE + term_sub_binary_heap_size(argv[0], temp_bin_size);
+
     term result_list = term_nil();
 
     if (num_segments == 1) {
@@ -3299,7 +3303,7 @@ static term nif_binary_split(Context *ctx, int argc, term argv[])
     }
 
     // binary:split/2,3 always return sub binaries, except when copied binaries are as small as sub-binaries.
-    if (UNLIKELY(memory_ensure_free_with_roots(ctx, LIST_SIZE(num_segments, TERM_BOXED_SUB_BINARY_SIZE), 2, argv, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+    if (UNLIKELY(memory_ensure_free_with_roots(ctx, heap_size, 2, argv, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
     }
 

src/libAtomVM/opcodesswitch.h

@@ -4711,34 +4711,57 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 #ifdef IMPL_EXECUTE_LOOP
                     VERIFY_IS_MATCH_STATE(src, "bs_match_string");
 
-                    if (bits % 8 != 0) {
-                        TRACE("bs_match_string: Unsupported bits size (must be evenly divisible by 8). bits=%u\n", (unsigned) bits);
-                        RAISE_ERROR(UNSUPPORTED_ATOM);
-                    }
-                    avm_int_t bytes = bits / 8;
                     avm_int_t bs_offset = term_get_match_state_offset(src);
                     term bs_bin = term_get_match_state_binary(src);
 
-                    if (bs_offset % 8 != 0) {
-                        TRACE("bs_match_string: Unsupported offset (must be evenly divisible by 8). bs_offset=%li\n", bs_offset);
-                        RAISE_ERROR(UNSUPPORTED_ATOM);
-                    }
-                    avm_int_t byte_offset = bs_offset / 8;
-
-                    TRACE("bs_match_string/4, fail=%u src=%p bits=%u offset=%u\n", (unsigned) fail, (void *) src, (unsigned) bits, (unsigned) offset);
-
                     size_t remaining = 0;
                     const uint8_t *str = module_get_str(mod, offset, &remaining);
                     if (IS_NULL_PTR(str)) {
                         TRACE("bs_match_string: Bad offset in strings table.\n");
                         RAISE_ERROR(BADARG_ATOM);
                     }
-                    if (memcmp(term_binary_data(bs_bin) + byte_offset, str, MIN(remaining, (unsigned int) bytes)) != 0) {
-                        TRACE("bs_match_string: failed to match\n");
-                        JUMP_TO_ADDRESS(mod->labels[fail]);
+
+                    TRACE("bs_match_string/4, fail=%u src=%p bits=%u offset=%u\n", (unsigned) fail, (void *) src, (unsigned) bits, (unsigned) offset);
+
+                    if (bits % 8 == 0 && bs_offset % 8 == 0) {
+                        avm_int_t bytes = bits / 8;
+                        avm_int_t byte_offset = bs_offset / 8;
+
+                        if (memcmp(term_binary_data(bs_bin) + byte_offset, str, MIN(remaining, (unsigned int) bytes)) != 0) {
+                            TRACE("bs_match_string: failed to match\n");
+                            JUMP_TO_ADDRESS(mod->labels[fail]);
+                        }
                     } else {
-                        term_set_match_state_offset(src, bs_offset + bits);
+                        // Compare unaligned bits
+                        const uint8_t *bs_str = (const uint8_t *) term_binary_data(bs_bin) + (bs_offset / 8);
+                        uint8_t bin_bit_offset = 7 - (bs_offset - (8 *(bs_offset / 8)));
+                        uint8_t str_bit_offset = 7;
+                        size_t remaining_bits = bits;
+                        while (remaining_bits > 0) {
+                            uint8_t str_ch = *str;
+                            uint8_t bin_ch = *bs_str;
+                            uint8_t str_ch_bit = (str_ch >> str_bit_offset) & 1;
+                            uint8_t bin_ch_bit = (bin_ch >> bin_bit_offset) & 1;
+                            if (str_ch_bit ^ bin_ch_bit) {
+                                TRACE("bs_match_string: failed to match\n");
+                                JUMP_TO_ADDRESS(mod->labels[fail]);
+                            }
+                            if (str_bit_offset) {
+                                str_bit_offset--;
+                            } else {
+                                str_bit_offset = 7;
+                                str++;
+                            }
+                            if (bin_bit_offset) {
+                                bin_bit_offset--;
+                            } else {
+                                bin_bit_offset = 7;
+                                bs_str++;
+                            }
+                            remaining_bits--;
+                        }
                     }
+                    term_set_match_state_offset(src, bs_offset + bits);
                 #endif
                 break;
             }

src/libAtomVM/otp_net.c

@@ -86,8 +86,10 @@ static term eai_errno_to_term(int err, GlobalContext *glb)
 #ifdef HAVE_EXTENDED_EAI_ERRNO
         case EAI_BADHINTS:
             return globalcontext_make_atom(glb, ATOM_STR("\xB", "eaibadhints"));
+#ifdef HAVE_EAI_OVERFLOW
         case EAI_OVERFLOW:
             return globalcontext_make_atom(glb, ATOM_STR("\xB", "eaioverflow"));
+#endif
         case EAI_PROTOCOL:
             return globalcontext_make_atom(glb, ATOM_STR("\xB", "eaiprotocol"));
         case EAI_SYSTEM:

src/libAtomVM/term.h

@@ -1257,7 +1257,7 @@ static inline term term_from_literal_binary(const void *data, size_t size, Heap
  */
 static inline size_t term_sub_binary_heap_size(term binary, size_t len)
 {
-    if (term_is_refc_binary(binary) && len >= SUB_BINARY_MIN) {
+    if ((term_is_refc_binary(binary) || term_is_sub_binary(binary)) && len >= SUB_BINARY_MIN) {
         return TERM_BOXED_SUB_BINARY_SIZE;
     } else {
         return term_binary_heap_size(len);

src/platforms/generic_unix/lib/CMakeLists.txt

@@ -104,6 +104,10 @@ check_symbol_exists(EAI_BADHINTS "netdb.h" HAVE_EXTENDED_EAI_ERRNO)
 if (HAVE_EXTENDED_EAI_ERRNO)
     target_compile_definitions(libAtomVM${PLATFORM_LIB_SUFFIX} PUBLIC HAVE_EXTENDED_EAI_ERRNO)
 endif()
+check_symbol_exists(EAI_OVERFLOW "netdb.h" HAVE_EAI_OVERFLOW)
+if (HAVE_EAI_OVERFLOW)
+    target_compile_definitions(libAtomVM${PLATFORM_LIB_SUFFIX} PUBLIC HAVE_EAI_OVERFLOW)
+endif()
 
 if (COVERAGE)
     include(CodeCoverage)