ProcessCallGraph Class Reference

#include <ProcessCallGraph.h>

Classes
struct	NodeType
struct	PathType
struct	ProcessType

Public Types
using	GraphType = boost::subgraph< boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, NodeType, boost::property< boost::edge_index_t, int >, boost::property< boost::graph_name_t, std::string > >>

Public Member Functions
std::pair< std::vector< unsigned int >, std::vector< unsigned int > >	dependencies (std::vector< unsigned int > const &path)
std::vector< unsigned int >	depends (unsigned int module) const
const edm::ModuleDescription &	module (unsigned int module) const
const NodeType &	operator[] (unsigned int module) const
void	preBeginJob (edm::PathsAndConsumesOfModulesBase const &, edm::ProcessContext const &)
void	preSourceConstruction (edm::ModuleDescription const &)
	ProcessCallGraph ()
const ProcessType &	processDescription (edm::ProcessContext const &) const
const ProcessType &	processDescription (std::string const &) const
const ProcessType &	processDescription (unsigned int) const
const std::vector< ProcessType > &	processes () const
unsigned int	processId (edm::ProcessContext const &) const
unsigned int	processId (std::string const &) const
unsigned int	size () const
const edm::ModuleDescription &	source () const

Private Member Functions
unsigned int	registerProcess (edm::ProcessContext const &)

Private Attributes
GraphType	graph_
std::vector< ProcessType >	process_description_
std::unordered_map< std::string, unsigned int >	process_id_
unsigned int	source_

Detailed Description

Definition at line 27 of file ProcessCallGraph.h.

Member Typedef Documentation

GraphType

using ProcessCallGraph::GraphType = boost::subgraph<boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, NodeType, boost::property<boost::edge_index_t, int>, boost::property<boost::graph_name_t, std::string> >>

Definition at line 47 of file ProcessCallGraph.h.

Constructor & Destructor Documentation

ProcessCallGraph()

ProcessCallGraph::ProcessCallGraph ( )

default

Member Function Documentation

dependencies()

std::pair< std::vector< unsigned int >, std::vector< unsigned int > > ProcessCallGraph::dependencies

(

std::vector< unsigned int > const &

path

)

Definition at line 184 of file ProcessCallGraph.cc.

                                         {
  std::vector<unsigned int> colors(boost::num_vertices(graph_));
  auto colormap = boost::make_container_vertex_map(colors);
 
  // first, find and count all the path's modules' dependencies
  boost::default_dfs_visitor visitor;
  for (unsigned int module : path)
    boost::depth_first_visit(graph_, module, visitor, colormap);
 
  unsigned int size = 0;
  for (unsigned int color : colors)
    if (color == 0)
      ++size;
 
  // allocate the output vectors
  std::vector<unsigned int> dependencies(size);
  dependencies.resize(0);
  std::vector<unsigned int> indices(path.size());
  indices.resize(0);
 
  // reset the color map
  for (unsigned int& color : colors)
    color = 0;
 
  // find again all the dependencies, and record those associated to each module
  struct record_vertices : boost::default_dfs_visitor {
    record_vertices(std::vector<unsigned int>& vertices) : vertices_(vertices) {}
 
    void discover_vertex(unsigned int vertex, GraphType const& graph) { vertices_.push_back(vertex); }
 
    std::vector<unsigned int>& vertices_;
  };
  record_vertices recorder(dependencies);
 
  for (unsigned int module : path) {
    // skip modules that have already been added as dependencies
    if (colors[module] != boost::black_color)
      boost::depth_first_visit(graph_, module, recorder, colormap);
    indices.push_back(dependencies.size());
  }
 
  return std::make_pair(dependencies, indices);
}

References colors, graph_, dqmdumpme::indices, module(), castor_dqm_sourceclient_file_cfg::path, size(), bphysicsOniaDQM_cfi::vertex, and AlignmentTracksFromVertexSelector_cfi::vertices.

Referenced by depends(), and preBeginJob().

depends()

std::vector< unsigned int > ProcessCallGraph::depends

(

unsigned int

module

)

const

Definition at line 155 of file ProcessCallGraph.cc.

                                                                           {
  std::vector<unsigned int> colors(boost::num_vertices(graph_));
  auto colormap = boost::make_container_vertex_map(colors);
 
  // depht-first visit all vertices starting from the given module
  boost::default_dfs_visitor visitor;
  boost::depth_first_visit(graph_, module, visitor, colormap);
 
  // count the visited vertices (the `black' ones) in order to properly size the
  // output vector; then fill the dependencies with the list of visited nodes
  unsigned int size = 0;
  for (unsigned int color : colors)
    if (boost::black_color == color)
      ++size;
  std::vector<unsigned int> dependencies(size);
  unsigned j = 0;
  for (unsigned int i = 0; i < colors.size(); ++i)
    if (boost::black_color == colors[i])
      dependencies[j++] = i;
  assert(size == j);
 
  return dependencies;
}

References cms::cuda::assert(), colors, dependencies(), graph_, mps_fire::i, dqmiolumiharvest::j, module(), and size().

module()

edm::ModuleDescription const & ProcessCallGraph::module

(

unsigned int

module

)

const

Definition at line 145 of file ProcessCallGraph.cc.

                                                                              {
  return graph_.m_graph[module].module_;
}

References graph_.

Referenced by FastTimerService::PlotsPerJob::book(), dependencies(), depends(), operator[](), preBeginJob(), and preSourceConstruction().

operator[]()

ProcessCallGraph::NodeType const & ProcessCallGraph::operator[]

(

unsigned int

module

)

const

Definition at line 150 of file ProcessCallGraph.cc.

                                                                                      {
  return graph_.m_graph[module];
}

References graph_, and module().

preBeginJob()

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

Definition at line 64 of file ProcessCallGraph.cc.

                                                                     {
  unsigned int pid = registerProcess(context);
 
  // work on the full graph (for the main process) or a subgraph (for a subprocess)
  GraphType& graph = context.isSubProcess() ? graph_.create_subgraph() : graph_.root();
 
  // set the graph name property to the process name
  boost::get_property(graph, boost::graph_name) = context.processName();
 
  // create graph vertices associated to all modules in the process
  unsigned int size = pathsAndConsumes.largestModuleID() - boost::num_vertices(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)
  std::vector<unsigned int> modules;
  modules.reserve(size);
  for (edm::ModuleDescription const* module : pathsAndConsumes.allModules()) {
    modules.push_back(module->id());
    graph_.m_graph[module->id()] = {*module, edmModuleTypeEnum(*module), false};
  }
 
  // add graph edges associated to module dependencies
  for (edm::ModuleDescription const* consumer : pathsAndConsumes.allModules()) {
    for (edm::ModuleDescription const* module : pathsAndConsumes.modulesWhoseProductsAreConsumedBy(consumer->id())) {
      // module `consumer' depends on module `module'
      boost::add_edge(consumer->id(), module->id(), graph_);
    }
  }
 
  // extract path names from the TriggerNamesService
  edm::service::TriggerNamesService const& tns = *edm::Service<edm::service::TriggerNamesService>();
 
  // extract the details of the paths and endpaths: name, modules on the path, and their dependencies
  size = pathsAndConsumes.paths().size();
  assert(tns.getTrigPaths().size() == size);
  std::vector<PathType> paths;
  paths.reserve(size);
  for (unsigned int i = 0; i < size; ++i) {
    std::vector<unsigned int> modules;
    for (edm::ModuleDescription const* module : pathsAndConsumes.modulesOnPath(i)) {
      modules.push_back(module->id());
      // mark the modules in the Paths as scheduled
      graph_.m_graph[module->id()].scheduled_ = true;
    }
    auto deps = dependencies(modules);
    paths.emplace_back(tns.getTrigPath(i), modules, deps.first, deps.second);
  }
  size = pathsAndConsumes.endPaths().size();
  std::vector<PathType> endPaths;
  endPaths.reserve(size);
  for (unsigned int i = 0; i < size; ++i) {
    std::vector<unsigned int> modules;
    for (edm::ModuleDescription const* module : pathsAndConsumes.modulesOnEndPath(i)) {
      modules.push_back(module->id());
      // mark the modules in the EndPaths as scheduled
      graph_.m_graph[module->id()].scheduled_ = true;
    }
    auto deps = dependencies(modules);
    endPaths.emplace_back(tns.getEndPath(i), modules, deps.first, deps.second);
  }
 
  // store the description of process, modules and paths
  process_description_.emplace_back(context.processName(), graph, modules, paths, endPaths);
  assert(process_description_.size() == pid + 1);
 
  // attach a subprocess to its parent
  if (context.isSubProcess()) {
    unsigned int parent_pid = processId(context.parentProcessContext());
    process_description_[parent_pid].subprocesses_.push_back(pid);
  }
}

References edm::PathsAndConsumesOfModulesBase::allModules(), cms::cuda::assert(), OfflineOutput_cfi::consumer, visDQMUpload::context, dependencies(), symbols::deps, edm::edmModuleTypeEnum(), edm::PathsAndConsumesOfModulesBase::endPaths(), edm::service::TriggerNamesService::getEndPath(), edm::service::TriggerNamesService::getTrigPath(), edm::service::TriggerNamesService::getTrigPaths(), graph_, mps_fire::i, edm::ModuleDescription::id(), edm::PathsAndConsumesOfModulesBase::largestModuleID(), module(), LogMessageMonitor_cff::modules, edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), edm::PathsAndConsumesOfModulesBase::modulesWhoseProductsAreConsumedBy(), Skims_PA_cff::paths, edm::PathsAndConsumesOfModulesBase::paths(), process_description_, processId(), registerProcess(), and size().

preSourceConstruction()

void ProcessCallGraph::preSourceConstruction

(

edm::ModuleDescription const &

module

)

Definition at line 51 of file ProcessCallGraph.cc.

                                                                               {
  // keep track of the Source module id
  source_ = module.id();
 
  // create graph vertex for the source module
  boost::add_vertex(graph_);
  graph_.m_graph[module.id()] = {module, edm::EDMModuleType::kSource, true};
}

References graph_, edm::ModuleDescription::id(), edm::kSource, module(), and source_.

processDescription() [1/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription

(

edm::ProcessContext const &

context

)

const

Definition at line 283 of file ProcessCallGraph.cc.

                                                                                                              {
  unsigned int pid = processId(context);
  return process_description_[pid];
}

References visDQMUpload::context, process_description_, and processId().

processDescription() [2/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription

(

std::string const &

processName

)

const

Definition at line 289 of file ProcessCallGraph.cc.

                                                                                                          {
  unsigned int pid = processId(processName);
  return process_description_[pid];
}

References process_description_, processId(), and SimL1EmulatorRepack_CalouGT_cff::processName.

processDescription() [3/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription

(

unsigned int

pid

)

const

Definition at line 278 of file ProcessCallGraph.cc.

                                                                                              {
  return process_description_.at(pid);
}

References process_description_.

Referenced by FastTimerService::PlotsPerJob::book(), and FastTimerService::PlotsPerJob::fill().

processes()

std::vector< ProcessCallGraph::ProcessType > const & ProcessCallGraph::processes

(

)

const

Definition at line 275 of file ProcessCallGraph.cc.

{ return process_description_; }

References process_description_.

Referenced by FastTimerService::PlotsPerJob::book(), FastTimerService::PlotsPerJob::PlotsPerJob(), and FastTimerService::ResourcesPerJob::ResourcesPerJob().

processId() [1/2]

unsigned int ProcessCallGraph::processId

(

edm::ProcessContext const &

context

)

const

Definition at line 255 of file ProcessCallGraph.cc.

                                                                               {
  auto id = process_id_.find(context.processName());
  if (id == process_id_.end())
    throw edm::Exception(edm::errors::LogicError)
        << "ProcessCallGraph::processId(): unexpected " << (context.isSubProcess() ? "subprocess" : "process") << " "
        << context.processName();
  return id->second;
}

References visDQMUpload::context, edm::errors::LogicError, and process_id_.

Referenced by preBeginJob(), and processDescription().

processId() [2/2]

unsigned int ProcessCallGraph::processId

(

std::string const &

processName

)

const

Definition at line 266 of file ProcessCallGraph.cc.

                                                                           {
  auto id = process_id_.find(processName);
  if (id == process_id_.end())
    throw edm::Exception(edm::errors::LogicError)
        << "ProcessCallGraph::processId(): unexpected (sub)process " << processName;
  return id->second;
}

References edm::errors::LogicError, process_id_, and SimL1EmulatorRepack_CalouGT_cff::processName.

registerProcess()

unsigned int ProcessCallGraph::registerProcess ( edm::ProcessContext const &  context )

private

Definition at line 231 of file ProcessCallGraph.cc.

                                                                               {
  static unsigned int s_id = 0;
 
  // registerProcess (called by preBeginJob) must be called for the parent process before its subprocess(es)
  if (context.isSubProcess() and process_id_.find(context.parentProcessContext().processName()) == process_id_.end()) {
    throw edm::Exception(edm::errors::LogicError)
        << "ProcessCallGraph::preBeginJob(): called for subprocess \"" << context.processName() << "\""
        << " before being called for its parent process \"" << context.parentProcessContext().processName() << "\"";
  }
 
  // registerProcess (called by preBeginJob) should be called once or each (sub)process
  auto id = process_id_.find(context.processName());
  if (id != process_id_.end()) {
    throw edm::Exception(edm::errors::LogicError)
        << "ProcessCallGraph::preBeginJob(): called twice for the same "
        << (context.isSubProcess() ? "subprocess" : "process") << " " << context.processName();
  }
 
  std::tie(id, std::ignore) = process_id_.insert(std::make_pair(context.processName(), s_id++));
  return id->second;
}

References visDQMUpload::context, Exception, SequenceTypes::ignore(), edm::errors::LogicError, process_id_, and s_id.

Referenced by preBeginJob().

size()

unsigned int ProcessCallGraph::size

(

void

)

const

Definition at line 139 of file ProcessCallGraph.cc.

{ return boost::num_vertices(graph_); }

References graph_.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), dependencies(), depends(), and preBeginJob().

source()

edm::ModuleDescription const & ProcessCallGraph::source

(

)

const

Definition at line 142 of file ProcessCallGraph.cc.

{ return graph_.m_graph[source_].module_; }

References graph_, and source_.

Referenced by FastTimerService::PlotsPerJob::book().

Member Data Documentation

graph_

GraphType ProcessCallGraph::graph_

private

Definition at line 172 of file ProcessCallGraph.h.

Referenced by dependencies(), depends(), module(), operator[](), preBeginJob(), preSourceConstruction(), size(), and source().

process_description_

std::vector<ProcessType> ProcessCallGraph::process_description_

private

Definition at line 181 of file ProcessCallGraph.h.

Referenced by preBeginJob(), processDescription(), and processes().

process_id_

std::unordered_map<std::string, unsigned int> ProcessCallGraph::process_id_

private

Definition at line 178 of file ProcessCallGraph.h.

Referenced by processId(), and registerProcess().

source_

unsigned int ProcessCallGraph::source_

private

Definition at line 175 of file ProcessCallGraph.h.

Referenced by Config.Process::dumpConfig(), Config.Process::dumpPython(), preSourceConstruction(), source(), and Config.Process::splitPython().