TestMultithreading.h

#pragma once
// multithreaded test of an iguana algorithm
 
#include <iguana/algorithms/AlgorithmSequence.h>
#ifdef USE_HIPO_MULTITHREADED_CHAIN
#include "Fuzzing.h"
#include <cassert>
#include <hipo4/chain.h>
#endif
 
inline int TestMultithreading(
    std::string const algo_name,
    std::vector<std::string> const prerequisite_algos,
    std::vector<std::string> const bank_names,
    std::string const data_file,
    int data_tag,
    int const num_events,
    int const num_threads,
    bool const vary_run,
    std::string const log_level)
{
 
#ifdef USE_HIPO_MULTITHREADED_CHAIN
 
  iguana::Logger log("test");
  log.SetLevel(log_level);
 
  // check arguments
  if(algo_name.empty() || bank_names.empty()) {
    log.Error("need algorithm name and banks");
    return 1;
  }
  if(data_file.empty()) {
    log.Error("need a data file for command 'multithreading'");
    return 1;
  }
 
  // set the concurrency model
  iguana::GlobalConcurrencyModel = "memoize";
 
  // find the 'RUN::config' bank, if any
  std::optional<hipo::banklist::size_type> run_config_bank_idx{};
  if(vary_run) {
    for(hipo::banklist::size_type idx = 0; idx < bank_names.size(); idx++) {
      if(bank_names.at(idx) == "RUN::config") {
        run_config_bank_idx = idx;
        break;
      }
    }
  }
 
  // start the HIPO chain
  hipo::chain ch(num_threads, false, false);
  ch.set_tags({data_tag});
  ch.add(data_file);
  auto banks = ch.getBanks(bank_names);
 
  // define the algorithm
  iguana::AlgorithmSequence seq;
  for(auto const& prerequisite_algo : prerequisite_algos)
    seq.Add(prerequisite_algo);
  seq.Add(algo_name);
  seq.PrintSequence();
  seq.SetLogLevel(algo_name, log_level);
  seq.iguana::Algorithm::SetLogLevel(log_level);
 
  // start the algorithm
  seq.Start(banks);
 
  // setup run number variation
  Fuzzing fuzz;
  if(vary_run) {
    seq.GetLog()->Warn("==================================================================================================");
    seq.GetLog()->Warn("RUN NUMBER VARIATION IS ENABLED, DO NOT ATTEMPT TO CROSS CHECK RESULTS WITH SINGLE-THREADED TESTS!");
    seq.GetLog()->Warn("==================================================================================================");
  }
 
  // define the event processor
  auto processor = [&seq,
                    &vary_run,
                    &run_config_bank_idx,
                    &fuzz](auto& banks, int file_idx, long event_idx) {
    // occasionally vary the run number; so far, algorithms with data-dependent configuration
    // parameters have dependence on run number, so this variation aims to improve thread
    // sanitizer test coverage
    if(vary_run && run_config_bank_idx.has_value()) {
      auto random_run = fuzz.RunNumRandom();
      if(random_run.has_value()) {
        seq.GetLog()->Trace("RANDOMLY VARIED RUN NUMBER TO BE {}", random_run.value());
        banks[run_config_bank_idx.value()].putInt("run", 0, random_run.value());
      }
    }
    // run the iguana algorithm
    seq.Run(banks);
  };
 
  // process events
  double percentage = num_events == 0 ? 100 : static_cast<double>(num_events) / ch.total_events() * 100;
  auto frac         = std::clamp(percentage, 0.0, 100.0) / 100.0;
  if(num_events != 0)
    assert((num_events == std::lround(ch.total_events() * frac)));
  ch.process(banks, processor, percentage);
 
  // stop the algorithm
  seq.Stop();
  return 0;
 
#else
  throw std::runtime_error("called command `multithreading` but HIPO version does not support it");
#endif
}