WireCell::Pgraph::Graph Class Reference

#include <Graph.h>

Public Member Functions
	Graph ()
void	add_node (Node *node)
bool	connect (Node *tail, Node *head, size_t tpind=0, size_t hpind=0)
std::vector< Node * >	sort_kahn ()
bool	execute ()
int	execute_upstream (Node *node)
bool	call_node (Node *node)
bool	connected ()

Private Attributes
std::vector< std::pair< Node *, Node * > >	m_edges
std::unordered_set< Node * >	m_nodes
std::unordered_map< Node *, std::vector< Node * > >	m_edges_forward
std::unordered_map< Node *, std::vector< Node * > >	m_edges_backward
Log::logptr_t	l

Detailed Description

Definition at line 35 of file Graph.h.

Constructor & Destructor Documentation

Graph::Graph

(

)

Definition at line 11 of file Graph.cxx.

    : l(Log::logger("pgraph"))
{
}

Member Function Documentation

void Graph::add_node

(

Node *

node

)

Definition at line 16 of file Graph.cxx.

{
    m_nodes.insert(node);
}

bool Graph::call_node

(

Node *

node

)

Definition at line 134 of file Graph.cxx.

{
    if (!node) {
        l->error("graph call: got nullptr node");
        return false;
    }
    bool ok = (*node)();
    // this can be very noisy but useful to uncomment to understand
    // the graph execution order.
    if (ok) {
        SPDLOG_LOGGER_TRACE(l, "graph call [{}] called: {}", ok, node->ident());
    }
    return ok;
}

bool Graph::connect	(	Node *	tail,
		Node *	head,
		size_t	tpind = 0,
		size_t	hpind = 0
	)

Definition at line 21 of file Graph.cxx.

{
    Port& tport = tail->output_ports()[tpind];
    Port& hport = head->input_ports()[hpind];
    if (tport.signature() != hport.signature()) {
        l->critical ("port signature mismatch: \"{}\" != \"{}\"",
                  tport.signature (), hport.signature());
        THROW(ValueError() << errmsg{"port signature mismatch"});
        return false;
    }

    m_edges.push_back(std::make_pair(tail,head));
    Edge edge = std::make_shared<Queue>();

    tport.plug(edge);
    hport.plug(edge);                

    add_node(tail);
    add_node(head);

    m_edges_forward[tail].push_back(head);
    m_edges_backward[head].push_back(tail);

    SPDLOG_LOGGER_TRACE(l, "connect {}:({}:{}) -> {}({}:{})",
             tail->ident(),
             demangle(tport.signature ()),
             tpind,
             head->ident(),
             demangle(hport.signature()),
             hpind);

    return true;
}

bool Graph::connected

(

)

Definition at line 149 of file Graph.cxx.

{
    for (auto n : m_nodes) {
        if (!n->connected()) {
            return false;
        }
    }
    return true;
}

bool Graph::execute

(

)

Definition at line 105 of file Graph.cxx.

{
    auto nodes = sort_kahn();
    l->debug("executing with {} nodes", nodes.size());

    while (true) {

        int count = 0;
        bool did_something = false;            

        for (auto nit = nodes.rbegin(); nit != nodes.rend(); ++nit, ++count) {
            Node* node = *nit;

            bool ok = call_node(node);
            if (ok) {
                SPDLOG_LOGGER_TRACE(l, "ran node {}: {}", count, node->ident());
                did_something = true;
                break;          // start again from bottom of graph
            }

        }

        if (!did_something) {
            return true;        // it's okay to do nothing.
        }
    }
    return true;    // shouldn't reach
}

int Graph::execute_upstream

(

Node *

node

)

Definition at line 88 of file Graph.cxx.

{
    int count = 0;
    for (auto parent : m_edges_backward[node]) {
        bool ok = call_node(parent);
        if (ok) {
            ++count;
            continue;
        }
        count += execute_upstream(parent);
    }
    bool ok = call_node(node);
    if (ok) { ++count; }
    return count;
}

std::vector< Node * > Graph::sort_kahn

(

)

Definition at line 55 of file Graph.cxx.

                                  {

    std::unordered_map<Node*, int> nincoming;
    for (auto th : m_edges) {

        nincoming[th.first] += 0; // make sure all nodes represented
        nincoming[th.second] += 1;
    }
                
    std::vector<Node*> ret;
    std::unordered_set<Node*> seeds;

    for (auto it : nincoming) {
        if (it.second == 0) {
            seeds.insert(it.first);
        }
    }

    while (!seeds.empty()) {
        Node* t = *seeds.begin();
        seeds.erase(t);
        ret.push_back(t);

        for (auto h : m_edges_forward[t]) {
            nincoming[h] -= 1;
            if (nincoming[h] == 0) {
                seeds.insert(h);
            }
        }
    }
    return ret;
}

Member Data Documentation

Log::logptr_t WireCell::Pgraph::Graph::l

private

Definition at line 70 of file Graph.h.

std::vector<std::pair<Node*,Node*> > WireCell::Pgraph::Graph::m_edges

private

Definition at line 66 of file Graph.h.

std::unordered_map< Node*, std::vector<Node*> > WireCell::Pgraph::Graph::m_edges_backward

private

Definition at line 68 of file Graph.h.

std::unordered_map< Node*, std::vector<Node*> > WireCell::Pgraph::Graph::m_edges_forward

private

Definition at line 68 of file Graph.h.

std::unordered_set<Node*> WireCell::Pgraph::Graph::m_nodes

private

Definition at line 67 of file Graph.h.

---

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

• wire-cell-build/pgraph/inc/WireCellPgraph/Graph.h
• wire-cell-build/pgraph/src/Graph.cxx