art::ProcessingOptionsHandler Class Reference

#include <ProcessingOptionsHandler.h>

Inheritance diagram for art::ProcessingOptionsHandler:

Public Member Functions
	ProcessingOptionsHandler (bpo::options_description &desc)
Public Member Functions inherited from art::OptionsHandler
virtual	~OptionsHandler ()=default
int	checkOptions (bpo::variables_map const &vm)
int	processOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config)

Private Member Functions
int	doCheckOptions (bpo::variables_map const &vm) override
int	doProcessOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config) override

Detailed Description

Definition at line 10 of file ProcessingOptionsHandler.h.

Constructor & Destructor Documentation

art::ProcessingOptionsHandler::ProcessingOptionsHandler ( bpo::options_description &  desc )

explicit

Definition at line 48 of file ProcessingOptionsHandler.cc.

{
  bpo::options_description processing_options{"Processing options"};
  // clang-format off
  processing_options.add_options()
    ("parallelism,j",
       bpo::value<int>(),
       "Number of threads AND schedules to use for event processing "
       "(default = 1, 0 = all cores).")
    ("nschedules",
       bpo::value<int>(),
       "Number of schedules to use for event processing (default = 1)")
    // Note: tbb wants nthreads to be an int!
    ("nthreads",
       bpo::value<int>(),
       "Number of threads to use for event processing (default = 1, 0 = all "
       "cores)")
    ("default-exceptions",
       "Some exceptions may be handled differently by default (e.g. "
       "ProductNotFound).")
    ("rethrow-default", "All exceptions default to rethrow.")
    ("rethrow-all",
       "All exceptions overridden to rethrow (cf rethrow-default).")
    ("errorOnMissingConsumes",
       bpo::value<bool>()->implicit_value(true, "true"),
       "If 'true', then an exception will be thrown if any module attempts "
       "to retrieve a product via the 'getBy*' interface without specifying "
       "the appropriate 'consumes<T>(...)' statement in the module constructor.")
    ("errorOnSIGINT",
       bpo::value<bool>()->implicit_value(true, "true"),
       "If 'true', a signal received from the user yields an art return code "
       "corresponding to an error; otherwise return 0.");
  // clang-format on
  desc.add(processing_options);
}

Member Function Documentation

int art::ProcessingOptionsHandler::doCheckOptions ( bpo::variables_map const &  vm )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 86 of file ProcessingOptionsHandler.cc.

{
  if ((vm.count("rethrow-all") + vm.count("rethrow-default") +
       vm.count("no-rethrow-default")) > 1) {
    throw Exception(errors::Configuration)
      << "Options --default-exceptions, --rethrow-all, and --rethrow-default "
         "\n"
      << "are mutually incompatible.\n";
  }

  // 'parallelism' is incompatible with either 'nthreads' or
  // 'nschedules'.
  if (vm.count("parallelism")) {
    if (vm.count("nthreads") or vm.count("nschedules")) {
      throw Exception(errors::Configuration) << "The -j/--parallelism option "
                                                "cannot be used with either "
                                                "--nthreads or --nschedules.\n";
    }
  }

  if (vm.count("nthreads") and vm["nthreads"].as<int>() < 0) {
    throw Exception(errors::Configuration)
      << "Option --nthreads must greater than or equal to 0.";
  }
  if (vm.count("nschedules") and vm["nschedules"].as<int>() < 1) {
    throw Exception(errors::Configuration)
      << "Option --nschedules must be at least 1.\n";
  }
  return 0;
}

int art::ProcessingOptionsHandler::doProcessOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 118 of file ProcessingOptionsHandler.cc.

{
  auto const scheduler_key = fhicl_key("services", "scheduler");

  if (vm.count("rethrow-all") == 1 || vm.count("rethrow-default") == 1) {
    raw_config.put(fhicl_key(scheduler_key, "defaultExceptions"), false);
    if (vm.count("rethrow-all") == 1) {
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "IgnoreCompletely"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "SkipEvent"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "FailModule"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "FailPath"));
    }
  }

  fillTable("errorOnMissingConsumes",
            fhicl_key(scheduler_key, "errorOnMissingConsumes"),
            vm,
            raw_config,
            false);
  fillTable("errorOnSIGINT",
            fhicl_key(scheduler_key, "errorOnSIGINT"),
            vm,
            raw_config,
            true);

  auto const num_schedules_key = fhicl_key(scheduler_key, "num_schedules");
  auto const num_threads_key = fhicl_key(scheduler_key, "num_threads");
  if (vm.count("parallelism")) {
    // 'nthreads' and 'nschedules' are set to the same value.
    auto const j = vm["parallelism"].as<int>();
    auto const nthreads =
      (j == 0) ? tbb::this_task_arena::max_concurrency() : j;
    raw_config.put(num_schedules_key, nthreads);
    raw_config.put(num_threads_key, nthreads);
    return 0;
  }

  if (vm.count("nschedules")) {
    raw_config.put(num_schedules_key, vm["nschedules"].as<int>());
  }
  if (vm.count("nthreads")) {
    auto const nt = vm["nthreads"].as<int>();
    auto const nthreads =
      (nt == 0) ? tbb::this_task_arena::max_concurrency() : nt;
    raw_config.put(num_threads_key, nthreads);
  }

  // If 'nschedules' or 'nthreads' does not exist in configuration,
  // assign the default value of 1.
  if (not exists_outside_prolog(raw_config, num_schedules_key)) {
    raw_config.put(num_schedules_key, 1);
  }
  if (not exists_outside_prolog(raw_config, num_threads_key)) {
    raw_config.put(num_threads_key, 1);
  }

  return 0;
}

---

The documentation for this class was generated from the following files:

• art/art/Framework/Art/ProcessingOptionsHandler.h
• art/art/Framework/Art/ProcessingOptionsHandler.cc