#include <PartitionIR.h>

Public Member Functions
std::unique_ptr< PGroups >	make_copy (void) const
	return a copy of PGroups

GroupKey	group_of (luci::CircleNode *node) const
	return group key of node, empty string if not found

const PGroup *	pgroup_of (luci::CircleNode *node) const
	return holding pgroup of node, nullptr if not found

Data Fields
std::vector< std::unique_ptr< PGroup > >	pgroups

std::map< const luci::CircleNode *, GroupKey >	node2group

std::map< uint32_t, PGroup * >	id2pgroup

GroupKey	default_group

Detailed Description

Definition at line 61 of file PartitionIR.h.

Member Function Documentation

◆ group_of()

GroupKey luci::PGroups::group_of ( luci::CircleNode * node ) const

return group key of node, empty string if not found

Definition at line 70 of file PartitionIR.cpp.

{
  assert(node != nullptr);
 
  LOGGER(l);
 
  auto it = node2group.find(node);
  if (it == node2group.end())
  {
    INFO(l) << "PGroups::group_of " << node << "(" << node->name() << ") not found" << std::endl;
    return "";
  }
  return it->second;
}

References INFO, LOGGER, luci::must_cast(), luci::CircleNode::name(), and node2group.

◆ make_copy()

std::unique_ptr< PGroups > luci::PGroups::make_copy ( void ) const

return a copy of PGroups

Definition at line 29 of file PartitionIR.cpp.

{
  auto d_pgroups = std::make_unique<luci::PGroups>();
 
  for (auto &s_pgroup : pgroups)
  {
    // make a copy of s_pgroup to d_pgroup
    std::unique_ptr<luci::PGroup> d_pgroup = std::make_unique<luci::PGroup>();
 
    d_pgroup->group = s_pgroup->group;
    d_pgroup->id = s_pgroup->id;
 
    for (auto &pnode : s_pgroup->pnodes)
    {
      auto pnodec = std::make_unique<luci::PNode>();
      pnodec->node = pnode->node;
      pnodec->group = pnode->group;
      pnodec->pgroup = d_pgroup.get();
      d_pgroup->pnodes.push_back(std::move(pnodec));
    }
 
    for (auto &input : s_pgroup->inputs)
      d_pgroup->inputs.push_back(input);
 
    for (auto &output : s_pgroup->outputs)
      d_pgroup->outputs.push_back(output);
 
    // copy node2group
    for (auto it = node2group.begin(); it != node2group.end(); ++it)
      d_pgroups->node2group[it->first] = it->second;
 
    // build id2pgroup
    d_pgroups->id2pgroup[d_pgroup->id] = d_pgroup.get();
 
    d_pgroups->pgroups.push_back(std::move(d_pgroup));
    // note: d_pgroup is now nullptr as it's moved
  }
 
  return d_pgroups;
}

References luci::must_cast(), node2group, and pgroups.

◆ pgroup_of()

const PGroup * luci::PGroups::pgroup_of ( luci::CircleNode * node ) const

return holding pgroup of node, nullptr if not found

Definition at line 85 of file PartitionIR.cpp.

{
  assert(node != nullptr);
 
  for (auto &pgroup : pgroups)
  {
    for (auto &pnode : pgroup->pnodes)
    {
      if (node == pnode->node)
        return pgroup.get();
    }
  }
  // node maybe graph input (CircleInput)
  return nullptr;
}