art::DebugOptionsHandler Class Reference

#include "DebugOptionsHandler.h"

Inheritance diagram for art::DebugOptionsHandler:

Public Member Functions
	DebugOptionsHandler (bpo::options_description &desc, std::string const &basename)
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 12 of file DebugOptionsHandler.h.

Constructor & Destructor Documentation

art::DebugOptionsHandler::DebugOptionsHandler ( bpo::options_description &  desc, std::string const &  basename  )

explicit

Definition at line 42 of file DebugOptionsHandler.cc.

References art::add_opt(), and s.

{
  bpo::options_description debug_options{"Debugging options"};
  auto options = debug_options.add_options();
  add_opt(options,
          "mt-diagnostics,M",
          bpo::value<std::string>(),
          "Log art-specific multi-threading diagnostics to "
          "the provided destination.");
  add_opt(options, "trace", "Activate tracing.");
  add_opt(options, "notrace", "Deactivate tracing.");
  add_opt(
    options, "timing", "Activate monitoring of time spent per event/module.");
  add_opt(options,
          "timing-db",
          bpo::value<std::string>(),
          "Output time-tracking data to SQLite3 database with name <db-file>.");
  add_opt(options, "notiming", "Deactivate time tracking.");
  add_opt(options,
          "memcheck",
          "Activate monitoring of memory use (deprecated--per-job "
          "memory information printed in job summary).");
  add_opt(options,
          "memcheck-db",
          bpo::value<std::string>(),
          "Output memory use data to SQLite3 database with name <db-file>.");
  add_opt(options, "nomemcheck", "Deactivate monitoring of memory use.");
  add_opt(
    options,
    "validate-config",
    bpo::value<std::string>(),
    "Output post-processed configuration to <file>; call constructors of all "
    "sources, modules and services, performing extra configuration "
    "verification.  Exit just before processing the event loop.");
  add_opt(
    options,
    "debug-config",
    bpo::value<std::string>(),
    ("Output post-processed configuration to <file> and exit. Equivalent to env ART_DEBUG_CONFIG=<file> "s +
     basename + " ...")
      .c_str());
  add_opt(
    options,
    "config-out",
    bpo::value<std::string>(),
    "Output post-processed configuration to <file> and continue with job.");
  add_opt(
    options, "annotate", "Include configuration parameter source information.");
  add_opt(options,
          "prefix-annotate",
          "Include configuration parameter source information "
          "on line preceding parameter declaration.");
  desc.add(debug_options);
}

Member Function Documentation

int art::OptionsHandler::checkOptions ( bpo::variables_map const &  vm )

inherited

Definition at line 51 of file OptionsHandler.cc.

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher([&vm, this] { return doCheckOptions(vm); },
                          thisClass + "::doCheckOptions()",
                          89);
}

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

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 99 of file DebugOptionsHandler.cc.

References art::errors::Configuration.

{
  if (vm.count("trace") + vm.count("notrace") > 1) {
    throw Exception(errors::Configuration)
      << "Options --trace and --notrace are incompatible.\n";
  }
  if (vm.count("timing") + vm.count("notiming") > 1) {
    throw Exception(errors::Configuration)
      << "Options --timing and --notiming are incompatible.\n";
  }
  if (vm.count("timing-db") + vm.count("notiming") > 1) {
    throw Exception(errors::Configuration)
      << "Options --timing-db and --notiming are incompatible.\n";
  }
  if (vm.count("memcheck") + vm.count("nomemcheck") > 1) {
    throw Exception(errors::Configuration)
      << "Options --memcheck and --nomemcheck are incompatible.\n";
  }
  if (vm.count("memcheck-db") + vm.count("nomemcheck") > 1) {
    throw Exception(errors::Configuration)
      << "Options --memcheck-db and --nomemcheck are incompatible.\n";
  }
  if (vm.count("validate-config") + vm.count("debug-config") +
        vm.count("config-out") >
      1) {
    throw Exception(errors::Configuration)
      << "Options --validate-config, --debug-config, and --config-out are "
         "incompatible.\n";
  }
  if (vm.count("annotate") + vm.count("prefix-annotate") > 1) {
    throw Exception(errors::Configuration)
      << "Options --annotate and --prefix-annotate are incompatible.\n";
  }

  if (vm.count("annotate") + vm.count("prefix-annotate") == 1 &&
      vm.count("debug-config") + vm.count("config-out") == 0) {
    throw Exception(errors::Configuration)
      << "Options --annotate and --prefix-annotate must be specified with "
         "either --debug-config or --config-out.\n";
  }

  return 0;
}

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

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 144 of file DebugOptionsHandler.cc.

References fhicl::intermediate_table::erase(), art::detail::exists_outside_prolog(), art::detail::fhicl_key(), fhicl::intermediate_table::get(), fhicl::intermediate_table::put(), fhicl::intermediate_table::putEmptyTable(), and s.

{

  using namespace fhicl::detail;

  auto const scheduler_key = fhicl_key("services", "scheduler");
  std::string debug_table;

  // Get ART_DEBUG_CONFIG value
  std::string fn;
  auto const result = destination_via_env();
  if (result.second) {
    debug_table = fhicl_key(scheduler_key, "debugConfig");
    fn = result.first;
  }

  // "validate-config" and "debug-config" win over ART_DEBUG_CONFIG
  if (vm.count("validate-config")) {
    debug_table = fhicl_key(scheduler_key, "validateConfig");
    fn = vm["validate-config"].as<std::string>();
  } else if (vm.count("debug-config")) {
    debug_table = fhicl_key(scheduler_key, "debugConfig");
    fn = vm["debug-config"].as<std::string>();
  } else if (vm.count("config-out")) {
    debug_table = fhicl_key(scheduler_key, "configOut");
    fn = vm["config-out"].as<std::string>();
  }
  if (!debug_table.empty()) {
    raw_config.put(fhicl_key(debug_table, "fileName"), fn);
  }

  std::string mode{"raw"};
  if (vm.count("annotate")) {
    mode = "annotate";
  }
  if (vm.count("prefix-annotate")) {
    mode = "prefix-annotate";
  }
  if (!debug_table.empty()) {
    raw_config.put(fhicl_key(debug_table, "printMode"), mode);
  }

  if (vm.count("trace")) {
    raw_config.put("services.scheduler.wantTracer", true);
  } else if (vm.count("notrace")) {
    raw_config.put("services.scheduler.wantTracer", false);
  }
  auto const timingdb = vm.count("timing-db");
  if (vm.count("timing") || timingdb) {
    raw_config.putEmptyTable("services.TimeTracker");
    if (timingdb)
      raw_config.put("services.TimeTracker.dbOutput.filename",
                     vm["timing-db"].as<std::string>());
  } else if (vm.count("notiming")) {
    raw_config.erase("services.TimeTracker");
  }
  auto const memdb = vm.count("memcheck-db");
  if (vm.count("memcheck") || memdb) {
    raw_config.putEmptyTable("services.MemoryTracker");
    if (memdb)
      raw_config.put("services.MemoryTracker.dbOutput.filename",
                     vm["memcheck-db"].as<std::string>());
  } else if (vm.count("nomemcheck")) {
    raw_config.erase("services.MemoryTracker");
  }

  // messagefacility configuration.
  auto const message_key = fhicl_key("services", "message");
  auto const dests_key = fhicl_key(message_key, "destinations");
  if (!detail::exists_outside_prolog(raw_config, message_key)) {
    raw_config.put(fhicl_key(dests_key, "STDOUT.categories.ArtReport.limit"),
                   100);
    raw_config.put(fhicl_key(dests_key, "STDOUT.categories.default.limit"), -1);
    raw_config.put(fhicl_key(dests_key, "STDOUT.type"), "cout");
    raw_config.put(fhicl_key(dests_key, "STDOUT.threshold"), "INFO");
  }
  assert(detail::exists_outside_prolog(raw_config, dests_key));
  auto const& dests = raw_config.get<table_t const&>(dests_key);

  // By default, suppress all logging of messages of MTdiagnostics category.
  for (auto const& p : dests) {
    std::string const& dest_name = p.first;
    if (dest_name == "statistics"s)
      continue; // statistics are special -- see below
    raw_config.put(
      fhicl_key(dests_key, dest_name, "categories.MTdiagnostics.limit"), 0);
  }

  // The statistics destination represents a table of named destinations.
  auto const& stats_dest_key = fhicl_key(dests_key, "statistics");
  if (detail::exists_outside_prolog(raw_config, stats_dest_key)) {
    auto const& stats_dests = raw_config.get<table_t const&>(stats_dest_key);
    for (auto const& p : stats_dests) {
      std::string const& dest_name = p.first;
      raw_config.put(
        fhicl_key(stats_dest_key, dest_name, "categories.MTdiagnostics.limit"),
        0);
    }
  }

  if (vm.count("mt-diagnostics") > 0) {
    auto const dest = vm["mt-diagnostics"].as<std::string>();
    std::regex const re_stdout{R"((STDOUT|cout))",
                               std::regex_constants::ECMAScript |
                                 std::regex_constants::icase};
    std::regex const re_stderr{R"((STDERR|cerr))",
                               std::regex_constants::ECMAScript |
                                 std::regex_constants::icase};
    if (std::regex_match(dest, re_stdout)) {
      // Special handling since the 'cout' destination is already the
      // default per above.
      raw_config.put(
        fhicl_key(dests_key, "STDOUT.categories.MTdiagnostics.limit"), -1);
      return 0;
    }

    auto const mt_dest_key = fhicl_key(dests_key, "MTdiagnostics");
    if (std::regex_match(dest, re_stderr)) {
      raw_config.put(fhicl_key(mt_dest_key, "type"), "cerr");
    } else {
      raw_config.put(fhicl_key(mt_dest_key, "type"), "file");
      raw_config.put(fhicl_key(mt_dest_key, "filename"), dest);
    }
    raw_config.put(fhicl_key(mt_dest_key, "categories.MTdiagnostics.limit"),
                   -1);
    raw_config.put(fhicl_key(mt_dest_key, "categories.default.limit"), 0);
  }

  return 0;
}

int art::OptionsHandler::processOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

inherited

Definition at line 60 of file OptionsHandler.cc.

Referenced by art::run_art_string_config().

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher(
    [&, this] { return doProcessOptions(vm, raw_config); },
    thisClass + "::doProcessOptions()",
    90);
}

---

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

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