tmc uts

Author: ConorWilliams

bench/CMakeLists.txt

@@ -100,7 +100,10 @@ endif()
 target_compile_definitions(benchmark PRIVATE TMC_WORK_ITEM=CORO)
 target_compile_definitions(benchmark PRIVATE TMC_PRIORITY_COUNT=1)
 target_compile_definitions(benchmark PRIVATE TMC_USE_HWLOC)
-target_compile_definitions(benchmark PRIVATE TMC_TRIVIAL_TASK)
+
+# TMC_TRIVIAL_TASK causes asserts to fail in debug builds...
+
+# target_compile_definitions(benchmark PRIVATE TMC_TRIVIAL_TASK)
 
 target_include_directories(benchmark PRIVATE ${tmc_SOURCE_DIR}/include)
 

bench/source/uts/config.hpp

@@ -1,6 +1,8 @@
 #ifndef DD1EB460_E250_4A8C_B35B_C99A803E5301
 #define DD1EB460_E250_4A8C_B35B_C99A803E5301
 
+#include <exception>
+#include <iostream>
 #include <stdexcept>
 
 #include "../util.hpp"
@@ -198,31 +200,25 @@ inline void setup_tree(int i) {
 
 inline auto result_tree(int i) -> result {
 
-  return {0, 0, 0};
-
   switch (i) {
-    case 1:
+    case 11:
       return {10, 4130071, 3305118};
-    case 2:
-      return {81, 4117769, 2342762};
-    case 3:
-      return {1572, 4112897, 3599034};
-    case 4:
-      return {134, 4132453, 3108986};
-    case 5:
-      return {20, 4147582, 2181318};
-    case 6:
+    case 12:
       return {13, 102181082, 81746377};
-    case 7:
-      return {67, 96793510, 53791152};
-    case 8:
+    case 13:
+      // TODO: what is the result?
+      return {0, 0, 0};
+    case 31:
+      return {1572, 4112897, 3599034};
+    case 32:
       return {17844, 111345631, 89076904};
-    case 9:
+    case 33:
+      // TODO: what is the result?
       return {0, 0, 0};
     default:
       assert(false && "Invalid tree id");
-      break;
   }
+  std::terminate();
 }
 
 #define MAKE_UTS_FOR(some_type)                                                                              \

bench/source/uts/tmc.cpp

@@ -0,0 +1,85 @@
+#include <algorithm>
+#include <iostream>
+#include <optional>
+#include <span>
+
+#include <benchmark/benchmark.h>
+
+#include "tmc/all_headers.hpp"
+
+#include "../util.hpp"
+#include "config.hpp"
+#include "external/uts.h"
+
+namespace {
+
+using namespace tmc;
+
+auto uts(int depth, Node *parent) -> task<result> {
+  //
+  result r(depth, 1, 0);
+
+  int num_children = uts_numChildren(parent);
+  int child_type = uts_childType(parent);
+
+  parent->numChildren = num_children;
+
+  if (num_children > 0) {
+
+    std::vector<Node> cs(num_children);
+    std::vector<task<result>> tsk(num_children);
+
+    for (int i = 0; i < num_children; i++) {
+
+      cs[i].type = child_type;
+      cs[i].height = parent->height + 1;
+      cs[i].numChildren = -1; // not yet determined
+
+      for (int j = 0; j < computeGranularity; j++) {
+        rng_spawn(parent->state.state, cs[i].state.state, i);
+      }
+
+      tsk[i] = uts(depth + 1, &cs[i]);
+    }
+
+    auto results = co_await spawn_many(tsk.data(), num_children);
+
+    for (auto &&res : results) {
+      r.maxdepth = max(r.maxdepth, res.maxdepth);
+      r.size += res.size;
+      r.leaves += res.leaves;
+    }
+  } else {
+    r.leaves = 1;
+  }
+  co_return r;
+};
+
+void uts_tmc(benchmark::State &state, int tree) {
+
+  state.counters["green_threads"] = state.range(0);
+
+  setup_tree(tree);
+
+  volatile int depth = 0;
+  Node root;
+
+  result r;
+
+  tmc::cpu_executor().set_thread_count(state.range(0)).init();
+
+  for (auto _ : state) {
+    uts_initRoot(&root, type);
+    r = tmc::post_waitable(tmc::cpu_executor(), uts(depth, &root), 0).get();
+  }
+
+  tmc::cpu_executor().teardown();
+
+  if (r != result_tree(tree)) {
+    std::cerr << "lf uts " << tree << " failed" << std::endl;
+  }
+}
+
+} // namespace
+
+MAKE_UTS_FOR(uts_tmc);