nifs: add zlib:compress/1

https://www.erlang.org/doc/apps/erts/zlib.html#compress/1

Signed-off-by: Jakub Gonet <jakub.gonet@swmansion.com>

Author: TheSobkiewicz

CHANGELOG.md

@@ -58,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Removed `externalterm_to_term_copy` added in [0.6.5] and introduced flags to `externalterm_to_term` to perform copy.
 - Release images for ESP32 chips are built with ESP-IDF v5.4
 - ESP32: SPI peripheral defaults to `"spi2"` instead of deprecated `hspi`
+- Added `zlib:compress/1`
 
 ### Fixed
 

src/libAtomVM/nifs.c

@@ -60,6 +60,9 @@
 #include "term_typedef.h"
 #include "unicode.h"
 #include "utils.h"
+#ifdef WITH_ZLIB
+#include "zlib.h"
+#endif
 
 #define MAX_NIF_NAME_LEN 260
 #define FLOAT_BUF_SIZE 64
@@ -198,6 +201,7 @@ static term nif_maps_next(Context *ctx, int argc, term argv[]);
 static term nif_unicode_characters_to_list(Context *ctx, int argc, term argv[]);
 static term nif_unicode_characters_to_binary(Context *ctx, int argc, term argv[]);
 static term nif_erlang_lists_subtract(Context *ctx, int argc, term argv[]);
+static term nif_zlib_compress_1(Context *ctx, int argc, term argv[]);
 
 #define DECLARE_MATH_NIF_FUN(moniker) \
     static term nif_math_##moniker(Context *ctx, int argc, term argv[]);
@@ -858,6 +862,12 @@ static const struct Nif erlang_lists_subtract_nif =
     .base.type = NIFFunctionType,
     .nif_ptr = nif_erlang_lists_subtract
 };
+static const struct Nif zlib_compress_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_zlib_compress_1
+};
+
 
 #define DEFINE_MATH_NIF(moniker)                    \
     static const struct Nif math_##moniker##_nif =  \
@@ -2520,58 +2530,77 @@ static term nif_erlang_float_to_list(Context *ctx, int argc, term argv[])
     return make_list_from_ascii_buf((uint8_t *) float_buf, len, ctx);
 }
 
-static term nif_erlang_list_to_binary_1(Context *ctx, int argc, term argv[])
+static term iolist_to_buffer(term list, char **buf, size_t *size)
 {
-    UNUSED(argc);
-
-    term t = argv[0];
-    VALIDATE_VALUE(t, term_is_list);
+    *buf = NULL;
+    *size = 0;
 
     size_t bin_size;
-    switch (interop_iolist_size(t, &bin_size)) {
+    switch (interop_iolist_size(list, &bin_size)) {
         case InteropOk:
             break;
         case InteropMemoryAllocFail:
-            RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+            return OUT_OF_MEMORY_ATOM;
         case InteropBadArg:
-            RAISE_ERROR(BADARG_ATOM);
+            return BADARG_ATOM;
+    }
+
+    if (bin_size == 0) {
+        return OK_ATOM;
     }
 
     char *bin_buf = NULL;
-    bool buf_allocated = true;
-    if (bin_size > 0) {
-        bin_buf = malloc(bin_size);
-        if (IS_NULL_PTR(bin_buf)) {
-            RAISE_ERROR(OUT_OF_MEMORY_ATOM);
-        }
+    bin_buf = malloc(bin_size * sizeof(char));
+    if (IS_NULL_PTR(bin_buf)) {
+        return OUT_OF_MEMORY_ATOM;
+    }
 
-        switch (interop_write_iolist(t, bin_buf)) {
-            case InteropOk:
-                break;
-            case InteropMemoryAllocFail:
-                free(bin_buf);
-                RAISE_ERROR(OUT_OF_MEMORY_ATOM);
-            case InteropBadArg:
-                free(bin_buf);
-                RAISE_ERROR(BADARG_ATOM);
-        }
+    switch (interop_write_iolist(list, bin_buf)) {
+        case InteropOk:
+            break;
+        case InteropMemoryAllocFail:
+            free(bin_buf);
+            return OUT_OF_MEMORY_ATOM;
+        case InteropBadArg:
+            free(bin_buf);
+            return BADARG_ATOM;
+    }
+
+    *buf = bin_buf;
+    *size = bin_size;
+    return OK_ATOM;
+}
+
+static term nif_erlang_list_to_binary_1(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+
+    term t = argv[0];
+    VALIDATE_VALUE(t, term_is_list);
+
+    char *bin_buf = NULL;
+    char *alloc_ptr = NULL;
+    size_t bin_size = 0;
+
+    term status = iolist_to_buffer(t, &bin_buf, &bin_size);
+    if (UNLIKELY(status != OK_ATOM)) {
+        RAISE_ERROR(status);
+    }
+    bool allocated = bin_size > 0;
+    if (allocated) {
+        alloc_ptr = bin_buf;
     } else {
         bin_buf = "";
-        buf_allocated = false;
+        bin_size = 0;
     }
 
-    if (UNLIKELY(memory_ensure_free_with_roots(ctx, term_binary_heap_size(bin_size), 1, argv, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
-        if (buf_allocated) {
-            free(bin_buf);
-        }
+    if (UNLIKELY(memory_ensure_free(ctx, term_binary_heap_size(bin_size)) != MEMORY_GC_OK)) {
+        free(alloc_ptr);
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
     }
     term bin_res = term_from_literal_binary(bin_buf, bin_size, &ctx->heap, ctx->global);
 
-    if (buf_allocated) {
-        free(bin_buf);
-    }
-
+    free(alloc_ptr);
     return bin_res;
 }
 
@@ -5837,6 +5866,85 @@ static term nif_erlang_lists_subtract(Context *ctx, int argc, term argv[])
     free(cons);
     return result;
 }
+
+#ifdef WITH_ZLIB
+static term nif_zlib_compress_1(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc)
+
+    term error = OK_ATOM;
+
+    Bytef *output_buf = NULL;
+    char *input_buf = NULL;
+    size_t input_size = 0;
+    char *alloc_ptr = NULL;
+
+    term input = argv[0];
+    if (LIKELY(term_is_list(input))) {
+        term status = iolist_to_buffer(input, &input_buf, &input_size);
+        if (UNLIKELY(status != OK_ATOM)) {
+            error = status;
+            goto cleanup;
+        }
+
+        bool allocated = input_size > 0;
+        if (allocated) {
+            alloc_ptr = input_buf;
+        } else {
+            input_buf = "";
+            input_size = 0;
+        }
+    } else if (LIKELY(term_is_binary(input))) {
+        input_buf = (char *) term_binary_data(input);
+        input_size = term_binary_size(input);
+    } else {
+        error = BADARG_ATOM;
+        goto cleanup;
+    }
+
+    // to_allocate is an upper bound for compression size
+    // changes to actual size after calling compress
+    uLong to_allocate = compressBound(input_size);
+    // TODO: use `to_allocate` binary directly instead of allocating a buffer
+    // Currently not possible, there's no way to shrink backing buffer for the binary
+    output_buf = malloc(to_allocate);
+    if (IS_NULL_PTR(output_buf)) {
+        error = OUT_OF_MEMORY_ATOM;
+        goto cleanup;
+    }
+
+    int z_ret = compress(output_buf, &to_allocate, (const Bytef *) input_buf, input_size);
+    if (UNLIKELY(z_ret != Z_OK)) {
+        error = OUT_OF_MEMORY_ATOM;
+        goto cleanup;
+    }
+
+    if (UNLIKELY(memory_ensure_free(ctx, term_binary_data_size_in_terms(to_allocate)) != MEMORY_GC_OK)) {
+        error = OUT_OF_MEMORY_ATOM;
+        goto cleanup;
+    }
+    term bin_res = term_from_literal_binary(output_buf, to_allocate, &ctx->heap, ctx->global);
+
+cleanup:
+    free(alloc_ptr);
+    free(output_buf);
+    if (UNLIKELY(error != OK_ATOM)) {
+        RAISE_ERROR(error);
+    }
+    return bin_res;
+}
+#endif
+#ifndef WITH_ZLIB
+static term nif_zlib_compress_1(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc)
+    UNUSED(argv)
+    UNUSED(ctx)
+    fprintf(stderr, "Error: zlib library needed to use zlib:compress/1\n");
+    RAISE_ERROR(UNDEFINED_ATOM);
+}
+#endif
+
 //
 // MAINTENANCE NOTE: Exception handling for fp operations using math
 // error handling is designed to be thread-safe, as errors are specified

src/libAtomVM/nifs.gperf

@@ -209,3 +209,4 @@ math:sinh/1, &math_sinh_nif
 math:sqrt/1, &math_sqrt_nif
 math:tan/1, &math_tan_nif
 math:tanh/1, &math_tanh_nif
+zlib:compress/1, &zlib_compress_nif

tests/erlang_tests/CMakeLists.txt

@@ -287,6 +287,8 @@ compile_erlang(test_split_binary)
 compile_erlang(test_binary_replace)
 compile_erlang(test_binary_match)
 
+compile_erlang(test_zlib_compress)
+
 compile_erlang(plusone)
 compile_erlang(plusone2)
 compile_erlang(minusone)
@@ -780,6 +782,8 @@ add_custom_target(erlang_test_modules DEPENDS
     test_binary_replace.beam
     test_binary_match.beam
 
+    test_zlib_compress.beam
+
     plusone.beam
     plusone2.beam
     minusone.beam

tests/erlang_tests/test_zlib_compress.erl

@@ -0,0 +1,82 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2024 Tomasz Sobkiewicz <tomasz.sobkiewicz@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(test_zlib_compress).
+
+-export([start/0]).
+
+start() ->
+    ok = compress_binary(),
+    ok = compress_iolist(),
+    ok = bad_inputs(),
+    0.
+
+compress_binary() ->
+    ToCompress =
+        <<"Actually, this sentence could be a bit shorter. We definitelly need to compress it.">>,
+    % Data from original erlang implementation
+    ProperlyCompressed =
+        <<120, 156, 13, 203, 203, 13, 128, 32, 16, 4, 208, 86, 166, 0, 67, 15, 86, 225, 153, 207,
+            24, 54, 65, 48, 236, 112, 176, 123, 185, 191, 119, 102, 173, 216, 218, 119, 64, 213, 28,
+            206, 46, 246, 76, 228, 177, 90, 65, 34, 34, 146, 9, 94, 199, 20, 103, 192, 69, 20, 222,
+            214, 77, 220, 11, 157, 44, 208, 216, 252, 121, 39, 221, 97, 10, 63, 241, 84, 30, 23>>,
+    ProperlyCompressed = zlib:compress(ToCompress),
+    ok.
+
+compress_iolist() ->
+    ToCompressList = [
+        <<"Actually,">>,
+        " this sentence ",
+        <<"could be ">>,
+        [[<<"a ">>, [<<"b">>, <<"i">>]], <<"t">>],
+        <<" shorter. ">>,
+        [<<"we ">>],
+        <<"definitely need ">>,
+        "to compress ",
+        <<"it.">>
+    ],
+    % Data from original erlang implementation
+    ProperlyCompressed =
+        <<120, 156, 13, 202, 219, 13, 128, 32, 12, 5, 208, 85, 238, 0, 134, 29, 28, 133, 199, 53,
+            52, 169, 197, 208, 18, 195, 246, 122, 190, 207, 89, 99, 101, 213, 125, 32, 186, 56, 156,
+            22, 180, 74, 212, 177, 180, 161, 16, 25, 69, 2, 222, 199, 12, 206, 132, 151, 104, 188,
+            196, 36, 168, 27, 70, 54, 196, 248, 247, 253, 76, 186, 67, 34, 125, 214, 36, 29, 203>>,
+    ProperlyCompressed = zlib:compress(ToCompressList),
+
+    true = is_binary(zlib:compress([])),
+    true = is_binary(zlib:compress([[]])),
+    true = is_binary(zlib:compress([[], []])),
+    true = is_binary(zlib:compress([[] | <<>>])),
+    ok.
+
+bad_inputs() ->
+    ok = raises(badarg, fun() -> zlib:compress(1) end),
+    ok = raises(badarg, fun() -> zlib:compress([{}]) end),
+    ok = raises(badarg, fun() -> zlib:compress([1024]) end),
+    ok.
+
+raises(Error, F) ->
+    try F() of
+        V ->
+            {unexpected, V}
+    catch
+        error:Error -> ok;
+        C:E -> {unexpected, C, E}
+    end.

tests/test.c

@@ -328,6 +328,8 @@ struct Test tests[] = {
     TEST_CASE(test_binary_replace),
     TEST_CASE(test_binary_match),
 
+    TEST_CASE(test_zlib_compress),
+
     TEST_CASE_COND(plusone, 134217728, LONG_MAX != 9223372036854775807),
 
     TEST_CASE_EXPECTED(plusone2, 1),