Add benchmark for the cpp-rust-wrapper driver

Author: havaker

benchmarks/basic/cpp-multi-wrapper/Dockerfile

@@ -0,0 +1,19 @@
+FROM fedora
+
+RUN dnf -y update
+RUN dnf -y install cmake g++ git cargo clang
+
+WORKDIR /wrapper
+RUN git clone https://github.com/hackathon-rust-cpp/cpp-rust-driver.git
+WORKDIR cpp-rust-driver
+RUN cd scylla-rust-wrapper && cargo build --release
+
+# Copy benchmark code into the container
+COPY source /source
+WORKDIR /source
+
+RUN cp /wrapper/cpp-rust-driver/scylla-rust-wrapper/target/release/libscylla*.a  /source
+RUN cp /wrapper/cpp-rust-driver/include/*  /source
+
+# Compile the code
+ RUN g++ main.cpp -o basic -std=c++17 -I/boost_1_76_0 -L. -lscylla_cpp_driver -lpthread -O3 -flto -Wall -Wshadow -ldl

benchmarks/basic/cpp-multi-wrapper/build.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker build . -t rust-driver-benchmarks-basic-cpp-multi-wrapper

benchmarks/basic/cpp-multi-wrapper/run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker run --rm -it --network host rust-driver-benchmarks-basic-cpp-multi-wrapper /source/basic "$@"

benchmarks/basic/cpp-multi-wrapper/source/config.hpp

@@ -0,0 +1,144 @@
+#ifndef CONFIG_HPP
+#define CONFIG_HPP
+
+#include <vector>
+#include <string>
+#include <cstring>
+#include <iostream>
+#include <stdio.h>
+
+enum class Workload {
+    Inserts,
+    Selects,
+    Mixed,
+};
+
+inline void print_usage();
+
+struct Config {
+    std::vector<std::string> node_addresses;
+    Workload workload;
+    int64_t tasks;
+    int64_t concurrency;
+    int64_t batch_size;
+    bool dont_prepare;
+
+    Config(int argc, const char *argv[]) {
+        node_addresses = {"127.0.0.1"};
+        workload = Workload::Inserts;
+        tasks = 1000 * 1000;
+        concurrency = 1024;
+        dont_prepare = false;
+
+        for (int a = 1; a < argc;) {
+            // --dont-prepare
+            if (strcmp(argv[a], "-d") == 0 || strcmp(argv[a], "--dont-prepare") == 0) {
+                dont_prepare = true;
+                a += 1;
+                continue;
+            }
+
+            if (a + 1 >= argc) {
+                fprintf(stderr, "ERROR: No value specified for argument %s!\n", argv[a]);
+                std::exit(1);
+            }
+
+            // --nodes
+            if (strcmp(argv[a], "-n") == 0 || strcmp(argv[a], "--nodes") == 0) {
+                std::vector<std::string> addresses = {""};
+
+                for (const char* c = argv[a + 1]; *c != 0; c++) {
+                    if (*c == ',') {
+                        addresses.push_back("");
+                    } else {
+                        addresses.back() += *c;
+                    }
+                }
+
+                node_addresses = addresses;
+
+                a += 2;
+                continue;
+            }
+
+            // --workload
+            if (strcmp(argv[a], "-w") == 0 || strcmp(argv[a], "--workload") == 0) {
+                if (strcmp(argv[a + 1], "inserts") == 0) {
+                    workload = Workload::Inserts;
+                } else if (strcmp(argv[a + 1], "selects") == 0) {
+                    workload = Workload::Selects;
+                } else if (strcmp(argv[a + 1], "mixed") == 0) {
+                    workload = Workload::Mixed;
+                } else {
+                    fprintf(stderr,
+                            "ERROR: Invalid workload specified: %s. (Allowed values: inserts, "
+                            "selects, mixed)\n",
+                            argv[a + 1]);
+                    
+                    std::exit(1);
+                }
+
+                a += 2;
+                continue;
+            }
+
+            // --tasks
+            if (strcmp(argv[a], "-t") == 0 || strcmp(argv[a], "--tasks") == 0) {
+                tasks = std::strtoll(argv[a + 1], nullptr, 10);
+
+                a += 2;
+                continue;
+            }
+
+            // --concurrency
+            if (strcmp(argv[a], "-c") == 0 || strcmp(argv[a], "--concurrency") == 0) {
+                concurrency = std::strtoll(argv[a + 1], nullptr, 10);
+
+                a += 2;
+                continue;
+            }
+
+            fprintf(stderr, "Unkown argument: %s\n", argv[a]);
+            std::exit(1);
+        }
+
+        batch_size = 256;
+
+        if (tasks/batch_size < concurrency) {
+            batch_size = std::max((int64_t)1, tasks / concurrency);
+        }
+    }
+
+    void print() {
+        std::cout << "Config:\n";
+        std::cout << "    nodes: [";
+        for (auto&& node_address : node_addresses) {
+            std::cout << node_address << ", ";
+        } 
+        std::cout << "]\n";
+
+        std::cout << "    workload: ";
+
+        switch (workload) {
+        case Workload::Inserts:
+            std::cout << "Inserts\n";
+            break;
+
+        case Workload::Selects:
+            std::cout << "Selects\n";
+            break;
+
+        case Workload::Mixed:
+            std::cout << "Mixed\n";
+            break;
+        }
+
+        std::cout << "    tasks: " << tasks << "\n";
+        std::cout << "    concurrency: " << concurrency << "\n";
+        std::cout << "    dont_prepare: " << (dont_prepare ? "true" : "false") << "\n";
+
+        std::cout << std::endl;
+    }
+};
+
+#endif