add abc as a submodule
parent
8766dc6ac8
commit
9635c0de3c
|
@ -4,3 +4,6 @@
|
|||
[submodule "lib/mockturtle"]
|
||||
path = lib/mockturtle
|
||||
url = https://github.com/lsils/mockturtle.git
|
||||
[submodule "lib/abc"]
|
||||
path = lib/abc
|
||||
url = https://github.com/berkeley-abc/abc.git
|
||||
|
|
|
@ -1,3 +1,8 @@
|
|||
# Add alice and mockturtle sub directories
|
||||
add_subdirectory(alice)
|
||||
add_subdirectory(mockturtle)
|
||||
|
||||
set(ABC_USE_NAMESPACE "pabc")
|
||||
|
||||
add_subdirectory(abc EXCLUDE_FROM_ALL)
|
||||
target_compile_definitions(libabc-pic PUBLIC "LIN64")
|
|
@ -0,0 +1 @@
|
|||
Subproject commit a5f4841486d4a491913943c5b92167a9e988abac
|
|
@ -5,4 +5,4 @@ file(GLOB_RECURSE FILENAMES *.cpp)
|
|||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
||||
|
||||
add_executable(phyLS phyLS.cpp ${FILENAMES})
|
||||
target_link_libraries(phyLS alice mockturtle)
|
||||
target_link_libraries(phyLS alice mockturtle libabc-pic)
|
||||
|
|
|
@ -0,0 +1,80 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file &fraig.hpp
|
||||
*
|
||||
* @brief performs combinational SAT sweeping
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/14
|
||||
*/
|
||||
|
||||
#ifndef AFRAIG_HPP
|
||||
#define AFRAIG_HPP
|
||||
|
||||
#include "aig/gia/gia.h"
|
||||
#include "proof/cec/cec.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class Afraig_command : public command {
|
||||
public:
|
||||
explicit Afraig_command(const environment::ptr &env)
|
||||
: command(env, "performs combinational SAT sweeping") {
|
||||
add_flag("--verbose, -v", "print the information");
|
||||
}
|
||||
|
||||
protected:
|
||||
void execute() {
|
||||
clock_t begin, end;
|
||||
double totalTime;
|
||||
|
||||
begin = clock();
|
||||
|
||||
if (store<pabc::Gia_Man_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty GIA network.\n";
|
||||
else {
|
||||
pabc::Gia_Man_t *pNtk, *pTemp;
|
||||
pNtk = store<pabc::Gia_Man_t *>().current();
|
||||
|
||||
pabc::Cec_ParFra_t ParsFra, *pPars = &ParsFra;
|
||||
// set defaults
|
||||
memset(pPars, 0, sizeof(pabc::Cec_ParFra_t));
|
||||
pPars->jType = 2; // solver type
|
||||
pPars->fSatSweeping = 1; // conflict limit at a node
|
||||
pPars->nWords = 4; // simulation words
|
||||
pPars->nRounds = 10; // simulation rounds
|
||||
pPars->nItersMax = 2000; // this is a miter
|
||||
pPars->nBTLimit = 1000000; // use logic cones
|
||||
pPars->nBTLimitPo = 0; // use logic outputs
|
||||
pPars->nSatVarMax =
|
||||
1000; // the max number of SAT variables before recycling SAT solver
|
||||
pPars->nCallsRecycle =
|
||||
500; // calls to perform before recycling SAT solver
|
||||
pPars->nGenIters = 100; // pattern generation iterations
|
||||
|
||||
pTemp = Cec_ManSatSweeping(pNtk, pPars, 0);
|
||||
|
||||
store<pabc::Gia_Man_t *>().extend();
|
||||
store<pabc::Gia_Man_t *>().current() = pTemp;
|
||||
}
|
||||
|
||||
end = clock();
|
||||
totalTime = (double)(end - begin) / CLOCKS_PER_SEC;
|
||||
|
||||
cout.setf(ios::fixed);
|
||||
cout << "[CPU time] " << setprecision(2) << totalTime << " s" << endl;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(Afraig, "Gia")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,70 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file get.hpp
|
||||
*
|
||||
* @brief converts the current network into GIA
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/14
|
||||
*/
|
||||
|
||||
#ifndef AGET_HPP
|
||||
#define AGET_HPP
|
||||
|
||||
#include "aig/gia/giaAig.h"
|
||||
#include "base/abc/abc.h"
|
||||
#include "base/abci/abcDar.c"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class Aget_command : public command {
|
||||
public:
|
||||
explicit Aget_command(const environment::ptr &env)
|
||||
: command(env, "converts the current network into GIA") {}
|
||||
|
||||
protected:
|
||||
void execute() {
|
||||
clock_t begin, end;
|
||||
double totalTime;
|
||||
|
||||
begin = clock();
|
||||
|
||||
if (store<pabc::Abc_Ntk_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty ABC AIG network\n";
|
||||
else {
|
||||
pabc::Abc_Ntk_t *pNtk = store<pabc::Abc_Ntk_t *>().current();
|
||||
|
||||
pabc::Aig_Man_t *pAig;
|
||||
pabc::Gia_Man_t *pGia;
|
||||
|
||||
if (pabc::Abc_NtkGetChoiceNum(pNtk))
|
||||
pAig = Abc_NtkToDarChoices(pNtk);
|
||||
else
|
||||
pAig = Abc_NtkToDar(pNtk, 0, 1);
|
||||
|
||||
pGia = Gia_ManFromAig(pAig);
|
||||
pabc::Aig_ManStop(pAig);
|
||||
store<pabc::Gia_Man_t *>().extend();
|
||||
store<pabc::Gia_Man_t *>().current() = pGia;
|
||||
}
|
||||
|
||||
end = clock();
|
||||
totalTime = (double)(end - begin) / CLOCKS_PER_SEC;
|
||||
|
||||
cout.setf(ios::fixed);
|
||||
cout << "[CPU time] " << setprecision(2) << totalTime << " s" << endl;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(Aget, "Gia")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,97 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file fraig.hpp
|
||||
*
|
||||
* @brief transforms a logic network into a functionally reduced AIG
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/14
|
||||
*/
|
||||
|
||||
#ifndef FRAIG_HPP
|
||||
#define FRAIG_HPP
|
||||
|
||||
#include "base/abc/abc.h"
|
||||
#include "proof/fraig/fraig.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class fraig_command : public command {
|
||||
public:
|
||||
explicit fraig_command(const environment::ptr &env)
|
||||
: command(env,
|
||||
"transforms a logic network into a functionally reduced AIG") {
|
||||
add_flag("--verbose, -v", "print the information");
|
||||
}
|
||||
|
||||
protected:
|
||||
void execute() {
|
||||
clock_t begin, end;
|
||||
double totalTime;
|
||||
|
||||
begin = clock();
|
||||
|
||||
if (store<pabc::Abc_Ntk_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty ABC AIG network.\n";
|
||||
else {
|
||||
pabc::Abc_Ntk_t *pNtk, *pNtkRes;
|
||||
pNtk = store<pabc::Abc_Ntk_t *>().current();
|
||||
if (!pabc::Abc_NtkIsLogic(pNtk) && !pabc::Abc_NtkIsStrash(pNtk))
|
||||
std::cerr << "Can only fraig a logic network or an AIG.\n";
|
||||
|
||||
pabc::Fraig_Params_t Params, *pParams = &Params;
|
||||
|
||||
// set defaults
|
||||
int fAllNodes = 0, fExdc = 0;
|
||||
|
||||
memset(pParams, 0, sizeof(pabc::Fraig_Params_t));
|
||||
pParams->nPatsRand =
|
||||
2048; // the number of words of random simulation info
|
||||
pParams->nPatsDyna =
|
||||
2048; // the number of words of dynamic simulation info
|
||||
pParams->nBTLimit = 100; // the max number of backtracks to perform
|
||||
pParams->fFuncRed = 1; // performs only one level hashing
|
||||
pParams->fFeedBack = 1; // enables solver feedback
|
||||
pParams->fDist1Pats = 1; // enables distance-1 patterns
|
||||
pParams->fDoSparse = 1; // performs equiv tests for sparse functions
|
||||
pParams->fChoicing = 0; // enables recording structural choices
|
||||
pParams->fTryProve = 0; // tries to solve the final miter
|
||||
pParams->fVerbose = 0; // the verbosiness flag
|
||||
pParams->fVerboseP = 0; // the verbosiness flag
|
||||
|
||||
if (is_set("verbose")) pParams->fVerbose ^= 1;
|
||||
|
||||
if (pabc::Abc_NtkIsStrash(pNtk))
|
||||
pNtkRes = pabc::Abc_NtkFraig(pNtk, &Params, fAllNodes, fExdc);
|
||||
else {
|
||||
pNtk = pabc::Abc_NtkStrash(pNtk, fAllNodes, !fAllNodes, 0);
|
||||
pNtkRes = pabc::Abc_NtkFraig(pNtk, &Params, fAllNodes, fExdc);
|
||||
pabc::Abc_NtkDelete(pNtk);
|
||||
}
|
||||
|
||||
if (pNtkRes == NULL) std::cerr << "Fraiging has failed.\n";
|
||||
|
||||
store<pabc::Abc_Ntk_t *>().extend();
|
||||
store<pabc::Abc_Ntk_t *>().current() = pNtkRes;
|
||||
}
|
||||
|
||||
end = clock();
|
||||
totalTime = (double)(end - begin) / CLOCKS_PER_SEC;
|
||||
|
||||
cout.setf(ios::fixed);
|
||||
cout << "[CPU time] " << setprecision(2) << totalTime << " s" << endl;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(fraig, "ABC")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,64 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file read.hpp
|
||||
*
|
||||
* @brief replaces the current network by the network read from file
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/14
|
||||
*/
|
||||
|
||||
#ifndef READ_HPP
|
||||
#define READ_HPP
|
||||
|
||||
#include "base/abc/abc.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class read_command : public command {
|
||||
public:
|
||||
explicit read_command(const environment::ptr &env)
|
||||
: command(env,
|
||||
"replaces the current network by the network read from file by "
|
||||
"ABC parser") {
|
||||
add_option("filename,-f", file_name, "name of input file");
|
||||
add_flag("--check, -c", "Disable network check after reading");
|
||||
add_flag("--buffer, -b", "Reading barrier buffers");
|
||||
}
|
||||
|
||||
protected:
|
||||
void execute() override {
|
||||
int fCheck = 1, fBarBufs = 0;
|
||||
if (is_set("check")) fCheck ^= 1;
|
||||
if (is_set("buffer")) fBarBufs ^= 1;
|
||||
|
||||
// fix the wrong symbol
|
||||
for (auto &x : file_name) {
|
||||
if (x == '>' || x == '\\') x = '/';
|
||||
}
|
||||
|
||||
assert(strlen((char *)(file_name.c_str())) < 900);
|
||||
|
||||
pabc::Abc_Ntk_t *pNtk = pabc::Io_Read(
|
||||
(char *)(file_name.c_str()),
|
||||
pabc::Io_ReadFileType((char *)(file_name.c_str())), fCheck, fBarBufs);
|
||||
|
||||
if (pNtk == NULL) std::cerr << "Error: Empty input format.\n";
|
||||
store<pabc::Abc_Ntk_t *>().extend();
|
||||
store<pabc::Abc_Ntk_t *>().current() = pNtk;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string file_name;
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(read, "I/O")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,67 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file resub.hpp
|
||||
*
|
||||
* @brief performs technology-independent restructuring of the AIG
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/02/28
|
||||
*/
|
||||
|
||||
#ifndef ABC_RESUB_HPP
|
||||
#define ABC_RESUB_HPP
|
||||
|
||||
#include "base/abci/abcRestruct.c"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class aresub_command : public command {
|
||||
public:
|
||||
explicit aresub_command(const environment::ptr &env)
|
||||
: command(env,
|
||||
"performs technology-independent restructuring of the AIG") {
|
||||
add_flag("--verbose, -v", "print the information");
|
||||
}
|
||||
|
||||
protected:
|
||||
void execute() {
|
||||
clock_t begin, end;
|
||||
double totalTime;
|
||||
|
||||
begin = clock();
|
||||
|
||||
if (store<pabc::Abc_Ntk_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty ABC AIG network\n";
|
||||
else {
|
||||
pabc::Abc_Ntk_t *pNtk = store<pabc::Abc_Ntk_t *>().current();
|
||||
|
||||
// set defaults
|
||||
int nCutsMax = 5, fUpdateLevel = 0, fUseZeros = 0, fVerbose = 0;
|
||||
|
||||
if (is_set("verbose")) fVerbose ^= 1;
|
||||
|
||||
Abc_NtkRestructure(pNtk, nCutsMax, fUpdateLevel, fUseZeros, fVerbose);
|
||||
store<pabc::Abc_Ntk_t *>().extend();
|
||||
store<pabc::Abc_Ntk_t *>().current() = pNtk;
|
||||
}
|
||||
|
||||
end = clock();
|
||||
totalTime = (double)(end - begin) / CLOCKS_PER_SEC;
|
||||
|
||||
cout.setf(ios::fixed);
|
||||
cout << "[CPU time] " << setprecision(2) << totalTime << " s" << endl;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(aresub, "ABC")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,66 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2022 */
|
||||
|
||||
/**
|
||||
* @file strash.hpp
|
||||
*
|
||||
* @brief transforms combinational logic into an AIG
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/01
|
||||
*/
|
||||
|
||||
#ifndef STRASH_HPP
|
||||
#define STRASH_HPP
|
||||
|
||||
#include "base/abc/abc.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class strash_command : public command {
|
||||
public:
|
||||
explicit strash_command(const environment::ptr &env)
|
||||
: command(env, "transforms combinational logic into an AIG") {}
|
||||
|
||||
protected:
|
||||
void execute() {
|
||||
clock_t begin, end;
|
||||
double totalTime;
|
||||
|
||||
begin = clock();
|
||||
|
||||
if (store<pabc::Abc_Ntk_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty ABC AIG network\n";
|
||||
else {
|
||||
pabc::Abc_Ntk_t *pNtk = store<pabc::Abc_Ntk_t *>().current();
|
||||
|
||||
// set defaults
|
||||
int fAllNodes = 0;
|
||||
int fRecord = 1;
|
||||
int fCleanup = 0;
|
||||
|
||||
pabc::Abc_Ntk_t *pNtkRes;
|
||||
|
||||
pNtkRes = Abc_NtkStrash(pNtk, fAllNodes, fCleanup, fRecord);
|
||||
store<pabc::Abc_Ntk_t *>().extend();
|
||||
store<pabc::Abc_Ntk_t *>().current() = pNtkRes;
|
||||
}
|
||||
|
||||
end = clock();
|
||||
totalTime = (double)(end - begin) / CLOCKS_PER_SEC;
|
||||
|
||||
cout.setf(ios::fixed);
|
||||
cout << "[CPU time] " << setprecision(2) << totalTime << " s" << endl;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(strash, "ABC")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,51 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2023 */
|
||||
|
||||
/**
|
||||
* @file write.hpp
|
||||
*
|
||||
* @brief writes the current network into file
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/03/14
|
||||
*/
|
||||
|
||||
#ifndef WRITE_HPP
|
||||
#define WRITE_HPP
|
||||
|
||||
#include "base/abc/abc.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
||||
class write_command : public command {
|
||||
public:
|
||||
explicit write_command(const environment::ptr &env)
|
||||
: command(env, "writes the current network into file by ABC parser") {
|
||||
add_option("filename,-f", file_name, "name of output file");
|
||||
}
|
||||
|
||||
protected:
|
||||
void execute() override {
|
||||
assert(strlen((char *)(file_name.c_str())) < 900);
|
||||
|
||||
if (store<pabc::Abc_Ntk_t *>().size() == 0u)
|
||||
std::cerr << "Error: Empty network.\n";
|
||||
else {
|
||||
auto pNtk = store<pabc::Abc_Ntk_t *>().current();
|
||||
pabc::Io_Write(pNtk, (char *)(file_name.c_str()),
|
||||
pabc::Io_ReadFileType((char *)(file_name.c_str())));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::string file_name;
|
||||
};
|
||||
|
||||
ALICE_ADD_COMMAND(write, "I/O")
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
|
@ -0,0 +1,751 @@
|
|||
/* phyLS: powerful heightened yielded Logic Synthesis
|
||||
* Copyright (C) 2022 */
|
||||
|
||||
/**
|
||||
* @file abc2mockturtle.hpp
|
||||
*
|
||||
* @brief convert format between abc and mockturtle
|
||||
*
|
||||
* @author Homyoung
|
||||
* @since 2023/02/27
|
||||
*/
|
||||
|
||||
#ifndef ABC2MOCKTURTLE_HPP
|
||||
#define ABC2MOCKTURTLE_HPP
|
||||
|
||||
#include <base/abc/abc.h>
|
||||
#include <base/io/ioAbc.h>
|
||||
|
||||
#include <map>
|
||||
#include <mockturtle/mockturtle.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace phyLS {
|
||||
|
||||
mockturtle::aig_network aig_new;
|
||||
pabc::Abc_Ntk_t* abc_ntk_;
|
||||
std::map<int, std::string> pi_names;
|
||||
std::map<int, std::string> po_names;
|
||||
|
||||
mockturtle::aig_network& abc2mockturtle_a(pabc::Abc_Ntk_t* abc_ntk_new) {
|
||||
// Convert abc aig network to the aig network in also
|
||||
pabc::Abc_Ntk_t* abc_ntk_aig;
|
||||
abc_ntk_aig = abc_ntk_new;
|
||||
mockturtle::aig_network aig;
|
||||
using sig = mockturtle::aig_network::signal;
|
||||
std::map<int, sig> signals;
|
||||
signals.clear();
|
||||
pi_names.clear();
|
||||
po_names.clear();
|
||||
|
||||
// create also network
|
||||
// process the also network primary input
|
||||
int i;
|
||||
pabc::Abc_Obj_t* pObj1;
|
||||
for (i = 0; (i < pabc::Abc_NtkPiNum(abc_ntk_aig)) &&
|
||||
(((pObj1) = pabc::Abc_NtkPi(abc_ntk_aig, i)), 1);
|
||||
i++) {
|
||||
sig pi = aig.create_pi();
|
||||
signals.insert(std::pair<int, sig>(pObj1->Id, pi));
|
||||
unsigned int a = pi.index;
|
||||
pi_names.insert(std::pair<int, std::string>(a, pabc::Abc_ObjName(pObj1)));
|
||||
}
|
||||
|
||||
// process the also network node
|
||||
int j, k;
|
||||
pabc::Abc_Obj_t *pNode, *pFanin1;
|
||||
for (i = 0; (i < pabc::Vec_PtrSize((abc_ntk_aig)->vObjs)) &&
|
||||
(((pNode) = pabc::Abc_NtkObj(abc_ntk_aig, i)), 1);
|
||||
i++) {
|
||||
if ((pNode) == NULL || !pabc::Abc_ObjIsNode(pNode)) {
|
||||
} else {
|
||||
std::vector<sig> children;
|
||||
children.clear();
|
||||
|
||||
if (pabc::Abc_AigNodeIsConst(pabc::Abc_ObjFanin0(pNode)))
|
||||
children.push_back((pNode->fCompl0)
|
||||
? aig.create_not(aig.get_constant(true))
|
||||
: aig.get_constant(true));
|
||||
else
|
||||
children.push_back(
|
||||
(pNode->fCompl0)
|
||||
? aig.create_not(signals[pabc::Abc_ObjFaninId0(pNode)])
|
||||
: signals[pabc::Abc_ObjFaninId0(pNode)]);
|
||||
|
||||
if (pabc::Abc_AigNodeIsConst(pabc::Abc_ObjFanin1(pNode)))
|
||||
children.push_back((pNode->fCompl1)
|
||||
? aig.create_not(aig.get_constant(true))
|
||||
: aig.get_constant(true));
|
||||
else
|
||||
children.push_back(
|
||||
(pNode->fCompl1)
|
||||
? aig.create_not(signals[pabc::Abc_ObjFaninId1(pNode)])
|
||||
: signals[pabc::Abc_ObjFaninId1(pNode)]);
|
||||
|
||||
assert(children.size() == 2u);
|
||||
signals.insert(std::pair<int, sig>(
|
||||
pNode->Id, aig.create_and(children[0], children[1])));
|
||||
}
|
||||
}
|
||||
|
||||
// process the also network primary output
|
||||
int m, n, n1;
|
||||
pabc::Abc_Obj_t *pObj2, *pFanin2;
|
||||
for (i = 0; (i < pabc::Abc_NtkPoNum(abc_ntk_aig)) &&
|
||||
(((pObj2) = pabc::Abc_NtkPo(abc_ntk_aig, i)), 1);
|
||||
i++) {
|
||||
if (pabc::Abc_AigNodeIsConst(pabc::Abc_ObjFanin0(pObj2))) {
|
||||
auto const o = (pObj2->fCompl0) ? aig.create_not(aig.get_constant(true))
|
||||
: aig.get_constant(true);
|
||||
aig.create_po(o);
|
||||
} else {
|
||||
auto const o = (pObj2->fCompl0)
|
||||
? aig.create_not(signals[pabc::Abc_ObjFaninId0(pObj2)])
|
||||
: signals[pabc::Abc_ObjFaninId0(pObj2)];
|
||||
aig.create_po(o);
|
||||
}
|
||||
po_names.insert(std::pair<int, std::string>(i, pabc::Abc_ObjName(pObj2)));
|
||||
}
|
||||
|
||||
aig_new = aig;
|
||||
return aig_new;
|
||||
}
|
||||
|
||||
pabc::Abc_Ntk_t* mockturtle2abc_x(const mockturtle::xmg_network& xmg) {
|
||||
// Convert xmg network to the netlist network in abc
|
||||
const int MAX = 3;
|
||||
bool const0_created = false;
|
||||
std::string constant_name = "1\'b0";
|
||||
// Initialize the abc network
|
||||
abc_ntk_ = pabc::Abc_NtkAlloc(pabc::ABC_NTK_NETLIST, pabc::ABC_FUNC_SOP, 1);
|
||||
abc_ntk_->pName = strdup("netlist");
|
||||
|
||||
mockturtle::topo_view topo_xmg{xmg};
|
||||
|
||||
// create abc network
|
||||
// process the abc network primary input
|
||||
topo_xmg.foreach_pi([&](auto const& n, auto index) {
|
||||
const auto index1 = topo_xmg.node_to_index(n);
|
||||
unsigned int a = index1;
|
||||
std::string input_name = pi_names[a];
|
||||
pabc::Io_ReadCreatePi(abc_ntk_, (char*)(input_name.c_str()));
|
||||
});
|
||||
|
||||
// process the abc network node
|
||||
topo_xmg.foreach_node([&](auto n) {
|
||||
if (topo_xmg.is_constant(n) || topo_xmg.is_pi(n)) return true;
|
||||
|
||||
auto func = topo_xmg.node_function(n);
|
||||
std::string node_name = std::to_string(topo_xmg.node_to_index(n));
|
||||
|
||||
std::vector<std::string> children;
|
||||
children.clear();
|
||||
char* pNamesIn[MAX];
|
||||
topo_xmg.foreach_fanin(n, [&](auto const& f) {
|
||||
auto index = topo_xmg.node_to_index(topo_xmg.get_node(f));
|
||||
std::string fanin_name = std::to_string(index);
|
||||
|
||||
if (topo_xmg.is_pi(topo_xmg.get_node(f))) {
|
||||
unsigned int b = index;
|
||||
children.push_back(pi_names[b]);
|
||||
} else if (topo_xmg.is_constant(topo_xmg.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children.push_back(constant_name);
|
||||
} else
|
||||
children.push_back(fanin_name);
|
||||
});
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++)
|
||||
pNamesIn[i] = (char*)(children[i].c_str());
|
||||
|
||||
pabc::Abc_Obj_t* pNode;
|
||||
pNode = pabc::Io_ReadCreateNode(abc_ntk_, (char*)(node_name.c_str()),
|
||||
pNamesIn, topo_xmg.fanin_size(n));
|
||||
std::string abc_func = "";
|
||||
int count = 0;
|
||||
for (auto cube : kitty::isop(func)) {
|
||||
topo_xmg.foreach_fanin(n, [&](auto const& f, auto index) {
|
||||
if (cube.get_mask(index) && topo_xmg.is_complemented(f))
|
||||
cube.flip_bit(index);
|
||||
});
|
||||
|
||||
for (auto i = 0u; i < topo_xmg.fanin_size(n); ++i)
|
||||
abc_func += (cube.get_mask(i) ? (cube.get_bit(i) ? '1' : '0') : '-');
|
||||
abc_func += " 1\n";
|
||||
count++;
|
||||
}
|
||||
|
||||
pabc::Abc_ObjSetData(
|
||||
pNode, pabc::Abc_SopRegister((pabc::Mem_Flex_t*)abc_ntk_->pManFunc,
|
||||
abc_func.c_str()));
|
||||
return true;
|
||||
});
|
||||
|
||||
// process the abc network primary output
|
||||
std::vector<std::string> children1;
|
||||
topo_xmg.foreach_po([&](auto const& f, auto index) {
|
||||
auto a = topo_xmg.node_to_index(topo_xmg.get_node(f));
|
||||
std::string fanin_name = std::to_string(a);
|
||||
|
||||
pabc::Io_ReadCreatePo(abc_ntk_, (char*)(po_names[index].c_str()));
|
||||
|
||||
if (topo_xmg.is_complemented(f)) {
|
||||
children1.clear();
|
||||
if (topo_xmg.is_pi(topo_xmg.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_xmg.is_constant(topo_xmg.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
pabc::Io_ReadCreateInv(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
} else {
|
||||
children1.clear();
|
||||
if (topo_xmg.is_pi(topo_xmg.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_xmg.is_constant(topo_xmg.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
|
||||
pabc::Io_ReadCreateBuf(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
}
|
||||
});
|
||||
|
||||
return abc_ntk_;
|
||||
}
|
||||
|
||||
pabc::Abc_Ntk_t* mockturtle2abc_a(const mockturtle::aig_network& aig) {
|
||||
// Convert aig network to the netlist network in abc
|
||||
const int MAX = 3;
|
||||
bool const0_created = false;
|
||||
std::string constant_name = "1\'b0";
|
||||
// Initialize the abc network
|
||||
abc_ntk_ = pabc::Abc_NtkAlloc(pabc::ABC_NTK_NETLIST, pabc::ABC_FUNC_SOP, 1);
|
||||
abc_ntk_->pName = strdup("netlist");
|
||||
|
||||
mockturtle::topo_view topo_aig{aig};
|
||||
|
||||
// create abc network
|
||||
// process the abc network primary input
|
||||
topo_aig.foreach_pi([&](auto const& n, auto index) {
|
||||
const auto index1 = topo_aig.node_to_index(n);
|
||||
unsigned int a = index1;
|
||||
std::string input_name = pi_names[a];
|
||||
pabc::Io_ReadCreatePi(abc_ntk_, (char*)(input_name.c_str()));
|
||||
});
|
||||
|
||||
// process the abc network node
|
||||
topo_aig.foreach_node([&](auto n) {
|
||||
if (topo_aig.is_constant(n) || topo_aig.is_pi(n)) return true;
|
||||
|
||||
auto func = topo_aig.node_function(n);
|
||||
std::string node_name = std::to_string(topo_aig.node_to_index(n));
|
||||
|
||||
std::vector<std::string> children;
|
||||
children.clear();
|
||||
char* pNamesIn[MAX];
|
||||
topo_aig.foreach_fanin(n, [&](auto const& f) {
|
||||
auto index = topo_aig.node_to_index(topo_aig.get_node(f));
|
||||
std::string fanin_name = std::to_string(index);
|
||||
|
||||
if (topo_aig.is_pi(topo_aig.get_node(f))) {
|
||||
unsigned int b = index;
|
||||
children.push_back(pi_names[b]);
|
||||
} else if (topo_aig.is_constant(topo_aig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children.push_back(constant_name);
|
||||
} else
|
||||
children.push_back(fanin_name);
|
||||
});
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++)
|
||||
pNamesIn[i] = (char*)(children[i].c_str());
|
||||
|
||||
pabc::Abc_Obj_t* pNode;
|
||||
pNode = pabc::Io_ReadCreateNode(abc_ntk_, (char*)(node_name.c_str()),
|
||||
pNamesIn, topo_aig.fanin_size(n));
|
||||
std::string abc_func = "";
|
||||
int count = 0;
|
||||
for (auto cube : kitty::isop(func)) {
|
||||
topo_aig.foreach_fanin(n, [&](auto const& f, auto index) {
|
||||
if (cube.get_mask(index) && topo_aig.is_complemented(f))
|
||||
cube.flip_bit(index);
|
||||
});
|
||||
|
||||
for (auto i = 0u; i < topo_aig.fanin_size(n); ++i)
|
||||
abc_func += (cube.get_mask(i) ? (cube.get_bit(i) ? '1' : '0') : '-');
|
||||
abc_func += " 1\n";
|
||||
count++;
|
||||
}
|
||||
|
||||
pabc::Abc_ObjSetData(
|
||||
pNode, pabc::Abc_SopRegister((pabc::Mem_Flex_t*)abc_ntk_->pManFunc,
|
||||
abc_func.c_str()));
|
||||
return true;
|
||||
});
|
||||
|
||||
// process the abc network primary output
|
||||
std::vector<std::string> children1;
|
||||
topo_aig.foreach_po([&](auto const& f, auto index) {
|
||||
auto a = topo_aig.node_to_index(topo_aig.get_node(f));
|
||||
std::string fanin_name = std::to_string(a);
|
||||
|
||||
pabc::Io_ReadCreatePo(abc_ntk_, (char*)(po_names[index].c_str()));
|
||||
|
||||
if (topo_aig.is_complemented(f)) {
|
||||
children1.clear();
|
||||
if (topo_aig.is_pi(topo_aig.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_aig.is_constant(topo_aig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
pabc::Io_ReadCreateInv(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
} else {
|
||||
children1.clear();
|
||||
if (topo_aig.is_pi(topo_aig.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_aig.is_constant(topo_aig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
|
||||
pabc::Io_ReadCreateBuf(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
}
|
||||
});
|
||||
|
||||
return abc_ntk_;
|
||||
}
|
||||
|
||||
pabc::Abc_Ntk_t* mockturtle2abc_m(const mockturtle::mig_network& mig) {
|
||||
// Convert mig network to the netlist network in abc
|
||||
const int MAX = 3;
|
||||
bool const0_created = false;
|
||||
std::string constant_name = "1\'b0";
|
||||
// Initialize the abc network
|
||||
abc_ntk_ = pabc::Abc_NtkAlloc(pabc::ABC_NTK_NETLIST, pabc::ABC_FUNC_SOP, 1);
|
||||
abc_ntk_->pName = strdup("netlist");
|
||||
|
||||
mockturtle::topo_view topo_mig{mig};
|
||||
|
||||
// create abc network
|
||||
// process the abc network primary input
|
||||
topo_mig.foreach_pi([&](auto const& n, auto index) {
|
||||
const auto index1 = topo_mig.node_to_index(n);
|
||||
unsigned int a = index1;
|
||||
std::string input_name = pi_names[a];
|
||||
pabc::Io_ReadCreatePi(abc_ntk_, (char*)(input_name.c_str()));
|
||||
});
|
||||
|
||||
// process the abc network node
|
||||
topo_mig.foreach_node([&](auto n) {
|
||||
if (topo_mig.is_constant(n) || topo_mig.is_pi(n)) return true;
|
||||
|
||||
auto func = topo_mig.node_function(n);
|
||||
std::string node_name = std::to_string(topo_mig.node_to_index(n));
|
||||
|
||||
std::vector<std::string> children;
|
||||
children.clear();
|
||||
char* pNamesIn[MAX];
|
||||
topo_mig.foreach_fanin(n, [&](auto const& f) {
|
||||
auto index = topo_mig.node_to_index(topo_mig.get_node(f));
|
||||
std::string fanin_name = std::to_string(index);
|
||||
|
||||
if (topo_mig.is_pi(topo_mig.get_node(f))) {
|
||||
unsigned int b = index;
|
||||
children.push_back(pi_names[b]);
|
||||
} else if (topo_mig.is_constant(topo_mig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children.push_back(constant_name);
|
||||
} else
|
||||
children.push_back(fanin_name);
|
||||
});
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++)
|
||||
pNamesIn[i] = (char*)(children[i].c_str());
|
||||
|
||||
pabc::Abc_Obj_t* pNode;
|
||||
pNode = pabc::Io_ReadCreateNode(abc_ntk_, (char*)(node_name.c_str()),
|
||||
pNamesIn, topo_mig.fanin_size(n));
|
||||
std::string abc_func = "";
|
||||
int count = 0;
|
||||
for (auto cube : kitty::isop(func)) {
|
||||
topo_mig.foreach_fanin(n, [&](auto const& f, auto index) {
|
||||
if (cube.get_mask(index) && topo_mig.is_complemented(f))
|
||||
cube.flip_bit(index);
|
||||
});
|
||||
|
||||
for (auto i = 0u; i < topo_mig.fanin_size(n); ++i)
|
||||
abc_func += (cube.get_mask(i) ? (cube.get_bit(i) ? '1' : '0') : '-');
|
||||
abc_func += " 1\n";
|
||||
count++;
|
||||
}
|
||||
|
||||
pabc::Abc_ObjSetData(
|
||||
pNode, pabc::Abc_SopRegister((pabc::Mem_Flex_t*)abc_ntk_->pManFunc,
|
||||
abc_func.c_str()));
|
||||
return true;
|
||||
});
|
||||
|
||||
// process the abc network primary output
|
||||
std::vector<std::string> children1;
|
||||
topo_mig.foreach_po([&](auto const& f, auto index) {
|
||||
auto a = topo_mig.node_to_index(topo_mig.get_node(f));
|
||||
std::string fanin_name = std::to_string(a);
|
||||
|
||||
pabc::Io_ReadCreatePo(abc_ntk_, (char*)(po_names[index].c_str()));
|
||||
|
||||
if (topo_mig.is_complemented(f)) {
|
||||
children1.clear();
|
||||
if (topo_mig.is_pi(topo_mig.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_mig.is_constant(topo_mig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
pabc::Io_ReadCreateInv(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
} else {
|
||||
children1.clear();
|
||||
if (topo_mig.is_pi(topo_mig.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_mig.is_constant(topo_mig.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
|
||||
pabc::Io_ReadCreateBuf(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
}
|
||||
});
|
||||
|
||||
return abc_ntk_;
|
||||
}
|
||||
|
||||
pabc::Abc_Ntk_t* mockturtle2abc_g(const mockturtle::xag_network& xag) {
|
||||
// Convert xag network to the netlist network in abc
|
||||
const int MAX = 3;
|
||||
bool const0_created = false;
|
||||
std::string constant_name = "1\'b0";
|
||||
// Initialize the abc network
|
||||
abc_ntk_ = pabc::Abc_NtkAlloc(pabc::ABC_NTK_NETLIST, pabc::ABC_FUNC_SOP, 1);
|
||||
abc_ntk_->pName = strdup("netlist");
|
||||
|
||||
mockturtle::topo_view topo_xag{xag};
|
||||
|
||||
// create abc network
|
||||
// process the abc network primary input
|
||||
topo_xag.foreach_pi([&](auto const& n, auto index) {
|
||||
const auto index1 = topo_xag.node_to_index(n);
|
||||
unsigned int a = index1;
|
||||
std::string input_name = pi_names[a];
|
||||
pabc::Io_ReadCreatePi(abc_ntk_, (char*)(input_name.c_str()));
|
||||
});
|
||||
|
||||
// process the abc network node
|
||||
topo_xag.foreach_node([&](auto n) {
|
||||
if (topo_xag.is_constant(n) || topo_xag.is_pi(n)) return true;
|
||||
|
||||
auto func = topo_xag.node_function(n);
|
||||
std::string node_name = std::to_string(topo_xag.node_to_index(n));
|
||||
|
||||
std::vector<std::string> children;
|
||||
children.clear();
|
||||
char* pNamesIn[MAX];
|
||||
topo_xag.foreach_fanin(n, [&](auto const& f) {
|
||||
auto index = topo_xag.node_to_index(topo_xag.get_node(f));
|
||||
std::string fanin_name = std::to_string(index);
|
||||
|
||||
if (topo_xag.is_pi(topo_xag.get_node(f))) {
|
||||
unsigned int b = index;
|
||||
children.push_back(pi_names[b]);
|
||||
} else if (topo_xag.is_constant(topo_xag.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children.push_back(constant_name);
|
||||
} else
|
||||
children.push_back(fanin_name);
|
||||
});
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++)
|
||||
pNamesIn[i] = (char*)(children[i].c_str());
|
||||
|
||||
pabc::Abc_Obj_t* pNode;
|
||||
pNode = pabc::Io_ReadCreateNode(abc_ntk_, (char*)(node_name.c_str()),
|
||||
pNamesIn, topo_xag.fanin_size(n));
|
||||
std::string abc_func = "";
|
||||
int count = 0;
|
||||
for (auto cube : kitty::isop(func)) {
|
||||
topo_xag.foreach_fanin(n, [&](auto const& f, auto index) {
|
||||
if (cube.get_mask(index) && topo_xag.is_complemented(f))
|
||||
cube.flip_bit(index);
|
||||
});
|
||||
|
||||
for (auto i = 0u; i < topo_xag.fanin_size(n); ++i)
|
||||
abc_func += (cube.get_mask(i) ? (cube.get_bit(i) ? '1' : '0') : '-');
|
||||
abc_func += " 1\n";
|
||||
count++;
|
||||
}
|
||||
|
||||
pabc::Abc_ObjSetData(
|
||||
pNode, pabc::Abc_SopRegister((pabc::Mem_Flex_t*)abc_ntk_->pManFunc,
|
||||
abc_func.c_str()));
|
||||
return true;
|
||||
});
|
||||
|
||||
// process the abc network primary output
|
||||
std::vector<std::string> children1;
|
||||
topo_xag.foreach_po([&](auto const& f, auto index) {
|
||||
auto a = topo_xag.node_to_index(topo_xag.get_node(f));
|
||||
std::string fanin_name = std::to_string(a);
|
||||
|
||||
pabc::Io_ReadCreatePo(abc_ntk_, (char*)(po_names[index].c_str()));
|
||||
|
||||
if (topo_xag.is_complemented(f)) {
|
||||
children1.clear();
|
||||
if (topo_xag.is_pi(topo_xag.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_xag.is_constant(topo_xag.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
pabc::Io_ReadCreateInv(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
} else {
|
||||
children1.clear();
|
||||
if (topo_xag.is_pi(topo_xag.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_xag.is_constant(topo_xag.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
|
||||
pabc::Io_ReadCreateBuf(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
}
|
||||
});
|
||||
|
||||
return abc_ntk_;
|
||||
}
|
||||
|
||||
pabc::Abc_Ntk_t* mockturtle2abc_l(const mockturtle::klut_network& klut) {
|
||||
// Convert klut network to the netlist network in abc
|
||||
const int MAX = 3;
|
||||
bool const0_created = false;
|
||||
std::string constant_name = "1\'b0";
|
||||
// Initialize the abc network
|
||||
abc_ntk_ = pabc::Abc_NtkAlloc(pabc::ABC_NTK_NETLIST, pabc::ABC_FUNC_SOP, 1);
|
||||
abc_ntk_->pName = strdup("netlist");
|
||||
|
||||
mockturtle::topo_view topo_klut{klut};
|
||||
|
||||
// create abc network
|
||||
// process the abc network primary input
|
||||
topo_klut.foreach_pi([&](auto const& n, auto index) {
|
||||
const auto index1 = topo_klut.node_to_index(n);
|
||||
unsigned int a = index1;
|
||||
std::string input_name = pi_names[a];
|
||||
pabc::Io_ReadCreatePi(abc_ntk_, (char*)(input_name.c_str()));
|
||||
});
|
||||
|
||||
// process the abc network node
|
||||
topo_klut.foreach_node([&](auto n) {
|
||||
if (topo_klut.is_constant(n) || topo_klut.is_pi(n)) return true;
|
||||
|
||||
auto func = topo_klut.node_function(n);
|
||||
std::string node_name = std::to_string(topo_klut.node_to_index(n));
|
||||
|
||||
std::vector<std::string> children;
|
||||
children.clear();
|
||||
char* pNamesIn[MAX];
|
||||
topo_klut.foreach_fanin(n, [&](auto const& f) {
|
||||
auto index = topo_klut.node_to_index(topo_klut.get_node(f));
|
||||
std::string fanin_name = std::to_string(index);
|
||||
|
||||
if (topo_klut.is_pi(topo_klut.get_node(f))) {
|
||||
unsigned int b = index;
|
||||
children.push_back(pi_names[b]);
|
||||
} else if (topo_klut.is_constant(topo_klut.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children.push_back(constant_name);
|
||||
} else
|
||||
children.push_back(fanin_name);
|
||||
});
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++)
|
||||
pNamesIn[i] = (char*)(children[i].c_str());
|
||||
|
||||
pabc::Abc_Obj_t* pNode;
|
||||
pNode = pabc::Io_ReadCreateNode(abc_ntk_, (char*)(node_name.c_str()),
|
||||
pNamesIn, topo_klut.fanin_size(n));
|
||||
std::string abc_func = "";
|
||||
int count = 0;
|
||||
for (auto cube : kitty::isop(func)) {
|
||||
topo_klut.foreach_fanin(n, [&](auto const& f, auto index) {
|
||||
if (cube.get_mask(index) && topo_klut.is_complemented(f))
|
||||
cube.flip_bit(index);
|
||||
});
|
||||
|
||||
for (auto i = 0u; i < topo_klut.fanin_size(n); ++i)
|
||||
abc_func += (cube.get_mask(i) ? (cube.get_bit(i) ? '1' : '0') : '-');
|
||||
abc_func += " 1\n";
|
||||
count++;
|
||||
}
|
||||
|
||||
pabc::Abc_ObjSetData(
|
||||
pNode, pabc::Abc_SopRegister((pabc::Mem_Flex_t*)abc_ntk_->pManFunc,
|
||||
abc_func.c_str()));
|
||||
return true;
|
||||
});
|
||||
|
||||
// process the abc network primary output
|
||||
std::vector<std::string> children1;
|
||||
topo_klut.foreach_po([&](auto const& f, auto index) {
|
||||
auto a = topo_klut.node_to_index(topo_klut.get_node(f));
|
||||
std::string fanin_name = std::to_string(a);
|
||||
|
||||
pabc::Io_ReadCreatePo(abc_ntk_, (char*)(po_names[index].c_str()));
|
||||
|
||||
if (topo_klut.is_complemented(f)) {
|
||||
children1.clear();
|
||||
if (topo_klut.is_pi(topo_klut.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_klut.is_constant(topo_klut.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
pabc::Io_ReadCreateInv(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
} else {
|
||||
children1.clear();
|
||||
if (topo_klut.is_pi(topo_klut.get_node(f))) {
|
||||
unsigned int b = a;
|
||||
children1.push_back(pi_names[b]);
|
||||
} else if (topo_klut.is_constant(topo_klut.get_node(f))) {
|
||||
// process the abc network constant node
|
||||
if (!const0_created) {
|
||||
pabc::Abc_NtkFindOrCreateNet(abc_ntk_,
|
||||
(char*)(constant_name.c_str()));
|
||||
pabc::Io_ReadCreateConst(abc_ntk_, (char*)(constant_name.c_str()), 0);
|
||||
const0_created = true;
|
||||
}
|
||||
children1.push_back(constant_name);
|
||||
} else
|
||||
children1.push_back(fanin_name);
|
||||
|
||||
pabc::Io_ReadCreateBuf(abc_ntk_, (char*)(children1[0].c_str()),
|
||||
(char*)(po_names[index].c_str()));
|
||||
}
|
||||
});
|
||||
|
||||
return abc_ntk_;
|
||||
}
|
||||
} // namespace phyLS
|
||||
|
||||
#endif
|
|
@ -40,5 +40,12 @@
|
|||
#include "commands/functional_reduction.hpp"
|
||||
#include "commands/convert_graph.hpp"
|
||||
#include "commands/lutmap.hpp"
|
||||
#include "commands/abc/read.hpp"
|
||||
#include "commands/abc/write.hpp"
|
||||
#include "commands/abc/strash.hpp"
|
||||
#include "commands/abc/resub.hpp"
|
||||
#include "commands/abc/fraig.hpp"
|
||||
#include "commands/abc/&get.hpp"
|
||||
#include "commands/abc/&fraig.hpp"
|
||||
|
||||
ALICE_MAIN(phyLS)
|
107
src/store.hpp
107
src/store.hpp
|
@ -26,6 +26,10 @@
|
|||
#ifndef STORE_HPP
|
||||
#define STORE_HPP
|
||||
|
||||
#include <aig/gia/gia.h>
|
||||
#include <aig/gia/giaAig.h>
|
||||
#include <base/abc/abc.h>
|
||||
#include <base/io/ioAbc.h>
|
||||
#include <fmt/format.h>
|
||||
|
||||
#include <alice/alice.hpp>
|
||||
|
@ -40,6 +44,8 @@
|
|||
#include <mockturtle/mockturtle.hpp>
|
||||
#include <mockturtle/views/names_view.hpp>
|
||||
|
||||
#include "./core/abc2mockturtle.hpp"
|
||||
|
||||
using namespace mockturtle;
|
||||
|
||||
namespace alice {
|
||||
|
@ -500,6 +506,107 @@ ALICE_CONVERT(xmg_network, element, mig_network) {
|
|||
return mig;
|
||||
}
|
||||
|
||||
/* ABC aiger */
|
||||
ALICE_ADD_STORE(pabc::Abc_Ntk_t *, "abc", "b", "ABC", "ABCs")
|
||||
|
||||
ALICE_DESCRIBE_STORE(pabc::Abc_Ntk_t *, abc) {
|
||||
const auto name = pabc::Abc_NtkName(abc);
|
||||
const auto pi_num = pabc::Abc_NtkPiNum(abc);
|
||||
const auto po_num = pabc::Abc_NtkPoNum(abc);
|
||||
return fmt::format("{} i/o = {}/{}", name, pi_num, po_num);
|
||||
}
|
||||
|
||||
ALICE_PRINT_STORE(pabc::Abc_Ntk_t *, os, abc) {
|
||||
os << "AIG PI/PO = " << pabc::Abc_NtkPiNum(abc) << "/"
|
||||
<< pabc::Abc_NtkPoNum(abc) << "\n";
|
||||
}
|
||||
|
||||
ALICE_PRINT_STORE_STATISTICS(pabc::Abc_Ntk_t *, os, abc) {
|
||||
Abc_NtkPrintStats(abc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
|
||||
}
|
||||
|
||||
ALICE_LOG_STORE_STATISTICS(pabc::Abc_Ntk_t *, abc) {
|
||||
return {{"name", pabc::Abc_NtkName(abc)},
|
||||
{"inputs", pabc::Abc_NtkPiNum(abc)},
|
||||
{"outputs", pabc::Abc_NtkPoNum(abc)},
|
||||
{"nodes", pabc::Abc_NtkNodeNum(abc)},
|
||||
{"levels", pabc::Abc_NtkLevel(abc)}};
|
||||
}
|
||||
|
||||
ALICE_CONVERT(pabc::Abc_Ntk_t *, element, aig_network) {
|
||||
pabc::Abc_Ntk_t *pNtk = element;
|
||||
aig_network aig = phyLS::abc2mockturtle_a(pNtk);
|
||||
return aig;
|
||||
}
|
||||
|
||||
ALICE_CONVERT(xmg_network, element, pabc::Abc_Ntk_t *) {
|
||||
xmg_network xmg = element;
|
||||
pabc::Abc_Ntk_t *pNtk = phyLS::mockturtle2abc_x(xmg);
|
||||
return pNtk;
|
||||
}
|
||||
|
||||
ALICE_CONVERT(aig_network, element, pabc::Abc_Ntk_t *) {
|
||||
aig_network aig = element;
|
||||
pabc::Abc_Ntk_t *pNtk = phyLS::mockturtle2abc_a(aig);
|
||||
return pNtk;
|
||||
}
|
||||
|
||||
ALICE_CONVERT(mig_network, element, pabc::Abc_Ntk_t *) {
|
||||
mig_network mig = element;
|
||||
pabc::Abc_Ntk_t *pNtk = phyLS::mockturtle2abc_m(mig);
|
||||
return pNtk;
|
||||
}
|
||||
|
||||
ALICE_CONVERT(xag_network, element, pabc::Abc_Ntk_t *) {
|
||||
xag_network xag = element;
|
||||
pabc::Abc_Ntk_t *pNtk = phyLS::mockturtle2abc_g(xag);
|
||||
return pNtk;
|
||||
}
|
||||
|
||||
ALICE_CONVERT(klut_network, element, pabc::Abc_Ntk_t *) {
|
||||
klut_network klut = element;
|
||||
pabc::Abc_Ntk_t *pNtk = phyLS::mockturtle2abc_l(klut);
|
||||
return pNtk;
|
||||
}
|
||||
|
||||
/* ABC Gia */
|
||||
ALICE_ADD_STORE(pabc::Gia_Man_t *, "gia", "i", "GIA", "GIAs")
|
||||
|
||||
ALICE_DESCRIBE_STORE(pabc::Gia_Man_t *, gia) {
|
||||
const auto name = pabc::Gia_ManName(gia);
|
||||
const auto pi_num = pabc::Gia_ManPiNum(gia);
|
||||
const auto po_num = pabc::Gia_ManPoNum(gia);
|
||||
return fmt::format("{} i/o = {}/{}", name, pi_num, po_num);
|
||||
}
|
||||
|
||||
ALICE_PRINT_STORE(pabc::Gia_Man_t *, os, gia) {
|
||||
os << "GIA PI/PO = " << pabc::Gia_ManPiNum(gia) << "/"
|
||||
<< pabc::Gia_ManPoNum(gia) << "\n";
|
||||
}
|
||||
|
||||
ALICE_PRINT_STORE_STATISTICS(pabc::Gia_Man_t *, os, gia) {
|
||||
pabc::Gps_Par_t Pars{};
|
||||
pabc::Gia_ManPrintStats(gia, &Pars);
|
||||
}
|
||||
|
||||
ALICE_LOG_STORE_STATISTICS(pabc::Gia_Man_t *, gia) {
|
||||
return {{"name", pabc::Gia_ManName(gia)},
|
||||
{"inputs", pabc::Gia_ManPiNum(gia)},
|
||||
{"outputs", pabc::Gia_ManPoNum(gia)},
|
||||
{"nodes", pabc::Gia_ManAndNum(gia)},
|
||||
{"levels", pabc::Gia_ManLevelNum(gia)}};
|
||||
}
|
||||
|
||||
ALICE_ADD_FILE_TYPE(gia, "Gia");
|
||||
|
||||
ALICE_READ_FILE(pabc::Gia_Man_t *, gia, filename, cmd) {
|
||||
return pabc::Gia_AigerRead((char *)filename.c_str(), 0, 0, 0);
|
||||
}
|
||||
|
||||
ALICE_WRITE_FILE(pabc::Gia_Man_t *, gia, gia, filename, cmd) {
|
||||
pabc::Gia_AigerWrite(gia, (char *)filename.c_str(), 1, 0, 0);
|
||||
}
|
||||
|
||||
} // namespace alice
|
||||
|
||||
#endif
|
||||
|
|
Loading…
Reference in New Issue