main.cpp 2.27 KB
Newer Older
1
#include "pls/internal/scheduling/scheduler.h"
2

3
using namespace pls::internal::scheduling;
4

5 6
#include "benchmark_runner.h"
#include "benchmark_base/unbalanced.h"
7

8
using namespace comparison_benchmarks::base;
9

10
#include <atomic>
11

12 13 14
int count_child_nodes(unbalanced::node &node) {
  if (node.get_num_children() < 1) {
    return 1;
15 16
  }

17 18 19 20 21 22
  std::atomic<int> count{1};
  for (int i = 0; i < node.get_num_children(); i++) {
    scheduler::spawn([i, &count, &node] {
      unbalanced::node child_node = node.spawn_child_node(i);
      count.fetch_add(count_child_nodes(child_node));
    });
23
  }
24
  scheduler::sync();
25

26
  return count;
27 28
}

29 30 31
int unbalanced_tree_search(int seed, int root_children, double q, int normal_children) {
  unbalanced::node root(seed, root_children, q, normal_children);
  return count_child_nodes(root);
32 33
}

34 35
constexpr int MAX_NUM_TASKS = 256;
constexpr int MAX_STACK_SIZE = 1024 * 2;
36

37 38 39 40
int main(int argc, char **argv) {
  int num_threads;
  string directory;
  benchmark_runner::read_args(argc, argv, num_threads, directory);
41

42 43 44
  string test_name = to_string(num_threads) + ".csv";
  string full_directory = directory + "/PLS_v3/";
  benchmark_runner runner{full_directory, test_name};
45
  runner.enable_memory_stats();
46
  runner.pre_allocate_stats();
47

48
  scheduler scheduler{(unsigned) num_threads, MAX_NUM_TASKS, MAX_STACK_SIZE};
49

50 51
//  scheduler.get_profiler().disable_memory_measure();
  runner.run_iterations(1, [&]() {
52 53 54 55 56
    scheduler.perform_work([&]() {
      unbalanced_tree_search(unbalanced::SEED,
                             unbalanced::ROOT_CHILDREN,
                             unbalanced::Q,
                             unbalanced::NORMAL_CHILDREN);
57
    });
58 59 60
  }, 0);
//  scheduler.get_profiler().current_run().print_dag(std::cout);
//  scheduler.get_profiler().current_run().print_stats();
61
  runner.commit_results(true);
62 63

}
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80

//int main() {
//  PROFILE_ENABLE
//  pls::malloc_scheduler_memory my_scheduler_memory{8, 2u << 18};
//  pls::scheduler scheduler{&my_scheduler_memory, 8};
//
//  scheduler.perform_work([&] {
//    PROFILE_MAIN_THREAD
//    for (int i = 0; i < 50; i++) {
//      PROFILE_WORK_BLOCK("Top Level")
//      int result = unbalanced_tree_search(SEED, ROOT_CHILDREN, Q, NORMAL_CHILDREN);
//      std::cout << result << std::endl;
//    }
//  });
//
//  PROFILE_SAVE("test_profile.prof")
//}