opselector Namespace Reference

Data Structures
class	OpSelector

Enumerations
enum class	SelectType { ID , NAME }

Functions
bool	exportModule (luci::Module *module, std::string &output_path)
template<>
std::vector< const luci::CircleNode * >	OpSelector::select_by< SelectType::ID > (const std::vector< std::string > &comma_tokens)
template<>
std::vector< const luci::CircleNode * >	OpSelector::select_by< SelectType::NAME > (const std::vector< std::string > &tokens)
template std::unique_ptr< luci::Module >	OpSelector::select_by< SelectType::ID > (const std::string &str)
template std::unique_ptr< luci::Module >	OpSelector::select_by< SelectType::NAME > (const std::string &str)

Enumeration Type Documentation

SelectType

enum class opselector::SelectType

strong

Enumerator
ID
NAME

Definition at line 25 of file SelectType.h.

{
  ID,
  NAME,
};

Function Documentation

exportModule()

bool opselector::exportModule	(	luci::Module *	module,
		std::string &	output_path
	)

Definition at line 29 of file ModuleIO.cpp.

{
  luci::CircleExporter exporter;
 
  luci::CircleFileExpContract contract(module, output_path);
 
  if (!exporter.invoke(&contract))
  {
    std::cerr << "ERROR: Failed to export '" << output_path << "'" << std::endl;
    return false;
  }
 
  return true;
}

References luci::CircleExporter::invoke().

Referenced by entry().

OpSelector::select_by< SelectType::ID >() [1/2]

template std::unique_ptr< luci::Module > opselector::OpSelector::select_by< SelectType::ID >

(

const std::string &

str

)

OpSelector::select_by< SelectType::ID >() [2/2]

template<>

std::vector< const luci::CircleNode * > opselector::OpSelector::select_by< SelectType::ID >

(

const std::vector< std::string > &

comma_tokens

)

Definition at line 265 of file OpSelector.cpp.

{
  std::vector<uint32_t> by_id;
 
  for (const auto &comma_token : comma_tokens)
  {
    auto dash_tokens = ::split_into_vector(comma_token, '-');
    if (not ::is_number(dash_tokens))
    {
      throw std::runtime_error{
        "ERROR: To select operator by id, please use these args: [0-9], '-', ','"};
    }
 
    // Convert string into integer
    std::vector<uint32_t> int_tokens;
    try
    {
      std::transform(dash_tokens.begin(), dash_tokens.end(), std::back_inserter(int_tokens),
                     [](const std::string &str) { return static_cast<uint32_t>(std::stoi(str)); });
    }
    catch (const std::out_of_range &)
    {
      // Uf input is big integer like '123467891234', stoi throws this exception.
      throw std::runtime_error{"ERROR: Argument is out of range."};
    }
    catch (...)
    {
      throw std::runtime_error{"ERROR: Unknown error"};
    }
 
    switch (int_tokens.size())
    {
      case 0: // inputs like "-"
      {
        throw std::runtime_error{"ERROR: Nothing was entered"};
      }
      case 1: // inputs like "1", "2"
      {
        by_id.push_back(int_tokens.at(0));
        break;
      }
      case 2: // inputs like "1-2", "11-50"
      {
        for (uint32_t i = int_tokens.at(0); i <= int_tokens.at(1); i++)
        {
          by_id.push_back(i);
        }
        break;
      }
      default: // inputs like "1-2-3"
      {
        throw std::runtime_error{"ERROR: Too many '-' in str."};
      }
    }
  }
 
  loco::Graph *graph = _module->graph(0);
  std::vector<const luci::CircleNode *> selected_nodes;
 
  for (auto node : loco::all_nodes(graph))
  {
    auto cnode = loco::must_cast<const luci::CircleNode *>(node);
 
    try
    {
      auto node_id = luci::get_node_id(cnode);
      for (auto selected_id : by_id)
      {
        if (selected_id == node_id)
        {
          selected_nodes.emplace_back(cnode);
        }
      }
    }
    catch (const std::runtime_error &)
    {
      continue;
    }
  }
 
  return selected_nodes;
}

OpSelector::select_by< SelectType::NAME >() [1/2]

template std::unique_ptr< luci::Module > opselector::OpSelector::select_by< SelectType::NAME >

(

const std::string &

str

)

OpSelector::select_by< SelectType::NAME >() [2/2]

template<>

std::vector< const luci::CircleNode * > opselector::OpSelector::select_by< SelectType::NAME >

(

const std::vector< std::string > &

tokens

)

Definition at line 265 of file OpSelector.cpp.

{
  loco::Graph *graph = _module->graph(0);
  std::vector<const luci::CircleNode *> selected_nodes;
 
  for (auto node : loco::all_nodes(graph))
  {
    auto cnode = loco::must_cast<const luci::CircleNode *>(node);
    std::string node_name = cnode->name();
 
    for (const auto &selected_name : tokens)
      if (selected_name.compare(node_name) == 0) // find the selected name
        selected_nodes.emplace_back(cnode);
  }
 
  return selected_nodes;
}