#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

edm::ModuleDescription const &	module (unsigned int module) const

NodeType const &	operator[] (unsigned int module) const

void	preBeginJob (edm::PathsAndConsumesOfModulesBase const &, edm::ProcessContext const &)

void	preSourceConstruction (edm::ModuleDescription const &)

	ProcessCallGraph ()=default

ProcessType const &	processDescription (unsigned int) const

ProcessType const &	processDescription (edm::ProcessContext const &) const

ProcessType const &	processDescription (std::string const &) const

std::vector< ProcessType > const &	processes () const

unsigned int	processId (edm::ProcessContext const &) const

unsigned int	processId (std::string const &) const

unsigned int	size () const

edm::ModuleDescription const &	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_ = edm::ModuleDescription::invalidID()

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 185 of file ProcessCallGraph.cc.

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

Referenced by depends(), and preBeginJob().

                                          {
   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);
 }

◆ depends()

std::vector< unsigned int > ProcessCallGraph::depends ( unsigned int module ) const

Definition at line 156 of file ProcessCallGraph.cc.

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

                                                                            {
   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;
 }

◆ module()

edm::ModuleDescription const & ProcessCallGraph::module ( unsigned int module ) const

Definition at line 146 of file ProcessCallGraph.cc.

References graph_.

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

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

◆ operator[]()

ProcessCallGraph::NodeType const & ProcessCallGraph::operator[] ( unsigned int module ) const

Definition at line 151 of file ProcessCallGraph.cc.

References graph_, and module().

                                                                                       {
   return graph_.m_graph[module];
 }

◆ preBeginJob()

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

Definition at line 62 of file ProcessCallGraph.cc.

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::invalidID(), 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(), size(), and source_.

Referenced by NVProfilerService::preBeginJob().

                                                                      {
   unsigned int pid = registerProcess(context);
 
   // check that the Source has already been added
   assert(source_ != edm::ModuleDescription::invalidID());
 
   // 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);
   }
 }

◆ preSourceConstruction()

void ProcessCallGraph::preSourceConstruction ( edm::ModuleDescription const & module )

Definition at line 47 of file ProcessCallGraph.cc.

References cms::cuda::assert(), graph_, edm::ModuleDescription::invalidID(), edm::kSource, module(), and source_.

Referenced by NVProfilerService::preSourceConstruction().

                                                                                {
   // check that the Source has not already been added
   assert(source_ == edm::ModuleDescription::invalidID());
 
   // 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};
 }

◆ processDescription() [1/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription ( unsigned int pid ) const

Definition at line 279 of file ProcessCallGraph.cc.

References process_description_.

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

                                                                                               {
   return process_description_.at(pid);
 }

◆ processDescription() [2/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription ( edm::ProcessContext const & context ) const

Definition at line 284 of file ProcessCallGraph.cc.

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

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

◆ processDescription() [3/3]

ProcessCallGraph::ProcessType const & ProcessCallGraph::processDescription ( std::string const & processName ) const

Definition at line 290 of file ProcessCallGraph.cc.

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

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

◆ processes()

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

Definition at line 276 of file ProcessCallGraph.cc.

References process_description_.

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

276 { return process_description_; }

ProcessCallGraph::process_description_

std::vector< ProcessType > process_description_

Definition: ProcessCallGraph.h:181

◆ processId() [1/2]

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

Definition at line 256 of file ProcessCallGraph.cc.

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

Referenced by preBeginJob(), and processDescription().

                                                                                {
   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;
 }

◆ processId() [2/2]

unsigned int ProcessCallGraph::processId ( std::string const & processName ) const

Definition at line 267 of file ProcessCallGraph.cc.

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

                                                                            {
   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;
 }

◆ registerProcess()

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

private

Definition at line 232 of file ProcessCallGraph.cc.

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

Referenced by preBeginJob().

                                                                                {
   // 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();
   }
 
   // this assumes that registerProcess (called by preBeginJob) is not called concurrently from different threads
   // otherwise, process_id_.size() should be replaces with an atomic counter
   std::tie(id, std::ignore) = process_id_.insert(std::make_pair(context.processName(), process_id_.size()));
   return id->second;
 }