[util] Add functions to pack 32-bit ints into 16 bits - magic! (#428)

The idea is to scale back accuracy as the number gets large, with the
thought that this could be used for something like timer interval where
a few seconds probably don't matter when you're waiting an hour.
Comes with free unit tests that prove it actually works!

Signed-off-by: Geoff Gustafson <geoff@linux.intel.com>

Author: grgustaf

src/zjs_unit_tests.c

@@ -56,10 +56,42 @@ static void test_default_convert_pin()
     zjs_assert(dev == 0 && pin == -1, "convert pin failure case");
 }
 
+// Test zjs_util int compression functions
+
+static int check_compress_reversible(uint32_t num)
+{
+    // checks whether uncompressing compressed value returns exact match
+    uint32_t reversed = zjs_uncompress_16_to_32(zjs_compress_32_to_16(num));
+    return num == reversed;
+}
+
+static int check_compress_close(uint32_t num)
+{
+    // checks whether uncompressing compressed value is within 0.05% of original
+    // 11-bit mantissa means 1/2048 ~= 0.05%
+    uint32_t reversed = zjs_uncompress_16_to_32(zjs_compress_32_to_16(num));
+    double ratio = reversed * 1.0 / num;
+    return ratio >= 0.9995 && ratio <= 1.0005;
+}
+
+static void test_compress_32()
+{
+    // expect these to be returned exactly
+    zjs_assert(check_compress_reversible(0), "compression of 0");
+    zjs_assert(check_compress_reversible(0x0cab), "compression of 0x0cab");
+    zjs_assert(check_compress_reversible(0x7fff), "compression of 0x7fff");
+
+    // these should be close
+    zjs_assert(check_compress_close(0x8000), "compression of 0x8000");
+    zjs_assert(check_compress_close(0xdeadbeef), "compression of 0xdeadbeef");
+    zjs_assert(check_compress_close(0xffffffff), "compression of 0xffffffff");
+}
+
 void zjs_run_unit_tests()
 {
     test_hex_to_byte();
     test_default_convert_pin();
+    test_compress_32();
 
     printf("TOTAL - %d of %d passed\n", passed, total);
     exit(!(passed == total));

src/zjs_util.c

@@ -204,6 +204,42 @@ void zjs_default_convert_pin(uint32_t orig, int *dev, int *pin) {
     }
 }
 
+// when accuracy isn't as important as space
+uint16_t zjs_compress_32_to_16(uint32_t num)
+{
+    int zeroes = __builtin_clzl(num);
+    if (sizeof(unsigned long) > 4) {
+        zeroes -= (sizeof(unsigned long) - 4) * 8;
+    }
+
+    if (zeroes >= 17)
+        return (uint16_t)num;
+
+    // take the top 16 bits
+    uint16_t compressed = (num << zeroes) >> 16;
+
+    // clear the bottom five bits to save leading zeroes
+    compressed &= 0xffe0;
+
+    // save the number of zeroes in bottom five bits
+    return compressed | (uint16_t)zeroes;
+}
+
+uint32_t zjs_uncompress_16_to_32(uint16_t num)
+{
+    if ((num & 0x8000) == 0)
+        return (uint32_t)num;
+
+    // take top 11 bits
+    uint32_t uncompressed = (num & 0xffe0) >> 5;
+
+    // recover the number of leading zeroes
+    int zeroes = num & 0x1f;
+
+    // shift back up to the right point
+    return uncompressed << (21 - zeroes);
+}
+
 jerry_value_t zjs_error(const char *error)
 {
     ZJS_PRINT("%s\n", error);

src/zjs_util.h

@@ -61,6 +61,9 @@ bool zjs_hex_to_byte(char *buf, uint8_t *byte);
 
 void zjs_default_convert_pin(uint32_t orig, int *dev, int *pin);
 
+uint16_t zjs_compress_32_to_16(uint32_t num);
+uint32_t zjs_uncompress_16_to_32(uint16_t num);
+
 jerry_value_t zjs_error(const char *error);
 
 #endif  // __zjs_util_h__