onert::ir::verifier::EdgeChecker Class Reference

#include <Verifier.h>

Collaboration diagram for onert::ir::verifier::EdgeChecker:

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 61 of file Verifier.h.

Member Function Documentation

verify() [1/2]

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

overridevirtualnoexcept

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

Definition at line 172 of file Verifier.cc.

{
  auto &operations = graph.operations();
  uint32_t errors = 0;
  operations.iterate([&](const OperationIndex &index, const IOperation &node) {
    for (auto &&operand_index : node.getInputs() | ir::Remove::UNDEFINED)
    {
      try
      {
        auto &operand = graph.operands().at(operand_index);
        bool operand_has_use = operand.getUses().contains(index);
        if (!operand_has_use)
        {
          VERBOSE(EdgeChecker) << "[ERROR] EDGE MISMATCH : Missing USE edge - Operand "
                               << operand_index << " to Operation " << index << std::endl;
          errors += 1;
        }
      }
      catch (const std::out_of_range &e)
      {
        VERBOSE(EdgeChecker) << "[ERROR] OPEARAND NOT FOUND : Operation " << index
                             << " has Operand " << operand_index
                             << ", but the operand object is not present in the graph" << std::endl;
        errors += 1;
      }
    }
    for (auto &&operand_index : node.getOutputs() | ir::Remove::UNDEFINED)
    {
      try
      {
        auto &operand = graph.operands().at(operand_index);
        if (operand.getDef() != index)
        {
          VERBOSE(EdgeChecker) << "[ERROR] EDGE MISMATCH : Missing DEF edge - Operand"
                               << operand_index << " to Operation " << index << std::endl;
          errors += 1;
        }
      }
      catch (const std::out_of_range &e)
      {
        VERBOSE(EdgeChecker) << "[ERROR] OPEARAND NOT FOUND : Operation " << index
                             << " has Operand " << operand_index
                             << ", but the operand object is not present in the graph" << std::endl;
        errors += 1;
      }
    }
  });
 
  VERBOSE(EdgeChecker) << "Total Number of errors : " << errors << std::endl;
 
  return errors == 0;
}

References onert::ir::IOperation::getInputs(), onert::ir::IOperation::getOutputs(), onert::ir::UNDEFINED, and VERBOSE.

verify() [2/2]

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

noexcept

Definition at line 240 of file Verifier.cc.

{
  const auto operations = extractOperations(training_usedefs);
  auto inputs_map = extractNodeInputs(training_usedefs);
  auto outputs_map = extractNodeOutputs(training_usedefs);
  uint32_t errors = 0;
  for (const auto &index : operations)
  {
    const auto &node_inputs = inputs_map[index];
    for (const auto &operand_index : node_inputs)
    {
      try
      {
        const auto &uses = training_usedefs.at(operand_index).getTrainingUses();
        bool operand_has_use = (uses.find(index) != uses.end());
        if (!operand_has_use)
        {
          VERBOSE(EdgeChecker) << "[ERROR] EDGE MISMATCH : Missing USE edge - Operand "
                               << operand_index << " to Operation " << index << std::endl;
          errors += 1;
        }
      }
      catch (const std::out_of_range &e)
      {
        VERBOSE(EdgeChecker) << "[ERROR] OPEARAND NOT FOUND : Operation " << index
                             << " has Operand " << operand_index
                             << ", but the operand object is not present in the graph" << std::endl;
        errors += 1;
      }
    }
 
    const auto &node_outputs = outputs_map[index];
    for (const auto &operand_index : node_outputs)
    {
      try
      {
        const auto &defs = training_usedefs.at(operand_index).getTrainingDefs();
        bool operand_has_def = (defs.find(index) != defs.end());
        if (!operand_has_def)
        {
          VERBOSE(EdgeChecker) << "[ERROR] EDGE MISMATCH : Missing DEF edge - Operand"
                               << operand_index << " to Operation " << index << std::endl;
          errors += 1;
        }
      }
      catch (const std::out_of_range &e)
      {
        VERBOSE(EdgeChecker) << "[ERROR] OPEARAND NOT FOUND : Operation " << index
                             << " has Operand " << operand_index
                             << ", but the operand object is not present in the graph" << std::endl;
        errors += 1;
      }
    }
  }
 
  VERBOSE(EdgeChecker) << "Total Number of errors : " << errors << std::endl;
 
  return errors == 0;
}

References VERBOSE.

---

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