libutil: add encode_size()

Problem: There is no equivalent to parse_size() which turns a number
into a human readable string using the same SI prefix characters
defined in parse_size().

Add an encode_size() function which returns a human readable string
representation of a number. While the result of encode_size() will
always be valid input to parse_size(), loss of precision when creating
the human readable string means that parse_size() of a string returned
from encode_size() may not return the exact original value. Instead
this function is mainly intended for creating human readable output.

Author: grondo

src/common/libutil/parse_size.c

@@ -15,6 +15,7 @@
 #include <stdint.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdbool.h>
 #include <math.h>
@@ -132,4 +133,29 @@ int parse_size (const char *s, uint64_t *vp)
     return 0;
 }
 
+const char *encode_size (uint64_t size)
+{
+    /* Allocate a thread-local buffer to make this function easy to use
+     * in output formats (its intended use case).
+     *
+     * Note: The maximum printable digits for a double is 15 (DBL_DIG).
+     *  We also account for an optional decimal point, suffix, and required
+     *  space for NUL to get a buffer size of 18. (We ignore the fact that
+     *  a precision is specified in the %g format below for safety).
+     */
+    static __thread char buf[18];
+    const char* suffix[] = {"", "K", "M", "G", "T", "P", "E"};
+    int i = 0;
+    double value = size;
+    while (value >= 1024) {
+        value /= 1024;
+        i++;
+    }
+    /* Note: UINT64_MAX is 16E so there is no possibility that 'i' will
+     * overflow the suffix array.
+     */
+    (void) snprintf (buf, sizeof (buf), "%.8g%s", value, suffix[i]);
+    return buf;
+}
+
 // vi:ts=4 sw=4 expandtab

src/common/libutil/parse_size.h

@@ -31,6 +31,17 @@
  */
 int parse_size (const char *s, uint64_t *vp);
 
+/* Format 'size' as a human readable string using suffixes documented
+ * above for parse_size(). Note that due to use of double precision
+ * arithmetic and because the result is rounded to 8 significant figures
+ * the returned string may be imprecise. Passing the result of encode_size()
+ * to parse_size() may not result in the same value for 'size'.
+ *
+ * The result is only good until the next call to encode_size() from the
+ * current thread.
+ */
+const char *encode_size (uint64_t size);
+
 #endif /* !_UTIL_PARSE_SIZE_H */
 
 // vi:ts=4 sw=4 expandtab