libutil: add parse_size()

Problem: it is useful to not have to write a one off parser for
options and config values that express a size with SI units.

Add parse_size().

Author: garlick

src/common/libutil/Makefile.am

@@ -102,7 +102,9 @@ libutil_la_SOURCES = \
 	basemoji.h \
 	basemoji.c \
 	sigutil.h \
-	sigutil.c
+	sigutil.c \
+	parse_size.h \
+	parse_size.c
 
 EXTRA_DIST = veb_mach.c
 

src/common/libutil/parse_size.c

@@ -0,0 +1,135 @@
+/************************************************************\
+ * Copyright 2023 Lawrence Livermore National Security, LLC
+ * (c.f. AUTHORS, NOTICE.LLNS, COPYING)
+ *
+ * This file is part of the Flux resource manager framework.
+ * For details, see https://github.com/flux-framework.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+\************************************************************/
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdint.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <math.h>
+
+#include <ccan/array_size/array_size.h>
+#include <ccan/str/str.h>
+
+#include "parse_size.h"
+
+struct scale {
+    const char *s;
+    uint64_t scale;
+};
+
+static struct scale mtab[] = {
+    { "", 1 },
+    { "k", 1024 },
+    { "K", 1024 }, // upper case K is not the SI prefix but is unambiguous
+    { "M", 1024*1024 },
+    { "G", 1024UL*1024*1024 },
+    { "T", 1024ULL*1024*1024*1024 },
+    { "P", 1024ULL*1024*1024*1024*1024 },
+    { "E", 1024ULL*1024*1024*1024*1024*1024 },
+};
+
+static int lookup_scale (const char *s, uint64_t *vp)
+{
+    for (int i = 0; i < ARRAY_SIZE (mtab); i++) {
+        if (streq (mtab[i].s, s)) {
+            *vp = mtab[i].scale;
+            return 0;
+        }
+    }
+    return -1;
+}
+
+static bool invalid_fp_size (double val)
+{
+    switch (fpclassify (val)) {
+        case FP_NORMAL:     // [[fallthrough]]
+        case FP_SUBNORMAL:  // [[fallthrough]]
+        case FP_ZERO:       // [[fallthrough]]
+            break;          // OK
+        case FP_NAN:        // [[fallthrough]]
+        case FP_INFINITE:   // [[fallthrough]]
+        default:            // something else, bad
+            return true;
+    }
+    if (val < 0.)
+        return true;
+    return false;
+}
+
+static int parse_as_integer (const char *s, uint64_t *up)
+{
+    char *endptr;
+    uint64_t u;
+    uint64_t scale;
+
+    // strtoull() allows a leading minus sign but we do not
+    if (strchr (s, '-')) {
+        errno = EINVAL;
+        return -1;
+    }
+    errno = 0;
+    u = strtoull (s, &endptr, 0);
+    if (errno != 0
+        || endptr == s
+        || lookup_scale (endptr, &scale) < 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    uint64_t result = u * scale;
+    if (result < u) {
+        errno = EOVERFLOW;
+        return -1;
+    }
+    *up = result;
+    return 0;
+}
+
+static int parse_as_double (const char *s, uint64_t *up)
+{
+    char *endptr;
+    double d;
+    uint64_t scale;
+
+    errno = 0;
+    d = strtold (s, &endptr);
+    if (errno != 0
+        || endptr == s
+        || lookup_scale (endptr, &scale) < 0
+        || invalid_fp_size (d)) {
+        errno = EINVAL;
+        return -1;
+    }
+    double result = floor (d * scale);
+    if (result > UINT64_MAX) {
+        errno = EOVERFLOW;
+        return -1;
+    }
+    *up = (uint64_t)result;
+    return 0;
+}
+
+int parse_size (const char *s, uint64_t *vp)
+{
+    if (!s || !vp) {
+        errno = EINVAL;
+        return -1;
+    }
+    if (parse_as_integer (s, vp) < 0
+        && parse_as_double (s, vp) < 0)
+        return -1;
+    return 0;
+}
+
+// vi:ts=4 sw=4 expandtab

src/common/libutil/parse_size.h

@@ -0,0 +1,36 @@
+/************************************************************\
+ * Copyright 2023 Lawrence Livermore National Security, LLC
+ * (c.f. AUTHORS, NOTICE.LLNS, COPYING)
+ *
+ * This file is part of the Flux resource manager framework.
+ * For details, see https://github.com/flux-framework.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+\************************************************************/
+
+#ifndef _UTIL_PARSE_SIZE_H
+#define _UTIL_PARSE_SIZE_H
+
+#include <stdint.h>
+
+/* Parse 's' as a floating point quantity scaled by optional suffix:
+ *
+ *  k,K   2^10 (1024)
+ *  M     2^20
+ *  G     2^30
+ *  T     2^40
+ *  P     2^50
+ *  E     2^60
+ *
+ * The numeric part is parsed with first strtoull(3) then strtod(3), so
+ * so all input supported by those functions should work including
+ * decimal (255), hex (0xf), octal (0377 prefix), exponent (2.55E2), etc.
+ *
+ * Assign the result to 'vp' and return 0 on success,
+ * or return -1 on failure with errno set (EINVAL, EOVERFLOW).
+ */
+int parse_size (const char *s, uint64_t *vp);
+
+#endif /* !_UTIL_PARSE_SIZE_H */
+
+// vi:ts=4 sw=4 expandtab