#include <PassTestGraphs.h>

Collaboration diagram for luci::ConstantFoldingTestGraph:

[legend]

Public Member Functions
	ConstantFoldingTestGraph (std::vector< uint32_t > input_shape, loco::DataType input_dtype)

virtual void	init ()=0

virtual	~ConstantFoldingTestGraph ()=default

virtual loco::Node *	createFoldedPattern ()=0

virtual luci::CircleConst *	getFoldedPattern ()=0

loco::Graph *	graph ()

Protected Attributes
loco::Graph	_g

luci::CircleInput *	_input = nullptr

luci::CircleOutput *	_output = nullptr

Detailed Description

ConstantFoldingTestGraph is a base class for testing constant folding passes. It creates Input and Output in the below graph. Child classes must implement Connector and Folded pattern.

[Input]   [Folded pattern] (Implemented by child class)
     \    /
   [Connector] (Implemented by child class)
        |
     [Output]

Connector should satisfy the below conditions

Input type == Output type == Folded pattern type
Input shape == Output shape == Folded pattern shape

For example, Add, Mul, Sub, .. can be a Connector

Definition at line 47 of file PassTestGraphs.h.

Constructor & Destructor Documentation

◆ ConstantFoldingTestGraph()

luci::ConstantFoldingTestGraph::ConstantFoldingTestGraph	(	std::vector< uint32_t >	input_shape,
		loco::DataType	input_dtype
	)

inline

Definition at line 50 of file PassTestGraphs.h.

  {
    _input = _g.nodes()->create<luci::CircleInput>();
    _output = _g.nodes()->create<luci::CircleOutput>();
 
    auto graph_input = _g.inputs()->create();
    _input->index(graph_input->index());
    auto graph_output = _g.outputs()->create();
    _output->index(graph_output->index());
 
    graph_input->dtype(input_dtype);
    graph_output->dtype(input_dtype);
    _input->dtype(input_dtype);
    _output->dtype(input_dtype);
 
    auto input_tensor_shape = std::make_unique<loco::TensorShape>();
    input_tensor_shape->rank(input_shape.size());
    for (int i = 0; i < input_shape.size(); i++)
      input_tensor_shape->dim(i).set(input_shape[i]);
    graph_input->shape(std::move(input_tensor_shape));
 
    auto output_tensor_shape = std::make_unique<loco::TensorShape>();
    output_tensor_shape->rank(input_shape.size());
    for (int i = 0; i < input_shape.size(); i++)
      output_tensor_shape->dim(i).set(input_shape[i]);
    graph_output->shape(std::move(output_tensor_shape));
 
    _input->rank(input_shape.size());
    for (int i = 0; i < input_shape.size(); i++)
      _input->dim(i).set(input_shape[i]);
 
    _output->rank(input_shape.size());
    for (int i = 0; i < input_shape.size(); i++)
      _output->dim(i).set(input_shape[i]);
 
    _input->name("input");
    _output->name("output");
  }