exo::TensorBroadcastConverter Class Reference

Pass to resolve TensorBroadcast IR. More...

#include <TensorBroadcastConverter.h>

Collaboration diagram for exo::TensorBroadcastConverter:

Public Member Functions
virtual const char *	name (void) const
bool	run (loco::Graph *graph)
	Disconnects loco::TensorBroadcast from the graph if following node is one of binary node: TFLAdd, TFLSub, TFLMul, TFLDiv, TFLMaximum and meets condition (TBA)
Public Member Functions inherited from logo::Pass
virtual	~Pass ()=default

Detailed Description

Pass to resolve TensorBroadcast IR.

Definition at line 29 of file TensorBroadcastConverter.h.

Member Function Documentation

name()

virtual const char * exo::TensorBroadcastConverter::name ( void  ) const

inlinevirtual

Reimplemented from logo::Pass.

Definition at line 32 of file TensorBroadcastConverter.h.

{ return "exo::TensorBroadcastConverter"; }

run()

bool exo::TensorBroadcastConverter::run ( loco::Graph *  graph )

virtual

Disconnects loco::TensorBroadcast from the graph if following node is one of binary node: TFLAdd, TFLSub, TFLMul, TFLDiv, TFLMaximum and meets condition (TBA)

Note

Before: x — TensorBroadcast — TFLXXX — output y -------------------—/

After: — TensorBroadcast — x — TFLXXX — output y –/

Implements logo::Pass.

Definition at line 132 of file TensorBroadcastConverter.cpp.

{
  Collector collector;
 
  auto active_nodes = loco::active_nodes(loco::output_nodes(graph));
 
  for (auto node : active_nodes)
  {
    if (node->dialect() == locoex::TFLDialect::get())
    {
      auto tfl_node = loco::must_cast<locoex::TFLNode *>(node);
      tfl_node->accept(&collector);
    }
  }
 
  bool changed = false;
 
  for (auto pair : collector.candidates)
  {
    if (mapping_condition(pair))
    {
      loco::TensorBroadcast *tensorbroadcast = pair.first;
      if (auto tfladd = dynamic_cast<locoex::TFLAdd *>(pair.second))
      {
        jump_connection<locoex::TFLAdd>(tensorbroadcast, tfladd);
        changed = true;
      }
      else if (auto tfldiv = dynamic_cast<locoex::TFLDiv *>(pair.second))
      {
        jump_connection<locoex::TFLDiv>(tensorbroadcast, tfldiv);
        changed = true;
      }
      else if (auto tflmul = dynamic_cast<locoex::TFLMul *>(pair.second))
      {
        jump_connection<locoex::TFLMul>(tensorbroadcast, tflmul);
        changed = true;
      }
      else if (auto tflsub = dynamic_cast<locoex::TFLSub *>(pair.second))
      {
        jump_connection<locoex::TFLSub>(tensorbroadcast, tflsub);
        changed = true;
      }
      else if (auto tflmaximum = dynamic_cast<locoex::TFLMaximum *>(pair.second))
      {
        jump_connection<locoex::TFLMaximum>(tensorbroadcast, tflmaximum);
        changed = true;
      }
      else
      {
        assert(false);
      }
    }
  }
 
  return changed;
}

References loco::active_nodes(), locoex::TFLDialect::get(), and loco::output_nodes().

Referenced by package.infer.session::inference().

---

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

• compiler/exo/src/Conversion/TensorBroadcastConverter.h
• compiler/exo/src/Conversion/TensorBroadcastConverter.cpp