onert::ir::verifier::DAGChecker Class Reference

#include <Verifier.h>

Collaboration diagram for onert::ir::verifier::DAGChecker:

Public Member Functions
bool	verify (const Graph &graph) const noexcept override
bool	verify (const train::UseDefChains &training_defuses) const noexcept
Public Member Functions inherited from onert::ir::verifier::IVerifier
virtual	~IVerifier ()=default

Detailed Description

Definition at line 41 of file Verifier.h.

Member Function Documentation

verify() [1/2]

bool onert::ir::verifier::DAGChecker::verify ( const Graph &  graph ) const

overridevirtualnoexcept

Implements onert::ir::verifier::IVerifier.

Definition at line 88 of file Verifier.cc.

{
  auto &operations = graph.operations();
  bool cyclic = false;
 
  OperationIndexMap<bool> visited;
  operations.iterate(
    [&](const OperationIndex &index, const IOperation &) { visited[index] = false; });
  OperationIndexMap<bool> on_stack = visited; // Copy from visited
 
  std::function<void(const OperationIndex &index, const IOperation &)> dfs_recursive =
    [&](const OperationIndex &index, const IOperation &node) -> void {
    if (on_stack[index])
      cyclic = true;
    if (visited[index])
      return;
    visited[index] = true;
    on_stack[index] = true;
 
    for (auto &&output : node.getOutputs() | Remove::DUPLICATED | Remove::UNDEFINED)
    {
      const auto &operand = graph.operands().at(output);
      for (const auto &use : operand.getUses())
      {
        dfs_recursive(use, graph.operations().at(use));
      }
    }
 
    on_stack[index] = false;
  };
 
  operations.iterate(dfs_recursive);
 
  return !cyclic;
}

References onert::ir::DUPLICATED, and onert::ir::UNDEFINED.

verify() [2/2]

bool onert::ir::verifier::DAGChecker::verify ( const train::UseDefChains &  training_defuses ) const

noexcept

Definition at line 125 of file Verifier.cc.

{
  bool cyclic = false;
  const auto operations = extractOperations(training_usedefs);
  auto outputs_map = extractNodeOutputs(training_usedefs);
 
  std::unordered_map<train::TrainingOperationIndex, bool> visited;
  for (const auto &node_index : operations)
    visited[node_index] = false;
  auto on_stack = visited; // Copy from visited
 
  std::function<void(const train::TrainingOperationIndex &index)> dfs_recursive =
    [&](const train::TrainingOperationIndex &index) -> void {
    if (on_stack[index])
      cyclic = true;
    if (visited[index])
      return;
    visited[index] = true;
    on_stack[index] = true;
 
    auto &node_outputs = outputs_map[index];
    for (const auto &output : node_outputs)
    {
      const auto &uses = training_usedefs.at(output).getTrainingUses();
      for (const auto &use : uses)
      {
        dfs_recursive(use);
      }
    }
 
    on_stack[index] = false;
  };
 
  for (const auto &node_index : operations)
    dfs_recursive(node_index);
 
  return !cyclic;
}

---

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

• runtime/onert/core/src/ir/verifier/Verifier.h
• runtime/onert/core/src/ir/verifier/Verifier.cc