Function dfs

src/graph/algorithms/TopologicalSort.cpp:127–186

}

std::vector<NodeID> dfs(Graph &g)
{
    std::vector<NodeID> dfs_order_vector;

    // Created visited vector
    std::vector<bool> visited(g.nodes().size(), false);

    // Create DFS stack
    std::stack<NodeID> stack;

    // Push inputs and mark as visited
    for (auto &input : g.nodes(NodeType::Input))
    {
        if (input != EmptyNodeID)
        {
            visited[input] = true;
            stack.push(input);
        }
    }

    // Push const nodes and mark as visited
    for (auto &const_node : g.nodes(NodeType::Const))
    {
        if (const_node != EmptyNodeID)
        {
            visited[const_node] = true;
            stack.push(const_node);
        }
    }

    // Iterate over vector and edges
    while (!stack.empty())
    {
        // Pop a node from stack and process
        NodeID n = stack.top();
        dfs_order_vector.push_back(n);
        stack.pop();

        // Mark node as visited
        if (!visited[n])
        {
            visited[n] = true;
        }

        const INode *node = g.node(n);
        ARM_COMPUTE_ERROR_ON(node == nullptr);
        // Reverse iterate to push branches from right to left and pop on the opposite order
        for (const auto &eid : arm_compute::utils::iterable::reverse_iterate(node->output_edges()))
        {
            const Edge *e = g.edge(eid);
            ARM_COMPUTE_ERROR_ON(e == nullptr);
            if (!visited[e->consumer_id()] && detail::all_inputs_are_visited(e->consumer(), visited))
            {
                stack.push(e->consumer_id());
            }
        }
    }