add casestudy files

src/casestudy/CMakeLists.txt

@@ -0,0 +1,95 @@
+cmake_minimum_required(VERSION 3.5)
+project(casestudy)
+
+# Default to C99
+if(NOT CMAKE_C_STANDARD)
+  set(CMAKE_C_STANDARD 99)
+endif()
+
+# Default to C++14
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 14)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+# uncomment the following section in order to fill in
+# further dependencies manually.
+# find_package(<dependency> REQUIRED)
+find_package(priority_executor REQUIRED)
+find_package(simple_timer REQUIRED)
+find_package(rclcpp REQUIRED)
+find_package(jsoncpp REQUIRED)
+find_package(casestudy_tools REQUIRED)
+
+# add_library(test_nodes src/test_nodes.cpp)
+# target_include_directories(test_nodes PUBLIC
+#   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+#   $<INSTALL_INTERFACE:include>
+# )
+# ament_target_dependencies(test_nodes
+#   rclcpp
+#   simple_timer
+#   casestudy_tools
+# )
+
+
+list(APPEND experiments
+  casestudy_2023customfile_singlethread
+  casestudy_2024ours_latency
+  casestudy_2024ours_executor2executor
+  casestudy_example
+)
+
+function(new_experiment experiment_name)
+  add_executable(${experiment_name} src/${experiment_name}.cpp)
+  target_include_directories(${experiment_name} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  )
+  ament_target_dependencies(${experiment_name}
+    rclcpp
+    priority_executor
+    simple_timer
+    casestudy_tools
+  )
+endfunction()
+
+foreach(experiment ${experiments})
+  new_experiment(${experiment})
+endforeach()
+
+target_link_libraries(casestudy_2023customfile_singlethread
+  jsoncpp
+)
+
+
+install(TARGETS
+  ${experiments}
+  DESTINATION lib/${PROJECT_NAME}
+)
+
+
+install(
+  DIRECTORY include/
+  DESTINATION include
+)
+
+
+if(BUILD_TESTING)
+  find_package(ament_lint_auto REQUIRED)
+  # the following line skips the linter which checks for copyrights
+  # uncomment the line when a copyright and license is not present in all source files
+  #set(ament_cmake_copyright_FOUND TRUE)
+  # the following line skips cpplint (only works in a git repo)
+  # uncomment the line when this package is not in a git repo
+  #set(ament_cmake_cpplint_FOUND TRUE)
+  ament_lint_auto_find_test_dependencies()
+endif()
+
+ament_export_include_directories(include)
+ament_package()

src/casestudy/package.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>casestudy</name>
+  <version>0.0.0</version>
+  <description>TODO: Package description</description>
+  <maintainer email="vboxuser@todo.todo">vboxuser</maintainer>
+  <license>TODO: License declaration</license>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+
+  <test_depend>ament_lint_auto</test_depend>
+  <test_depend>ament_lint_common</test_depend>
+
+  <depend>priority_executor</depend>
+  <depend>simple_timer</depend>
+  <depend>casestudy_tools</depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>

src/casestudy/src/casestudy_2023customfile_singlethread.cpp

@@ -0,0 +1,213 @@
+#include "rclcpp/rclcpp.hpp"
+#include "priority_executor/priority_executor.hpp"
+#include "priority_executor/priority_memory_strategy.hpp"
+#include "casestudy_tools/test_nodes.hpp"
+#include <string>
+#include <fstream>
+#include <unistd.h>
+#include "std_msgs/msg/string.hpp"
+#include "casestudy_tools/primes_workload.hpp"
+#include <sys/prctl.h>
+#include "casestudy_tools/primes_workload.hpp"
+#include "casestudy_tools/experiment.hpp"
+#include "jsoncpp/json/reader.h"
+
+// bool should_do_task = true;
+std::atomic<bool> should_do_task(true);
+
+void run_one_executor(std::function<void(std::atomic<bool> &)> exec_fun, int idx)
+{
+  (void)idx;
+  // set this process to highest priority
+  struct sched_param param;
+  param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;
+  int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  if (result != 0)
+  {
+    std::cout << "ros_experiment: sched_setscheduler failed: " << result << ": " << strerror(errno) << std::endl;
+  }
+
+  // set process name
+  prctl(PR_SET_NAME, "ros_experiment", 0, 0, 0);
+
+  exec_fun(should_do_task);
+}
+
+int ros_experiment(int argc, char **arg, std::string file_name, ExperimentConfig config)
+{
+
+  rclcpp::init(argc, arg);
+  // we have to create a node to process any passed parameters
+  auto node = rclcpp::Node::make_shared("experiment_node");
+  node->declare_parameter("executor_type", "edf");
+
+  std::string executor_type;
+  node->get_parameter("executor_type", executor_type);
+  std::cout << "using executor type: " << executor_type << std::endl;
+
+  // TODO: move experiment configuration to main
+  config.executor_type = executor_type;
+  config.nodes.push_back(node);
+
+  Experiment experiment(config);
+  // std::string result_log = experiment.run(should_do_task);
+  std::vector<std::function<void(std::atomic<bool> &)>> exec_funs = experiment.getRunFunctions();
+  std::cout << "got " << exec_funs.size() << " executors" << std::endl;
+  std::vector<std::thread> exec_threads;
+  int i = 0;
+  experiment.resetTimers();
+  for (auto exec_fun : exec_funs)
+  {
+    exec_threads.push_back(std::thread(run_one_executor, exec_fun, i));
+    i++;
+  }
+
+  for (auto &t : exec_threads)
+  {
+    t.join();
+  }
+
+  experiment.writeLogsToFile(file_name, "2023customfile_singlethread");
+
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  std::ifstream input_file("taskset.json"); // Replace with actual filename
+
+  if (!input_file.is_open())
+  {
+    std::cerr << "Error opening file!" << std::endl;
+    return 1;
+  }
+
+  Json::Value root;
+  Json::Reader reader;
+  bool parsingSuccessful = reader.parse(input_file, root);
+
+  if (!parsingSuccessful)
+  {
+    std::cerr << "Error parsing file!" << std::endl;
+    return 1;
+  }
+
+  // set ourselves to the second highest priority
+  struct sched_param param;
+  param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  if (result != 0)
+  {
+    std::cout << "ros_experiment: sched_setscheduler failed: " << result << ": " << strerror(errno) << std::endl;
+  }
+  // calibrate the dummy load
+  // Naive way to calibrate dummy workload for current system
+  int dummy_load_calib = 1;
+  while (1)
+  {
+    timeval ctime, ftime;
+    int duration_us;
+    gettimeofday(&ctime, NULL);
+    dummy_load(100); // 100ms
+    gettimeofday(&ftime, NULL);
+    duration_us = (ftime.tv_sec - ctime.tv_sec) * 1000000 + (ftime.tv_usec - ctime.tv_usec);
+    RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "dummy_load_calib: %d (duration_us: %d ns)", dummy_load_calib, duration_us);
+    if (abs(duration_us - 100 * 1000) < 500)
+    { // error margin: 500us
+      break;
+    }
+    dummy_load_calib = 100 * 1000 * dummy_load_calib / duration_us;
+    if (dummy_load_calib <= 0)
+      dummy_load_calib = 1;
+    DummyLoadCalibration::setCalibration(dummy_load_calib);
+  }
+  // DummyLoadCalibration::setCalibration(2900);
+  ExperimentConfig config;
+
+  // config.chain_lengths = {4, 3, 4};
+  for (uint i = 0; i < root["chain_lengths"].size(); i++)
+  {
+    config.chain_lengths.push_back(root["chain_lengths"][i].asUInt());
+  }
+
+  // config.node_ids = {{0, 1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}};
+  for (uint i = 0; i < root["node_ids"].size(); i++)
+  {
+    std::vector<uint32_t> node_ids_row;
+    for (uint j = 0; j < root["node_ids"][i].size(); j++)
+    {
+      node_ids_row.push_back(root["node_ids"][i][j].asUInt());
+    }
+    config.node_ids.push_back(node_ids_row);
+  }
+  // config.node_priorities = {3, 2, 1, 0, 6, 5, 4, 10, 9, 8, 7}; // PICAS-style prioritiesA
+  for (uint i = 0; i < root["node_priorities"].size(); i++)
+  {
+    config.node_priorities.push_back(root["node_priorities"][i].asUInt());
+  }
+
+  // disabled for custom
+  config.num_groups = 0;
+  // config.group_memberships = {0, 0, 1, 2, 0, 0, 1, 0, 0, 1, 2};
+
+  // config.chain_timer_control = {0, 1, 2};
+  for (uint i = 0; i < root["chain_timer_control"].size(); i++)
+  {
+    config.chain_timer_control.push_back(root["chain_timer_control"][i].asInt());
+  }
+
+  // config.node_runtimes = {5, 5, 5, 5,      // chain 1
+  //                         10, 20, 5,       // chain 2
+  //                         10, 10, 15, 20}; // chain 3
+  for (uint i = 0; i < root["node_runtimes"].size(); i++)
+  {
+    config.node_runtimes.push_back(root["node_runtimes"][i].asDouble());
+  }
+  // config.chain_periods = {50, 100, 110};
+  for (uint i = 0; i < root["chain_periods"].size(); i++)
+  {
+    config.chain_periods.push_back(root["chain_periods"][i].asInt());
+  }
+  // config.node_executor_assignments = {}; // empty - multicore mode
+  for (uint i = 0; i < root["node_executor_assignments"].size(); i++)
+  {
+    config.node_executor_assignments.push_back(root["node_executor_assignments"][i].asUInt() - 1);
+  }
+  // single threaded mode - assign executors to cpu cores
+  for (uint i = 0; i < root["executor_to_cpu_core"].size(); i++)
+  {
+    config.executor_to_cpu_assignments.push_back(root["executor_to_cpu_core"][i].asUInt() - 1);
+  }
+
+  config.parallel_mode = false;
+  config.cores = 4;
+
+  // sanity_check_config(config);
+
+  // from 35/65 to 100/0 in increments of 5
+  // for (int i = 0; i <= (100 - 35) / 5; i++)
+  // {
+  // for now, run with 100% ros
+  int i = (100 - 35) / 5;
+  int ros_budget = 35 + i * 5;
+  int other_task_budget = 65 - i * 5;
+  std::cout << "ROS budget: " << ros_budget << " Other task budget: " << other_task_budget << std::endl;
+  // do other task in a separate thread
+  should_do_task.store(true);
+  double other_task_time = 80 * other_task_budget / 100.0;
+  std::thread other_task(do_other_task, other_task_time, 80, std::ref(should_do_task));
+
+  // do ros task
+
+  std::string file_name = "ros_" + std::to_string(ros_budget);
+  // ros_experiment(argc, argv, file_name);
+  std::thread ros_task(ros_experiment, argc, argv, file_name, config);
+  std::cout << "tasks started" << std::endl;
+  ros_task.join();
+  other_task.join();
+  std::cout << "tasks joined" << std::endl;
+
+  // // run once
+  // break;
+  // }
+}

src/casestudy/src/casestudy_2024ours_executor2executor.cpp

@@ -0,0 +1,215 @@
+#include "casestudy_tools/experiment.hpp"
+#include "casestudy_tools/primes_workload.hpp"
+#include <string>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+// bool should_do_task = true;
+std::atomic<bool> should_do_task(true);
+
+void run_one_executor(std::function<void(std::atomic<bool> &)> exec_fun,
+                      int idx) {
+  (void)idx;
+  // set this process to highest priority
+  // struct sched_param param;
+  // param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;
+  // int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  // if (result != 0)
+  // {
+  //   std::cout << "ros_experiment: sched_setscheduler failed: " << result <<
+  //   ": " << strerror(errno) << std::endl;
+  // }
+  sched_attr rt_attr;
+  rt_attr.size = sizeof(rt_attr);
+  rt_attr.sched_flags = 0;
+  rt_attr.sched_nice = 0;
+  rt_attr.sched_priority = 99;
+  rt_attr.sched_policy = SCHED_FIFO;
+  rt_attr.sched_runtime = 0;
+  rt_attr.sched_period = 0;
+  int result = sched_setattr(0, &rt_attr, 0);
+  if (result != 0) {
+    std::cout << "executor task: could not set scheduler: " << result << ": "
+              << strerror(errno) << std::endl;
+  }
+
+  // set process name
+  prctl(PR_SET_NAME, "ros_experiment", 0, 0, 0);
+
+  exec_fun(should_do_task);
+}
+
+int ros_experiment(rclcpp::Node::SharedPtr node, std::string file_name,
+                   ExperimentConfig config) {
+
+  std::string executor_type;
+  node->get_parameter("executor_type", executor_type);
+  int num_subscribers;
+  node->get_parameter("num_subscribers", num_subscribers);
+  int num_chains;
+  node->get_parameter("num_chains", num_chains);
+  std::cout << "using executor type: " << executor_type << std::endl;
+
+  // TODO: move experiment configuration to main
+  config.executor_type = executor_type;
+  config.nodes.push_back(node);
+
+  Experiment experiment(config);
+  // std::string result_log = experiment.run(should_do_task);
+  std::vector<std::function<void(std::atomic<bool> &)>> exec_funs =
+      experiment.getRunFunctions();
+  std::cout << "got " << exec_funs.size() << " executors" << std::endl;
+  std::vector<std::thread> exec_threads;
+  int i = 0;
+  experiment.resetTimers();
+  for (auto exec_fun : exec_funs) {
+    exec_threads.push_back(std::thread(run_one_executor, exec_fun, i));
+    i++;
+  }
+
+  for (auto &t : exec_threads) {
+    t.join();
+  }
+
+  std::string outputname = "2024ours_executor2executor";
+  outputname +=
+      "_" + std::to_string(num_subscribers) + "_" + std::to_string(num_chains);
+  experiment.writeLogsToFile(file_name, outputname);
+
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  rclcpp::init(argc, argv);
+  // we have to create a node to process any passed parameters
+  auto node = rclcpp::Node::make_shared("experiment_node");
+  // auto node = rclcpp::Node::make_shared("experiment_node",
+  // rclcpp::NodeOptions().use_intra_process_comms(true));
+  node->declare_parameter("executor_type", "edf");
+  node->declare_parameter("num_subscribers", 3);
+  node->declare_parameter("num_chains", 1);
+  node->declare_parameter("runtime", 0);
+
+  int num_s;
+  node->get_parameter("num_subscribers", num_s);
+  int runtime;
+  node->get_parameter("runtime", runtime);
+  int num_chains;
+  node->get_parameter("num_chains", num_chains);
+
+  // set ourselves to the second highest priority
+  // struct sched_param param;
+  // param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  // int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  sched_attr rt_attr;
+  rt_attr.size = sizeof(rt_attr);
+  rt_attr.sched_policy = SCHED_FIFO;
+  // rt_attr.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  rt_attr.sched_priority = 99;
+  int result = sched_setattr(0, &rt_attr, 0);
+
+  if (result != 0) {
+    std::cout << "ros_experiment: sched_setscheduler failed: " << result << ": "
+              << strerror(errno) << std::endl;
+  }
+  // calibrate the dummy load
+  // Naive way to calibrate dummy workload for current system
+  int dummy_load_calib = 1;
+  while (1) {
+    timeval ctime, ftime;
+    int duration_us;
+    gettimeofday(&ctime, NULL);
+    dummy_load(100); // 100ms
+    gettimeofday(&ftime, NULL);
+    duration_us = (ftime.tv_sec - ctime.tv_sec) * 1000000 +
+                  (ftime.tv_usec - ctime.tv_usec);
+    RCLCPP_INFO(rclcpp::get_logger("rclcpp"),
+                "dummy_load_calib: %d (duration_us: %d ns)", dummy_load_calib,
+                duration_us);
+    if (abs(duration_us - 100 * 1000) < 500) { // error margin: 500us
+      break;
+    }
+    dummy_load_calib = 100 * 1000 * dummy_load_calib / duration_us;
+    if (dummy_load_calib <= 0)
+      dummy_load_calib = 1;
+    DummyLoadCalibration::setCalibration(dummy_load_calib);
+  }
+  // DummyLoadCalibration::setCalibration(2900);
+  ExperimentConfig config;
+
+  // runtimes and timers subject to change
+  config.chain_lengths = {};
+  config.node_ids = {};
+  config.chain_timer_control = {};
+  config.chain_periods = {};
+  config.node_runtimes = {};
+  config.node_executor_assignments = {};
+  int node_id = 0;
+  for (int c = 0; c < num_chains; c++) {
+    config.node_ids.push_back({});
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_ids[c].push_back(node_id);
+      if (i == 0) {
+        // first node is the publisher, and goes in the first executor
+        config.node_executor_assignments.push_back(0);
+      } else {
+        // all other nodes go in the second executor
+        config.node_executor_assignments.push_back(1);
+      }
+      node_id++;
+    }
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_priorities.push_back(i);
+    }
+    config.chain_lengths.push_back(num_s+1);
+    config.chain_periods.push_back(10);
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_runtimes.push_back(runtime);
+    }
+    config.chain_timer_control.push_back(c);
+  }
+
+  config.executor_to_cpu_assignments = {0, 1};
+
+  std::cout << "node ids: " << std::endl;
+  for (size_t i = 0; i < config.node_ids.size(); i++) {
+    for (size_t j = 0; j < config.node_ids[i].size(); j++) {
+      std::cout << config.node_ids[i][j] << " ";
+    }
+    std::cout << std::endl;
+  }
+
+
+  config.num_groups = 0;
+  config.group_memberships = {}; // no groups
+
+  config.parallel_mode = false;
+  config.cores = 1;
+  config.special_cases.push_back("2024ours_latency");
+
+  // sanity_check_config(config);
+
+  // from 35/65 to 100/0 in increments of 5
+  // for (int i = 0; i <= (100 - 35) / 5; i++)
+  // {
+  // for now, run with 100% ros
+  int i = (100 - 35) / 5;
+  int ros_budget = 35 + i * 5;
+  int other_task_budget = 65 - i * 5;
+  std::cout << "ROS budget: " << ros_budget
+            << " Other task budget: " << other_task_budget << std::endl;
+  // do other task in a separate thread
+  should_do_task.store(true);
+
+  // do ros task
+  std::string file_name = "ros_" + std::to_string(ros_budget);
+  // ros_experiment(argc, argv, file_name);
+  std::thread ros_task(ros_experiment, node, file_name, config);
+  std::cout << "tasks started" << std::endl;
+  ros_task.join();
+  std::cout << "tasks joined" << std::endl;
+
+  // // run once
+  // break;
+  // }
+}

src/casestudy/src/casestudy_2024ours_latency.cpp

@@ -0,0 +1,208 @@
+#include "casestudy_tools/experiment.hpp"
+#include "casestudy_tools/primes_workload.hpp"
+#include <string>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+// bool should_do_task = true;
+std::atomic<bool> should_do_task(true);
+
+
+void run_one_executor(std::function<void(std::atomic<bool> &)> exec_fun,
+                      int idx) {
+  (void)idx;
+  // set this process to highest priority
+  // struct sched_param param;
+  // param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;
+  // int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  // if (result != 0)
+  // {
+  //   std::cout << "ros_experiment: sched_setscheduler failed: " << result <<
+  //   ": " << strerror(errno) << std::endl;
+  // }
+  sched_attr rt_attr;
+  rt_attr.size = sizeof(rt_attr);
+  rt_attr.sched_flags = 0;
+  rt_attr.sched_nice = 0;
+  rt_attr.sched_priority = 99;
+  rt_attr.sched_policy = SCHED_FIFO;
+  rt_attr.sched_runtime = 0;
+  rt_attr.sched_period = 0;
+  int result = sched_setattr(0, &rt_attr, 0);
+  if (result != 0) {
+    std::cout << "executor task: could not set scheduler: " << result << ": "
+              << strerror(errno) << std::endl;
+  }
+
+  // set process name
+  prctl(PR_SET_NAME, "ros_experiment", 0, 0, 0);
+
+  exec_fun(should_do_task);
+}
+
+int ros_experiment(rclcpp::Node::SharedPtr node, std::string file_name,
+                   ExperimentConfig config) {
+
+  std::string executor_type;
+  node->get_parameter("executor_type", executor_type);
+  int num_subscribers;
+  node->get_parameter("num_subscribers", num_subscribers);
+  int num_chains;
+  node->get_parameter("num_chains", num_chains);
+  std::cout << "using executor type: " << executor_type << std::endl;
+
+  // TODO: move experiment configuration to main
+  config.executor_type = executor_type;
+  config.nodes.push_back(node);
+
+  Experiment experiment(config);
+  // std::string result_log = experiment.run(should_do_task);
+  std::vector<std::function<void(std::atomic<bool> &)>> exec_funs =
+      experiment.getRunFunctions();
+  std::cout << "got " << exec_funs.size() << " executors" << std::endl;
+  std::vector<std::thread> exec_threads;
+  int i = 0;
+  experiment.resetTimers();
+  for (auto exec_fun : exec_funs) {
+    exec_threads.push_back(std::thread(run_one_executor, exec_fun, i));
+    i++;
+  }
+
+  for (auto &t : exec_threads) {
+    t.join();
+  }
+
+  std::string outputname = "2024ours_latency";
+  outputname +=
+      "_" + std::to_string(num_subscribers) + "_" + std::to_string(num_chains);
+  experiment.writeLogsToFile(file_name, outputname);
+
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  rclcpp::init(argc, argv);
+  // we have to create a node to process any passed parameters
+  auto node = rclcpp::Node::make_shared("experiment_node");
+  // auto node = rclcpp::Node::make_shared("experiment_node",
+  // rclcpp::NodeOptions().use_intra_process_comms(true));
+  node->declare_parameter("executor_type", "edf");
+  node->declare_parameter("num_subscribers", 3);
+  node->declare_parameter("num_chains", 1);
+  node->declare_parameter("runtime", 0);
+
+  int num_s;
+  node->get_parameter("num_subscribers", num_s);
+  int runtime;
+  node->get_parameter("runtime", runtime);
+  int num_chains;
+  node->get_parameter("num_chains", num_chains);
+
+  // set ourselves to the second highest priority
+  // struct sched_param param;
+  // param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  // int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  sched_attr rt_attr;
+  rt_attr.size = sizeof(rt_attr);
+  rt_attr.sched_policy = SCHED_FIFO;
+  // rt_attr.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  rt_attr.sched_priority = 99;
+  int result = sched_setattr(0, &rt_attr, 0);
+
+  if (result != 0) {
+    std::cout << "ros_experiment: sched_setscheduler failed: " << result << ": "
+              << strerror(errno) << std::endl;
+  }
+  // calibrate the dummy load
+  // Naive way to calibrate dummy workload for current system
+  int dummy_load_calib = 1;
+  while (1) {
+    timeval ctime, ftime;
+    int duration_us;
+    gettimeofday(&ctime, NULL);
+    dummy_load(100); // 100ms
+    gettimeofday(&ftime, NULL);
+    duration_us = (ftime.tv_sec - ctime.tv_sec) * 1000000 +
+                  (ftime.tv_usec - ctime.tv_usec);
+    RCLCPP_INFO(rclcpp::get_logger("rclcpp"),
+                "dummy_load_calib: %d (duration_us: %d ns)", dummy_load_calib,
+                duration_us);
+    if (abs(duration_us - 100 * 1000) < 500) { // error margin: 500us
+      break;
+    }
+    dummy_load_calib = 100 * 1000 * dummy_load_calib / duration_us;
+    if (dummy_load_calib <= 0)
+      dummy_load_calib = 1;
+    DummyLoadCalibration::setCalibration(dummy_load_calib);
+  }
+  // DummyLoadCalibration::setCalibration(2900);
+  ExperimentConfig config;
+
+  // runtimes and timers subject to change
+  config.chain_lengths = {};
+  config.node_ids = {};
+  config.chain_timer_control = {};
+  config.chain_periods = {};
+  config.node_runtimes = {};
+  int node_id = 0;
+  for (int c = 0; c < num_chains; c++) {
+    config.node_ids.push_back({});
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_ids[c].push_back(node_id);
+      node_id++;
+    }
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_priorities.push_back(i);
+    }
+    config.chain_lengths.push_back(num_s+1);
+    config.chain_periods.push_back(10);
+    for (int i = 0; i < num_s + 1; i++) {
+      config.node_runtimes.push_back(runtime);
+    }
+    config.chain_timer_control.push_back(c);
+  }
+
+  std::cout << "node ids: " << std::endl;
+  for (size_t i = 0; i < config.node_ids.size(); i++) {
+    for (size_t j = 0; j < config.node_ids[i].size(); j++) {
+      std::cout << config.node_ids[i][j] << " ";
+    }
+    std::cout << std::endl;
+  }
+
+
+  config.num_groups = 0;
+  config.group_memberships = {}; // no groups
+
+  config.node_executor_assignments = {};
+  // config.node_executor_assignments = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  config.parallel_mode = false;
+  config.cores = 1;
+  config.special_cases.push_back("2024ours_latency");
+
+  // sanity_check_config(config);
+
+  // from 35/65 to 100/0 in increments of 5
+  // for (int i = 0; i <= (100 - 35) / 5; i++)
+  // {
+  // for now, run with 100% ros
+  int i = (100 - 35) / 5;
+  int ros_budget = 35 + i * 5;
+  int other_task_budget = 65 - i * 5;
+  std::cout << "ROS budget: " << ros_budget
+            << " Other task budget: " << other_task_budget << std::endl;
+  // do other task in a separate thread
+  should_do_task.store(true);
+
+  // do ros task
+  std::string file_name = "ros_" + std::to_string(ros_budget);
+  // ros_experiment(argc, argv, file_name);
+  std::thread ros_task(ros_experiment, node, file_name, config);
+  std::cout << "tasks started" << std::endl;
+  ros_task.join();
+  std::cout << "tasks joined" << std::endl;
+
+  // // run once
+  // break;
+  // }
+}

src/casestudy/src/casestudy_example.cpp

@@ -0,0 +1,132 @@
+#include "rclcpp/rclcpp.hpp"
+#include "priority_executor/priority_executor.hpp"
+#include "priority_executor/priority_memory_strategy.hpp"
+#include "casestudy_tools/test_nodes.hpp"
+#include <string>
+#include <fstream>
+#include <unistd.h>
+#include "std_msgs/msg/string.hpp"
+#include "casestudy_tools/primes_workload.hpp"
+#include <sys/prctl.h>
+#include "casestudy_tools/primes_workload.hpp"
+#include "casestudy_tools/experiment.hpp"
+
+// bool should_do_task = true;
+std::atomic<bool> should_do_task(true);
+
+void run_one_executor(std::function<void(std::atomic<bool> &)> exec_fun, int idx)
+{
+  (void)idx;
+  // cpu_set_t cpuset;
+  // CPU_ZERO(&cpuset);
+  // CPU_SET(0, &cpuset);
+  // CPU_SET(1, &cpuset);
+  // CPU_SET(2, &cpuset);
+  // CPU_SET(3, &cpuset);
+
+  // int result = sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
+  // if (result != 0)
+  // {
+  //   std::cout << "ros_experiment: sched_setaffinity failed: " << result << ": " << strerror(errno) << std::endl;
+  // }
+
+  // set this process to second highest priority
+  struct sched_param param;
+  param.sched_priority = sched_get_priority_max(SCHED_FIFO) - 2;
+  int result = sched_setscheduler(0, SCHED_FIFO, &param);
+  if (result != 0)
+  {
+    std::cout << "ros_experiment: sched_setscheduler failed: " << result << ": " << strerror(errno) << std::endl;
+  }
+
+  // set process name
+  prctl(PR_SET_NAME, "ros_experiment", 0, 0, 0);
+
+  exec_fun(should_do_task);
+}
+
+int ros_experiment(int argc, char **arg, std::string file_name, ExperimentConfig config)
+{
+
+  rclcpp::init(argc, arg);
+  // we have to create a node to process any passed parameters
+  auto node = rclcpp::Node::make_shared("experiment_parameters");
+  node->declare_parameter("executor_type", "edf");
+
+  std::string executor_type;
+  node->get_parameter("executor_type", executor_type);
+  std::cout << "using executor type: " << executor_type << std::endl;
+
+  // TODO: move experiment configuration to main
+  config.executor_type = executor_type;
+  config.parallel_mode = true;
+  config.nodes.push_back(node);
+
+  Experiment experiment(config);
+  // std::string result_log = experiment.run(should_do_task);
+  std::vector<std::function<void(std::atomic<bool> &)>> exec_funs = experiment.getRunFunctions();
+  std::cout << "got " << exec_funs.size() << " executors" << std::endl;
+  std::vector<std::thread> exec_threads;
+  int i = 0;
+  experiment.resetTimers();
+  for (auto exec_fun : exec_funs)
+  {
+    exec_threads.push_back(std::thread(run_one_executor, exec_fun, i));
+    i++;
+  }
+
+  for (auto &t : exec_threads)
+  {
+    t.join();
+  }
+  std::string outputname = "casestudy_example";
+  experiment.writeLogsToFile(file_name, outputname);
+
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+
+  // calibrate the dummy load
+  // Naive way to calibrate dummy workload for current system
+  int dummy_load_calib = 1;
+  while (1)
+  {
+    timeval ctime, ftime;
+    int duration_us;
+    gettimeofday(&ctime, NULL);
+    dummy_load(100); // 100ms
+    gettimeofday(&ftime, NULL);
+    duration_us = (ftime.tv_sec - ctime.tv_sec) * 1000000 + (ftime.tv_usec - ctime.tv_usec);
+    RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "dummy_load_calib: %d (duration_us: %d ns)", dummy_load_calib, duration_us);
+    if (abs(duration_us - 100 * 1000) < 500)
+    { // error margin: 500us
+      break;
+    }
+    dummy_load_calib = 100 * 1000 * dummy_load_calib / duration_us;
+    if (dummy_load_calib <= 0)
+      dummy_load_calib = 1;
+    DummyLoadCalibration::setCalibration(dummy_load_calib);
+  }
+  // DummyLoadCalibration::setCalibration(2900);
+  ExperimentConfig config;
+  config.chain_lengths = {2, 2};
+  config.node_ids = {{0, 1}, {2, 3}};
+  config.node_priorities = {1, 0, 3, 2};
+  config.chain_timer_control = {0, 1};
+
+  config.node_runtimes = {10, 10, 10, 10};
+  // node 0 has a period of 80, and is the only timer
+  config.chain_periods = {100, 100};
+  config.node_executor_assignments = {};
+  config.parallel_mode = true;
+  config.cores = 2;
+
+  sanity_check_config(config);
+
+  std::thread ros_task(ros_experiment, argc, argv, "cs_example", config);
+  std::cout << "tasks started" << std::endl;
+  ros_task.join();
+  std::cout << "tasks joined" << std::endl;
+}