mir Namespace Reference

Namespaces
namespace	ops

Data Structures
class	AffineQuantization
struct	AvgPool2DOpAttributes
struct	Conv2DOpAttributes
struct	Deconv2DOpAttributes
struct	DotEdge
class	DotGraph
struct	DotNode
class	DotNodeBuilder
class	ExternalRegion
class	Graph
class	GraphPatternMatcher
class	Index
class	IVisitor
	Interface for visitors Use in MIR component if you want to enforce to implement visits for all operations. More...
struct	MaxPool2DOpAttributes
class	Operation
struct	PadOpAttributes
struct	Region
class	Shape
class	ShapeIter
class	ShapeRange
class	Tensor
class	TensorType
class	TensorVariant
class	Visitor
	Base visitor with empty fallback function. More...

Enumerations
enum class	DataFormat { NCHW , NHWC }
enum class	DataType {   UNKNOWN , FLOAT32 , FLOAT64 , INT32 ,   INT64 , UINT8 }

Functions
constexpr std::size_t	wrap_index (std::int32_t index, std::size_t limit) noexcept
int	getDataBatchDimIndex (DataFormat data_format)
int	getDataChannelDimIndex (DataFormat data_format)
int	getDataSpatialDimIndex (DataFormat data_format, int dim)
std::string	toString (DataFormat data_format)
std::size_t	getDataTypeSize (DataType type)
std::vector< Operation * >	getSortedNodes (Graph *graph)
	Returns nodes of the graph sorted topologically.
std::ostream &	operator<< (std::ostream &s, const Index &idx)
void	dumpGraph (const Graph *graph, std::ostream &stream)
const std::string &	getTypeName (Operation::Type type)
Shape	broadcastShapes (const Shape &lhs_shape, const Shape &rhs_shape)
std::string	toString (const Shape &shape)
template<int32_t... Ints>
Shape	transposeShape (const Shape &shape)
template<unsigned int... Ints>
TensorVariant	transposeTensor (const TensorVariant &tensor)
std::ostream &	operator<< (std::ostream &stream, const DotGraph &graph)

Variables
constexpr std::size_t	MAX_DIMENSION_COUNT = 8
	maximum number of dimensions what an Index, Shape or Tensor can have

Enumeration Type Documentation

DataFormat

enum class mir::DataFormat

strong

Enumerator
NCHW
NHWC

Definition at line 26 of file DataFormat.h.

{
  NCHW,
  NHWC
};

DataType

enum class mir::DataType

strong

Enumerator
UNKNOWN
FLOAT32
FLOAT64
INT32
INT64
UINT8

Definition at line 26 of file DataType.h.

{
  UNKNOWN,
  FLOAT32,
  FLOAT64,
  INT32,
  INT64,
  UINT8
};

Function Documentation

broadcastShapes()

Shape mir::broadcastShapes	(	const Shape &	lhs_shape,
		const Shape &	rhs_shape
	)

Definition at line 43 of file Shape.cpp.

{
  const int num_dims = std::max(lhs_shape.rank(), rhs_shape.rank());
  Shape result_shape(num_dims);
 
  for (int i = 0; i < num_dims; ++i)
  {
    const std::int32_t lhs_dim =
      (i >= num_dims - lhs_shape.rank()) ? lhs_shape.dim(i - (num_dims - lhs_shape.rank())) : 1;
    const std::int32_t rhs_dim =
      (i >= num_dims - rhs_shape.rank()) ? rhs_shape.dim(i - (num_dims - rhs_shape.rank())) : 1;
    if (lhs_dim == 1)
    {
      result_shape.dim(i) = rhs_dim;
    }
    else
    {
      assert(rhs_dim == 1 || rhs_dim == lhs_dim);
      result_shape.dim(i) = lhs_dim;
    }
  }
 
  return result_shape;
}

References mir::Shape::dim(), and mir::Shape::rank().

Referenced by TEST().

dumpGraph()

void mir::dumpGraph	(	const Graph *	graph,
		std::ostream &	stream
	)

Definition at line 25 of file IrDotDumper.cpp.

{
  DotGraph dot_graph;
 
  for (const auto *node : graph->getNodes())
  {
    dot_graph.addNode(DotNodeBuilder(*node).getDotNode());
    for (const Operation::Output *input : node->getInputs())
    {
      dot_graph.addEdge({input->getNode()->getId(), node->getId()});
    }
  }
 
  stream << dot_graph;
}

References mir::DotGraph::addEdge(), mir::DotGraph::addNode(), and mir::DotNodeBuilder::getDotNode().

Referenced by main(), and nnc::DumperPass::run().

getDataBatchDimIndex()

int mir::getDataBatchDimIndex ( DataFormat  data_format )

inline

Definition at line 32 of file DataFormat.h.

{
  switch (data_format)
  {
    case DataFormat::NCHW:
    case DataFormat::NHWC:
      return 0;
    default:
      assert(false);
      return -1; // Dummy value to silence compiler warning.
  }
}

References NCHW, and NHWC.

getDataChannelDimIndex()

int mir::getDataChannelDimIndex ( DataFormat  data_format )

inline

Definition at line 45 of file DataFormat.h.

{
  switch (data_format)
  {
    case DataFormat::NCHW:
      return 1;
    case DataFormat::NHWC:
      return 3;
    default:
      assert(false);
      return -1; // Dummy value to silene compiler warning.
  }
}

References NCHW, and NHWC.

getDataSpatialDimIndex()

int mir::getDataSpatialDimIndex ( DataFormat  data_format, int  dim  )

inline

Definition at line 59 of file DataFormat.h.

{
  assert(dim >= 0 && dim <= 1);
  switch (data_format)
  {
    case DataFormat::NCHW:
      return 2 + dim;
    case DataFormat::NHWC:
      return 1 + dim;
    default:
      assert(false);
      return -1; // Dummy value to silence compiler warning.
  }
}

References NCHW, and NHWC.

getDataTypeSize()

std::size_t mir::getDataTypeSize ( DataType  type )

inline

Definition at line 36 of file DataType.h.

{
  switch (type)
  {
    case DataType::FLOAT32:
      return sizeof(float);
    case DataType::FLOAT64:
      return sizeof(double);
    case DataType::INT32:
      return sizeof(int32_t);
    case DataType::INT64:
      return sizeof(int64_t);
    case DataType::UINT8:
      return sizeof(uint8_t);
    default:
      assert(false);
      return 0;
  }
}

Referenced by mir::TensorVariant::TensorVariant().

getSortedNodes()

std::vector< Operation * > mir::getSortedNodes

(

Graph *

graph

)

Returns nodes of the graph sorted topologically.

Note

Sorting order priority 1) Graph input node (input index order) 2) Constant node (unordered - cannot predict order) 3) Ready node (unordered - cannot predict order)

Definition at line 42 of file Graph.cpp.

{
  std::deque<Operation *> ready_nodes;
  std::unordered_map<Operation *, std::size_t> num_visited_input_edges;
 
  // Use input vector first to maintain correct input order
  for (Operation *op : graph->getInputs())
  {
    ready_nodes.push_back(op);
  }
 
  for (Operation *op : graph->getNodes())
  {
    // Skip already pushed input node
    if ((op->getNumInputs() == 0) && (op->getType() != Operation::Type::input))
    {
      ready_nodes.push_back(op);
    }
  }
 
  std::vector<Operation *> sorted_nodes;
  while (!ready_nodes.empty())
  {
    Operation *src_node = ready_nodes.front();
    ready_nodes.pop_front();
    sorted_nodes.push_back(src_node);
    for (Operation::Output &output : src_node->getOutputs())
    {
      for (const auto use : output.getUses())
      {
        Operation *dst_node = use.getNode();
        if (++num_visited_input_edges[dst_node] == dst_node->getNumInputs())
        {
          ready_nodes.push_back(dst_node);
        }
      }
    }
  }
 
  return sorted_nodes;
}

References mir::Operation::getNumInputs(), and mir::Operation::getOutputs().

Referenced by mir::Graph::accept(), and nnc::DeadCodeElimination::run().

getTypeName()

const std::string & mir::getTypeName

(

Operation::Type

type

)

Returns

the opcode of operation in string format, like "Add", "Conv2d", etc.

Definition at line 71 of file Operation.cpp.

{
  switch (type)
  {
#define HANDLE_OP(OpType, OpClass)          \
  case Operation::Type::OpType:             \
  {                                         \
    static const std::string name(#OpType); \
    return name;                            \
  }
#include "mir/Operations.inc"
#undef HANDLE_OP
  }
  throw std::runtime_error("unexpected opcode");
}

Referenced by mir::DotNodeBuilder::DotNodeBuilder().

operator<<() [1/2]

std::ostream & mir::operator<<	(	std::ostream &	s,
		const Index &	idx
	)

Definition at line 36 of file Index.cpp.

{
  s << "[ ";
  for (int32_t i = 0; i < idx.rank(); ++i)
  {
    if (i != 0)
      s << ", ";
    s << idx.at(i);
  }
  s << "]";
 
  return s;
}

References mir::Index::at(), and mir::Index::rank().

operator<<() [2/2]

std::ostream & mir::operator<<	(	std::ostream &	stream,
		const DotGraph &	graph
	)

Definition at line 26 of file DotGraph.cpp.

{
  stream << "digraph D {" << std::endl;
  for (const auto &node : graph._nodes)
  {
    stream << node.id << " [shape=record label=\"" << node.label << "\"];" << std::endl;
  }
  for (const auto &edge : graph._edges)
  {
    stream << edge.src_id << " -> " << edge.dst_id << ";" << std::endl;
  }
  stream << "}" << std::endl;
  return stream;
}

toString() [1/2]

std::string mir::toString

(

const Shape &

shape

)

Definition at line 68 of file Shape.cpp.

{
  std::stringstream ss;
 
  ss << "[";
  for (int32_t axis = 0; axis < shape.rank(); ++axis)
  {
    if (axis != 0)
      ss << ", ";
    if (shape.dim(axis) == Shape::autoDim)
      ss << "AUTO";
    else
      ss << shape.dim(axis);
  }
  ss << "]";
 
  return ss.str();
}

References mir::Shape::dim(), and mir::Shape::rank().

toString() [2/2]

std::string mir::toString ( DataFormat  data_format )

inline

Definition at line 74 of file DataFormat.h.

{
  switch (data_format)
  {
    case DataFormat::NCHW:
      return "NCHW";
    case DataFormat::NHWC:
      return "NHWC";
    default:
      assert(false);
      return ""; // Dummy value to silence compiler warning.
  }
}

References NCHW, and NHWC.

Referenced by mir::DotNodeBuilder::DotNodeBuilder(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), mir::DotNodeBuilder::visit(), and mir::DotNodeBuilder::visit().

transposeShape()

template<int32_t... Ints>

Shape mir::transposeShape

(

const Shape &

shape

)

Definition at line 29 of file TensorUtil.h.

{
  assert(sizeof...(Ints) == shape.rank());
  return {shape.dim(Ints)...};
}

References mir::Shape::dim(), and mir::Shape::rank().

transposeTensor()

template<unsigned int... Ints>

TensorVariant mir::transposeTensor

(

const TensorVariant &

tensor

)

Definition at line 35 of file TensorUtil.h.

{
  const auto &shape = tensor.getShape();
  Shape transposed_shape{shape.dim(Ints)...};
 
  auto elem_type = tensor.getElementType();
  auto elem_size = tensor.getElementSize();
  TensorType transposed_type(elem_type, transposed_shape);
  if (tensor.getType().isQuantized())
    transposed_type.setQuantization(tensor.getType().getQuantization());
 
  TensorVariant transposed_tensor(transposed_type);
 
  for (const auto &index : ShapeRange(shape))
  {
    Index transposed_index{index.at(Ints)...};
    std::memcpy(transposed_tensor.at(transposed_index), tensor.at(index), elem_size);
  }
 
  return transposed_tensor;
}

References mir::TensorVariant::at(), mir::Shape::dim(), and mir::TensorType::setQuantization().

wrap_index()

constexpr std::size_t mir::wrap_index ( std::int32_t  index, std::size_t  limit  )

inlineconstexprnoexcept

Definition at line 30 of file Common.h.

{
  return static_cast<std::size_t>(index >= 0 ? index : limit + index);
}

Referenced by mir::Index::at(), mir::Index::at(), mir::Shape::dim(), and mir::Shape::dim().

Variable Documentation

MAX_DIMENSION_COUNT

constexpr std::size_t mir::MAX_DIMENSION_COUNT = 8

constexpr

maximum number of dimensions what an Index, Shape or Tensor can have

Definition at line 28 of file Common.h.