rrr Namespace Reference

Namespaces
namespace	NewBdd

Classes
struct	Action
class	Analyzer
class	AndNetwork
class	BddAnalyzer
class	BddMspfAnalyzer
struct	is_invokable
class	LevelBasePartitioner
struct	NS
class	Optimizer
struct	Parameter
class	Partitioner
class	SatSolver
class	Scheduler
class	Simulator
struct	SW

Typedefs
using	seconds = int64_t
using	clock_type = std::chrono::steady_clock
using	time_point = std::chrono::time_point<clock_type>
template<typename T>
using	summary = std::vector<std::pair<std::string, T>>

Enumerations
enum	NodeType {   PI , PO , AND , XOR ,   LUT }
enum	SatResult { SAT , UNSAT , UNDET }
enum	VarValue : char {   UNDEF , TRUE , FALSE , TEMP_TRUE ,   TEMP_FALSE }
enum	ActionType {   NONE , REMOVE_FANIN , REMOVE_UNUSED , REMOVE_BUFFER ,   REMOVE_CONST , ADD_FANIN , TRIVIAL_COLLAPSE , TRIVIAL_DECOMPOSE ,   SORT_FANINS , READ , SAVE , LOAD ,   POP_BACK , INSERT }

Functions
template<typename Ntk>
void	Perform (Ntk *pNtk, Parameter const *pPar)
template<typename Ntk>
void	GiaReader (Gia_Man_t *pGia, Ntk *pNtk)
template<typename Ntk>
Gia_Man_t *	CreateGia (Ntk *pNtk, bool fHash=true)
template<typename Ntk>
void	Abc9Execute (Ntk *pNtk, std::string Command)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const std::vector< T > &v)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const std::set< T > &s)
void	PrintComplementedEdges (std::function< void(std::function< void(int, bool)> const &)> const &ForEachEdge)
template<typename T>
void	PrintNext (std::ostream &os, T t)
template<typename T, typename... Args>
void	PrintNext (std::ostream &os, T t, Args... args)
bool	ForEachCombinationStopRec (std::vector< int > &v, int n, int k, std::function< bool(std::vector< int > const &)> const &func)

Typedef Documentation

clock_type

using rrr::clock_type = std::chrono::steady_clock

Definition at line 62 of file rrrTypes.h.

seconds

using rrr::seconds = int64_t

Definition at line 61 of file rrrTypes.h.

summary

template<typename T>

using rrr::summary = std::vector<std::pair<std::string, T>>

Definition at line 66 of file rrrTypes.h.

time_point

using rrr::time_point = std::chrono::time_point<clock_type>

Definition at line 63 of file rrrTypes.h.

Enumeration Type Documentation

ActionType

enum rrr::ActionType

Enumerator
NONE
REMOVE_FANIN
REMOVE_UNUSED
REMOVE_BUFFER
REMOVE_CONST
ADD_FANIN
TRIVIAL_COLLAPSE
TRIVIAL_DECOMPOSE
SORT_FANINS
READ
SAVE
LOAD
POP_BACK
INSERT

Definition at line 32 of file rrrTypes.h.

                  {
    NONE,
    REMOVE_FANIN,
    REMOVE_UNUSED,
    REMOVE_BUFFER,
    REMOVE_CONST,
    ADD_FANIN,
    TRIVIAL_COLLAPSE,
    TRIVIAL_DECOMPOSE,
    SORT_FANINS,
    READ,
    SAVE,
    LOAD,
    POP_BACK,
    INSERT
  };

NodeType

enum rrr::NodeType

Enumerator
PI
PO
AND
XOR
LUT

Definition at line 10 of file rrrTypes.h.

                {
    PI,
    PO,
    AND,
    XOR,
    LUT
  };

SatResult

enum rrr::SatResult

Enumerator
SAT
UNSAT
UNDET

Definition at line 18 of file rrrTypes.h.

                 {
    SAT,
    UNSAT,
    UNDET
  };

VarValue

enum rrr::VarValue : char

Enumerator
UNDEF
TRUE
FALSE
TEMP_TRUE
TEMP_FALSE

Definition at line 24 of file rrrTypes.h.

               : char {
    UNDEF,
    TRUE,
    FALSE,
    TEMP_TRUE,
    TEMP_FALSE
  };

Function Documentation

Abc9Execute()

template<typename Ntk>

void rrr::Abc9Execute	(	Ntk *	pNtk,
		std::string	Command )

Definition at line 69 of file rrrAbc.h.

                                                 {
    Abc_Frame_t *pAbc = Abc_FrameGetGlobalFrame();
    Abc_FrameUpdateGia(pAbc, CreateGia(pNtk));
    if(Abc_FrameIsBatchMode()) {
      int r = Cmd_CommandExecute(pAbc, Command.c_str());
      assert(r == 0);
    } else {
      Abc_FrameSetBatchMode(1);
      int r = Cmd_CommandExecute(pAbc, Command.c_str());
      assert(r == 0);
      Abc_FrameSetBatchMode(0);
    }
    pNtk->Read(Abc_FrameReadGia(pAbc), GiaReader<Ntk>, false);
  }

Here is the call graph for this function:

CreateGia()

template<typename Ntk>

Gia_Man_t * rrr::CreateGia	(	Ntk *	pNtk,
		bool	fHash = true )

Definition at line 32 of file rrrAbc.h.

                                                     {
    Gia_Man_t *pGia = Gia_ManStart(pNtk->GetNumNodes());
    if(fHash) {
      Gia_ManHashStart(pGia);
    }
    std::vector<int> v(pNtk->GetNumNodes());
    v[0] = Gia_ManConst0Lit();
    pNtk->ForEachPi([&](int id) {
      v[id] = Gia_ManAppendCi(pGia);
    });
    pNtk->ForEachInt([&](int id) {
      assert(pNtk->GetNodeType(id) == rrr::AND);
      int x = -1;
      pNtk->ForEachFanin(id, [&](int fi, bool c) {
        if(x == -1) {
          x = Abc_LitNotCond(v[fi], c);
        } else if(fHash) {
          x = Gia_ManHashAnd(pGia, x, Abc_LitNotCond(v[fi], c));
        } else {
          x = Gia_ManAppendAnd(pGia, x, Abc_LitNotCond(v[fi], c));
        }
      });
      if(x == -1) {
        x = Abc_LitNot(v[0]);
      }
      v[id] = x;
    });
    pNtk->ForEachPoDriver([&](int fi, bool c) {
      Gia_ManAppendCo(pGia, Abc_LitNotCond(v[fi], c));
    });
    if(fHash) {
      Gia_ManHashStop(pGia);
    }
    return pGia;  
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ForEachCombinationStopRec()

bool rrr::ForEachCombinationStopRec	(	std::vector< int > &	v,
		int	n,
		int	k,
		std::function< bool(std::vector< int > const &)> const &	func )

Definition at line 240 of file rrrUtils.h.

                                                                                                                         {
    if(k == 0) {
      return func(v);
    }
    for(int i = v.back() + 1; i < n - k + 1; i++) {
      v.push_back(i);
      if(ForEachCombinationStopRec(v, n, k-1, func)) {
        return true;
      }
      v.pop_back();
    }
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GiaReader()

template<typename Ntk>

void rrr::GiaReader	(	Gia_Man_t *	pGia,
		Ntk *	pNtk )

Definition at line 14 of file rrrAbc.h.

                                             {
    int i;
    Gia_Obj_t *pObj;
    pNtk->Reserve(Gia_ManObjNum(pGia));
    Gia_ManConst0(pGia)->Value = pNtk->GetConst0();
    Gia_ManForEachObj1(pGia, pObj, i) {
      if(Gia_ObjIsCi(pObj)) {
        pObj->Value = pNtk->AddPi();
      } else if(Gia_ObjIsCo(pObj)) {
        pNtk->AddPo(Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj));
      } else {
        // TODO: support XOR (and BUF and MUX?), maybe create another function
        pObj->Value = pNtk->AddAnd(Gia_ObjFanin0(pObj)->Value, Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC0(pObj), Gia_ObjFaninC1(pObj));
      }
    }
  }

Here is the caller graph for this function:

operator<<() [1/2]

template<typename T>

std::ostream & rrr::operator<<	(	std::ostream &	os,
		const std::set< T > &	s )

Definition at line 74 of file rrrUtils.h.

                                                             {
    std::string delim;
    os << "{";
    for(T const &e: s) {
      os << delim << e;
      delim = ", ";
    }
    os << "}";
    return os;
  }

operator<<() [2/2]

template<typename T>

std::ostream & rrr::operator<<	(	std::ostream &	os,
		const std::vector< T > &	v )

Definition at line 62 of file rrrUtils.h.

                                                                {
    std::string delim;
    os << "[";
    for(T const &e: v) {
      os << delim << e;
      delim = ", ";
    }
    os << "]";
    return os;
  }

Perform()

template<typename Ntk>

void rrr::Perform	(	Ntk *	pNtk,
		Parameter const *	pPar )

Definition at line 19 of file rrr.h.

                                                 {
    assert(!pPar->fUseBddCspf || !pPar->fUseBddMspf);
    switch(pPar->nPartitionType) {
    case 0:
      if(pPar->fUseBddCspf) {
        Scheduler<Ntk, Optimizer<Ntk, BddAnalyzer<Ntk>>, Partitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      } else if(pPar->fUseBddMspf) {
        Scheduler<Ntk, Optimizer<Ntk, BddMspfAnalyzer<Ntk>>, Partitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      } else {
        Scheduler<Ntk, Optimizer<Ntk, Analyzer<Ntk, Simulator<Ntk>, SatSolver<Ntk>>>, Partitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      }
      break;
    case 1:
      if(pPar->fUseBddCspf) {
        Scheduler<Ntk, Optimizer<Ntk, BddAnalyzer<Ntk>>, LevelBasePartitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      } else if(pPar->fUseBddMspf) {
        Scheduler<Ntk, Optimizer<Ntk, BddMspfAnalyzer<Ntk>>, LevelBasePartitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      } else {
        Scheduler<Ntk, Optimizer<Ntk, Analyzer<Ntk, Simulator<Ntk>, SatSolver<Ntk>>>, LevelBasePartitioner<Ntk>> sch(pNtk, pPar);
        sch.Run();
      }
      break;
    default:
      assert(0);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

PrintComplementedEdges()

void rrr::PrintComplementedEdges

(

std::function< void(std::function< void(int, bool)> const &)> const &

ForEachEdge

)

Definition at line 85 of file rrrUtils.h.

                                                                                                          {
    std::string delim;
    std::cout << "[";
    ForEachEdge([&] (int id, bool c) {
      std::cout << delim << (c? "!": "") << id;
      delim = ", ";
    });
    std::cout << "]";
  }

Here is the caller graph for this function:

PrintNext() [1/2]

template<typename T>

void rrr::PrintNext	(	std::ostream &	os,
		T	t )

Definition at line 218 of file rrrUtils.h.

                                      {
    os << t;
  }

Here is the caller graph for this function:

PrintNext() [2/2]

template<typename T, typename... Args>

void rrr::PrintNext	(	std::ostream &	os,
		T	t,
		Args...	args )

Definition at line 223 of file rrrUtils.h.

                                                    {
    os << t << " ";
    PrintNext(os, args...);
  }  

Here is the call graph for this function: