GlobalSim::GraphSvc Class Reference

The GraphSvc can be used to create an execution graph of the global simulation part of the job. More...

#include <GraphSvc.h>

Inheritance diagram for GlobalSim::GraphSvc:

Collaboration diagram for GlobalSim::GraphSvc:

Public Member Functions
virtual StatusCode	initialize () override
	Initialise.
virtual StatusCode	start () override
	Start - do graph calculation here, to ensure EventLoopMgr initialized already.
virtual StatusCode	finalize () override
	Finalise.

Private Attributes
StringProperty	m_fileName {this,"FileName","graph.dot","Output file"}
StringProperty	m_topSequence {this,"SequenceNameFilter","AthAlgSeq","Regex of sequence names to include"}
ServiceHandle< IAlgResourcePool >	m_algResourcePool

Detailed Description

The GraphSvc can be used to create an execution graph of the global simulation part of the job.

Definition at line 17 of file GraphSvc.h.

Member Function Documentation

finalize()

StatusCode GlobalSim::GraphSvc::finalize ( )

overridevirtual

Finalise.

Definition at line 178 of file GraphSvc.cxx.

                                  {
 
        ATH_MSG_INFO("To view graph run: dot -Teps " << m_fileName.value() << " -o graph.eps; gv graph.eps &");
 
        return StatusCode::SUCCESS;
 
    }

initialize()

StatusCode GlobalSim::GraphSvc::initialize ( )

overridevirtual

Initialise.

Definition at line 21 of file GraphSvc.cxx.

                                    {
        return StatusCode::SUCCESS;
    }

start()

StatusCode GlobalSim::GraphSvc::start ( )

overridevirtual

Start - do graph calculation here, to ensure EventLoopMgr initialized already.

Definition at line 25 of file GraphSvc.cxx.

                               {
 
        std::function<void(IAlgorithm*,std::set<IAlgorithm*>&,bool)> func;
 
        std::regex sequenceNameRegex( m_topSequence.value() );
 
        // locate the desired algs ...
        func = [&](IAlgorithm* alg, std::set<IAlgorithm*>& thealgs, bool isAdding) {
            isAdding = (isAdding || std::regex_search( std::string(alg->nameKey()) , sequenceNameRegex) ); // activate adding when get to target
            if(isAdding) {
                thealgs.insert(alg);
            }
            if(auto seq = dynamic_cast<Gaudi::Sequence*>( alg )) {
                auto subalgs = seq->subAlgorithms();
                for(auto thisAlg : *subalgs) {
                    func(thisAlg,thealgs,isAdding);
                }
            }
        };
 
        // Get the list of algorithms
        const std::list<IAlgorithm*>& algos      = m_algResourcePool->getTopAlgList();
        std::set<IAlgorithm*> subalgs;
        for ( IAlgorithm* ialgoPtr : algos ) {
            func(ialgoPtr,subalgs,false);
        }
 
 
        DataObjIDColl globalInp, globalOutp;
        std::map<std::string, DataObjIDColl> algosOutputDependenciesMap;
        std::map<std::string, DataObjIDColl> algosInputDependenciesMap;
 
        for ( IAlgorithm* ialgoPtr : subalgs ) {
            if(ialgoPtr->isSequence()) continue; // don't look at sequences, shouldn't have any inputs/outputs
 
            Gaudi::Algorithm* algoPtr = dynamic_cast<Gaudi::Algorithm*>( ialgoPtr );
            if ( !algoPtr ) continue;
            DataObjIDColl algoOutputs;
            for ( const auto & id : algoPtr->outputDataObjs() ) {
                globalOutp.insert( id );
                algoOutputs.insert( id );
            }
 
 
 
            DataObjIDColl i1, i2;
            DHHVisitor    avis( i1, i2 );
            algoPtr->acceptDHVisitor( &avis );
 
            DataObjIDColl algoDependencies;
            for ( const DataObjID& id : algoPtr->inputDataObjs() ) {
                algoDependencies.insert( id );
                globalInp.insert( id );
            }
 
            std::string algoName = ialgoPtr->nameKey();
            if(ialgoPtr->type()!= algoName) {
                algoName = ialgoPtr->type() + "/" + algoName;
            }
 
            algosInputDependenciesMap[algoName] = std::move(algoDependencies);
            algosOutputDependenciesMap[algoName] = std::move(algoOutputs);
 
        }
 
 
        ATH_MSG_INFO("Creating " << m_fileName.value());
        std::ofstream stream{ m_fileName, std::ofstream::out };
        stream << "digraph datadeps {\n  rankdir=\"LR\";\n"; // left-to-right graph
 
        auto addNode = [&](std::string_view id, std::string_view name, std::string_view shape="box", std::string_view textcol="" ) {
            stream << "  " << id << " [label=\"" << name << "\"";
            if(!textcol.empty()) stream << ", fontcolor=\"" << textcol << "\"";
            stream << ";shape=" << shape << "];\n"; // adds a node
        };
        auto addEdge = [&](std::string_view srcId, std::string_view tgtId, std::string_view label ) {
            stream << "  " << srcId << " -> " << tgtId << " [label=\"" << label << "\"];\n"; // adds an edge
        };
 
        // find all inputs that do not have an output. These will be our 'starting nodes' of shape='plaintext'
        std::map<std::string,std::pair<std::set<std::string>,std::set<std::string>>> deps;
 
        // key is dep name, value is pair of sets, first are "producers" of dep, second a "consumers" of dep
        // if has no producer, is a global input. if has no consumer, is a global output.
 
        std::map<std::string,std::string> inputTypes;
 
        for ( const auto& [algName, ideps] : algosInputDependenciesMap ) {
            for (const auto &dep: ideps) {
                deps[dep.key()].second.insert(algName); // alg is a consumer
                // store classes of inputs
                inputTypes[dep.key()] = dep.className();
            }
        }
        for ( const auto& [algName, odeps] : algosOutputDependenciesMap ) {
            for (const auto &dep: odeps) {
                deps[dep.key()].first.insert(algName); // alg is a producer
            }
        }
 
        std::size_t algoIndex = 0ul;
        std::map<std::string,std::string> keyToName;
        std::string inputs,outputs;
        // start by creating nodes of global inputs and outputs
        for( auto& [dep, pcs] : deps) {
            auto& [producers,consumers] = pcs;
            if(producers.empty()) {
                std::string algIndex = "Input_" + std::to_string( algoIndex );
                addNode( algIndex, inputTypes[dep]+"/"+dep.substr(dep.find("+")+1), "plaintext", (dep.find("ConditionStore")==0) ? "blue" : "" );
                keyToName[dep] = algIndex;
                algoIndex++;
                producers.insert(dep); // its a self-producer
                inputs += algIndex + "; ";
            } else if(consumers.empty()) {
                std::string algIndex = "Output_" + std::to_string( algoIndex );
                addNode( algIndex, dep.substr(dep.find("+")+1), "plaintext" );
                keyToName[dep] = algIndex;
                algoIndex++;
                consumers.insert(dep); // its a self-consumer
                outputs += algIndex + "; ";
            }
        }
        // create nodes of all algorithms
        for ( const auto& [algName, ideps] : algosInputDependenciesMap ) {
            std::string algIndex = "Alg_" + std::to_string( algoIndex );
            addNode( algIndex, algName, "box" );
            keyToName[algName] = std::move(algIndex);
            algoIndex++;
        }
        // now go through deps and create link from every producer to every consumer
        for( const auto& [dep, pcs] : deps) {
            auto& [producers,consumers] = pcs;
            for(auto& producer : producers) {
                for(auto& consumer: consumers) {
                    addEdge(keyToName.at(producer),keyToName.at(consumer),dep!=producer && dep!=consumer ? (inputTypes[dep]+"/"+dep.substr(dep.find("+")+1)) : " ");
                }
            }
        }
 
        if(!inputs.empty()) {
            stream << "   { rank = same; " << inputs << "}\n";
        }
        if(!outputs.empty()) {
            stream << "   { rank = same; " << outputs << "}\n";
        }
 
        stream << "}\n";
        stream.close();
 
        return StatusCode::SUCCESS;
 
    }

Member Data Documentation

m_algResourcePool

ServiceHandle<IAlgResourcePool> GlobalSim::GraphSvc::m_algResourcePool

private

Initial value:

{this,"AlgResourcePool","AlgResourcePool",
                                                          "Algorithm resource pool service."}

Definition at line 35 of file GraphSvc.h.

                                                         {this,"AlgResourcePool","AlgResourcePool",
                                                          "Algorithm resource pool service."};

m_fileName

StringProperty GlobalSim::GraphSvc::m_fileName {this,"FileName","graph.dot","Output file"}

private

Definition at line 32 of file GraphSvc.h.

{this,"FileName","graph.dot","Output file"};

m_topSequence

StringProperty GlobalSim::GraphSvc::m_topSequence {this,"SequenceNameFilter","AthAlgSeq","Regex of sequence names to include"}

private

Definition at line 33 of file GraphSvc.h.

{this,"SequenceNameFilter","AthAlgSeq","Regex of sequence names to include"};

---

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

• GraphSvc.h
• GraphSvc.cxx