FU::Util: Add gzip_compress() wrapper for libdeflate/zlib-ng/zlib

And use it for automatic output compression in FU, as (potentially) faster alternative to Compress::Raw::Zlib. Was also planning to maybe add support for Zstd or Brotli, but given the performance of libdeflate, I'm not sure that's really necessary. Brotli does tend to do a better job at compressing HTML, though.
2025-03-18 16:58:31 +01:00 · 2025-03-18 16:58:31 +01:00 · bc33fe53f0
commit bc33fe53f0
parent c2e0f158ac
5 changed files with 237 additions and 10 deletions
--- a/c/compress.c
+++ b/c/compress.c
@ -0,0 +1,128 @@
+static const char *fugz_imps[] = {"", "libdeflate", "zlib-ng", "zlib"};
+static int fugz_imp = -1;
+
+
+/* zlib & zlib-ng */
+
+typedef struct {
+    const char *next_in;
+    unsigned int avail_in;
+    unsigned long total_in;
+    char *next_out;
+    unsigned int avail_out;
+    unsigned long total_out;
+    const char *msg;
+    struct internal_state *state;
+    void *zalloc;
+    void *zfree;
+    void *opaque;
+    int data_type;
+    unsigned long adler;
+    unsigned long reserved;
+} z_stream;
+
+static int (*deflate)(z_stream *, int);
+static int (*deflateEnd)(z_stream *);
+static int (*deflateInit2)(z_stream *, int, int, int, int, int);
+static int (*deflateInit2_)(z_stream *, int, int, int, int, int, const char *, int);
+static unsigned long (*compressBound)(unsigned long);
+
+
+/* libdeflate */
+
+static struct libdeflate_compressor *fugz_ld_ctx;
+static int fugz_ld_comp = -1;
+
+static struct libdeflate_compressor *(*libdeflate_alloc_compressor)(int);
+static void (*libdeflate_free_compressor)(struct libdeflate_compressor *);
+static size_t (*libdeflate_gzip_compress_bound)(struct libdeflate_compressor *, size_t);
+static size_t (*libdeflate_gzip_compress)(struct libdeflate_compressor *, const void *, size_t, void *, size_t);
+
+
+
+static const char *fugz_lib() {
+    if (fugz_imp >= 0) goto done;
+
+    void *handle;
+    if ((handle = dlopen("libdeflate.so", RTLD_LAZY))) {
+        if ((libdeflate_alloc_compressor = dlsym(handle, "libdeflate_alloc_compressor"))
+           && (libdeflate_free_compressor = dlsym(handle, "libdeflate_free_compressor"))
+           && (libdeflate_gzip_compress_bound = dlsym(handle, "libdeflate_gzip_compress_bound"))
+           && (libdeflate_gzip_compress = dlsym(handle, "libdeflate_gzip_compress"))) {
+            fugz_imp = 1;
+            goto done;
+        }
+    }
+
+    int i;
+    for (i=2; i<=3; i++) {
+        if ((handle = dlopen(i == 2 ? "libz-ng.so" : "libz.so", RTLD_LAZY))) {
+            if (((deflate = dlsym(handle, "zng_deflate")) || (deflate = dlsym(handle, "deflate")))
+               && ((deflateEnd = dlsym(handle, "zng_deflateEnd")) || (deflateEnd = dlsym(handle, "deflateEnd")))
+               && ((deflateInit2 = dlsym(handle, "zng_deflateInit2")) || (deflateInit2_ = dlsym(handle, "deflateInit2_")))
+               && ((compressBound = dlsym(handle, "zng_compressBound")) || (compressBound = dlsym(handle, "compressBound")))) {
+                fugz_imp = i;
+                goto done;
+            }
+        }
+    }
+    fugz_imp = 0;
+
+done:
+    return fugz_imps[fugz_imp];
+}
+
+
+static SV *fugz_compress_ld(pTHX_ int level, const char *bytes, size_t inlen) {
+    if (fugz_ld_comp != level) {
+        if (fugz_ld_ctx) libdeflate_free_compressor(fugz_ld_ctx);
+        fugz_ld_ctx = NULL;
+        fugz_ld_comp = level;
+    }
+    if (!fugz_ld_ctx) fugz_ld_ctx = libdeflate_alloc_compressor(level);
+
+    size_t outlen = libdeflate_gzip_compress_bound(fugz_ld_ctx, inlen);
+    SV *out = sv_2mortal(newSV(outlen));
+    SvPOK_only(out);
+    size_t len = libdeflate_gzip_compress(fugz_ld_ctx, bytes, inlen, SvPVX(out), outlen);
+    if (!len) fu_confess("Libdeflate compression failed"); /* Shouldn't happen */
+    SvCUR_set(out, len);
+    return out;
+}
+
+
+static SV *fugz_compress_zlib(pTHX_ int level, const char *bytes, size_t inlen) {
+    z_stream stream;
+    memset(&stream, 0, sizeof(stream));
+
+    int r = deflateInit2
+        ? deflateInit2(&stream, level > 9 ? 9 : level, 8, 16+15, 9, 0)
+        : deflateInit2_(&stream, level > 9 ? 9 : level, 8, 16+15, 9, 0, "1.3.1", (int)sizeof(stream));
+    if (r) fu_confess("Zlib compression failed (%d)", r);
+
+    stream.avail_out = compressBound(inlen) + 64; /* compressBound() does not include the gzip header */
+    SV *out = sv_2mortal(newSV(stream.avail_out));
+    SvPOK_only(out);
+    stream.next_out = SvPVX(out);
+    stream.next_in = bytes;
+    stream.avail_in = inlen;
+
+    if ((r = deflate(&stream, 4)) != 1) fu_confess("Zlib compression failed (%d)", r);
+
+    SvCUR_set(out, stream.total_out);
+    deflateEnd(&stream);
+    return out;
+}
+
+
+static SV *fugz_compress(pTHX_ IV level, SV *in) {
+    if (level < 0 || level > 12) fu_confess("Invalid compression level: %"IVdf, level);
+    if (!*fugz_lib()) fu_confess("Unable to load a suitable compression library");
+
+    STRLEN inlen;
+    const char *bytes = SvPVbyte(in, inlen);
+
+    if (fugz_imp == 1) return fugz_compress_ld(aTHX_ level, bytes, inlen);
+    else return fugz_compress_zlib(aTHX_ level, bytes, inlen);
+    return &PL_sv_undef;
+}