DependencyGraph Class Reference

Classes
struct	node

Public Member Functions
	DependencyGraph (const ParameterSet &, ActivityRegistry &)
void	postBeginJob ()
void	preBeginJob (PathsAndConsumesOfModulesBase const &, ProcessContext const &)
void	preSourceConstruction (ModuleDescription const &)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
enum	EDMModuleType {   EDMModuleType::Unknown, EDMModuleType::Source, EDMModuleType::ESSource, EDMModuleType::ESProducer,   EDMModuleType::EDAnalyzer, EDMModuleType::EDProducer, EDMModuleType::EDFilter, EDMModuleType::OutputModule }
using	GraphType = boost::subgraph< boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, boost::property< boost::vertex_attribute_t, GraphvizAttributes, node >, boost::property< boost::edge_index_t, int, boost::property< boost::edge_attribute_t, GraphvizAttributes > >, boost::property< boost::graph_name_t, std::string, boost::property< boost::graph_graph_attribute_t, GraphvizAttributes, boost::property< boost::graph_vertex_attribute_t, GraphvizAttributes, boost::property< boost::graph_edge_attribute_t, GraphvizAttributes > >> >> >
using	GraphvizAttributes = std::map< std::string, std::string >

Private Member Functions
bool	highlighted (std::string const &module)

Static Private Member Functions
static const char *	edmModuleType (edm::ModuleDescription const &module)
static EDMModuleType	edmModuleTypeEnum (edm::ModuleDescription const &module)

Private Attributes
std::string	m_filename
GraphType	m_graph
std::unordered_set< std::string >	m_highlightModules
bool	m_initialized
bool	m_showPathDependencies

Static Private Attributes
static constexpr const char *	module_type_desc []
static constexpr const char *	shapes []

Detailed Description

Definition at line 55 of file DependencyGraph.cc.

Member Typedef Documentation

GraphType

using DependencyGraph::GraphType = boost::subgraph<boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, boost::property<boost::vertex_attribute_t, GraphvizAttributes, node>, boost::property<boost::edge_index_t, int, boost::property<boost::edge_attribute_t, GraphvizAttributes> >, boost::property< boost::graph_name_t, std::string, boost::property<boost::graph_graph_attribute_t, GraphvizAttributes, boost::property<boost::graph_vertex_attribute_t, GraphvizAttributes, boost::property<boost::graph_edge_attribute_t, GraphvizAttributes> >> >> >

private

Definition at line 121 of file DependencyGraph.cc.

GraphvizAttributes

using DependencyGraph::GraphvizAttributes = std::map<std::string, std::string>

private

Definition at line 96 of file DependencyGraph.cc.

Member Enumeration Documentation

EDMModuleType

enum DependencyGraph::EDMModuleType

strongprivate

Enumerator
Unknown
Source
ESSource
ESProducer
EDAnalyzer
EDProducer
EDFilter
OutputModule

Definition at line 68 of file DependencyGraph.cc.

{ Unknown, Source, ESSource, ESProducer, EDAnalyzer, EDProducer, EDFilter, OutputModule };

Constructor & Destructor Documentation

DependencyGraph()

DependencyGraph::DependencyGraph	(	const ParameterSet &	config,
		ActivityRegistry &	registry
	)

Definition at line 168 of file DependencyGraph.cc.

References postBeginJob(), preBeginJob(), preSourceConstruction(), edm::ActivityRegistry::watchPostBeginJob(), edm::ActivityRegistry::watchPreBeginJob(), and edm::ActivityRegistry::watchPreSourceConstruction().

    : m_filename(config.getUntrackedParameter<std::string>("fileName")),
      m_highlightModules(
          make_unordered_set(config.getUntrackedParameter<std::vector<std::string>>("highlightModules"))),
      m_showPathDependencies(config.getUntrackedParameter<bool>("showPathDependencies")),
      m_initialized(false) {
  registry.watchPreSourceConstruction(this, &DependencyGraph::preSourceConstruction);
  registry.watchPreBeginJob(this, &DependencyGraph::preBeginJob);
  registry.watchPostBeginJob(this, &DependencyGraph::postBeginJob);
}

Member Function Documentation

edmModuleType()

const char * DependencyGraph::edmModuleType ( edm::ModuleDescription const &  module )

staticprivate

Definition at line 156 of file DependencyGraph.cc.

References edm::edmModuleTypeEnum(), and edm::module_type_desc.

                                                                             {
  return module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(edmModuleTypeEnum(module))];
}

edmModuleTypeEnum()

DependencyGraph::EDMModuleType DependencyGraph::edmModuleTypeEnum ( edm::ModuleDescription const &  module )

staticprivate

Definition at line 135 of file DependencyGraph.cc.

References mixOne_cfi::ESProducer, edm::pset::Registry::instance(), edm::module_type_desc, muonDTDigis_cfi::pset, CollectionTags_cfi::Source, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, reco::Unknown, and findQualityFiles::v.

Referenced by preBeginJob().

                                                                                                  {
  auto const &registry = *edm::pset::Registry::instance();
  auto const &pset = *registry.getMapped(module.parameterSetID());

  if (not pset.existsAs<std::string>("@module_edm_type"))
    return EDMModuleType::Unknown;

  std::string const &t = pset.getParameter<std::string>("@module_edm_type");
  for (EDMModuleType v : {EDMModuleType::Source,
                          EDMModuleType::ESSource,
                          EDMModuleType::ESProducer,
                          EDMModuleType::EDAnalyzer,
                          EDMModuleType::EDProducer,
                          EDMModuleType::EDFilter,
                          EDMModuleType::OutputModule}) {
    if (t == module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(v)])
      return v;
  }
  return EDMModuleType::Unknown;
}

fillDescriptions()

void DependencyGraph::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 160 of file DependencyGraph.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
  edm::ParameterSetDescription desc;
  desc.addUntracked<std::string>("fileName", "dependency.dot");
  desc.addUntracked<std::vector<std::string>>("highlightModules", {});
  desc.addUntracked<bool>("showPathDependencies", true);
  descriptions.add("DependencyGraph", desc);
}

highlighted()

bool DependencyGraph::highlighted ( std::string const &  module )

inlineprivate

Definition at line 66 of file DependencyGraph.cc.

Referenced by preBeginJob(), and preSourceConstruction().

{ return (m_highlightModules.find(module) != m_highlightModules.end()); }

postBeginJob()

void DependencyGraph::postBeginJob

(

)

Definition at line 404 of file DependencyGraph.cc.

References mps_fire::i, m_filename, m_graph, m_initialized, and MillePedeFileConverter_cfg::out.

Referenced by DependencyGraph().

                                   {
  if (not m_initialized)
    return;

  // remove the nodes corresponding to the modules that have been removed from the process
  for (int i = boost::num_vertices(m_graph) - 1; i > 1; --i) {
    if (m_graph.m_graph[i].label.empty())
      boost::remove_vertex(i, m_graph.m_graph);
  }

  // draw the dependency graph
  std::ofstream out(m_filename);
  boost::write_graphviz(out, m_graph);
  out.close();
}

preBeginJob()

void DependencyGraph::preBeginJob	(	PathsAndConsumesOfModulesBase const &	pathsAndConsumes,
		ProcessContext const &	context
	)

Definition at line 208 of file DependencyGraph.cc.

References edm::PathsAndConsumesOfModulesBase::allModules(), OfflineOutput_cfi::consumer, visDQMUpload::context, edmModuleTypeEnum(), edm::PathsAndConsumesOfModulesBase::endPaths(), newFWLiteAna::found, get, highlighted(), mps_fire::i, dqmiolumiharvest::j, edm::PathsAndConsumesOfModulesBase::largestModuleID(), m_graph, m_initialized, m_showPathDependencies, callgraph::module, edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), edm::PathsAndConsumesOfModulesBase::modulesWhoseProductsAreConsumedBy(), Skims_PA_cff::paths, edm::PathsAndConsumesOfModulesBase::paths(), callgraph::previous, shapes, findQualityFiles::size, and triggerResults.

Referenced by DependencyGraph().

                                                                 {
  // if the Service is not in the main Process do not do anything
  if (context.isSubProcess() and not m_initialized) {
    edm::LogError("DependencyGraph") << "You have requested an instance of the DependencyGraph Service in the \""
                                     << context.processName()
                                     << "\" SubProcess, which is not supported.\nPlease move it to the main process.";
    return;
  }

  if (not context.isSubProcess()) {
    // set the graph name property to the process name
    boost::get_property(m_graph, boost::graph_name) = context.processName();
    boost::get_property(m_graph, boost::graph_graph_attribute)["label"] = "process " + context.processName();
    boost::get_property(m_graph, boost::graph_graph_attribute)["labelloc"] = "top";

    // create graph vertices associated to all modules in the process
    auto size = pathsAndConsumes.largestModuleID() - boost::num_vertices(m_graph) + 1;
    for (size_t i = 0; i < size; ++i)
      boost::add_vertex(m_graph);

    m_initialized = true;
  } else {
    // create a subgraph to match the subprocess
    auto &graph = m_graph.create_subgraph();

    // set the subgraph name property to the subprocess name
    boost::get_property(graph, boost::graph_name) = "cluster" + context.processName();
    boost::get_property(graph, boost::graph_graph_attribute)["label"] = "subprocess " + context.processName();
    boost::get_property(graph, boost::graph_graph_attribute)["labelloc"] = "top";

    // create graph vertices associated to all modules in the subprocess
    auto size = pathsAndConsumes.largestModuleID() - boost::num_vertices(m_graph) + 1;
    for (size_t i = 0; i < size; ++i)
      boost::add_vertex(graph);
  }

  // set the vertices properties (use the module id as the global index into the graph)
  for (edm::ModuleDescription const *module : pathsAndConsumes.allModules()) {
    m_graph.m_graph[module->id()] = {
        module->moduleLabel(), module->moduleName(), module->id(), edmModuleTypeEnum(*module), false};

    auto &attributes = boost::get(boost::get(boost::vertex_attribute, m_graph), module->id());
    attributes["label"] = module->moduleLabel();
    attributes["tooltip"] = module->moduleName();
    attributes["shape"] = shapes[static_cast<std::underlying_type_t<EDMModuleType>>(edmModuleTypeEnum(*module))];
    attributes["style"] = "filled";
    attributes["color"] = "black";
    attributes["fillcolor"] = highlighted(module->moduleLabel()) ? "green" : "lightgrey";
  }

  // paths and endpaths
  auto const &paths = pathsAndConsumes.paths();
  auto const &endps = pathsAndConsumes.endPaths();

  // add graph edges associated to module dependencies
  for (edm::ModuleDescription const *consumer : pathsAndConsumes.allModules()) {
    for (edm::ModuleDescription const *module : pathsAndConsumes.modulesWhoseProductsAreConsumedBy(consumer->id())) {
      edm::LogInfo("DependencyGraph") << "module " << consumer->moduleLabel() << " depends on module "
                                      << module->moduleLabel();
      auto edge_status = boost::add_edge(consumer->id(), module->id(), m_graph);
      // highlight the edge between highlighted nodes
      if (highlighted(module->moduleLabel()) and highlighted(consumer->moduleLabel())) {
        auto const &edge = edge_status.first;
        auto &attributes = boost::get(boost::get(boost::edge_attribute, m_graph), edge);
        attributes["color"] = "darkgreen";
      }
    }
  }

  // save each Path and EndPath as a Graphviz subgraph
  for (unsigned int i = 0; i < paths.size(); ++i) {
    // create a subgraph to match the Path
    auto &graph = m_graph.create_subgraph();

    // set the subgraph name property to the Path name
    boost::get_property(graph, boost::graph_name) = paths[i];
    boost::get_property(graph, boost::graph_graph_attribute)["label"] = "Path " + paths[i];
    boost::get_property(graph, boost::graph_graph_attribute)["labelloc"] = "bottom";

    // add to the subgraph the node corresponding to the scheduled modules on the Path
    for (edm::ModuleDescription const *module : pathsAndConsumes.modulesOnPath(i)) {
      boost::add_vertex(module->id(), graph);
    }
  }
  for (unsigned int i = 0; i < endps.size(); ++i) {
    // create a subgraph to match the EndPath
    auto &graph = m_graph.create_subgraph();

    // set the subgraph name property to the EndPath name
    boost::get_property(graph, boost::graph_name) = endps[i];
    boost::get_property(graph, boost::graph_graph_attribute)["label"] = "EndPath " + endps[i];
    boost::get_property(graph, boost::graph_graph_attribute)["labelloc"] = "bottom";

    // add to the subgraph the node corresponding to the scheduled modules on the EndPath
    for (edm::ModuleDescription const *module : pathsAndConsumes.modulesOnEndPath(i)) {
      boost::add_vertex(module->id(), graph);
    }
  }

  // optionally, add a dependency of the TriggerResults module on the PathStatusInserter modules
  const int size = boost::num_vertices(m_graph);
  int triggerResults = -1;
  bool highlightTriggerResults = false;
  for (int i = 0; i < size; ++i) {
    if (m_graph.m_graph[i].label == "TriggerResults") {
      triggerResults = i;
      highlightTriggerResults = highlighted("TriggerResults");
      break;
    }
  }

  // mark the modules in the paths as scheduled, and add a soft dependency to reflect the order of modules along each path
  edm::ModuleDescription const *previous;
  for (unsigned int i = 0; i < paths.size(); ++i) {
    previous = nullptr;
    for (edm::ModuleDescription const *module : pathsAndConsumes.modulesOnPath(i)) {
      m_graph.m_graph[module->id()].scheduled = true;
      auto &attributes = boost::get(boost::get(boost::vertex_attribute, m_graph), module->id());
      attributes["fillcolor"] = highlighted(module->moduleLabel()) ? "lightgreen" : "white";
      if (previous and m_showPathDependencies) {
        edm::LogInfo("DependencyGraph") << "module " << module->moduleLabel() << " follows module "
                                        << previous->moduleLabel() << " in Path " << paths[i];
        auto edge_status = boost::lookup_edge(module->id(), previous->id(), m_graph);
        bool found = edge_status.second;
        if (not found) {
          edge_status = boost::add_edge(module->id(), previous->id(), m_graph);
          auto const &edge = edge_status.first;
          auto &edgeAttributes = boost::get(boost::get(boost::edge_attribute, m_graph), edge);
          edgeAttributes["style"] = "dashed";
          // highlight the edge between highlighted nodes
          if (highlighted(module->moduleLabel()) and highlighted(previous->moduleLabel()))
            edgeAttributes["color"] = "darkgreen";
        }
      }
      previous = module;
    }
    // previous points to the last scheduled module on the path
    if (previous and m_showPathDependencies) {
      // look for the PathStatusInserter module corresponding to this path
      for (int j = 0; j < size; ++j) {
        if (m_graph.m_graph[j].label == paths[i]) {
          edm::LogInfo("DependencyGraph") << "module " << paths[i] << " implicitly follows module "
                                          << previous->moduleLabel() << " in Path " << paths[i];
          // add an edge from the PathStatusInserter module to the last module scheduled on the path
          auto edge_status = boost::add_edge(j, previous->id(), m_graph);
          auto const &edge = edge_status.first;
          auto &edgeAttributes = boost::get(boost::get(boost::edge_attribute, m_graph), edge);
          edgeAttributes["style"] = "dashed";
          // highlight the edge between highlighted nodes
          bool highlightedPath = highlighted(paths[i]);
          if (highlightedPath and highlighted(previous->moduleLabel()))
            edgeAttributes["color"] = "darkgreen";
          if (triggerResults > 0) {
            // add an edge from the TriggerResults module to the PathStatusInserter module
            auto edge_status = boost::add_edge(triggerResults, j, m_graph);
            auto const &edge = edge_status.first;
            auto &edgeAttributes = boost::get(boost::get(boost::edge_attribute, m_graph), edge);
            edgeAttributes["style"] = "dashed";
            // highlight the edge between highlighted nodes
            if (highlightedPath and highlightTriggerResults)
              edgeAttributes["color"] = "darkgreen";
          }
          break;
        }
      }
    }
  }

  // mark the modules in the endpaths as scheduled, and add a soft dependency to reflect the order of modules along each endpath
  for (unsigned int i = 0; i < endps.size(); ++i) {
    previous = nullptr;
    for (edm::ModuleDescription const *module : pathsAndConsumes.modulesOnEndPath(i)) {
      m_graph.m_graph[module->id()].scheduled = true;
      auto &attributes = boost::get(boost::get(boost::vertex_attribute, m_graph), module->id());
      attributes["fillcolor"] = highlighted(module->moduleLabel()) ? "lightgreen" : "white";
      if (previous and m_showPathDependencies) {
        edm::LogInfo("DependencyGraph") << "module " << module->moduleLabel() << " follows module "
                                        << previous->moduleLabel() << " in EndPath " << i;
        auto edge_status = boost::lookup_edge(module->id(), previous->id(), m_graph);
        bool found = edge_status.second;
        if (not found) {
          edge_status = boost::add_edge(module->id(), previous->id(), m_graph);
          auto const &edge = edge_status.first;
          auto &edgeAttributes = boost::get(boost::get(boost::edge_attribute, m_graph), edge);
          edgeAttributes["style"] = "dashed";
          // highlight the edge between highlighted nodes
          if (highlighted(module->moduleLabel()) and highlighted(previous->moduleLabel()))
            edgeAttributes["color"] = "darkgreen";
        }
      }
      previous = module;
    }
  }
}

preSourceConstruction()

void DependencyGraph::preSourceConstruction

(

ModuleDescription const &

module

)

Definition at line 194 of file DependencyGraph.cc.

References get, highlighted(), m_graph, shapes, and Source.

Referenced by DependencyGraph().

                                                                           {
  // create graph vertex for the source module and fill its attributes
  boost::add_vertex(m_graph);
  m_graph.m_graph[module.id()] =
      node{module.moduleLabel(), module.moduleName(), module.id(), EDMModuleType::Source, true};
  auto &attributes = boost::get(boost::get(boost::vertex_attribute, m_graph), 0);
  attributes["label"] = module.moduleLabel();
  attributes["tooltip"] = module.moduleName();
  attributes["shape"] = shapes[static_cast<std::underlying_type_t<EDMModuleType>>(EDMModuleType::Source)];
  attributes["style"] = "filled";
  attributes["color"] = "black";
  attributes["fillcolor"] = highlighted(module.moduleLabel()) ? "lightgreen" : "white";
}

Member Data Documentation

m_filename

std::string DependencyGraph::m_filename

private

Definition at line 124 of file DependencyGraph.cc.

Referenced by postBeginJob().

m_graph

GraphType DependencyGraph::m_graph

private

Definition at line 122 of file DependencyGraph.cc.

Referenced by postBeginJob(), preBeginJob(), and preSourceConstruction().

m_highlightModules

std::unordered_set<std::string> DependencyGraph::m_highlightModules

private

Definition at line 125 of file DependencyGraph.cc.

m_initialized

bool DependencyGraph::m_initialized

private

Definition at line 128 of file DependencyGraph.cc.

Referenced by postBeginJob(), and preBeginJob().

m_showPathDependencies

bool DependencyGraph::m_showPathDependencies

private

Definition at line 127 of file DependencyGraph.cc.

Referenced by preBeginJob().

module_type_desc

constexpr const char * DependencyGraph::module_type_desc

staticprivate

Initial value:

{
      "Unknown", "Source", "ESSource", "ESProducer", "EDAnalyzer", "EDProducer", "EDFilter", "OutputModule"}

Definition at line 70 of file DependencyGraph.cc.

shapes

constexpr const char * DependencyGraph::shapes

staticprivate

Initial value:

{
      "note",      
      "oval",      
      "cylinder",  
      "cylinder",  
      "oval",      
      "box",       
      "diamond",   
      "oval",      
  }

Definition at line 73 of file DependencyGraph.cc.

Referenced by preBeginJob(), and preSourceConstruction().