rrr::Scheduler< Ntk, Opt, Par >::CompareJobPointers Struct Reference

#include <rrrScheduler.h>

Public Member Functions
bool	operator() (Job const *lhs, Job const *rhs) const
	Scheduler (Ntk *pNtk, Parameter const *pPar)
	~Scheduler ()
void	Run ()

Detailed Description

template<typename Ntk, typename Opt, typename Par>
struct rrr::Scheduler< Ntk, Opt, Par >::CompareJobPointers

Definition at line 132 of file rrrScheduler.h.

Constructor & Destructor Documentation

~Scheduler()

rrr::Scheduler< Ntk, Opt, Par >::~Scheduler

(

)

Definition at line 99 of file rrrScheduler.h.

                                       {
#ifdef ABC_USE_PTHREADS
    if(fMultiThreading) {
      {
        std::unique_lock<std::mutex> l(mutexPendingJobs);
        fTerminate = true;
        condPendingJobs.notify_all();
      }
      for(std::thread &t: vThreads) {
        t.join();
      }
      return;
    }
#endif
    delete pOpt;
  }

Member Function Documentation

operator()()

template<typename Ntk, typename Opt, typename Par>

bool rrr::Scheduler< Ntk, Opt, Par >::CompareJobPointers::operator() ( Job const * lhs, Job const * rhs ) const

inline

Definition at line 134 of file rrrScheduler.h.

                                                          {
      return lhs->id > rhs->id;
    }

Run()

void rrr::Scheduler< Ntk, Opt, Par >::Run

(

)

Definition at line 102 of file rrrScheduler.h.

                                     {
    timeStart = GetCurrentTime();
    double costStart = CostFunction(pNtk);
    if(fPartitioning) {
      fDeterministic = false; // it is deterministic anyways as we wait until all jobs finish each round
      pNtk->Sweep();
      par.AssignNetwork(pNtk);
      while(nCreatedJobs < nJobs) {
        assert(nParallelPartitions > 0);
        if(nCreatedJobs < nFinishedJobs + nParallelPartitions) {
          Ntk *pSubNtk = par.Extract(iSeed + nCreatedJobs);
          if(pSubNtk) {
            Job *pJob = CreateJob(pSubNtk, iSeed + nCreatedJobs, CostFunction(pSubNtk));
            Print(1, pJob->prefix, "created ", ":", "i/o", "=", pJob->pNtk->GetNumPis(), "/", pJob->pNtk->GetNumPos(), ",", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", pJob->costInitial);
            continue;
          }
        }
        if(nCreatedJobs == nFinishedJobs) {
          PrintWarning("failed to partition");
          break;
        }
        while(nFinishedJobs < nCreatedJobs) {
          OnJobEnd([&](Job *pJob) {
            double cost = CostFunction(pJob->pNtk);
            Print(1, pJob->prefix, "finished", ":", "i/o", "=", pJob->pNtk->GetNumPis(), "/", pJob->pNtk->GetNumPos(), ",", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", cost);
            Print(0, "", "job", pJob->id, "(", nFinishedJobs + 1, "/", nJobs, ")", ":", "i/o", "=", pJob->pNtk->GetNumPis(), "/", pJob->pNtk->GetNumPos(), ",", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", cost, "(", 100 * (cost - pJob->costInitial) / pJob->costInitial, "%", ")", ",", "duration", "=", pJob->duration, "s", ",", "elapsed", "=", GetElapsedTime(), "s");
            par.Insert(pJob->pNtk);
          });
        }
        if(fOptOnInsert) {
          time_point timeStartLocal = GetCurrentTime();
          CallAbc(pNtk, std::string("&put; ") + pCompress2rs + "; dc2; &get");
          time_point timeEndLocal = GetCurrentTime();
          par.AssignNetwork(pNtk);
          double cost = CostFunction(pNtk);
          Print(0, "", "c2rs; dc2", ":", std::string(34, ' '), "node", "=", pNtk->GetNumInts(), ",", "level", "=", pNtk->GetNumLevels(), ",", "cost", "=", cost, "(", 100 * (cost - costStart) / costStart, "%", ")", ",", "duration", "=", Duration(timeStartLocal, timeEndLocal), "s", ",", "elapsed", "=", GetElapsedTime(), "s");
        }
      }
      while(nFinishedJobs < nCreatedJobs) {
        OnJobEnd([&](Job *pJob) {
          double cost = CostFunction(pJob->pNtk);
          Print(1, pJob->prefix, "finished", ":", "i/o", "=", pJob->pNtk->GetNumPis(), "/", pJob->pNtk->GetNumPos(), ",", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", CostFunction(pJob->pNtk));
          Print(0, "", "job", pJob->id, "(", nFinishedJobs + 1, "/", nJobs, ")", ":", "i/o", "=", pJob->pNtk->GetNumPis(), "/", pJob->pNtk->GetNumPos(), ",", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", cost, "(", 100 * (cost - pJob->costInitial) / pJob->costInitial, "%", ")", ",", "duration", "=", pJob->duration, "s", ",", "elapsed", "=", GetElapsedTime(), "s");
          par.Insert(pJob->pNtk);
        });
      }
      if(fOptOnInsert) {
        CallAbc(pNtk, std::string("&put; ") + pCompress2rs + "; dc2; &get");
        par.AssignNetwork(pNtk);
      }
    } else if(nJobs > 1) {
      double costBest = costStart;
      for(int i = 0; i < nJobs; i++) {
        Ntk *pCopy = new Ntk(*pNtk);
        CreateJob(pCopy, iSeed + i, costBest);
      }
      for(int i = 0; i < nJobs; i++) {
        OnJobEnd([&](Job *pJob) {
          double cost = CostFunction(pJob->pNtk);
          Print(0, "", "job", pJob->id, "(", nFinishedJobs + 1, "/", nJobs, ")", ":", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", cost, "(", 100 * (cost - pJob->costInitial) / pJob->costInitial, "%", ")", ",", "duration", "=", pJob->duration, "s", ",", "elapsed", "=", GetElapsedTime(), "s");
          if(cost < costBest) {
            costBest = cost;
            *pNtk = *(pJob->pNtk);
          }
          delete pJob->pNtk;
        });
      }
    } else {
      CreateJob(pNtk, iSeed, costStart);
      OnJobEnd([&](Job *pJob) {
        double cost = CostFunction(pJob->pNtk);
        Print(0, "", "job", pJob->id, "(", nFinishedJobs + 1, "/", nJobs, ")", ":", "node", "=", pJob->pNtk->GetNumInts(), ",", "level", "=", pJob->pNtk->GetNumLevels(), ",", "cost", "=", cost, "(", 100 * (cost - pJob->costInitial) / pJob->costInitial, "%", ")", ",", "duration", "=", pJob->duration, "s", ",", "elapsed", "=", GetElapsedTime(), "s");
      });
    }
    double cost = CostFunction(pNtk);
    double duration = GetElapsedTime();
    Print(0, "\n", "stats summary", ":");
    for(std::string key: vStatsSummaryKeys) {
      Print(0, "\t", SW{30, true}, key, ":", SW{10}, mStatsSummary[key]);
    }
    Print(0, "", "runtime summary", ":");
    for(std::string key: vTimesSummaryKeys) {
      Print(0, "\t", SW{30, true}, key, ":", mTimesSummary[key], "s", "(", 100 * mTimesSummary[key] / duration, "%", ")");
    }
    Print(0, "", "end", ":", "cost", "=", cost, "(", 100 * (cost - costStart) / costStart, "%", ")", ",", "time", "=", duration, "s");
  }

Scheduler()

rrr::Scheduler< Ntk, Opt, Par >::Scheduler	(	Ntk *	pNtk,
		Parameter const *	pPar )

Definition at line 98 of file rrrScheduler.h.

                                                                      :
    pNtk(pNtk),
    nVerbose(pPar->nSchedulerVerbose),
    iSeed(pPar->iSeed),
    nFlow(pPar->nSchedulerFlow),
    nJobs(pPar->nJobs),
    fMultiThreading(pPar->nThreads > 1),
    fPartitioning(pPar->nPartitionSize > 0),
    fDeterministic(pPar->fDeterministic),
    nParallelPartitions(pPar->nParallelPartitions),
    fOptOnInsert(pPar->fOptOnInsert),
    nTimeout(pPar->nTimeout),
    nCreatedJobs(0),
    nFinishedJobs(0),
    par(pPar),
    pOpt(NULL) {
    // prepare cost function
    CostFunction = [](Ntk *pNtk) {
      int nTwoInputSize = 0;
      pNtk->ForEachInt([&](int id) {
        nTwoInputSize += pNtk->GetNumFanins(id) - 1;
      });
      return nTwoInputSize;
    };
#ifdef ABC_USE_PTHREADS
    fTerminate = false;
    if(fMultiThreading) {
      vThreads.reserve(pPar->nThreads);
      for(int i = 0; i < pPar->nThreads; i++) {
        vThreads.emplace_back(std::bind(&Scheduler::Thread, this, pPar));
      }
      return;
    }
#endif
    assert(!fMultiThreading);
    pOpt = new Opt(pPar, CostFunction);
  }

---

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

• src/opt/rrr/rrrScheduler.h