mpqsolver::bisection Namespace Reference

Data Structures
class	BisectionSolver
class	VISQErrorApproximator

Typedefs
using	NodeDepthType = std::map< luci::CircleNode *, float >

Enumerations
enum class	ParameterizerResult : int32_t { SUCCESS = 0 , FAILURE = 1 }
	status of parameterization More...

Functions
ParameterizerResult	compute_depth (const luci::Module *module, NodeDepthType &nodes_depth, float &min_depth, float &max_depth)
	compute maximal distance from graph inputs to graph nodes along with min/max values of distance and return status of computation (Assumes graph has no cycles)

Typedef Documentation

NodeDepthType

using mpqsolver::bisection::NodeDepthType = typedef std::map<luci::CircleNode *, float>

Definition at line 28 of file DepthParameterizer.h.

Enumeration Type Documentation

ParameterizerResult

enum class mpqsolver::bisection::ParameterizerResult : int32_t

strong

status of parameterization

Enumerator
SUCCESS
FAILURE

Definition at line 33 of file DepthParameterizer.h.

{
  SUCCESS = 0,
  FAILURE = 1
};

Function Documentation

compute_depth()

ParameterizerResult mpqsolver::bisection::compute_depth	(	const luci::Module *	module,
		NodeDepthType &	nodes_depth,
		float &	min_depth,
		float &	max_depth
	)

compute maximal distance from graph inputs to graph nodes along with min/max values of distance and return status of computation (Assumes graph has no cycles)

compute maximal distance from graph inputs to graph nodes along with min/max values of distance and return status of compuation (success/failure)

Definition at line 28 of file DepthParameterizer.cpp.

{
  if (module == nullptr)
    return ParameterizerResult::FAILURE;
 
  if (module->size() != 1)
    return ParameterizerResult::FAILURE;
 
  auto graph = module->graph(0);
  if (!graph)
    return ParameterizerResult::FAILURE;
 
  // initializing
  std::vector<luci::CircleNode *> to_process;
  std::map<std::string, float> named_depth;
  {
    auto inputs = loco::input_nodes(graph);
    for (auto &node : inputs)
    {
      auto cnode = loco::must_cast<luci::CircleNode *>(node);
      to_process.emplace_back(cnode);
      nodes_depth[cnode] = 0.f;
      named_depth[cnode->name()] = 0.f;
    }
  }
 
  // enumerating
  while (!to_process.empty())
  {
    auto cur_node = to_process.back();
    to_process.pop_back();
    auto iter = nodes_depth.find(cur_node);
    if (iter == nodes_depth.end())
    {
      return ParameterizerResult::FAILURE; // unexpected
    }
    float cur_depth = iter->second + 1;
    // processing children
    auto children = loco::succs(cur_node);
    for (auto &child : children)
    {
      auto cichild = loco::must_cast<luci::CircleNode *>(child);
      auto node_depth = nodes_depth.find(cichild);
      if (node_depth == nodes_depth.end() || node_depth->second < cur_depth)
      {
        // initialize depth
        nodes_depth[cichild] = cur_depth;
        to_process.push_back(cichild);
        named_depth[cichild->name()] = cur_depth;
      }
    }
  }
 
  // compute min/max of depth parameter
  auto minmax = std::minmax_element(
    nodes_depth.begin(), nodes_depth.end(),
    [=](const std::pair<luci::CircleNode *, float> &el1,
        const std::pair<luci::CircleNode *, float> &el2) { return el1.second < el2.second; });
 
  min_depth = minmax.first->second;
  max_depth = minmax.second->second;
 
  return ParameterizerResult::SUCCESS;
}

References FAILURE, loco::input_nodes(), SUCCESS, and loco::succs().

Referenced by mpqsolver::bisection::BisectionSolver::run().