Use CLI11 parser for all native benchmarks (#4)

This PR attempts to resolve some inconsistencies in argument parsing in native benchmarks, and uses CLI11 parser globally for native benchmarks. It also refactors distances, linear/ridge regression, and kmeans benchmarks to use some common code for consistency.

* Add CLI11 header to repo

* Combine cosine and correlation distances into one file

* Use CLI11 in distances, linear/ridge regression, kmeans benches

* Pass around results of benchmarks for verification if needed (as NumericTablePtr or ResultPtr or std::tuple)

* General refactoring of benches converted to use CLI11 for easier readability

Author: bibikar

Makefile

@@ -37,16 +37,16 @@ native: data
 	@echo "# Compiling native benchmarks"
 	$(MAKE) -C native
 	@echo "# Running native benchmarks"
-	native/bin/cosine $(BATCH) $(HOST) native cosine_distances \
-		$(NUM_THREADS) double $(DISTANCES_SIZE)
-	native/bin/correlation $(BATCH) $(HOST) native correlation_distances \
-		$(NUM_THREADS) double $(DISTANCES_SIZE)
-	native/bin/ridge $(BATCH) $(HOST) native ridge \
-		$(NUM_THREADS) double $(REGRESSION_SIZE)
-	native/bin/linear $(BATCH) $(HOST) native linear \
-		$(NUM_THREADS) double $(REGRESSION_SIZE)
-	native/bin/kmeans $(BATCH) $(HOST) native kmeans \
-		$(NUM_THREADS) double $(KMEANS_SIZE) $(DATA_DIR) $(MULTIPLIER)
+	native/bin/distances --batch "$(BATCH)" --arch "$(HOST)" \
+		--num-threads "$(NUM_THREADS)" --size "$(DISTANCES_SIZE)"
+	native/bin/ridge --batch "$(BATCH)" --arch "$(HOST)" \
+		--num-threads "$(NUM_THREADS)" --size "$(REGRESSION_SIZE)"
+	native/bin/linear --batch "$(BATCH)" --arch "$(HOST)" \
+		--num-threads "$(NUM_THREADS)" --size "$(REGRESSION_SIZE)"
+	native/bin/kmeans --batch "$(BATCH)" --arch "$(HOST)" \
+		--num-threads "$(NUM_THREADS)" --data-multiplier "$(MULTIPLIER)" \
+		--filex $(KMEANS_DATA) --filei $(basename $(KMEANS_DATA)).init.npy \
+		--filet $(basename $(KMEANS_DATA)).tol.npy
 	native/bin/two_class_svm \
 		--fileX data/two/X-$(SVM_SAMPLES)x$(SVM_FEATURES).npy \
 		--fileY data/two/y-$(SVM_SAMPLES)x$(SVM_FEATURES).npy \

native/CLI11

@@ -2,17 +2,17 @@
 #
 # SPDX-License-Identifier: MIT
 
-BENCHMARKS += correlation cosine kmeans linear ridge \
+BENCHMARKS += distances kmeans linear ridge pca \
 			  two_class_svm multi_class_svm log_reg_lbfgs \
 			  decision_forest_regr decision_forest_clsf
 CXXSRCS = $(addsuffix _bench.cpp,$(BENCHMARKS))
 
 CXX = icc
-CXXFLAGS += -m64 -fPIC -fp-model strict -O3 -g -fomit-frame-pointer \
+CXXFLAGS += -m64 -fPIC -fp-model strict -O3 -fomit-frame-pointer \
 		  -xSSE4.2 -axCORE-AVX2,COMMON-AVX512
-CXXFLAGS += -std=c++14
+CXXFLAGS += -std=c++14 -g
 LDFLAGS += -ldaal_core -ldaal_thread -Wl,-rpath,$(CONDA_PREFIX)/lib
-CXXINCLUDE += CLI11/include
+CXXINCLUDE += include
 
 ifneq ($(CONDA_PREFIX),)
 	LDFLAGS += -L"$(CONDA_PREFIX)/lib"

native/Makefile

@@ -0,0 +1,174 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <chrono>
+
+#include "CLI11.hpp"
+#include "daal.h"
+
+namespace dm = daal::data_management;
+namespace ds = daal::services;
+namespace da = daal::algorithms;
+
+/*
+ * Parse a size argument as given to the command-line options.
+ * This consists of each element of the size, delimited by
+ * a 'x' or ','.
+ *
+ * Parameters
+ * ----------
+ * in : std::string
+ *     String to parse
+ * size : std::vector<int> &size
+ *     Vector to which we should output size values
+ */
+void parse_size(std::string in, std::vector<int> &size) {
+
+    std::stringstream tmp(in);
+    int i;
+
+    while (tmp >> i) {
+        size.push_back(i);
+        char c = tmp.peek();
+        if (c == 'x' || c == ',')
+            tmp.ignore();
+    }
+
+}
+
+
+/*
+ * Terminate the program with an error message if the number of dimensions
+ * in the given size vector does not match the expected number of dimensions.
+ *
+ * Parameters
+ * ----------
+ * size : std::vector<int> &size
+ *     Vector to check
+ * expected : int
+ *     Number of dimensions we expect
+ */
+void check_dims(std::vector<int> &size, int expected) {
+
+    if (size.size() != expected) {
+        std::cerr << "error: expected " << expected << " dimensions in size "
+                  << "but got " << size.size();
+        std::exit(1);
+    }
+
+}
+
+
+/*
+ * Try to set DAAL's number of threads to the given number of threads,
+ * and returns the actual number of threads DAAL will use.
+ *
+ * Parameters
+ * ----------
+ * num_threads : int
+ *     Number of threads we ask DAAL to use
+ *
+ * Returns
+ * -------
+ * int
+ *     Number of threads DAAL says it will use
+ */
+int set_threads(int num_threads) {
+
+    if (num_threads > 0)
+        ds::Environment::getInstance()->setNumberOfThreads(num_threads);
+
+    return ds::Environment::getInstance()->getNumberOfThreads();
+
+}
+
+
+/*
+ * Time the given function for the specified number of repetitions,
+ * returning a pair of a vector of durations and the LAST result.
+ */
+template <typename T>
+std::pair<std::vector<std::chrono::duration<double>>, T>
+time_vec(std::function<T()> func, int reps) {
+
+    std::vector<std::chrono::duration<double>> vec;
+    T result;
+    for (int i = 0; i < reps; i++) {
+        auto t0 = std::chrono::high_resolution_clock::now();
+        result = func();
+        auto t1 = std::chrono::high_resolution_clock::now();
+        vec.push_back(t1 - t0);
+    }
+    return std::make_pair(vec, result);
+
+}
+
+
+/*
+ * Time the given function for the specified number of repetitions,
+ * returning a pair of the minimum duration and the LAST result.
+ */
+template <typename T>
+std::pair<double, T> time_min(std::function<T()> func, int reps) {
+
+    auto pair = time_vec(func, reps);
+    auto times = pair.first;
+    double time = std::min_element(times.begin(), times.end())->count();
+
+    return std::make_pair(time, pair.second);
+
+}
+
+
+/*
+ * Create a DAAL HomogenNumericTable from an array in memory.
+ */
+template <typename T>
+dm::NumericTablePtr make_table(T *data, size_t rows, size_t cols) {
+
+    return dm::HomogenNumericTable<T>::create(data, cols, rows);
+
+}
+
+
+/*
+ * Generate an array of random numbers.
+ */
+double *gen_random(size_t n) {
+
+    double *x = new double[n];
+    for (size_t i = 0; i < n; i++)
+        x[i] = (double) rand() / RAND_MAX;
+    return x;
+
+}
+
+
+void add_common_args(CLI::App &app,
+                     std::string &batch, std::string &arch,
+                     std::string &prefix, int &num_threads,
+                     bool &header, bool &verbose) {
+
+    batch = "?";
+    app.add_option("-b,--batch", batch, "Batch ID, for bookkeeping");
+
+    arch = "?";
+    app.add_option("-a,--arch", arch, "Machine architecture, for bookkeeping");
+
+    prefix = "Native-C";
+    app.add_option("-p,--prefix", prefix, "Prefix string, for bookkeeping");
+
+    num_threads = 0;
+    app.add_option("-n,--num-threads", num_threads, "Number of threads for DAAL to use", true);
+
+    header = false;
+    app.add_flag("--header", header, "Output CSV header");
+
+    verbose = false;
+    app.add_flag("--verbose", header, "Output extra debug messages");
+
+}
+
+