benchmark/nixlbench: switched to cxxopts

This patch replaces gflags-based parameter parsing with cxxopts-based
parsing, and removes the gflags dependency.

This change will enable us to support config file-based parameters in
upcoming patches.

Unfortunately, gflags is not flexible enough for our needs. For example,
it does not indicate whether a parameter was explicitly provided by the
user or if it is using a default. This functionality is required for
correct parameter specification priority: first, a value provided by the
user on the command line; then a value from the config file; and finally,
the default value.

Additionally, gflags does not support dynamically formed arguments,
which is needed to handle a list of tasks as discussed. For this use
case, the config file would look like:

[general]
...
num_tasks=2

[task0]
local=...
remote=...
type=write
...

[task1]
local=...
remote=...
type=read
...

This translates to command line parameters like:

--num_tasks=2 --task0.local=... ... --task1.local=...

Since gflags is a compile-time mechanism, it cannot support this level
of dynamic argument handling.

Signed-off-by: Anton Nayshtut <[email protected]>

Author: anton-nayshtut

benchmark/nixlbench/meson.build

@@ -103,9 +103,6 @@ if cuda_available
     endif
 endif
 
-# GFlags
-gflags_dep = dependency('gflags', required: true)
-
 # OpenMP
 openmp_dep = dependency('openmp', required: true)
 
@@ -166,7 +163,7 @@ configure_file(
     install_dir: get_option('includedir') / 'nixlbench'
 )
 
-deps = [gflags_dep, nixl_lib, nixl_build, nixl_serdes, openmp_dep]
+deps = [nixl_lib, nixl_build, nixl_serdes, openmp_dep]
 args = []
 if etcd_available
     deps += [etcd_dep]
@@ -208,7 +205,7 @@ if nvshmem_available
     nvcc_args += ['-L' + meson.current_build_dir() + '/src/utils']
     nvcc_args += ['-L' + meson.current_build_dir() + '/src/runtime']
     nvcc_args += ['-L' + meson.current_build_dir() + '/src/worker']
-    nvcc_args += ['-lnixl', '-lnixl_build', '-lserdes', '-lgflags', '-lcuda', '-lcudart', '-lnvshmem']
+    nvcc_args += ['-lnixl', '-lnixl_build', '-lserdes', '-lcuda', '-lcudart', '-lnvshmem']
     nvcc_args += args
     nvcc_cmd_files = [
                  meson.current_build_dir() + '/src/utils/libutils.a.p/utils.cpp.o',

benchmark/nixlbench/src/main.cpp

@@ -19,7 +19,6 @@
 #include <iostream>
 #include <nixl.h>
 #include <sys/time.h>
-#include <gflags/gflags.h>
 #include "utils/utils.h"
 #include "utils/scope_guard.h"
 #include "worker/nixl/nixl_worker.h"
@@ -182,9 +181,7 @@ static std::unique_ptr<xferBenchWorker> createWorker(int *argc, char ***argv) {
 }
 
 int main(int argc, char *argv[]) {
-    gflags::ParseCommandLineFlags(&argc, &argv, true);
-
-    int ret = xferBenchConfig::loadFromFlags();
+    int ret = xferBenchConfig::parseConfig(argc, argv);
     if (0 != ret) {
         return EXIT_FAILURE;
     }
@@ -236,7 +233,5 @@ int main(int argc, char *argv[]) {
         return EXIT_FAILURE;
     }
 
-    gflags::ShutDownCommandLineFlags();
-
     return worker_ptr->signaled() ? EXIT_FAILURE : EXIT_SUCCESS;
 }

benchmark/nixlbench/src/utils/meson.build

@@ -21,7 +21,6 @@ utils_sources = [
 
 utils_deps = [
   cuda_dep,
-  gflags_dep,
   openmp_dep
 ]
 

benchmark/nixlbench/src/utils/utils.cpp

@@ -35,19 +35,42 @@
 #include "runtime/etcd/etcd_rt.h"
 #include "utils/utils.h"
 
+enum xferBenchParamType
+{
+    XBPT_STRING,
+    XBPT_BOOL,
+    XBPT_UINT64,
+    XBPT_INT32,
+    __XBPT_LAST
+};
+
+struct xferBenchParamInfo
+{
+    const char *name;
+    const char *help;
+    xferBenchParamType type;
+    union {
+        const char *str;
+        bool b;
+        uint64_t u64;
+        int32_t i32;
+    } def_value;
+};
+
 // Define gflags params
 #define NB_ARG_STRING(param_name, def_val, help_text) \
-    DEFINE_string(param_name, def_val, help_text);
+    { .name = # param_name, .help = help_text, .type = XBPT_STRING, .def_value = { .str = def_val } },
 #define NB_ARG_BOOL(param_name, def_val, help_text) \
-    DEFINE_bool(param_name, def_val, help_text);
+    { .name = # param_name, .help = help_text, .type = XBPT_BOOL, .def_value = { .b = def_val } },
 #define NB_ARG_UINT64(param_name, def_val, help_text) \
-    DEFINE_uint64(param_name, def_val, help_text);
+    { .name = # param_name, .help = help_text, .type = XBPT_UINT64, .def_value = { .u64 = def_val} },
 #define NB_ARG_INT32(param_name, def_val, help_text) \
-    DEFINE_int32(param_name, def_val, help_text);
+    { .name = # param_name, .help = help_text, .type = XBPT_INT32, .def_value = { .i32 = def_val } },
 
 /**********
  * xferBench Config
  **********/
+const xferBenchParamInfo xbench_params[] = {
 NB_ARG_STRING(benchmark_group, "default", \
               "Name of benchmark group. Use different names to run multiple benchmarks in parallel " \
               "(Default: default)")
@@ -135,6 +158,7 @@ NB_ARG_STRING(gusli_device_security, "", \
               "If empty or fewer than devices, uses 'sec=0x3' as default. " \
               "For GUSLI backend, use device_list in format 'id:type:path' where type is F (file) " \
               "or K (kernel device).")
+};
 
 #undef NB_ARG_INT32
 #undef NB_ARG_UINT64
@@ -196,9 +220,52 @@ uint64_t xferBenchConfig::gusli_bdev_byte_offset = 0;
 std::string xferBenchConfig::gusli_device_security = "";
 
 int
-xferBenchConfig::loadFromFlags() {
+xferBenchConfig::parseConfig(int argc, char *argv[])
+{
+    cxxopts::Options options("nixlbench", "NIXL Benchmark Tool");
+
+    options.add_options()
+        ("help", "Print usage");
+
+    for (size_t i = 0; i < sizeof(xbench_params) / sizeof(xbench_params[0]); i++) {
+        const xferBenchParamInfo *param = &xbench_params[i];
+
+        switch (param->type) {
+        case XBPT_STRING:
+            options.add_options()
+                (param->name, param->help, cxxopts::value<std::string>()->default_value(param->def_value.str));
+            break;
+        case XBPT_BOOL:
+            options.add_options()
+                (param->name, param->help, cxxopts::value<bool>()->default_value(param->def_value.b ? "true" : "false"));
+            break;
+        case XBPT_UINT64:
+            options.add_options()
+                (param->name, param->help, cxxopts::value<uint64_t>()->default_value(std::to_string(param->def_value.u64)));
+            break;
+        case XBPT_INT32:
+            options.add_options()
+                (param->name, param->help, cxxopts::value<int32_t>()->default_value(std::to_string(param->def_value.i32)));
+            break;
+        default:
+            std::cerr << param->name << ": unsupported param type: " << param->type << std::endl;
+            return -1;
+        }
+    }
+
+    auto result = options.parse(argc, argv);
+    if (result.count("help")) {
+      std::cout << options.help() << std::endl;
+      return -1;
+    }
+
+    return loadParams(result);
+}
+
+int
+xferBenchConfig::loadParams(cxxopts::ParseResult &result) {
 #define NB_ARG(name) \
-    FLAGS_ ##name
+    result[#name].as<decltype(name)>()
 
     benchmark_group = NB_ARG(benchmark_group);
     runtime_type = NB_ARG(runtime_type);

benchmark/nixlbench/src/utils/utils.h

@@ -28,6 +28,7 @@
 #include <optional>
 #include <utils/common/nixl_time.h>
 #include "runtime/runtime.h"
+#include "utils/external/cxxopts.hpp"
 
 #if HAVE_CUDA
 #include <cuda.h>
@@ -178,7 +179,7 @@ class xferBenchConfig {
         static std::string gusli_device_security;
 
         static int
-        loadFromFlags();
+        parseConfig(int argc, char *argv[]);
         static void
         printConfig();
         static void
@@ -189,6 +190,10 @@ class xferBenchConfig {
         parseDeviceList();
         static bool
         isStorageBackend();
+
+protected:
+        static int
+        loadParams(cxxopts::ParseResult &options);
 };
 
 // Shared GUSLI device config used by utils and nixl_worker

benchmark/nixlbench/src/worker/meson.build

@@ -20,7 +20,6 @@ worker_sources = [
 
 worker_deps = [
   cuda_dep,
-  gflags_dep,
   openmp_dep,
   etcd_dep
 ]