Function run_cycle

performance-tests/bench/node_controller/main.cpp:906–981

}

int run_cycle(
  const std::string& name,
  ProcessManagerPtr process_manager,
  DDS::DomainParticipant_var participant,
  StatusDataWriter_var status_writer_impl,
  AllocatedScenarioDataReader_var allocated_scenario_reader_impl,
  ReportDataWriter_var report_writer_impl)
{
  OpenDDS::DCPS::DomainParticipantImpl* part_impl = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(participant.in());
  if (!part_impl) {
    std::cerr << "Invalid Participant\n" << std::flush;
    return 1;
  }

  const NodeId this_node_id = part_impl->get_id();

  // Wait for Status Publication with Test Controller and Write Status
  if (!write_status(name, this_node_id, AVAILABLE, *status_writer_impl)) {
    std::cerr << "Write status (available) failed\n" << std::flush;
    return 1;
  }

  Bench::TestController::AllocatedScenario scenario;
  wait_for_full_scenario(name, this_node_id, status_writer_impl, allocated_scenario_reader_impl, scenario);

  // This constructor traps signals, wait until we really need it.
  auto spawned_process_manager = std::make_shared<SpawnedProcessManager>(name, this_node_id, process_manager);

  Bench::NodeController::Configs& configs = scenario.configs;
  for (CORBA::ULong node = 0; node < configs.length(); ++node) {
    if (configs[node].node_id == this_node_id) {
      spawned_process_manager->timeout(configs[node].timeout);
      const CORBA::ULong allocated_scenario_count = configs[node].spawned_processes.length();
      for (CORBA::ULong config = 0; config < allocated_scenario_count; config++) {
        SpawnedProcessId& id = configs[node].spawned_processes[config].spawned_process_id;
        const SpawnedProcessId end = id + configs[node].spawned_processes[config].count;
        for (; id < end; id++) {
          if (spawned_process_manager->add_spawned_process(configs[node].spawned_processes[config])) {
            return 1;
          }
        }
      }
      break;
    }
  }

  using Builder::ZERO;

  if (scenario.launch_time < ZERO) {
    const auto duration = -1 * get_duration(scenario.launch_time);
    if (duration > std::chrono::milliseconds(100)) {
      std::this_thread::sleep_until(std::chrono::steady_clock::now() + duration);
    }
  } else {
    const auto now = std::chrono::system_clock::now();
    const auto duration = std::chrono::system_clock::time_point(get_duration(scenario.launch_time)) - now;
    if (duration > std::chrono::milliseconds(100)) {
      std::this_thread::sleep_until(std::chrono::steady_clock::now() + duration);