rrr::LevelBasePartitioner< Ntk > Class Template Reference

#include <rrrLevelBasePartitioner.h>

Public Member Functions
	LevelBasePartitioner (Parameter const *pPar)
void	AssignNetwork (Ntk *pNtk)
Ntk *	Extract (int iSeed)
void	Insert (Ntk *pSubNtk)

Detailed Description

template<typename Ntk>
class rrr::LevelBasePartitioner< Ntk >

Definition at line 16 of file rrrLevelBasePartitioner.h.

Constructor & Destructor Documentation

LevelBasePartitioner()

template<typename Ntk>

rrr::LevelBasePartitioner< Ntk >::LevelBasePartitioner

(

Parameter const *

pPar

)

Definition at line 210 of file rrrLevelBasePartitioner.h.

                                                                       :
    nVerbose(pPar->nPartitionerVerbose),
    nPartitionSize(pPar->nPartitionSize),
    nPartitionSizeMin(pPar->nPartitionSizeMin) {
  }

Member Function Documentation

AssignNetwork()

template<typename Ntk>

void rrr::LevelBasePartitioner< Ntk >::AssignNetwork

(

Ntk *

pNtk

)

Definition at line 217 of file rrrLevelBasePartitioner.h.

                                                          {
    pNtk = pNtk_;
    assert(mSubNtk2Io.empty());
    assert(sBlocked.empty());
    vFailed.clear();
    vLevels.clear();
  }

Extract()

template<typename Ntk>

Ntk * rrr::LevelBasePartitioner< Ntk >::Extract

(

int

iSeed

)

Definition at line 230 of file rrrLevelBasePartitioner.h.

                                                   {
    // pick a center node from candidates that do not belong to any other ongoing partitions
    vFailed.resize(pNtk->GetNumNodes());
    if(vLevels.empty()) {
      ComputeLevel();
    }
    std::mt19937 rng(iSeed);
    std::vector<int> vInts = pNtk->GetInts();
    std::shuffle(vInts.begin(), vInts.end(), rng);
    for(int i = 0; i < int_size(vInts); i++) {
      int id = vInts[i];
      if(vFailed[id]) {
        continue;
      }
      if(!sBlocked.count(id)) {
        Print(0, "try partitioning with node", id, "(", i, "/", int_size(vInts), ")");
        Ntk *pSubNtk = ExtractIOI(id);
        if(pSubNtk) {
          return pSubNtk;
        }
      }
      vFailed[id] = true;
    }
    return NULL;
  }

Insert()

template<typename Ntk>

void rrr::LevelBasePartitioner< Ntk >::Insert

(

Ntk *

pSubNtk

)

Definition at line 257 of file rrrLevelBasePartitioner.h.

                                                     {
    for(int i: std::get<0>(mSubNtk2Io[pSubNtk])) {
      sBlocked.erase(i);
    }
    std::pair<std::vector<int>, std::vector<bool>> vNewSignals = pNtk->Insert(pSubNtk, std::get<1>(mSubNtk2Io[pSubNtk]), std::get<2>(mSubNtk2Io[pSubNtk]), std::get<3>(mSubNtk2Io[pSubNtk]));
    std::vector<int> &vOldOutputs = std::get<3>(mSubNtk2Io[pSubNtk]);
    std::vector<int> &vNewOutputs = vNewSignals.first;
    std::vector<bool> &vNewCompls = vNewSignals.second;
    // need to remap updated outputs that are used as inputs in other partitions
    std::map<int, int> mOutput2Idx;
    for(int idx = 0; idx < int_size(vOldOutputs); idx++) {
      mOutput2Idx[vOldOutputs[idx]] = idx;
    }
    for(auto &entry: mSubNtk2Io) {
      if(entry.first != pSubNtk) {
        std::vector<int> &vInputs = std::get<1>(entry.second);
        std::vector<bool> &vCompls = std::get<2>(entry.second);
        for(int i = 0; i < int_size(vInputs); i++) {
          if(mOutput2Idx.count(vInputs[i])) {
            int idx = mOutput2Idx[vInputs[i]];
            vInputs[i] = vNewOutputs[idx];
            vCompls[i] = vCompls[i] ^ vNewCompls[idx];
          }
        }
      }
    }
    delete pSubNtk;
    mSubNtk2Io.erase(pSubNtk);
    vFailed.clear(); // clear, there isn't really a way to track
    vLevels.clear();
  }

---

The documentation for this class was generated from the following file:

• src/opt/rrr/rrrLevelBasePartitioner.h