rrr::Optimizer< Ntk, Ana > Class Template Reference

#include <rrrOptimizer.h>

Classes
struct	Stats

Public Member Functions
	Optimizer (Parameter const *pPar, std::function< double(Ntk *)> CostFunction)
void	AssignNetwork (Ntk *pNtk_, bool fReuse=false)
void	SetPrintLine (std::function< void(std::string)> const &PrintLine_)
void	Run (int iSeed=0, seconds nTimeout_=0)
void	ResetSummary ()
summary< int >	GetStatsSummary () const
summary< double >	GetTimesSummary () const

Detailed Description

template<typename Ntk, typename Ana>
class rrr::Optimizer< Ntk, Ana >

Definition at line 17 of file rrrOptimizer.h.

Constructor & Destructor Documentation

Optimizer()

template<typename Ntk, typename Ana>

rrr::Optimizer< Ntk, Ana >::Optimizer	(	Parameter const *	pPar,
		std::function< double(Ntk *)>	CostFunction )

Definition at line 1277 of file rrrOptimizer.h.

                                                                                               :
    pNtk(NULL),
    nVerbose(pPar->nOptimizerVerbose),
    CostFunction(CostFunction),
    nSortTypeOriginal(pPar->nSortType),
    nSortType(pPar->nSortType),
    nFlow(pPar->nOptimizerFlow),
    nDistance(pPar->nDistance),
    fCompatible(pPar->fUseBddCspf),
    fGreedy(pPar->fGreedy),
    ana(pPar),
    target(-1) {
  }

Member Function Documentation

AssignNetwork()

template<typename Ntk, typename Ana>

void rrr::Optimizer< Ntk, Ana >::AssignNetwork	(	Ntk *	pNtk_,
		bool	fReuse = false )

Definition at line 1292 of file rrrOptimizer.h.

                                                                 {
    pNtk = pNtk_;
    target = -1;
    pNtk->AddCallback(std::bind(&Optimizer<Ntk, Ana>::ActionCallback, this, std::placeholders::_1));
    ana.AssignNetwork(pNtk, fReuse);
  }

GetStatsSummary()

template<typename Ntk, typename Ana>

summary< int > rrr::Optimizer< Ntk, Ana >::GetStatsSummary

(

)

const

Definition at line 1441 of file rrrOptimizer.h.

                                                          {
    summary<int> v;
    for(auto const &entry: stats) {
      v.emplace_back("opt " + entry.first + " tried node", entry.second.nTried);
      v.emplace_back("opt " + entry.first + " tried fanin", entry.second.nTriedFis);
      v.emplace_back("opt " + entry.first + " added node", entry.second.nAdded);
      v.emplace_back("opt " + entry.first + " added fanin", entry.second.nAddedFis);
      v.emplace_back("opt " + entry.first + " changed", entry.second.nChanged);
      v.emplace_back("opt " + entry.first + " up", entry.second.nUps);
      v.emplace_back("opt " + entry.first + " eq", entry.second.nEqs);
      v.emplace_back("opt " + entry.first + " dn", entry.second.nDowns);
    }
    summary<int> v2 = ana.GetStatsSummary();
    v.insert(v.end(), v2.begin(), v2.end());
    return v;
  }

GetTimesSummary()

template<typename Ntk, typename Ana>

summary< double > rrr::Optimizer< Ntk, Ana >::GetTimesSummary

(

)

const

Definition at line 1459 of file rrrOptimizer.h.

                                                             {
    summary<double> v;
    for(auto const &entry: stats) {
      v.emplace_back("opt " + entry.first + " add", entry.second.durationAdd);
      v.emplace_back("opt " + entry.first + " reduce", entry.second.durationReduce);
    }
    summary<double> v2 = ana.GetTimesSummary();
    v.insert(v.end(), v2.begin(), v2.end());
    return v;
  }

ResetSummary()

template<typename Ntk, typename Ana>

void rrr::Optimizer< Ntk, Ana >::ResetSummary

(

)

Definition at line 1435 of file rrrOptimizer.h.

                                         {
    stats.clear();
    ana.ResetSummary();
  }

Run()

template<typename Ntk, typename Ana>

void rrr::Optimizer< Ntk, Ana >::Run	(	int	iSeed = 0,
		seconds	nTimeout_ = 0 )

Definition at line 1309 of file rrrOptimizer.h.

                                                            {
    rng.seed(iSeed);
    vRandPiOrder.clear();
    vRandCosts.clear();
    if(nSortTypeOriginal < 0) {
      nSortType = rng() % 18;
      Print(0, "fanin cost function =", nSortType);
    }
    nTimeout = nTimeout_;
    start = GetCurrentTime();
    switch(nFlow) {
    case 0:
      RemoveRedundancy();
      statsLocal.Reset();
      ApplyReverseTopologically([&](int id) {
        std::vector<int> vCands;
        if(nDistance) {
          vCands = pNtk->GetNeighbors(id, true, nDistance);
        } else {
          vCands = pNtk->GetPisInts();
        }
        SingleResub(id, vCands);
      });
      stats["single"] += statsLocal;
      Print(0, statsLocal.GetString());
      break;
    case 1:
      RemoveRedundancy();
      statsLocal.Reset();
      ApplyReverseTopologically([&](int id) {
        std::vector<int> vCands;
        if(nDistance) {
          vCands = pNtk->GetNeighbors(id, true, nDistance);
        } else {
          vCands = pNtk->GetPisInts();
        }
        MultiResub(id, vCands);
      });
      stats["multi"] += statsLocal;
      Print(0, statsLocal.GetString());
      break;
    case 2: {
      RemoveRedundancy();
      double dCost = CostFunction(pNtk);
      while(true) {
        statsLocal.Reset();
        ApplyReverseTopologically([&](int id) {
          std::vector<int> vCands;
          if(nDistance) {
            vCands = pNtk->GetNeighbors(id, true, nDistance);
          } else {
            vCands = pNtk->GetPisInts();
          }
          SingleResub(id, vCands);
        });
        stats["single"] += statsLocal;
        Print(0, "single", ":", "cost", "=", CostFunction(pNtk), ",", statsLocal.GetString());
        statsLocal.Reset();
        ApplyReverseTopologically([&](int id) {
          std::vector<int> vCands;
          if(nDistance) {
            vCands = pNtk->GetNeighbors(id, true, nDistance);
          } else {
            vCands = pNtk->GetPisInts();
            // vCands = pNtk->GetInts();
          }
          MultiResub(id, vCands);
        });
        stats["multi"] += statsLocal;
        Print(0, "multi ", ":", "cost", "=", CostFunction(pNtk), ",", statsLocal.GetString());
        double dNewCost = CostFunction(pNtk);
        if(dNewCost < dCost) {
          dCost = dNewCost;
        } else {
          break;
        }
      }
      break;
    }
    case 3: {
      RemoveRedundancy();
      std::vector<int> vCands;
      if(!nDistance) {
        vCands = pNtk->GetPisInts();
        std::shuffle(vCands.begin(), vCands.end(), rng);
      }
      Stats statsSingle, statsMulti;
      ApplyRandomlyStop([&](int id) {
        statsLocal.Reset();
        if(nDistance) {
          vCands = pNtk->GetNeighbors(id, true, nDistance);
          std::shuffle(vCands.begin(), vCands.end(), rng);
        }
        bool fChanged;
        if(rng() & 1) {
          fChanged = SingleResubStop(id, vCands);
          statsSingle += statsLocal;
        } else {
          fChanged = MultiResubStop(id, vCands);
          statsMulti += statsLocal;
        }
        return fChanged;
      });
      stats["single"] += statsSingle;
      stats["multi"] += statsMulti;
      Print(0, "single", ":", statsSingle.GetString());
      Print(0, "multi ", ":", statsMulti.GetString());
      break;
    }
    case 4: {
      RemoveRedundancy();
      ApplyCombinationSampledRandomlyStop(3, 100, [&](std::vector<int> const &vTargets) {
        return MultiTargetResub(vTargets);
      });
      break;
    }
    default:
      assert(0);
    }
  }

Here is the call graph for this function:

SetPrintLine()

template<typename Ntk, typename Ana>

void rrr::Optimizer< Ntk, Ana >::SetPrintLine

(

std::function< void(std::string)> const &

PrintLine_

)

Definition at line 1300 of file rrrOptimizer.h.

                                                                                       {
    PrintLine = PrintLine_;
  }

---

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

• src/opt/rrr/rrrOptimizer.h