Compression algorithms face off on memory-constrained embedded systems

Microcontrollers that log sensor readings, transmit data over wireless links, and sleep between tasks live or die by how efficiently they handle bytes. A research team from the Department of Technical Cybernetics at the University of Žilina in Slovakia has now put five popular lossless compression algorithms through their paces directly on an Arm Cortex-M33 microcontroller, revealing stark trade-offs between compressed size, execution speed, and memory consumption that challenge common assumptions about which compressor is best for embedded work.

The study, published in Frontiers in Computer Science, evaluated LZW, Heatshrink, LZ4, FastLZ, and Miniz on an STM32U575ZI microcontroller running at 160 MHz, a chip equipped with 2 MB of Flash and 786 KB of SRAM. Rather than benchmarking on a desktop computer and extrapolating, the researchers compiled C implementations of each library and executed every compression test on the microcontroller itself, using the Arm DWT cycle counter for timing measurements with a nominal resolution of 6.25 nanoseconds.

The test workload was a 104,067-byte sensor dataset containing repetitive time-series measurements of soil and ambient temperature, humidity, battery voltage, timestamps, and identifiers collected by a wireless sensor network node. Crucially, the team stored this dataset in three different representations: a conventional comma-separated values (CSV) text file at 104,067 bytes, a binary format at 33,576 bytes, and a bit-packed binary format at 26,581 bytes. Each entry shrank from between 63 and 87 bytes in CSV to exactly 24 bytes in binary and 19 bytes (152 bits) in the bit-packed scheme.

The results expose a three-way tug-of-war. Miniz, which implements the DEFLATE algorithm combining LZ77-style back-references with Huffman entropy coding, produced the smallest compressed output of all: just 11,352 bytes when applied to the binary representation, reducing it to 33.81 percent of its original size. But that victory came at a cost. The Miniz configuration also recorded the longest compression time among minimum-output runs at 219 milliseconds and 512 microseconds, and the largest total application RAM requirement at 113,216 bytes once input and output buffers were included consistently.

At the opposite extreme, LZ4 with its acceleration parameter set to 16 delivered the fastest compression of the entire parameter sweep: 9 milliseconds and 437 microseconds on the bit-packed representation, producing a 25,692-byte output. LZ4 achieves this speed through hash-based match finding and a simple byte-aligned token format that minimizes branches and parsing overhead. When the researchers normalized total application RAM across all minimum-output configurations, including the common input and output buffers, algorithm static memory, and maximum stack usage, LZ4 operating on the bit-packed representation required the least memory at 58,496 bytes.

FastLZ emerged as a compelling middle ground. Among configurations selected for minimum compressed output, FastLZ on the binary representation achieved the shortest execution time at 31 milliseconds and 653 microseconds, producing a 17,591-byte output with 74,512 bytes of total application RAM. Heatshrink, an LZSS-style compressor designed specifically for small embedded systems, produced the second-smallest compressed output on the bit-packed representation at 13,941 bytes while requiring 58,740 bytes of RAM and compressing in 113 milliseconds and 335 microseconds.

One of the most striking findings concerns data representation rather than algorithm choice. Converting the CSV file to binary format before compression proved dramatically effective, since text encoding wastes bytes on ASCII characters that binary storage packs more densely. However, the bit-packed representation, despite being the smallest input, actually worsened compression effectiveness compared to ordinary binary. The researchers attribute this to reduced byte alignment and the loss of recurring byte-level patterns that the dictionary-based compressors rely on. When bits are packed across byte boundaries, the repetitive structures that LZ-family algorithms exploit become harder to detect.

The team also observed that Miniz compression levels 1 through 9 produced almost identical output sizes for this dataset, indicating that increased search effort yielded no additional compression on these inputs. LZW revealed an exponential memory curve: static RAM usage rose from 2,560 bytes with 9-bit codes to 327,680 bytes with 16-bit codes, because dictionary capacity grows as 2 raised to the code width. On the bit-packed representation, LZW with 16-bit code storage actually expanded the input, producing a compression ratio of 137.24 percent.

To connect compression to energy savings, the researchers developed a parametric model linking payload size to transmission time and transmit-state energy. Under hypothetical interface parameters of 9,600 bytes per second throughput, 3.3 volts, and 50 milliamperes transmit current, transmitting the original CSV payload would take 10.840 seconds and require 1.789 joules, whereas transmitting the Miniz-compressed binary output would take 1.183 seconds and require 0.195 joules. The model predicts a 66.19 percent reduction in transmission time and energy relative to the uncompressed binary representation, and 89.09 percent relative to the original CSV, though the authors emphasize these are illustrative calculations, not measurements.

The researchers have released their complete benchmarking framework publicly on GitHub, written in C, allowing other developers to evaluate the same five algorithms on their own application-specific datasets. Their conclusion is unambiguous: no single compression configuration wins on all three evaluated properties, so the algorithm and parameter setting must be chosen based on whether an application prioritizes smallest storage, fastest execution, or lowest memory footprint. The results are strongly dataset-dependent, and the team recommends that anyone building an embedded data-logging or transmission system run these tests on their own expected data structure before committing to a compressor.

Subject of Research: An experimental study evaluating LZW, Heatshrink, LZ4, FastLZ, and Miniz compression algorithms on an STM32U575ZI microcontroller across CSV, binary, and bit-packed data representations, measuring compression ratio, execution time, and total RAM consumption.

Article Title: Experimental evaluation of compression algorithms for memory-constrained embedded systems

Article References: Bača, T., Formanek, L., Ševčík, P., & Karpiš, O. (2026). Experimental evaluation of compression algorithms for memory-constrained embedded systems. Frontiers in Computer Science, 8, Article 1925314. https://doi.org/10.3389/fcomp.2026.1925314

Image Credits: AI Generated

DOI: 10.3389/fcomp.2026.1925314

Keywords: embedded systems, data compression, microcontrollers, LZ4, Miniz, DEFLATE, LZW, Heatshrink, FastLZ, STM32, Arm Cortex-M33, RAM usage