add multithreaded executable

- src/many-async.cc: leverage std::async to run concurrent experiments.
- CMakeLists.txt: add memory list option and make it default to ON.
- src/CMakeLists.txt: make the NameGame.cc into a library now that it's
  being used by three different executables.
- add compile definition with tipping points cmake option.
- add many-async executable.

Signed-off-by: Aiden Woodruff <woodra@rpi.edu>

2 files changed, 72 insertions, 8 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7e0e575..f681e54 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,10 +1,13 @@
-add_executable(one
-        one.cc
+add_library(tipping-points
         NameGame.cc
 )
-target_link_libraries(one PRIVATE SNAP::SNAP)
-add_executable(many
-        many.cc
-        NameGame.cc
-)
-target_link_libraries(many PRIVATE SNAP::SNAP)
+target_link_libraries(tipping-points PUBLIC SNAP::SNAP)
+if(TIPPINGPOINTS_MEMLIST)
+        target_compile_definitions(tipping-points PUBLIC TP_MEMLIST)
+endif()
+add_executable(one one.cc)
+target_link_libraries(one PRIVATE tipping-points)
+add_executable(many many.cc)
+target_link_libraries(many PRIVATE tipping-points)
+add_executable(many-async many-async.cc)
+target_link_libraries(many-async PRIVATE tipping-points)
diff --git a/src/many-async.cc b/src/many-async.cc
new file mode 100644
index 0000000..9df475b
--- /dev/null
+++ b/src/many-async.cc
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <fstream>
+#include <future>
+#include <vector>
+
+#include "NameGame.h"
+
+constexpr int group_size = 1000, T = 100;
+constexpr int cmsize_min = 200, cmsize_max = 600;
+constexpr int trials = 100;
+constexpr int workers = 6;
+
+using RunVec = std::vector<std::pair<int, int>>;
+
+RunVec run_trials(int cmsize_start, int cmsize_end) {
+        tp::NameGame namegame(group_size, 0, 12);
+        RunVec runs;
+        for (int i = cmsize_start; i < cmsize_end; ++i) {
+                for (int j = 0; j < trials; ++j) {
+                        namegame.setCMsize(i);
+                        namegame.initMemory();
+                        namegame.clearRecord();
+                        int a = namegame.run(group_size * T);
+                        runs.push_back({i, a});
+                }
+                std::cout << "finished cmsize " << i << std::endl;
+        }
+        return runs;
+}
+
+int main(int argc, char* argv[]) {
+        RunVec all_runs;
+        std::vector<std::future<RunVec>> futs;
+        for (int i = 0; i < workers; ++i) {
+                int range_size = cmsize_max - cmsize_min + 1;
+                int worker_range_size = range_size / workers;
+                int worker_range_start = cmsize_min + worker_range_size * i;
+                int worker_range_end = worker_range_start + worker_range_size
+                        + (i == workers - 1 ? range_size % workers : 0);
+                std::cout << "worker " << i << " will work on range " << worker_range_start
+                        << " to " << worker_range_end << std::endl;
+                futs.push_back(
+                        std::async(run_trials, worker_range_start, worker_range_end
+                ));
+        }
+        for (int i = 0; i < workers; ++i) {
+                RunVec v = futs[i].get();
+                all_runs.insert(all_runs.end(), v.begin(), v.end());
+        }
+        std::ofstream f("many-async.csv");
+        if (!f) {
+                std::cerr << "ERROR: opening many-async.csv" << std::endl;
+                return 1;
+        }
+        f << "cmsize,adopters\n";
+        for (const auto& p : all_runs) {
+                f << p.first << ',' << p.second << '\n';
+        }
+        return 0;
+}
+