luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Version abc70216

This commit is contained in:
Alan Mishchenko 2007-02-16 08:01:00 -08:00
parent 5f3e4c0fe2
commit 607c253cd2
58 changed files with 135367 additions and 2091 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -12,7 +12,8 @@ MODULES := src/base/abc src/base/abci src/base/cmd src/base/io src/base/main src
src/map/fpga src/map/mapper src/map/mio src/map/super src/map/if \
src/misc/extra src/misc/mvc src/misc/st src/misc/util src/misc/espresso src/misc/nm src/misc/vec src/misc/hash \
src/opt/cut src/opt/dec src/opt/fxu src/opt/rwr src/opt/sim src/opt/ret src/opt/res src/opt/kit \
src/sat/bsat src/sat/csat src/sat/msat src/sat/fraig
src/sat/bsat src/sat/csat src/sat/msat src/sat/fraig \
src/phys/place
default: $(PROG)
@ -22,7 +23,7 @@ OPTFLAGS := -g -O
CFLAGS += -Wall -Wno-unused-function $(OPTFLAGS) $(patsubst %, -I%, $(MODULES))
CXXFLAGS += $(CFLAGS)
LIBS := -ldl -rdynamic -lreadline -ltermcap
LIBS := -ldl -rdynamic -lreadline -ltermcap libhmetis.a
SRC :=
GARBAGE := core core.* *.stackdump ./tags $(PROG)

66
abc.dsp
View File

@ -42,7 +42,7 @@ RSC=rc.exe
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\opt\res" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\opt\res" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /I "src\phys\place" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /c
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
@ -50,7 +50,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /profile /machine:I386 /out:"_TEST/abc.exe"
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib lib/libhmetis.lib /nologo /subsystem:console /profile /machine:I386 /out:"_TEST/abc.exe"
!ELSEIF "$(CFG)" == "abc - Win32 Debug"
@ -66,7 +66,7 @@ LINK32=link.exe
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\opt\res" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\opt\res" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /I "src\phys\place" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /GZ /c
# SUBTRACT CPP /X
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
@ -75,7 +75,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"_TEST/abc.exe" /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib lib/libhmetis.lib /nologo /subsystem:console /debug /machine:I386 /out:"_TEST/abc.exe" /pdbtype:sept
!ENDIF
@ -290,6 +290,10 @@ SOURCE=.\src\base\abci\abcOrder.c
# End Source File
# Begin Source File
SOURCE=.\src\base\abci\abcPlace.c
# End Source File
# Begin Source File
SOURCE=.\src\base\abci\abcPrint.c
# End Source File
# Begin Source File
@ -2406,9 +2410,61 @@ SOURCE=.\src\misc\hash\hashPtr.h
# End Source File
# End Group
# End Group
# Begin Group "temp"
# Begin Group "phys"
# PROP Default_Filter ""
# Begin Group "place"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\src\phys\place\libhmetis.h
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_base.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_base.h
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_bin.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_genqp.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_gordian.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_gordian.h
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_legalize.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_pads.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_partition.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_qpsolver.c
# End Source File
# Begin Source File
SOURCE=.\src\phys\place\place_qpsolver.h
# End Source File
# End Group
# End Group
# End Group
# Begin Group "Header Files"

933
abc.plg
View File

@ -1,933 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: abc - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDB.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\opt\res" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR"Debug/" /Fp"Debug/abc.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c
"C:\_projects\abc\src\base\ver\verCore.c"
"C:\_projects\abc\src\base\ver\verParse.c"
]
Creating command line "cl.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDB.tmp"
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDC.tmp" with contents
[
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/abc.pdb" /debug /machine:I386 /out:"_TEST/abc.exe" /pdbtype:sept
.\Debug\abcAig.obj
.\Debug\abcCheck.obj
.\Debug\abcDfs.obj
.\Debug\abcFanio.obj
.\Debug\abcFunc.obj
.\Debug\abcHie.obj
.\Debug\abcLatch.obj
.\Debug\abcLib.obj
.\Debug\abcMinBase.obj
.\Debug\abcNames.obj
.\Debug\abcNetlist.obj
.\Debug\abcNtk.obj
.\Debug\abcObj.obj
.\Debug\abcRefs.obj
.\Debug\abcShow.obj
.\Debug\abcSop.obj
.\Debug\abcUtil.obj
.\Debug\abc.obj
.\Debug\abcAttach.obj
.\Debug\abcAuto.obj
.\Debug\abcBalance.obj
.\Debug\abcBmc.obj
.\Debug\abcClpBdd.obj
.\Debug\abcClpSop.obj
.\Debug\abcCut.obj
.\Debug\abcDebug.obj
.\Debug\abcDress.obj
.\Debug\abcDsd.obj
.\Debug\abcEspresso.obj
.\Debug\abcExtract.obj
.\Debug\abcFpga.obj
.\Debug\abcFpgaFast.obj
.\Debug\abcFraig.obj
.\Debug\abcFxu.obj
.\Debug\abcGen.obj
.\Debug\abcIf.obj
.\Debug\abcIvy.obj
.\Debug\abcLut.obj
.\Debug\abcMap.obj
.\Debug\abcMini.obj
.\Debug\abcMiter.obj
.\Debug\abcMulti.obj
.\Debug\abcMv.obj
.\Debug\abcNtbdd.obj
.\Debug\abcOdc.obj
.\Debug\abcOrder.obj
.\Debug\abcPrint.obj
.\Debug\abcProve.obj
.\Debug\abcReconv.obj
.\Debug\abcRefactor.obj
.\Debug\abcRenode.obj
.\Debug\abcReorder.obj
.\Debug\abcRestruct.obj
.\Debug\abcResub.obj
.\Debug\abcRewrite.obj
.\Debug\abcRr.obj
.\Debug\abcSat.obj
.\Debug\abcStrash.obj
.\Debug\abcSweep.obj
.\Debug\abcSymm.obj
.\Debug\abcTiming.obj
.\Debug\abcUnate.obj
.\Debug\abcUnreach.obj
.\Debug\abcVerify.obj
.\Debug\abcXsim.obj
.\Debug\cmd.obj
.\Debug\cmdAlias.obj
.\Debug\cmdApi.obj
.\Debug\cmdFlag.obj
.\Debug\cmdHist.obj
.\Debug\cmdUtils.obj
.\Debug\io.obj
.\Debug\ioReadAiger.obj
.\Debug\ioReadBaf.obj
.\Debug\ioReadBench.obj
.\Debug\ioReadBlif.obj
.\Debug\ioReadBlifAig.obj
.\Debug\ioReadBlifMv.obj
.\Debug\ioReadEdif.obj
.\Debug\ioReadEqn.obj
.\Debug\ioReadPla.obj
.\Debug\ioUtil.obj
.\Debug\ioWriteAiger.obj
.\Debug\ioWriteBaf.obj
.\Debug\ioWriteBench.obj
.\Debug\ioWriteBlif.obj
.\Debug\ioWriteBlifMv.obj
.\Debug\ioWriteCnf.obj
.\Debug\ioWriteDot.obj
.\Debug\ioWriteEqn.obj
.\Debug\ioWriteGml.obj
.\Debug\ioWriteList.obj
.\Debug\ioWritePla.obj
.\Debug\libSupport.obj
.\Debug\main.obj
.\Debug\mainFrame.obj
.\Debug\mainInit.obj
.\Debug\mainUtils.obj
.\Debug\verCore.obj
.\Debug\verFormula.obj
.\Debug\verParse.obj
.\Debug\verStream.obj
.\Debug\hopBalance.obj
.\Debug\hopCheck.obj
.\Debug\hopDfs.obj
.\Debug\hopMan.obj
.\Debug\hopMem.obj
.\Debug\hopObj.obj
.\Debug\hopOper.obj
.\Debug\hopTable.obj
.\Debug\hopUtil.obj
.\Debug\ivyBalance.obj
.\Debug\ivyCanon.obj
.\Debug\ivyCheck.obj
.\Debug\ivyCut.obj
.\Debug\ivyCutTrav.obj
.\Debug\ivyDfs.obj
.\Debug\ivyDsd.obj
.\Debug\ivyFanout.obj
.\Debug\ivyFastMap.obj
.\Debug\ivyFraig.obj
.\Debug\ivyHaig.obj
.\Debug\ivyMan.obj
.\Debug\ivyMem.obj
.\Debug\ivyMulti.obj
.\Debug\ivyObj.obj
.\Debug\ivyOper.obj
.\Debug\ivyResyn.obj
.\Debug\ivyRwr.obj
.\Debug\ivySeq.obj
.\Debug\ivyShow.obj
.\Debug\ivyTable.obj
.\Debug\ivyUtil.obj
.\Debug\rwtDec.obj
.\Debug\rwtMan.obj
.\Debug\rwtUtil.obj
.\Debug\mem.obj
.\Debug\cuddAddAbs.obj
.\Debug\cuddAddApply.obj
.\Debug\cuddAddFind.obj
.\Debug\cuddAddInv.obj
.\Debug\cuddAddIte.obj
.\Debug\cuddAddNeg.obj
.\Debug\cuddAddWalsh.obj
.\Debug\cuddAndAbs.obj
.\Debug\cuddAnneal.obj
.\Debug\cuddApa.obj
.\Debug\cuddAPI.obj
.\Debug\cuddApprox.obj
.\Debug\cuddBddAbs.obj
.\Debug\cuddBddCorr.obj
.\Debug\cuddBddIte.obj
.\Debug\cuddBridge.obj
.\Debug\cuddCache.obj
.\Debug\cuddCheck.obj
.\Debug\cuddClip.obj
.\Debug\cuddCof.obj
.\Debug\cuddCompose.obj
.\Debug\cuddDecomp.obj
.\Debug\cuddEssent.obj
.\Debug\cuddExact.obj
.\Debug\cuddExport.obj
.\Debug\cuddGenCof.obj
.\Debug\cuddGenetic.obj
.\Debug\cuddGroup.obj
.\Debug\cuddHarwell.obj
.\Debug\cuddInit.obj
.\Debug\cuddInteract.obj
.\Debug\cuddLCache.obj
.\Debug\cuddLevelQ.obj
.\Debug\cuddLinear.obj
.\Debug\cuddLiteral.obj
.\Debug\cuddMatMult.obj
.\Debug\cuddPriority.obj
.\Debug\cuddRead.obj
.\Debug\cuddRef.obj
.\Debug\cuddReorder.obj
.\Debug\cuddSat.obj
.\Debug\cuddSign.obj
.\Debug\cuddSolve.obj
.\Debug\cuddSplit.obj
.\Debug\cuddSubsetHB.obj
.\Debug\cuddSubsetSP.obj
.\Debug\cuddSymmetry.obj
.\Debug\cuddTable.obj
.\Debug\cuddUtil.obj
.\Debug\cuddWindow.obj
.\Debug\cuddZddCount.obj
.\Debug\cuddZddFuncs.obj
.\Debug\cuddZddGroup.obj
.\Debug\cuddZddIsop.obj
.\Debug\cuddZddLin.obj
.\Debug\cuddZddMisc.obj
.\Debug\cuddZddPort.obj
.\Debug\cuddZddReord.obj
.\Debug\cuddZddSetop.obj
.\Debug\cuddZddSymm.obj
.\Debug\cuddZddUtil.obj
.\Debug\epd.obj
.\Debug\mtrBasic.obj
.\Debug\mtrGroup.obj
.\Debug\parseCore.obj
.\Debug\parseEqn.obj
.\Debug\parseStack.obj
.\Debug\dsdApi.obj
.\Debug\dsdCheck.obj
.\Debug\dsdLocal.obj
.\Debug\dsdMan.obj
.\Debug\dsdProc.obj
.\Debug\dsdTree.obj
.\Debug\reoApi.obj
.\Debug\reoCore.obj
.\Debug\reoProfile.obj
.\Debug\reoSift.obj
.\Debug\reoSwap.obj
.\Debug\reoTest.obj
.\Debug\reoTransfer.obj
.\Debug\reoUnits.obj
.\Debug\msatActivity.obj
.\Debug\msatClause.obj
.\Debug\msatClauseVec.obj
.\Debug\msatMem.obj
.\Debug\msatOrderH.obj
.\Debug\msatQueue.obj
.\Debug\msatRead.obj
.\Debug\msatSolverApi.obj
.\Debug\msatSolverCore.obj
.\Debug\msatSolverIo.obj
.\Debug\msatSolverSearch.obj
.\Debug\msatSort.obj
.\Debug\msatVec.obj
.\Debug\fraigApi.obj
.\Debug\fraigCanon.obj
.\Debug\fraigChoice.obj
.\Debug\fraigFanout.obj
.\Debug\fraigFeed.obj
.\Debug\fraigMan.obj
.\Debug\fraigMem.obj
.\Debug\fraigNode.obj
.\Debug\fraigPrime.obj
.\Debug\fraigSat.obj
.\Debug\fraigTable.obj
.\Debug\fraigUtil.obj
.\Debug\fraigVec.obj
.\Debug\csat_apis.obj
.\Debug\satInter.obj
.\Debug\satMem.obj
.\Debug\satSolver.obj
.\Debug\satStore.obj
.\Debug\satTrace.obj
.\Debug\satUtil.obj
.\Debug\pr.obj
.\Debug\fxu.obj
.\Debug\fxuCreate.obj
.\Debug\fxuHeapD.obj
.\Debug\fxuHeapS.obj
.\Debug\fxuList.obj
.\Debug\fxuMatrix.obj
.\Debug\fxuPair.obj
.\Debug\fxuPrint.obj
.\Debug\fxuReduce.obj
.\Debug\fxuSelect.obj
.\Debug\fxuSingle.obj
.\Debug\fxuUpdate.obj
.\Debug\rwrDec.obj
.\Debug\rwrEva.obj
.\Debug\rwrExp.obj
.\Debug\rwrLib.obj
.\Debug\rwrMan.obj
.\Debug\rwrPrint.obj
.\Debug\rwrTemp.obj
.\Debug\rwrUtil.obj
.\Debug\cutApi.obj
.\Debug\cutCut.obj
.\Debug\cutExpand.obj
.\Debug\cutMan.obj
.\Debug\cutMerge.obj
.\Debug\cutNode.obj
.\Debug\cutOracle.obj
.\Debug\cutPre22.obj
.\Debug\cutSeq.obj
.\Debug\cutTruth.obj
.\Debug\decAbc.obj
.\Debug\decFactor.obj
.\Debug\decMan.obj
.\Debug\decPrint.obj
.\Debug\decUtil.obj
.\Debug\simMan.obj
.\Debug\simSat.obj
.\Debug\simSeq.obj
.\Debug\simSupp.obj
.\Debug\simSwitch.obj
.\Debug\simSym.obj
.\Debug\simSymSat.obj
.\Debug\simSymSim.obj
.\Debug\simSymStr.obj
.\Debug\simUtils.obj
.\Debug\retArea.obj
.\Debug\retCore.obj
.\Debug\retDelay.obj
.\Debug\retFlow.obj
.\Debug\retIncrem.obj
.\Debug\retInit.obj
.\Debug\retLvalue.obj
.\Debug\kitBdd.obj
.\Debug\kitFactor.obj
.\Debug\kitGraph.obj
.\Debug\kitHop.obj
.\Debug\kitIsop.obj
.\Debug\kitSop.obj
.\Debug\kitTruth.obj
.\Debug\resCore.obj
.\Debug\resDivs.obj
.\Debug\resFilter.obj
.\Debug\resSat.obj
.\Debug\resSim.obj
.\Debug\resStrash.obj
.\Debug\resUpdate.obj
.\Debug\resWin.obj
.\Debug\bdcCore.obj
.\Debug\bdcDec.obj
.\Debug\bdcTable.obj
.\Debug\fpga.obj
.\Debug\fpgaCore.obj
.\Debug\fpgaCreate.obj
.\Debug\fpgaCut.obj
.\Debug\fpgaCutUtils.obj
.\Debug\fpgaFanout.obj
.\Debug\fpgaLib.obj
.\Debug\fpgaMatch.obj
.\Debug\fpgaSwitch.obj
.\Debug\fpgaTime.obj
.\Debug\fpgaTruth.obj
.\Debug\fpgaUtils.obj
.\Debug\fpgaVec.obj
.\Debug\mapper.obj
.\Debug\mapperCanon.obj
.\Debug\mapperCore.obj
.\Debug\mapperCreate.obj
.\Debug\mapperCut.obj
.\Debug\mapperCutUtils.obj
.\Debug\mapperFanout.obj
.\Debug\mapperLib.obj
.\Debug\mapperMatch.obj
.\Debug\mapperRefs.obj
.\Debug\mapperSuper.obj
.\Debug\mapperSwitch.obj
.\Debug\mapperTable.obj
.\Debug\mapperTime.obj
.\Debug\mapperTree.obj
.\Debug\mapperTruth.obj
.\Debug\mapperUtils.obj
.\Debug\mapperVec.obj
.\Debug\mio.obj
.\Debug\mioApi.obj
.\Debug\mioFunc.obj
.\Debug\mioRead.obj
.\Debug\mioUtils.obj
.\Debug\super.obj
.\Debug\superAnd.obj
.\Debug\superGate.obj
.\Debug\superWrite.obj
.\Debug\ifCore.obj
.\Debug\ifCut.obj
.\Debug\ifMan.obj
.\Debug\ifMap.obj
.\Debug\ifPrepro.obj
.\Debug\ifReduce.obj
.\Debug\ifSeq.obj
.\Debug\ifTime.obj
.\Debug\ifTruth.obj
.\Debug\ifUtil.obj
.\Debug\extraBddAuto.obj
.\Debug\extraBddKmap.obj
.\Debug\extraBddMisc.obj
.\Debug\extraBddSymm.obj
.\Debug\extraBddUnate.obj
.\Debug\extraUtilBitMatrix.obj
.\Debug\extraUtilCanon.obj
.\Debug\extraUtilFile.obj
.\Debug\extraUtilMemory.obj
.\Debug\extraUtilMisc.obj
.\Debug\extraUtilProgress.obj
.\Debug\extraUtilReader.obj
.\Debug\extraUtilTruth.obj
.\Debug\extraUtilUtil.obj
.\Debug\st.obj
.\Debug\stmm.obj
.\Debug\mvc.obj
.\Debug\mvcApi.obj
.\Debug\mvcCompare.obj
.\Debug\mvcContain.obj
.\Debug\mvcCover.obj
.\Debug\mvcCube.obj
.\Debug\mvcDivide.obj
.\Debug\mvcDivisor.obj
.\Debug\mvcList.obj
.\Debug\mvcLits.obj
.\Debug\mvcMan.obj
.\Debug\mvcOpAlg.obj
.\Debug\mvcOpBool.obj
.\Debug\mvcPrint.obj
.\Debug\mvcSort.obj
.\Debug\mvcUtils.obj
.\Debug\cofactor.obj
.\Debug\cols.obj
.\Debug\compl.obj
.\Debug\contain.obj
.\Debug\cubehack.obj
.\Debug\cubestr.obj
.\Debug\cvrin.obj
.\Debug\cvrm.obj
.\Debug\cvrmisc.obj
.\Debug\cvrout.obj
.\Debug\dominate.obj
.\Debug\equiv.obj
.\Debug\espresso.obj
.\Debug\essen.obj
.\Debug\exact.obj
.\Debug\expand.obj
.\Debug\gasp.obj
.\Debug\gimpel.obj
.\Debug\globals.obj
.\Debug\hack.obj
.\Debug\indep.obj
.\Debug\irred.obj
.\Debug\map.obj
.\Debug\matrix.obj
.\Debug\mincov.obj
.\Debug\opo.obj
.\Debug\pair.obj
.\Debug\part.obj
.\Debug\primes.obj
.\Debug\reduce.obj
.\Debug\rows.obj
.\Debug\set.obj
.\Debug\setc.obj
.\Debug\sharp.obj
.\Debug\sminterf.obj
.\Debug\solution.obj
.\Debug\sparse.obj
.\Debug\unate.obj
.\Debug\verify.obj
.\Debug\nmApi.obj
.\Debug\nmTable.obj
.\Debug\ioWriteVerilog.obj
.\Debug\ioReadVerilog.obj
]
Creating command line "link.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDC.tmp"
<h3>Output Window</h3>
Compiling...
verCore.c
verParse.c
Linking...
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDD.tmp" with contents
[
/nologo /o"Debug/abc.bsc"
.\Debug\abcAig.sbr
.\Debug\abcCheck.sbr
.\Debug\abcDfs.sbr
.\Debug\abcFanio.sbr
.\Debug\abcFunc.sbr
.\Debug\abcHie.sbr
.\Debug\abcLatch.sbr
.\Debug\abcLib.sbr
.\Debug\abcMinBase.sbr
.\Debug\abcNames.sbr
.\Debug\abcNetlist.sbr
.\Debug\abcNtk.sbr
.\Debug\abcObj.sbr
.\Debug\abcRefs.sbr
.\Debug\abcShow.sbr
.\Debug\abcSop.sbr
.\Debug\abcUtil.sbr
.\Debug\abc.sbr
.\Debug\abcAttach.sbr
.\Debug\abcAuto.sbr
.\Debug\abcBalance.sbr
.\Debug\abcBmc.sbr
.\Debug\abcClpBdd.sbr
.\Debug\abcClpSop.sbr
.\Debug\abcCut.sbr
.\Debug\abcDebug.sbr
.\Debug\abcDress.sbr
.\Debug\abcDsd.sbr
.\Debug\abcEspresso.sbr
.\Debug\abcExtract.sbr
.\Debug\abcFpga.sbr
.\Debug\abcFpgaFast.sbr
.\Debug\abcFraig.sbr
.\Debug\abcFxu.sbr
.\Debug\abcGen.sbr
.\Debug\abcIf.sbr
.\Debug\abcIvy.sbr
.\Debug\abcLut.sbr
.\Debug\abcMap.sbr
.\Debug\abcMini.sbr
.\Debug\abcMiter.sbr
.\Debug\abcMulti.sbr
.\Debug\abcMv.sbr
.\Debug\abcNtbdd.sbr
.\Debug\abcOdc.sbr
.\Debug\abcOrder.sbr
.\Debug\abcPrint.sbr
.\Debug\abcProve.sbr
.\Debug\abcReconv.sbr
.\Debug\abcRefactor.sbr
.\Debug\abcRenode.sbr
.\Debug\abcReorder.sbr
.\Debug\abcRestruct.sbr
.\Debug\abcResub.sbr
.\Debug\abcRewrite.sbr
.\Debug\abcRr.sbr
.\Debug\abcSat.sbr
.\Debug\abcStrash.sbr
.\Debug\abcSweep.sbr
.\Debug\abcSymm.sbr
.\Debug\abcTiming.sbr
.\Debug\abcUnate.sbr
.\Debug\abcUnreach.sbr
.\Debug\abcVerify.sbr
.\Debug\abcXsim.sbr
.\Debug\cmd.sbr
.\Debug\cmdAlias.sbr
.\Debug\cmdApi.sbr
.\Debug\cmdFlag.sbr
.\Debug\cmdHist.sbr
.\Debug\cmdUtils.sbr
.\Debug\io.sbr
.\Debug\ioReadAiger.sbr
.\Debug\ioReadBaf.sbr
.\Debug\ioReadBench.sbr
.\Debug\ioReadBlif.sbr
.\Debug\ioReadBlifAig.sbr
.\Debug\ioReadBlifMv.sbr
.\Debug\ioReadEdif.sbr
.\Debug\ioReadEqn.sbr
.\Debug\ioReadPla.sbr
.\Debug\ioUtil.sbr
.\Debug\ioWriteAiger.sbr
.\Debug\ioWriteBaf.sbr
.\Debug\ioWriteBench.sbr
.\Debug\ioWriteBlif.sbr
.\Debug\ioWriteBlifMv.sbr
.\Debug\ioWriteCnf.sbr
.\Debug\ioWriteDot.sbr
.\Debug\ioWriteEqn.sbr
.\Debug\ioWriteGml.sbr
.\Debug\ioWriteList.sbr
.\Debug\ioWritePla.sbr
.\Debug\libSupport.sbr
.\Debug\main.sbr
.\Debug\mainFrame.sbr
.\Debug\mainInit.sbr
.\Debug\mainUtils.sbr
.\Debug\verCore.sbr
.\Debug\verFormula.sbr
.\Debug\verParse.sbr
.\Debug\verStream.sbr
.\Debug\hopBalance.sbr
.\Debug\hopCheck.sbr
.\Debug\hopDfs.sbr
.\Debug\hopMan.sbr
.\Debug\hopMem.sbr
.\Debug\hopObj.sbr
.\Debug\hopOper.sbr
.\Debug\hopTable.sbr
.\Debug\hopUtil.sbr
.\Debug\ivyBalance.sbr
.\Debug\ivyCanon.sbr
.\Debug\ivyCheck.sbr
.\Debug\ivyCut.sbr
.\Debug\ivyCutTrav.sbr
.\Debug\ivyDfs.sbr
.\Debug\ivyDsd.sbr
.\Debug\ivyFanout.sbr
.\Debug\ivyFastMap.sbr
.\Debug\ivyFraig.sbr
.\Debug\ivyHaig.sbr
.\Debug\ivyMan.sbr
.\Debug\ivyMem.sbr
.\Debug\ivyMulti.sbr
.\Debug\ivyObj.sbr
.\Debug\ivyOper.sbr
.\Debug\ivyResyn.sbr
.\Debug\ivyRwr.sbr
.\Debug\ivySeq.sbr
.\Debug\ivyShow.sbr
.\Debug\ivyTable.sbr
.\Debug\ivyUtil.sbr
.\Debug\rwtDec.sbr
.\Debug\rwtMan.sbr
.\Debug\rwtUtil.sbr
.\Debug\mem.sbr
.\Debug\cuddAddAbs.sbr
.\Debug\cuddAddApply.sbr
.\Debug\cuddAddFind.sbr
.\Debug\cuddAddInv.sbr
.\Debug\cuddAddIte.sbr
.\Debug\cuddAddNeg.sbr
.\Debug\cuddAddWalsh.sbr
.\Debug\cuddAndAbs.sbr
.\Debug\cuddAnneal.sbr
.\Debug\cuddApa.sbr
.\Debug\cuddAPI.sbr
.\Debug\cuddApprox.sbr
.\Debug\cuddBddAbs.sbr
.\Debug\cuddBddCorr.sbr
.\Debug\cuddBddIte.sbr
.\Debug\cuddBridge.sbr
.\Debug\cuddCache.sbr
.\Debug\cuddCheck.sbr
.\Debug\cuddClip.sbr
.\Debug\cuddCof.sbr
.\Debug\cuddCompose.sbr
.\Debug\cuddDecomp.sbr
.\Debug\cuddEssent.sbr
.\Debug\cuddExact.sbr
.\Debug\cuddExport.sbr
.\Debug\cuddGenCof.sbr
.\Debug\cuddGenetic.sbr
.\Debug\cuddGroup.sbr
.\Debug\cuddHarwell.sbr
.\Debug\cuddInit.sbr
.\Debug\cuddInteract.sbr
.\Debug\cuddLCache.sbr
.\Debug\cuddLevelQ.sbr
.\Debug\cuddLinear.sbr
.\Debug\cuddLiteral.sbr
.\Debug\cuddMatMult.sbr
.\Debug\cuddPriority.sbr
.\Debug\cuddRead.sbr
.\Debug\cuddRef.sbr
.\Debug\cuddReorder.sbr
.\Debug\cuddSat.sbr
.\Debug\cuddSign.sbr
.\Debug\cuddSolve.sbr
.\Debug\cuddSplit.sbr
.\Debug\cuddSubsetHB.sbr
.\Debug\cuddSubsetSP.sbr
.\Debug\cuddSymmetry.sbr
.\Debug\cuddTable.sbr
.\Debug\cuddUtil.sbr
.\Debug\cuddWindow.sbr
.\Debug\cuddZddCount.sbr
.\Debug\cuddZddFuncs.sbr
.\Debug\cuddZddGroup.sbr
.\Debug\cuddZddIsop.sbr
.\Debug\cuddZddLin.sbr
.\Debug\cuddZddMisc.sbr
.\Debug\cuddZddPort.sbr
.\Debug\cuddZddReord.sbr
.\Debug\cuddZddSetop.sbr
.\Debug\cuddZddSymm.sbr
.\Debug\cuddZddUtil.sbr
.\Debug\epd.sbr
.\Debug\mtrBasic.sbr
.\Debug\mtrGroup.sbr
.\Debug\parseCore.sbr
.\Debug\parseEqn.sbr
.\Debug\parseStack.sbr
.\Debug\dsdApi.sbr
.\Debug\dsdCheck.sbr
.\Debug\dsdLocal.sbr
.\Debug\dsdMan.sbr
.\Debug\dsdProc.sbr
.\Debug\dsdTree.sbr
.\Debug\reoApi.sbr
.\Debug\reoCore.sbr
.\Debug\reoProfile.sbr
.\Debug\reoSift.sbr
.\Debug\reoSwap.sbr
.\Debug\reoTest.sbr
.\Debug\reoTransfer.sbr
.\Debug\reoUnits.sbr
.\Debug\msatActivity.sbr
.\Debug\msatClause.sbr
.\Debug\msatClauseVec.sbr
.\Debug\msatMem.sbr
.\Debug\msatOrderH.sbr
.\Debug\msatQueue.sbr
.\Debug\msatRead.sbr
.\Debug\msatSolverApi.sbr
.\Debug\msatSolverCore.sbr
.\Debug\msatSolverIo.sbr
.\Debug\msatSolverSearch.sbr
.\Debug\msatSort.sbr
.\Debug\msatVec.sbr
.\Debug\fraigApi.sbr
.\Debug\fraigCanon.sbr
.\Debug\fraigChoice.sbr
.\Debug\fraigFanout.sbr
.\Debug\fraigFeed.sbr
.\Debug\fraigMan.sbr
.\Debug\fraigMem.sbr
.\Debug\fraigNode.sbr
.\Debug\fraigPrime.sbr
.\Debug\fraigSat.sbr
.\Debug\fraigTable.sbr
.\Debug\fraigUtil.sbr
.\Debug\fraigVec.sbr
.\Debug\csat_apis.sbr
.\Debug\satInter.sbr
.\Debug\satMem.sbr
.\Debug\satSolver.sbr
.\Debug\satStore.sbr
.\Debug\satTrace.sbr
.\Debug\satUtil.sbr
.\Debug\pr.sbr
.\Debug\fxu.sbr
.\Debug\fxuCreate.sbr
.\Debug\fxuHeapD.sbr
.\Debug\fxuHeapS.sbr
.\Debug\fxuList.sbr
.\Debug\fxuMatrix.sbr
.\Debug\fxuPair.sbr
.\Debug\fxuPrint.sbr
.\Debug\fxuReduce.sbr
.\Debug\fxuSelect.sbr
.\Debug\fxuSingle.sbr
.\Debug\fxuUpdate.sbr
.\Debug\rwrDec.sbr
.\Debug\rwrEva.sbr
.\Debug\rwrExp.sbr
.\Debug\rwrLib.sbr
.\Debug\rwrMan.sbr
.\Debug\rwrPrint.sbr
.\Debug\rwrTemp.sbr
.\Debug\rwrUtil.sbr
.\Debug\cutApi.sbr
.\Debug\cutCut.sbr
.\Debug\cutExpand.sbr
.\Debug\cutMan.sbr
.\Debug\cutMerge.sbr
.\Debug\cutNode.sbr
.\Debug\cutOracle.sbr
.\Debug\cutPre22.sbr
.\Debug\cutSeq.sbr
.\Debug\cutTruth.sbr
.\Debug\decAbc.sbr
.\Debug\decFactor.sbr
.\Debug\decMan.sbr
.\Debug\decPrint.sbr
.\Debug\decUtil.sbr
.\Debug\simMan.sbr
.\Debug\simSat.sbr
.\Debug\simSeq.sbr
.\Debug\simSupp.sbr
.\Debug\simSwitch.sbr
.\Debug\simSym.sbr
.\Debug\simSymSat.sbr
.\Debug\simSymSim.sbr
.\Debug\simSymStr.sbr
.\Debug\simUtils.sbr
.\Debug\retArea.sbr
.\Debug\retCore.sbr
.\Debug\retDelay.sbr
.\Debug\retFlow.sbr
.\Debug\retIncrem.sbr
.\Debug\retInit.sbr
.\Debug\retLvalue.sbr
.\Debug\kitBdd.sbr
.\Debug\kitFactor.sbr
.\Debug\kitGraph.sbr
.\Debug\kitHop.sbr
.\Debug\kitIsop.sbr
.\Debug\kitSop.sbr
.\Debug\kitTruth.sbr
.\Debug\resCore.sbr
.\Debug\resDivs.sbr
.\Debug\resFilter.sbr
.\Debug\resSat.sbr
.\Debug\resSim.sbr
.\Debug\resStrash.sbr
.\Debug\resUpdate.sbr
.\Debug\resWin.sbr
.\Debug\bdcCore.sbr
.\Debug\bdcDec.sbr
.\Debug\bdcTable.sbr
.\Debug\fpga.sbr
.\Debug\fpgaCore.sbr
.\Debug\fpgaCreate.sbr
.\Debug\fpgaCut.sbr
.\Debug\fpgaCutUtils.sbr
.\Debug\fpgaFanout.sbr
.\Debug\fpgaLib.sbr
.\Debug\fpgaMatch.sbr
.\Debug\fpgaSwitch.sbr
.\Debug\fpgaTime.sbr
.\Debug\fpgaTruth.sbr
.\Debug\fpgaUtils.sbr
.\Debug\fpgaVec.sbr
.\Debug\mapper.sbr
.\Debug\mapperCanon.sbr
.\Debug\mapperCore.sbr
.\Debug\mapperCreate.sbr
.\Debug\mapperCut.sbr
.\Debug\mapperCutUtils.sbr
.\Debug\mapperFanout.sbr
.\Debug\mapperLib.sbr
.\Debug\mapperMatch.sbr
.\Debug\mapperRefs.sbr
.\Debug\mapperSuper.sbr
.\Debug\mapperSwitch.sbr
.\Debug\mapperTable.sbr
.\Debug\mapperTime.sbr
.\Debug\mapperTree.sbr
.\Debug\mapperTruth.sbr
.\Debug\mapperUtils.sbr
.\Debug\mapperVec.sbr
.\Debug\mio.sbr
.\Debug\mioApi.sbr
.\Debug\mioFunc.sbr
.\Debug\mioRead.sbr
.\Debug\mioUtils.sbr
.\Debug\super.sbr
.\Debug\superAnd.sbr
.\Debug\superGate.sbr
.\Debug\superWrite.sbr
.\Debug\ifCore.sbr
.\Debug\ifCut.sbr
.\Debug\ifMan.sbr
.\Debug\ifMap.sbr
.\Debug\ifPrepro.sbr
.\Debug\ifReduce.sbr
.\Debug\ifSeq.sbr
.\Debug\ifTime.sbr
.\Debug\ifTruth.sbr
.\Debug\ifUtil.sbr
.\Debug\extraBddAuto.sbr
.\Debug\extraBddKmap.sbr
.\Debug\extraBddMisc.sbr
.\Debug\extraBddSymm.sbr
.\Debug\extraBddUnate.sbr
.\Debug\extraUtilBitMatrix.sbr
.\Debug\extraUtilCanon.sbr
.\Debug\extraUtilFile.sbr
.\Debug\extraUtilMemory.sbr
.\Debug\extraUtilMisc.sbr
.\Debug\extraUtilProgress.sbr
.\Debug\extraUtilReader.sbr
.\Debug\extraUtilTruth.sbr
.\Debug\extraUtilUtil.sbr
.\Debug\st.sbr
.\Debug\stmm.sbr
.\Debug\mvc.sbr
.\Debug\mvcApi.sbr
.\Debug\mvcCompare.sbr
.\Debug\mvcContain.sbr
.\Debug\mvcCover.sbr
.\Debug\mvcCube.sbr
.\Debug\mvcDivide.sbr
.\Debug\mvcDivisor.sbr
.\Debug\mvcList.sbr
.\Debug\mvcLits.sbr
.\Debug\mvcMan.sbr
.\Debug\mvcOpAlg.sbr
.\Debug\mvcOpBool.sbr
.\Debug\mvcPrint.sbr
.\Debug\mvcSort.sbr
.\Debug\mvcUtils.sbr
.\Debug\cofactor.sbr
.\Debug\cols.sbr
.\Debug\compl.sbr
.\Debug\contain.sbr
.\Debug\cubehack.sbr
.\Debug\cubestr.sbr
.\Debug\cvrin.sbr
.\Debug\cvrm.sbr
.\Debug\cvrmisc.sbr
.\Debug\cvrout.sbr
.\Debug\dominate.sbr
.\Debug\equiv.sbr
.\Debug\espresso.sbr
.\Debug\essen.sbr
.\Debug\exact.sbr
.\Debug\expand.sbr
.\Debug\gasp.sbr
.\Debug\gimpel.sbr
.\Debug\globals.sbr
.\Debug\hack.sbr
.\Debug\indep.sbr
.\Debug\irred.sbr
.\Debug\map.sbr
.\Debug\matrix.sbr
.\Debug\mincov.sbr
.\Debug\opo.sbr
.\Debug\pair.sbr
.\Debug\part.sbr
.\Debug\primes.sbr
.\Debug\reduce.sbr
.\Debug\rows.sbr
.\Debug\set.sbr
.\Debug\setc.sbr
.\Debug\sharp.sbr
.\Debug\sminterf.sbr
.\Debug\solution.sbr
.\Debug\sparse.sbr
.\Debug\unate.sbr
.\Debug\verify.sbr
.\Debug\nmApi.sbr
.\Debug\nmTable.sbr
.\Debug\ioWriteVerilog.sbr
.\Debug\ioReadVerilog.sbr]
Creating command line "bscmake.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSPDDD.tmp"
Creating browse info file...
<h3>Output Window</h3>
<h3>Results</h3>
abc.exe - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

4
abc.rc
View File

@ -2,7 +2,7 @@
set check # checks intermediate networks
#set checkfio # prints warnings when fanins/fanouts are duplicated
set checkread # checks new networks after reading from file
#set backup # saves backup networks retrived by "undo" and "recall"
set backup # saves backup networks retrived by "undo" and "recall"
set savesteps 1 # sets the maximum number of backup networks to save
set progressbar # display the progress bar
@ -53,7 +53,7 @@ alias rb read_bench
alias ret retime
alias rp read_pla
alias rt read_truth
alias rv read_ver
alias rv read_verilog
alias rvl read_verlib
alias rsup read_super mcnc5_old.super
alias rlib read_library

903
abclib.plg
View File

@ -1,903 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: abclib - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137A.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I "src\base\abc" /I "src\base\abci" /I "src\base\abcs" /I "src\base\seq" /I "src\base\cmd" /I "src\base\io" /I "src\base\main" /I "src\bdd\cudd" /I "src\bdd\epd" /I "src\bdd\mtr" /I "src\bdd\parse" /I "src\bdd\dsd" /I "src\bdd\reo" /I "src\sop\ft" /I "src\sat\asat" /I "src\sat\bsat" /I "src\sat\msat" /I "src\sat\fraig" /I "src\opt\cut" /I "src\opt\dec" /I "src\opt\fxu" /I "src\opt\sim" /I "src\opt\rwr" /I "src\opt\kit" /I "src\map\fpga" /I "src\map\if" /I "src\map\mapper" /I "src\map\mio" /I "src\map\super" /I "src\misc\extra" /I "src\misc\st" /I "src\misc\mvc" /I "src\misc\util" /I "src\misc\npn" /I "src\misc\vec" /I "src\misc\espresso" /I "src\misc\nm" /I "src\misc\hash" /I "src\aig\ivy" /I "src\aig\hop" /I "src\aig\rwt" /I "src\aig\deco" /I "src\aig\mem" /I "src\temp\esop" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "__STDC__" /D "HAVE_ASSERT_H" /FR"abclib\DebugLib/" /Fp"abclib\DebugLib/abclib.pch" /YX /Fo"abclib\DebugLib/" /Fd"abclib\DebugLib/" /FD /GZ /c
"C:\_projects\abc\src\sat\asat\jfront.c"
]
Creating command line "cl.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137A.tmp"
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137B.tmp" with contents
[
/nologo /out:"abclib\abclib_debug.lib"
.\abclib\DebugLib\abcAig.obj
.\abclib\DebugLib\abcCheck.obj
.\abclib\DebugLib\abcDfs.obj
.\abclib\DebugLib\abcFanio.obj
.\abclib\DebugLib\abcFunc.obj
.\abclib\DebugLib\abcLatch.obj
.\abclib\DebugLib\abcLib.obj
.\abclib\DebugLib\abcMinBase.obj
.\abclib\DebugLib\abcNames.obj
.\abclib\DebugLib\abcNetlist.obj
.\abclib\DebugLib\abcNtk.obj
.\abclib\DebugLib\abcObj.obj
.\abclib\DebugLib\abcRefs.obj
.\abclib\DebugLib\abcShow.obj
.\abclib\DebugLib\abcSop.obj
.\abclib\DebugLib\abcUtil.obj
.\abclib\DebugLib\abc.obj
.\abclib\DebugLib\abcAttach.obj
.\abclib\DebugLib\abcAuto.obj
.\abclib\DebugLib\abcBalance.obj
.\abclib\DebugLib\abcBmc.obj
.\abclib\DebugLib\abcClpBdd.obj
.\abclib\DebugLib\abcClpSop.obj
.\abclib\DebugLib\abcCut.obj
.\abclib\DebugLib\abcDebug.obj
.\abclib\DebugLib\abcDress.obj
.\abclib\DebugLib\abcDsd.obj
.\abclib\DebugLib\abcEspresso.obj
.\abclib\DebugLib\abcExtract.obj
.\abclib\DebugLib\abcFpga.obj
.\abclib\DebugLib\abcFpgaFast.obj
.\abclib\DebugLib\abcFraig.obj
.\abclib\DebugLib\abcFxu.obj
.\abclib\DebugLib\abcGen.obj
.\abclib\DebugLib\abcIf.obj
.\abclib\DebugLib\abcIvy.obj
.\abclib\DebugLib\abcLut.obj
.\abclib\DebugLib\abcMap.obj
.\abclib\DebugLib\abcMini.obj
.\abclib\DebugLib\abcMiter.obj
.\abclib\DebugLib\abcMulti.obj
.\abclib\DebugLib\abcMv.obj
.\abclib\DebugLib\abcNtbdd.obj
.\abclib\DebugLib\abcOrder.obj
.\abclib\DebugLib\abcPrint.obj
.\abclib\DebugLib\abcProve.obj
.\abclib\DebugLib\abcReconv.obj
.\abclib\DebugLib\abcRefactor.obj
.\abclib\DebugLib\abcRenode.obj
.\abclib\DebugLib\abcReorder.obj
.\abclib\DebugLib\abcRestruct.obj
.\abclib\DebugLib\abcResub.obj
.\abclib\DebugLib\abcRewrite.obj
.\abclib\DebugLib\abcRr.obj
.\abclib\DebugLib\abcSat.obj
.\abclib\DebugLib\abcStrash.obj
.\abclib\DebugLib\abcSweep.obj
.\abclib\DebugLib\abcSymm.obj
.\abclib\DebugLib\abcTiming.obj
.\abclib\DebugLib\abcUnate.obj
.\abclib\DebugLib\abcUnreach.obj
.\abclib\DebugLib\abcVerify.obj
.\abclib\DebugLib\abcXsim.obj
.\abclib\DebugLib\cmd.obj
.\abclib\DebugLib\cmdAlias.obj
.\abclib\DebugLib\cmdApi.obj
.\abclib\DebugLib\cmdFlag.obj
.\abclib\DebugLib\cmdHist.obj
.\abclib\DebugLib\cmdUtils.obj
.\abclib\DebugLib\io.obj
.\abclib\DebugLib\ioReadAiger.obj
.\abclib\DebugLib\ioReadBaf.obj
.\abclib\DebugLib\ioReadBench.obj
.\abclib\DebugLib\ioReadBlif.obj
.\abclib\DebugLib\ioReadBlifAig.obj
.\abclib\DebugLib\ioReadEdif.obj
.\abclib\DebugLib\ioReadEqn.obj
.\abclib\DebugLib\ioReadPla.obj
.\abclib\DebugLib\ioUtil.obj
.\abclib\DebugLib\ioWriteAiger.obj
.\abclib\DebugLib\ioWriteBaf.obj
.\abclib\DebugLib\ioWriteBench.obj
.\abclib\DebugLib\ioWriteBlif.obj
.\abclib\DebugLib\ioWriteCnf.obj
.\abclib\DebugLib\ioWriteDot.obj
.\abclib\DebugLib\ioWriteEqn.obj
.\abclib\DebugLib\ioWriteGml.obj
.\abclib\DebugLib\ioWriteList.obj
.\abclib\DebugLib\ioWritePla.obj
.\abclib\DebugLib\ioWriteVer.obj
.\abclib\DebugLib\ioWriteVerAux.obj
.\abclib\DebugLib\libSupport.obj
.\abclib\DebugLib\main.obj
.\abclib\DebugLib\mainFrame.obj
.\abclib\DebugLib\mainInit.obj
.\abclib\DebugLib\mainUtils.obj
.\abclib\DebugLib\verCore.obj
.\abclib\DebugLib\verFormula.obj
.\abclib\DebugLib\verParse.obj
.\abclib\DebugLib\verStream.obj
.\abclib\DebugLib\verWords.obj
.\abclib\DebugLib\cuddAddAbs.obj
.\abclib\DebugLib\cuddAddApply.obj
.\abclib\DebugLib\cuddAddFind.obj
.\abclib\DebugLib\cuddAddInv.obj
.\abclib\DebugLib\cuddAddIte.obj
.\abclib\DebugLib\cuddAddNeg.obj
.\abclib\DebugLib\cuddAddWalsh.obj
.\abclib\DebugLib\cuddAndAbs.obj
.\abclib\DebugLib\cuddAnneal.obj
.\abclib\DebugLib\cuddApa.obj
.\abclib\DebugLib\cuddAPI.obj
.\abclib\DebugLib\cuddApprox.obj
.\abclib\DebugLib\cuddBddAbs.obj
.\abclib\DebugLib\cuddBddCorr.obj
.\abclib\DebugLib\cuddBddIte.obj
.\abclib\DebugLib\cuddBridge.obj
.\abclib\DebugLib\cuddCache.obj
.\abclib\DebugLib\cuddCheck.obj
.\abclib\DebugLib\cuddClip.obj
.\abclib\DebugLib\cuddCof.obj
.\abclib\DebugLib\cuddCompose.obj
.\abclib\DebugLib\cuddDecomp.obj
.\abclib\DebugLib\cuddEssent.obj
.\abclib\DebugLib\cuddExact.obj
.\abclib\DebugLib\cuddExport.obj
.\abclib\DebugLib\cuddGenCof.obj
.\abclib\DebugLib\cuddGenetic.obj
.\abclib\DebugLib\cuddGroup.obj
.\abclib\DebugLib\cuddHarwell.obj
.\abclib\DebugLib\cuddInit.obj
.\abclib\DebugLib\cuddInteract.obj
.\abclib\DebugLib\cuddLCache.obj
.\abclib\DebugLib\cuddLevelQ.obj
.\abclib\DebugLib\cuddLinear.obj
.\abclib\DebugLib\cuddLiteral.obj
.\abclib\DebugLib\cuddMatMult.obj
.\abclib\DebugLib\cuddPriority.obj
.\abclib\DebugLib\cuddRead.obj
.\abclib\DebugLib\cuddRef.obj
.\abclib\DebugLib\cuddReorder.obj
.\abclib\DebugLib\cuddSat.obj
.\abclib\DebugLib\cuddSign.obj
.\abclib\DebugLib\cuddSolve.obj
.\abclib\DebugLib\cuddSplit.obj
.\abclib\DebugLib\cuddSubsetHB.obj
.\abclib\DebugLib\cuddSubsetSP.obj
.\abclib\DebugLib\cuddSymmetry.obj
.\abclib\DebugLib\cuddTable.obj
.\abclib\DebugLib\cuddUtil.obj
.\abclib\DebugLib\cuddWindow.obj
.\abclib\DebugLib\cuddZddCount.obj
.\abclib\DebugLib\cuddZddFuncs.obj
.\abclib\DebugLib\cuddZddGroup.obj
.\abclib\DebugLib\cuddZddIsop.obj
.\abclib\DebugLib\cuddZddLin.obj
.\abclib\DebugLib\cuddZddMisc.obj
.\abclib\DebugLib\cuddZddPort.obj
.\abclib\DebugLib\cuddZddReord.obj
.\abclib\DebugLib\cuddZddSetop.obj
.\abclib\DebugLib\cuddZddSymm.obj
.\abclib\DebugLib\cuddZddUtil.obj
.\abclib\DebugLib\epd.obj
.\abclib\DebugLib\mtrBasic.obj
.\abclib\DebugLib\mtrGroup.obj
.\abclib\DebugLib\parseCore.obj
.\abclib\DebugLib\parseEqn.obj
.\abclib\DebugLib\parseStack.obj
.\abclib\DebugLib\dsdApi.obj
.\abclib\DebugLib\dsdCheck.obj
.\abclib\DebugLib\dsdLocal.obj
.\abclib\DebugLib\dsdMan.obj
.\abclib\DebugLib\dsdProc.obj
.\abclib\DebugLib\dsdTree.obj
.\abclib\DebugLib\reoApi.obj
.\abclib\DebugLib\reoCore.obj
.\abclib\DebugLib\reoProfile.obj
.\abclib\DebugLib\reoSift.obj
.\abclib\DebugLib\reoSwap.obj
.\abclib\DebugLib\reoTest.obj
.\abclib\DebugLib\reoTransfer.obj
.\abclib\DebugLib\reoUnits.obj
.\abclib\DebugLib\added.obj
.\abclib\DebugLib\asatmem.obj
.\abclib\DebugLib\solver.obj
.\abclib\DebugLib\msatActivity.obj
.\abclib\DebugLib\msatClause.obj
.\abclib\DebugLib\msatClauseVec.obj
.\abclib\DebugLib\msatMem.obj
.\abclib\DebugLib\msatOrderH.obj
.\abclib\DebugLib\msatQueue.obj
.\abclib\DebugLib\msatRead.obj
.\abclib\DebugLib\msatSolverApi.obj
.\abclib\DebugLib\msatSolverCore.obj
.\abclib\DebugLib\msatSolverIo.obj
.\abclib\DebugLib\msatSolverSearch.obj
.\abclib\DebugLib\msatSort.obj
.\abclib\DebugLib\msatVec.obj
.\abclib\DebugLib\fraigApi.obj
.\abclib\DebugLib\fraigCanon.obj
.\abclib\DebugLib\fraigChoice.obj
.\abclib\DebugLib\fraigFanout.obj
.\abclib\DebugLib\fraigFeed.obj
.\abclib\DebugLib\fraigMan.obj
.\abclib\DebugLib\fraigMem.obj
.\abclib\DebugLib\fraigNode.obj
.\abclib\DebugLib\fraigPrime.obj
.\abclib\DebugLib\fraigSat.obj
.\abclib\DebugLib\fraigTable.obj
.\abclib\DebugLib\fraigUtil.obj
.\abclib\DebugLib\fraigVec.obj
.\abclib\DebugLib\csat_apis.obj
.\abclib\DebugLib\satMem.obj
.\abclib\DebugLib\satSolver.obj
.\abclib\DebugLib\satUtil.obj
.\abclib\DebugLib\fxu.obj
.\abclib\DebugLib\fxuCreate.obj
.\abclib\DebugLib\fxuHeapD.obj
.\abclib\DebugLib\fxuHeapS.obj
.\abclib\DebugLib\fxuList.obj
.\abclib\DebugLib\fxuMatrix.obj
.\abclib\DebugLib\fxuPair.obj
.\abclib\DebugLib\fxuPrint.obj
.\abclib\DebugLib\fxuReduce.obj
.\abclib\DebugLib\fxuSelect.obj
.\abclib\DebugLib\fxuSingle.obj
.\abclib\DebugLib\fxuUpdate.obj
.\abclib\DebugLib\rwrDec.obj
.\abclib\DebugLib\rwrEva.obj
.\abclib\DebugLib\rwrExp.obj
.\abclib\DebugLib\rwrLib.obj
.\abclib\DebugLib\rwrMan.obj
.\abclib\DebugLib\rwrPrint.obj
.\abclib\DebugLib\rwrTemp.obj
.\abclib\DebugLib\rwrUtil.obj
.\abclib\DebugLib\cutApi.obj
.\abclib\DebugLib\cutCut.obj
.\abclib\DebugLib\cutExpand.obj
.\abclib\DebugLib\cutMan.obj
.\abclib\DebugLib\cutMerge.obj
.\abclib\DebugLib\cutNode.obj
.\abclib\DebugLib\cutOracle.obj
.\abclib\DebugLib\cutPre22.obj
.\abclib\DebugLib\cutSeq.obj
.\abclib\DebugLib\cutTruth.obj
.\abclib\DebugLib\decAbc.obj
.\abclib\DebugLib\decFactor.obj
.\abclib\DebugLib\decMan.obj
.\abclib\DebugLib\decPrint.obj
.\abclib\DebugLib\decUtil.obj
.\abclib\DebugLib\simMan.obj
.\abclib\DebugLib\simSat.obj
.\abclib\DebugLib\simSeq.obj
.\abclib\DebugLib\simSupp.obj
.\abclib\DebugLib\simSwitch.obj
.\abclib\DebugLib\simSym.obj
.\abclib\DebugLib\simSymSat.obj
.\abclib\DebugLib\simSymSim.obj
.\abclib\DebugLib\simSymStr.obj
.\abclib\DebugLib\simUtils.obj
.\abclib\DebugLib\retArea.obj
.\abclib\DebugLib\retCore.obj
.\abclib\DebugLib\retDelay.obj
.\abclib\DebugLib\retFlow.obj
.\abclib\DebugLib\retIncrem.obj
.\abclib\DebugLib\retInit.obj
.\abclib\DebugLib\retLvalue.obj
.\abclib\DebugLib\kitBdd.obj
.\abclib\DebugLib\kitFactor.obj
.\abclib\DebugLib\kitGraph.obj
.\abclib\DebugLib\kitHop.obj
.\abclib\DebugLib\kitIsop.obj
.\abclib\DebugLib\kitSop.obj
.\abclib\DebugLib\kitTruth.obj
.\abclib\DebugLib\fpga.obj
.\abclib\DebugLib\fpgaCore.obj
.\abclib\DebugLib\fpgaCreate.obj
.\abclib\DebugLib\fpgaCut.obj
.\abclib\DebugLib\fpgaCutUtils.obj
.\abclib\DebugLib\fpgaFanout.obj
.\abclib\DebugLib\fpgaLib.obj
.\abclib\DebugLib\fpgaMatch.obj
.\abclib\DebugLib\fpgaSwitch.obj
.\abclib\DebugLib\fpgaTime.obj
.\abclib\DebugLib\fpgaTruth.obj
.\abclib\DebugLib\fpgaUtils.obj
.\abclib\DebugLib\fpgaVec.obj
.\abclib\DebugLib\mapper.obj
.\abclib\DebugLib\mapperCanon.obj
.\abclib\DebugLib\mapperCore.obj
.\abclib\DebugLib\mapperCreate.obj
.\abclib\DebugLib\mapperCut.obj
.\abclib\DebugLib\mapperCutUtils.obj
.\abclib\DebugLib\mapperFanout.obj
.\abclib\DebugLib\mapperLib.obj
.\abclib\DebugLib\mapperMatch.obj
.\abclib\DebugLib\mapperRefs.obj
.\abclib\DebugLib\mapperSuper.obj
.\abclib\DebugLib\mapperSwitch.obj
.\abclib\DebugLib\mapperTable.obj
.\abclib\DebugLib\mapperTime.obj
.\abclib\DebugLib\mapperTree.obj
.\abclib\DebugLib\mapperTruth.obj
.\abclib\DebugLib\mapperUtils.obj
.\abclib\DebugLib\mapperVec.obj
.\abclib\DebugLib\mio.obj
.\abclib\DebugLib\mioApi.obj
.\abclib\DebugLib\mioFunc.obj
.\abclib\DebugLib\mioRead.obj
.\abclib\DebugLib\mioUtils.obj
.\abclib\DebugLib\super.obj
.\abclib\DebugLib\superAnd.obj
.\abclib\DebugLib\superGate.obj
.\abclib\DebugLib\superWrite.obj
.\abclib\DebugLib\ifCore.obj
.\abclib\DebugLib\ifCut.obj
.\abclib\DebugLib\ifMan.obj
.\abclib\DebugLib\ifMap.obj
.\abclib\DebugLib\ifPrepro.obj
.\abclib\DebugLib\ifReduce.obj
.\abclib\DebugLib\ifSeq.obj
.\abclib\DebugLib\ifTime.obj
.\abclib\DebugLib\ifTruth.obj
.\abclib\DebugLib\ifUtil.obj
.\abclib\DebugLib\extraBddAuto.obj
.\abclib\DebugLib\extraBddKmap.obj
.\abclib\DebugLib\extraBddMisc.obj
.\abclib\DebugLib\extraBddSymm.obj
.\abclib\DebugLib\extraBddUnate.obj
.\abclib\DebugLib\extraUtilBitMatrix.obj
.\abclib\DebugLib\extraUtilCanon.obj
.\abclib\DebugLib\extraUtilFile.obj
.\abclib\DebugLib\extraUtilMemory.obj
.\abclib\DebugLib\extraUtilMisc.obj
.\abclib\DebugLib\extraUtilProgress.obj
.\abclib\DebugLib\extraUtilReader.obj
.\abclib\DebugLib\extraUtilTruth.obj
.\abclib\DebugLib\extraUtilUtil.obj
.\abclib\DebugLib\st.obj
.\abclib\DebugLib\stmm.obj
.\abclib\DebugLib\mvc.obj
.\abclib\DebugLib\mvcApi.obj
.\abclib\DebugLib\mvcCompare.obj
.\abclib\DebugLib\mvcContain.obj
.\abclib\DebugLib\mvcCover.obj
.\abclib\DebugLib\mvcCube.obj
.\abclib\DebugLib\mvcDivide.obj
.\abclib\DebugLib\mvcDivisor.obj
.\abclib\DebugLib\mvcList.obj
.\abclib\DebugLib\mvcLits.obj
.\abclib\DebugLib\mvcMan.obj
.\abclib\DebugLib\mvcOpAlg.obj
.\abclib\DebugLib\mvcOpBool.obj
.\abclib\DebugLib\mvcPrint.obj
.\abclib\DebugLib\mvcSort.obj
.\abclib\DebugLib\mvcUtils.obj
.\abclib\DebugLib\cofactor.obj
.\abclib\DebugLib\cols.obj
.\abclib\DebugLib\compl.obj
.\abclib\DebugLib\contain.obj
.\abclib\DebugLib\cubehack.obj
.\abclib\DebugLib\cubestr.obj
.\abclib\DebugLib\cvrin.obj
.\abclib\DebugLib\cvrm.obj
.\abclib\DebugLib\cvrmisc.obj
.\abclib\DebugLib\cvrout.obj
.\abclib\DebugLib\dominate.obj
.\abclib\DebugLib\equiv.obj
.\abclib\DebugLib\espresso.obj
.\abclib\DebugLib\essen.obj
.\abclib\DebugLib\exact.obj
.\abclib\DebugLib\expand.obj
.\abclib\DebugLib\gasp.obj
.\abclib\DebugLib\gimpel.obj
.\abclib\DebugLib\globals.obj
.\abclib\DebugLib\hack.obj
.\abclib\DebugLib\indep.obj
.\abclib\DebugLib\irred.obj
.\abclib\DebugLib\map.obj
.\abclib\DebugLib\matrix.obj
.\abclib\DebugLib\mincov.obj
.\abclib\DebugLib\opo.obj
.\abclib\DebugLib\pair.obj
.\abclib\DebugLib\part.obj
.\abclib\DebugLib\primes.obj
.\abclib\DebugLib\reduce.obj
.\abclib\DebugLib\rows.obj
.\abclib\DebugLib\set.obj
.\abclib\DebugLib\setc.obj
.\abclib\DebugLib\sharp.obj
.\abclib\DebugLib\sminterf.obj
.\abclib\DebugLib\solution.obj
.\abclib\DebugLib\sparse.obj
.\abclib\DebugLib\unate.obj
.\abclib\DebugLib\verify.obj
.\abclib\DebugLib\nmApi.obj
.\abclib\DebugLib\nmTable.obj
.\abclib\DebugLib\hopBalance.obj
.\abclib\DebugLib\hopCheck.obj
.\abclib\DebugLib\hopDfs.obj
.\abclib\DebugLib\hopMan.obj
.\abclib\DebugLib\hopMem.obj
.\abclib\DebugLib\hopObj.obj
.\abclib\DebugLib\hopOper.obj
.\abclib\DebugLib\hopTable.obj
.\abclib\DebugLib\hopUtil.obj
.\abclib\DebugLib\ivyBalance.obj
.\abclib\DebugLib\ivyCanon.obj
.\abclib\DebugLib\ivyCheck.obj
.\abclib\DebugLib\ivyCut.obj
.\abclib\DebugLib\ivyCutTrav.obj
.\abclib\DebugLib\ivyDfs.obj
.\abclib\DebugLib\ivyDsd.obj
.\abclib\DebugLib\ivyFanout.obj
.\abclib\DebugLib\ivyFastMap.obj
.\abclib\DebugLib\ivyFraig.obj
.\abclib\DebugLib\ivyHaig.obj
.\abclib\DebugLib\ivyMan.obj
.\abclib\DebugLib\ivyMem.obj
.\abclib\DebugLib\ivyMulti.obj
.\abclib\DebugLib\ivyObj.obj
.\abclib\DebugLib\ivyOper.obj
.\abclib\DebugLib\ivyResyn.obj
.\abclib\DebugLib\ivyRwr.obj
.\abclib\DebugLib\ivySeq.obj
.\abclib\DebugLib\ivyShow.obj
.\abclib\DebugLib\ivyTable.obj
.\abclib\DebugLib\ivyUtil.obj
.\abclib\DebugLib\rwtDec.obj
.\abclib\DebugLib\rwtMan.obj
.\abclib\DebugLib\rwtUtil.obj
.\abclib\DebugLib\mem.obj
.\abclib\DebugLib\jfront.obj
]
Creating command line "link.exe -lib @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137B.tmp"
<h3>Output Window</h3>
Compiling...
jfront.c
Creating library...
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137C.tmp" with contents
[
/nologo /o"abclib\DebugLib/abclib.bsc"
.\abclib\DebugLib\abcAig.sbr
.\abclib\DebugLib\abcCheck.sbr
.\abclib\DebugLib\abcDfs.sbr
.\abclib\DebugLib\abcFanio.sbr
.\abclib\DebugLib\abcFunc.sbr
.\abclib\DebugLib\abcLatch.sbr
.\abclib\DebugLib\abcLib.sbr
.\abclib\DebugLib\abcMinBase.sbr
.\abclib\DebugLib\abcNames.sbr
.\abclib\DebugLib\abcNetlist.sbr
.\abclib\DebugLib\abcNtk.sbr
.\abclib\DebugLib\abcObj.sbr
.\abclib\DebugLib\abcRefs.sbr
.\abclib\DebugLib\abcShow.sbr
.\abclib\DebugLib\abcSop.sbr
.\abclib\DebugLib\abcUtil.sbr
.\abclib\DebugLib\abc.sbr
.\abclib\DebugLib\abcAttach.sbr
.\abclib\DebugLib\abcAuto.sbr
.\abclib\DebugLib\abcBalance.sbr
.\abclib\DebugLib\abcBmc.sbr
.\abclib\DebugLib\abcClpBdd.sbr
.\abclib\DebugLib\abcClpSop.sbr
.\abclib\DebugLib\abcCut.sbr
.\abclib\DebugLib\abcDebug.sbr
.\abclib\DebugLib\abcDress.sbr
.\abclib\DebugLib\abcDsd.sbr
.\abclib\DebugLib\abcEspresso.sbr
.\abclib\DebugLib\abcExtract.sbr
.\abclib\DebugLib\abcFpga.sbr
.\abclib\DebugLib\abcFpgaFast.sbr
.\abclib\DebugLib\abcFraig.sbr
.\abclib\DebugLib\abcFxu.sbr
.\abclib\DebugLib\abcGen.sbr
.\abclib\DebugLib\abcIf.sbr
.\abclib\DebugLib\abcIvy.sbr
.\abclib\DebugLib\abcLut.sbr
.\abclib\DebugLib\abcMap.sbr
.\abclib\DebugLib\abcMini.sbr
.\abclib\DebugLib\abcMiter.sbr
.\abclib\DebugLib\abcMulti.sbr
.\abclib\DebugLib\abcMv.sbr
.\abclib\DebugLib\abcNtbdd.sbr
.\abclib\DebugLib\abcOrder.sbr
.\abclib\DebugLib\abcPrint.sbr
.\abclib\DebugLib\abcProve.sbr
.\abclib\DebugLib\abcReconv.sbr
.\abclib\DebugLib\abcRefactor.sbr
.\abclib\DebugLib\abcRenode.sbr
.\abclib\DebugLib\abcReorder.sbr
.\abclib\DebugLib\abcRestruct.sbr
.\abclib\DebugLib\abcResub.sbr
.\abclib\DebugLib\abcRewrite.sbr
.\abclib\DebugLib\abcRr.sbr
.\abclib\DebugLib\abcSat.sbr
.\abclib\DebugLib\abcStrash.sbr
.\abclib\DebugLib\abcSweep.sbr
.\abclib\DebugLib\abcSymm.sbr
.\abclib\DebugLib\abcTiming.sbr
.\abclib\DebugLib\abcUnate.sbr
.\abclib\DebugLib\abcUnreach.sbr
.\abclib\DebugLib\abcVerify.sbr
.\abclib\DebugLib\abcXsim.sbr
.\abclib\DebugLib\cmd.sbr
.\abclib\DebugLib\cmdAlias.sbr
.\abclib\DebugLib\cmdApi.sbr
.\abclib\DebugLib\cmdFlag.sbr
.\abclib\DebugLib\cmdHist.sbr
.\abclib\DebugLib\cmdUtils.sbr
.\abclib\DebugLib\io.sbr
.\abclib\DebugLib\ioReadAiger.sbr
.\abclib\DebugLib\ioReadBaf.sbr
.\abclib\DebugLib\ioReadBench.sbr
.\abclib\DebugLib\ioReadBlif.sbr
.\abclib\DebugLib\ioReadBlifAig.sbr
.\abclib\DebugLib\ioReadEdif.sbr
.\abclib\DebugLib\ioReadEqn.sbr
.\abclib\DebugLib\ioReadPla.sbr
.\abclib\DebugLib\ioUtil.sbr
.\abclib\DebugLib\ioWriteAiger.sbr
.\abclib\DebugLib\ioWriteBaf.sbr
.\abclib\DebugLib\ioWriteBench.sbr
.\abclib\DebugLib\ioWriteBlif.sbr
.\abclib\DebugLib\ioWriteCnf.sbr
.\abclib\DebugLib\ioWriteDot.sbr
.\abclib\DebugLib\ioWriteEqn.sbr
.\abclib\DebugLib\ioWriteGml.sbr
.\abclib\DebugLib\ioWriteList.sbr
.\abclib\DebugLib\ioWritePla.sbr
.\abclib\DebugLib\ioWriteVer.sbr
.\abclib\DebugLib\ioWriteVerAux.sbr
.\abclib\DebugLib\libSupport.sbr
.\abclib\DebugLib\main.sbr
.\abclib\DebugLib\mainFrame.sbr
.\abclib\DebugLib\mainInit.sbr
.\abclib\DebugLib\mainUtils.sbr
.\abclib\DebugLib\verCore.sbr
.\abclib\DebugLib\verFormula.sbr
.\abclib\DebugLib\verParse.sbr
.\abclib\DebugLib\verStream.sbr
.\abclib\DebugLib\verWords.sbr
.\abclib\DebugLib\cuddAddAbs.sbr
.\abclib\DebugLib\cuddAddApply.sbr
.\abclib\DebugLib\cuddAddFind.sbr
.\abclib\DebugLib\cuddAddInv.sbr
.\abclib\DebugLib\cuddAddIte.sbr
.\abclib\DebugLib\cuddAddNeg.sbr
.\abclib\DebugLib\cuddAddWalsh.sbr
.\abclib\DebugLib\cuddAndAbs.sbr
.\abclib\DebugLib\cuddAnneal.sbr
.\abclib\DebugLib\cuddApa.sbr
.\abclib\DebugLib\cuddAPI.sbr
.\abclib\DebugLib\cuddApprox.sbr
.\abclib\DebugLib\cuddBddAbs.sbr
.\abclib\DebugLib\cuddBddCorr.sbr
.\abclib\DebugLib\cuddBddIte.sbr
.\abclib\DebugLib\cuddBridge.sbr
.\abclib\DebugLib\cuddCache.sbr
.\abclib\DebugLib\cuddCheck.sbr
.\abclib\DebugLib\cuddClip.sbr
.\abclib\DebugLib\cuddCof.sbr
.\abclib\DebugLib\cuddCompose.sbr
.\abclib\DebugLib\cuddDecomp.sbr
.\abclib\DebugLib\cuddEssent.sbr
.\abclib\DebugLib\cuddExact.sbr
.\abclib\DebugLib\cuddExport.sbr
.\abclib\DebugLib\cuddGenCof.sbr
.\abclib\DebugLib\cuddGenetic.sbr
.\abclib\DebugLib\cuddGroup.sbr
.\abclib\DebugLib\cuddHarwell.sbr
.\abclib\DebugLib\cuddInit.sbr
.\abclib\DebugLib\cuddInteract.sbr
.\abclib\DebugLib\cuddLCache.sbr
.\abclib\DebugLib\cuddLevelQ.sbr
.\abclib\DebugLib\cuddLinear.sbr
.\abclib\DebugLib\cuddLiteral.sbr
.\abclib\DebugLib\cuddMatMult.sbr
.\abclib\DebugLib\cuddPriority.sbr
.\abclib\DebugLib\cuddRead.sbr
.\abclib\DebugLib\cuddRef.sbr
.\abclib\DebugLib\cuddReorder.sbr
.\abclib\DebugLib\cuddSat.sbr
.\abclib\DebugLib\cuddSign.sbr
.\abclib\DebugLib\cuddSolve.sbr
.\abclib\DebugLib\cuddSplit.sbr
.\abclib\DebugLib\cuddSubsetHB.sbr
.\abclib\DebugLib\cuddSubsetSP.sbr
.\abclib\DebugLib\cuddSymmetry.sbr
.\abclib\DebugLib\cuddTable.sbr
.\abclib\DebugLib\cuddUtil.sbr
.\abclib\DebugLib\cuddWindow.sbr
.\abclib\DebugLib\cuddZddCount.sbr
.\abclib\DebugLib\cuddZddFuncs.sbr
.\abclib\DebugLib\cuddZddGroup.sbr
.\abclib\DebugLib\cuddZddIsop.sbr
.\abclib\DebugLib\cuddZddLin.sbr
.\abclib\DebugLib\cuddZddMisc.sbr
.\abclib\DebugLib\cuddZddPort.sbr
.\abclib\DebugLib\cuddZddReord.sbr
.\abclib\DebugLib\cuddZddSetop.sbr
.\abclib\DebugLib\cuddZddSymm.sbr
.\abclib\DebugLib\cuddZddUtil.sbr
.\abclib\DebugLib\epd.sbr
.\abclib\DebugLib\mtrBasic.sbr
.\abclib\DebugLib\mtrGroup.sbr
.\abclib\DebugLib\parseCore.sbr
.\abclib\DebugLib\parseEqn.sbr
.\abclib\DebugLib\parseStack.sbr
.\abclib\DebugLib\dsdApi.sbr
.\abclib\DebugLib\dsdCheck.sbr
.\abclib\DebugLib\dsdLocal.sbr
.\abclib\DebugLib\dsdMan.sbr
.\abclib\DebugLib\dsdProc.sbr
.\abclib\DebugLib\dsdTree.sbr
.\abclib\DebugLib\reoApi.sbr
.\abclib\DebugLib\reoCore.sbr
.\abclib\DebugLib\reoProfile.sbr
.\abclib\DebugLib\reoSift.sbr
.\abclib\DebugLib\reoSwap.sbr
.\abclib\DebugLib\reoTest.sbr
.\abclib\DebugLib\reoTransfer.sbr
.\abclib\DebugLib\reoUnits.sbr
.\abclib\DebugLib\added.sbr
.\abclib\DebugLib\asatmem.sbr
.\abclib\DebugLib\solver.sbr
.\abclib\DebugLib\msatActivity.sbr
.\abclib\DebugLib\msatClause.sbr
.\abclib\DebugLib\msatClauseVec.sbr
.\abclib\DebugLib\msatMem.sbr
.\abclib\DebugLib\msatOrderH.sbr
.\abclib\DebugLib\msatQueue.sbr
.\abclib\DebugLib\msatRead.sbr
.\abclib\DebugLib\msatSolverApi.sbr
.\abclib\DebugLib\msatSolverCore.sbr
.\abclib\DebugLib\msatSolverIo.sbr
.\abclib\DebugLib\msatSolverSearch.sbr
.\abclib\DebugLib\msatSort.sbr
.\abclib\DebugLib\msatVec.sbr
.\abclib\DebugLib\fraigApi.sbr
.\abclib\DebugLib\fraigCanon.sbr
.\abclib\DebugLib\fraigChoice.sbr
.\abclib\DebugLib\fraigFanout.sbr
.\abclib\DebugLib\fraigFeed.sbr
.\abclib\DebugLib\fraigMan.sbr
.\abclib\DebugLib\fraigMem.sbr
.\abclib\DebugLib\fraigNode.sbr
.\abclib\DebugLib\fraigPrime.sbr
.\abclib\DebugLib\fraigSat.sbr
.\abclib\DebugLib\fraigTable.sbr
.\abclib\DebugLib\fraigUtil.sbr
.\abclib\DebugLib\fraigVec.sbr
.\abclib\DebugLib\csat_apis.sbr
.\abclib\DebugLib\satMem.sbr
.\abclib\DebugLib\satSolver.sbr
.\abclib\DebugLib\satUtil.sbr
.\abclib\DebugLib\fxu.sbr
.\abclib\DebugLib\fxuCreate.sbr
.\abclib\DebugLib\fxuHeapD.sbr
.\abclib\DebugLib\fxuHeapS.sbr
.\abclib\DebugLib\fxuList.sbr
.\abclib\DebugLib\fxuMatrix.sbr
.\abclib\DebugLib\fxuPair.sbr
.\abclib\DebugLib\fxuPrint.sbr
.\abclib\DebugLib\fxuReduce.sbr
.\abclib\DebugLib\fxuSelect.sbr
.\abclib\DebugLib\fxuSingle.sbr
.\abclib\DebugLib\fxuUpdate.sbr
.\abclib\DebugLib\rwrDec.sbr
.\abclib\DebugLib\rwrEva.sbr
.\abclib\DebugLib\rwrExp.sbr
.\abclib\DebugLib\rwrLib.sbr
.\abclib\DebugLib\rwrMan.sbr
.\abclib\DebugLib\rwrPrint.sbr
.\abclib\DebugLib\rwrTemp.sbr
.\abclib\DebugLib\rwrUtil.sbr
.\abclib\DebugLib\cutApi.sbr
.\abclib\DebugLib\cutCut.sbr
.\abclib\DebugLib\cutExpand.sbr
.\abclib\DebugLib\cutMan.sbr
.\abclib\DebugLib\cutMerge.sbr
.\abclib\DebugLib\cutNode.sbr
.\abclib\DebugLib\cutOracle.sbr
.\abclib\DebugLib\cutPre22.sbr
.\abclib\DebugLib\cutSeq.sbr
.\abclib\DebugLib\cutTruth.sbr
.\abclib\DebugLib\decAbc.sbr
.\abclib\DebugLib\decFactor.sbr
.\abclib\DebugLib\decMan.sbr
.\abclib\DebugLib\decPrint.sbr
.\abclib\DebugLib\decUtil.sbr
.\abclib\DebugLib\simMan.sbr
.\abclib\DebugLib\simSat.sbr
.\abclib\DebugLib\simSeq.sbr
.\abclib\DebugLib\simSupp.sbr
.\abclib\DebugLib\simSwitch.sbr
.\abclib\DebugLib\simSym.sbr
.\abclib\DebugLib\simSymSat.sbr
.\abclib\DebugLib\simSymSim.sbr
.\abclib\DebugLib\simSymStr.sbr
.\abclib\DebugLib\simUtils.sbr
.\abclib\DebugLib\retArea.sbr
.\abclib\DebugLib\retCore.sbr
.\abclib\DebugLib\retDelay.sbr
.\abclib\DebugLib\retFlow.sbr
.\abclib\DebugLib\retIncrem.sbr
.\abclib\DebugLib\retInit.sbr
.\abclib\DebugLib\retLvalue.sbr
.\abclib\DebugLib\kitBdd.sbr
.\abclib\DebugLib\kitFactor.sbr
.\abclib\DebugLib\kitGraph.sbr
.\abclib\DebugLib\kitHop.sbr
.\abclib\DebugLib\kitIsop.sbr
.\abclib\DebugLib\kitSop.sbr
.\abclib\DebugLib\kitTruth.sbr
.\abclib\DebugLib\fpga.sbr
.\abclib\DebugLib\fpgaCore.sbr
.\abclib\DebugLib\fpgaCreate.sbr
.\abclib\DebugLib\fpgaCut.sbr
.\abclib\DebugLib\fpgaCutUtils.sbr
.\abclib\DebugLib\fpgaFanout.sbr
.\abclib\DebugLib\fpgaLib.sbr
.\abclib\DebugLib\fpgaMatch.sbr
.\abclib\DebugLib\fpgaSwitch.sbr
.\abclib\DebugLib\fpgaTime.sbr
.\abclib\DebugLib\fpgaTruth.sbr
.\abclib\DebugLib\fpgaUtils.sbr
.\abclib\DebugLib\fpgaVec.sbr
.\abclib\DebugLib\mapper.sbr
.\abclib\DebugLib\mapperCanon.sbr
.\abclib\DebugLib\mapperCore.sbr
.\abclib\DebugLib\mapperCreate.sbr
.\abclib\DebugLib\mapperCut.sbr
.\abclib\DebugLib\mapperCutUtils.sbr
.\abclib\DebugLib\mapperFanout.sbr
.\abclib\DebugLib\mapperLib.sbr
.\abclib\DebugLib\mapperMatch.sbr
.\abclib\DebugLib\mapperRefs.sbr
.\abclib\DebugLib\mapperSuper.sbr
.\abclib\DebugLib\mapperSwitch.sbr
.\abclib\DebugLib\mapperTable.sbr
.\abclib\DebugLib\mapperTime.sbr
.\abclib\DebugLib\mapperTree.sbr
.\abclib\DebugLib\mapperTruth.sbr
.\abclib\DebugLib\mapperUtils.sbr
.\abclib\DebugLib\mapperVec.sbr
.\abclib\DebugLib\mio.sbr
.\abclib\DebugLib\mioApi.sbr
.\abclib\DebugLib\mioFunc.sbr
.\abclib\DebugLib\mioRead.sbr
.\abclib\DebugLib\mioUtils.sbr
.\abclib\DebugLib\super.sbr
.\abclib\DebugLib\superAnd.sbr
.\abclib\DebugLib\superGate.sbr
.\abclib\DebugLib\superWrite.sbr
.\abclib\DebugLib\ifCore.sbr
.\abclib\DebugLib\ifCut.sbr
.\abclib\DebugLib\ifMan.sbr
.\abclib\DebugLib\ifMap.sbr
.\abclib\DebugLib\ifPrepro.sbr
.\abclib\DebugLib\ifReduce.sbr
.\abclib\DebugLib\ifSeq.sbr
.\abclib\DebugLib\ifTime.sbr
.\abclib\DebugLib\ifTruth.sbr
.\abclib\DebugLib\ifUtil.sbr
.\abclib\DebugLib\extraBddAuto.sbr
.\abclib\DebugLib\extraBddKmap.sbr
.\abclib\DebugLib\extraBddMisc.sbr
.\abclib\DebugLib\extraBddSymm.sbr
.\abclib\DebugLib\extraBddUnate.sbr
.\abclib\DebugLib\extraUtilBitMatrix.sbr
.\abclib\DebugLib\extraUtilCanon.sbr
.\abclib\DebugLib\extraUtilFile.sbr
.\abclib\DebugLib\extraUtilMemory.sbr
.\abclib\DebugLib\extraUtilMisc.sbr
.\abclib\DebugLib\extraUtilProgress.sbr
.\abclib\DebugLib\extraUtilReader.sbr
.\abclib\DebugLib\extraUtilTruth.sbr
.\abclib\DebugLib\extraUtilUtil.sbr
.\abclib\DebugLib\st.sbr
.\abclib\DebugLib\stmm.sbr
.\abclib\DebugLib\mvc.sbr
.\abclib\DebugLib\mvcApi.sbr
.\abclib\DebugLib\mvcCompare.sbr
.\abclib\DebugLib\mvcContain.sbr
.\abclib\DebugLib\mvcCover.sbr
.\abclib\DebugLib\mvcCube.sbr
.\abclib\DebugLib\mvcDivide.sbr
.\abclib\DebugLib\mvcDivisor.sbr
.\abclib\DebugLib\mvcList.sbr
.\abclib\DebugLib\mvcLits.sbr
.\abclib\DebugLib\mvcMan.sbr
.\abclib\DebugLib\mvcOpAlg.sbr
.\abclib\DebugLib\mvcOpBool.sbr
.\abclib\DebugLib\mvcPrint.sbr
.\abclib\DebugLib\mvcSort.sbr
.\abclib\DebugLib\mvcUtils.sbr
.\abclib\DebugLib\cofactor.sbr
.\abclib\DebugLib\cols.sbr
.\abclib\DebugLib\compl.sbr
.\abclib\DebugLib\contain.sbr
.\abclib\DebugLib\cubehack.sbr
.\abclib\DebugLib\cubestr.sbr
.\abclib\DebugLib\cvrin.sbr
.\abclib\DebugLib\cvrm.sbr
.\abclib\DebugLib\cvrmisc.sbr
.\abclib\DebugLib\cvrout.sbr
.\abclib\DebugLib\dominate.sbr
.\abclib\DebugLib\equiv.sbr
.\abclib\DebugLib\espresso.sbr
.\abclib\DebugLib\essen.sbr
.\abclib\DebugLib\exact.sbr
.\abclib\DebugLib\expand.sbr
.\abclib\DebugLib\gasp.sbr
.\abclib\DebugLib\gimpel.sbr
.\abclib\DebugLib\globals.sbr
.\abclib\DebugLib\hack.sbr
.\abclib\DebugLib\indep.sbr
.\abclib\DebugLib\irred.sbr
.\abclib\DebugLib\map.sbr
.\abclib\DebugLib\matrix.sbr
.\abclib\DebugLib\mincov.sbr
.\abclib\DebugLib\opo.sbr
.\abclib\DebugLib\pair.sbr
.\abclib\DebugLib\part.sbr
.\abclib\DebugLib\primes.sbr
.\abclib\DebugLib\reduce.sbr
.\abclib\DebugLib\rows.sbr
.\abclib\DebugLib\set.sbr
.\abclib\DebugLib\setc.sbr
.\abclib\DebugLib\sharp.sbr
.\abclib\DebugLib\sminterf.sbr
.\abclib\DebugLib\solution.sbr
.\abclib\DebugLib\sparse.sbr
.\abclib\DebugLib\unate.sbr
.\abclib\DebugLib\verify.sbr
.\abclib\DebugLib\nmApi.sbr
.\abclib\DebugLib\nmTable.sbr
.\abclib\DebugLib\hopBalance.sbr
.\abclib\DebugLib\hopCheck.sbr
.\abclib\DebugLib\hopDfs.sbr
.\abclib\DebugLib\hopMan.sbr
.\abclib\DebugLib\hopMem.sbr
.\abclib\DebugLib\hopObj.sbr
.\abclib\DebugLib\hopOper.sbr
.\abclib\DebugLib\hopTable.sbr
.\abclib\DebugLib\hopUtil.sbr
.\abclib\DebugLib\ivyBalance.sbr
.\abclib\DebugLib\ivyCanon.sbr
.\abclib\DebugLib\ivyCheck.sbr
.\abclib\DebugLib\ivyCut.sbr
.\abclib\DebugLib\ivyCutTrav.sbr
.\abclib\DebugLib\ivyDfs.sbr
.\abclib\DebugLib\ivyDsd.sbr
.\abclib\DebugLib\ivyFanout.sbr
.\abclib\DebugLib\ivyFastMap.sbr
.\abclib\DebugLib\ivyFraig.sbr
.\abclib\DebugLib\ivyHaig.sbr
.\abclib\DebugLib\ivyMan.sbr
.\abclib\DebugLib\ivyMem.sbr
.\abclib\DebugLib\ivyMulti.sbr
.\abclib\DebugLib\ivyObj.sbr
.\abclib\DebugLib\ivyOper.sbr
.\abclib\DebugLib\ivyResyn.sbr
.\abclib\DebugLib\ivyRwr.sbr
.\abclib\DebugLib\ivySeq.sbr
.\abclib\DebugLib\ivyShow.sbr
.\abclib\DebugLib\ivyTable.sbr
.\abclib\DebugLib\ivyUtil.sbr
.\abclib\DebugLib\rwtDec.sbr
.\abclib\DebugLib\rwtMan.sbr
.\abclib\DebugLib\rwtUtil.sbr
.\abclib\DebugLib\mem.sbr
.\abclib\DebugLib\jfront.sbr]
Creating command line "bscmake.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP137C.tmp"
Creating browse info file...
<h3>Output Window</h3>
<h3>Results</h3>
abclib_debug.lib - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

29
abctestlib.dsw
View File

@ -1,29 +0,0 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "abctestlib"=.\abctestlib.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

35
abctestlib.plg
View File

@ -1,35 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: abctestlib - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP1389.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR"Debug/" /Fp"Debug/abctestlib.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c
"C:\_projects\abc\demo.c"
]
Creating command line "cl.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP1389.tmp"
Creating temporary file "C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP138A.tmp" with contents
[
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib C:\_projects\abc\abclib\abclib_debug.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/abctestlib.pdb" /debug /machine:I386 /out:"_TEST/abctestlib.exe" /pdbtype:sept
.\Debug\demo.obj
]
Creating command line "link.exe @C:\DOCUME~1\alanmi\LOCALS~1\Temp\RSP138A.tmp"
<h3>Output Window</h3>
Compiling...
demo.c
Linking...
Creating command line "bscmake.exe /nologo /o"Debug/abctestlib.bsc" .\Debug\demo.sbr"
Creating browse info file...
<h3>Output Window</h3>
<h3>Results</h3>
abctestlib.exe - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

13
src/base/abc/abc.h
View File

@ -116,12 +116,17 @@ typedef enum {
#endif
#endif
#ifndef SINT64
#define SINT64
#ifdef _WIN32
typedef signed __int64 sint64; // compatible with MS VS 6.0
#else
typedef long long sint64;
#endif
#endif
typedef struct Abc_Lib_t_ Abc_Lib_t;
typedef struct Abc_Ntk_t_ Abc_Ntk_t;
typedef struct Abc_Obj_t_ Abc_Obj_t;
@ -204,6 +209,7 @@ struct Abc_Ntk_t_
int * pModel; // counter-example (for miters)
Abc_Ntk_t * pExdc; // the EXDC network (if given)
void * pData; // misc
Abc_Ntk_t * pCopy;
// node attributes
Vec_Ptr_t * vAttrs; // managers of various node attributes (node functionality, global BDDs, etc)
};
@ -521,6 +527,11 @@ extern void Abc_AigPrintNode( Abc_Obj_t * pNode );
extern bool Abc_AigNodeIsAcyclic( Abc_Obj_t * pNode, Abc_Obj_t * pRoot );
extern void Abc_AigCheckFaninOrder( Abc_Aig_t * pMan );
extern void Abc_AigSetNodePhases( Abc_Ntk_t * pNtk );
extern Vec_Ptr_t * Abc_AigUpdateStart( Abc_Aig_t * pMan );
extern void Abc_AigUpdateStop( Abc_Aig_t * pMan );
extern void Abc_AigUpdateReset( Abc_Aig_t * pMan );
extern void Abc_AigUpdateAdd( Abc_Aig_t * pMan, Abc_Obj_t * pObj );
extern Vec_Ptr_t * Abc_AigUpdateRead( Abc_Aig_t * pMan );
/*=== abcAttach.c ==========================================================*/
extern int Abc_NtkAttach( Abc_Ntk_t * pNtk );
/*=== abcBalance.c ==========================================================*/
@ -733,7 +744,7 @@ extern int Abc_NodeRef_rec( Abc_Obj_t * pNode );
/*=== abcRefactor.c ==========================================================*/
extern int Abc_NtkRefactor( Abc_Ntk_t * pNtk, int nNodeSizeMax, int nConeSizeMax, bool fUpdateLevel, bool fUseZeros, bool fUseDcs, bool fVerbose );
/*=== abcRewrite.c ==========================================================*/
extern int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose );
extern int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose, int fPlaceEnable );
/*=== abcSat.c ==========================================================*/
extern int Abc_NtkMiterSat( Abc_Ntk_t * pNtk, sint64 nConfLimit, sint64 nInsLimit, int fVerbose, sint64 * pNumConfs, sint64 * pNumInspects );
extern void * Abc_NtkMiterSatCreate( Abc_Ntk_t * pNtk, int fAllPrimes );

98
src/base/abc/abcAig.c
View File

@ -59,6 +59,7 @@ struct Abc_Aig_t_
Vec_Ptr_t * vStackReplaceNew; // the nodes to be used for replacement
Vec_Vec_t * vLevels; // the nodes to be updated
Vec_Vec_t * vLevelsR; // the nodes to be updated
Vec_Ptr_t * vUpdates; // the added and removed nodes
int nStrash0;
int nStrash1;
@ -162,6 +163,8 @@ void Abc_AigFree( Abc_Aig_t * pMan )
assert( Vec_PtrSize( pMan->vStackReplaceOld ) == 0 );
assert( Vec_PtrSize( pMan->vStackReplaceNew ) == 0 );
// free the table
if ( pMan->vUpdates )
Vec_PtrFree( pMan->vUpdates );
Vec_VecFree( pMan->vLevels );
Vec_VecFree( pMan->vLevelsR );
Vec_PtrFree( pMan->vStackReplaceOld );
@ -322,6 +325,9 @@ Abc_Obj_t * Abc_AigAndCreate( Abc_Aig_t * pMan, Abc_Obj_t * p0, Abc_Obj_t * p1 )
// if ( pAnd->pNtk->pManCut )
// Abc_NodeGetCuts( pAnd->pNtk->pManCut, pAnd );
pAnd->pCopy = NULL;
// add the node to the list of updated nodes
if ( pMan->vUpdates )
Vec_PtrPush( pMan->vUpdates, pAnd );
return pAnd;
}
@ -359,6 +365,9 @@ Abc_Obj_t * Abc_AigAndCreateFrom( Abc_Aig_t * pMan, Abc_Obj_t * p0, Abc_Obj_t *
// if ( pAnd->pNtk->pManCut )
// Abc_NodeGetCuts( pAnd->pNtk->pManCut, pAnd );
pAnd->pCopy = NULL;
// add the node to the list of updated nodes
if ( pMan->vUpdates )
Vec_PtrPush( pMan->vUpdates, pAnd );
return pAnd;
}
@ -539,6 +548,9 @@ void Abc_AigAndDelete( Abc_Aig_t * pMan, Abc_Obj_t * pThis )
// delete the cuts if defined
if ( pThis->pNtk->pManCut )
Abc_NodeFreeCuts( pThis->pNtk->pManCut, pThis );
// add the node to the list of updated nodes
if ( pMan->vUpdates )
Vec_PtrPush( pMan->vUpdates, pThis );
}
/**Function*************************************************************
@ -1343,6 +1355,92 @@ void Abc_AigSetNodePhases( Abc_Ntk_t * pNtk )
pObj->fPhase = (Abc_ObjFanin0(pObj)->fPhase ^ Abc_ObjFaninC0(pObj));
}
/**Function*************************************************************
Synopsis [Start the update list.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Ptr_t * Abc_AigUpdateStart( Abc_Aig_t * pMan )
{
assert( pMan->vUpdates == NULL );
return pMan->vUpdates = Vec_PtrAlloc( 1000 );
}
/**Function*************************************************************
Synopsis [Start the update list.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_AigUpdateStop( Abc_Aig_t * pMan )
{
assert( pMan->vUpdates != NULL );
Vec_PtrFree( pMan->vUpdates );
}
/**Function*************************************************************
Synopsis [Start the update list.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_AigUpdateReset( Abc_Aig_t * pMan )
{
assert( pMan->vUpdates != NULL );
Vec_PtrClear( pMan->vUpdates );
}
/**Function*************************************************************
Synopsis [Add a new update.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_AigUpdateAdd( Abc_Aig_t * pMan, Abc_Obj_t * pObj )
{
if ( pMan->vUpdates )
Vec_PtrPush( pMan->vUpdates, pObj );
}
/**Function*************************************************************
Synopsis [Read the updates array.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Ptr_t * Abc_AigUpdateRead( Abc_Aig_t * pMan )
{
return pMan->vUpdates;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////

294
src/base/abc/abcHie.c
View File

@ -54,16 +54,17 @@ void Abc_NtkFlattenLogicHierarchy_rec( Abc_Ntk_t * pNtkNew, Abc_Ntk_t * pNtk, in
assert( Abc_NtkBoxNum(pNtk) == 1 );
pObj = Abc_NtkBox( pNtk, 0 );
Abc_NtkDupBox( pNtkNew, pObj, 1 );
pObj->pCopy->pData = pNtk;
// connect blackbox fanins to the PI nets
assert( Abc_ObjFaninNum(pObj->pCopy) == Abc_NtkPiNum(pNtk) );
Abc_NtkForEachPi( pNtk, pTerm, i )
Abc_ObjAddFanin( Abc_ObjFanin(pObj->pCopy,i), Abc_ObjFanout0(pTerm) );
Abc_ObjAddFanin( Abc_ObjFanin(pObj->pCopy,i), Abc_ObjFanout0(pTerm)->pCopy );
// connect blackbox fanouts to the PO nets
assert( Abc_ObjFanoutNum(pObj->pCopy) == Abc_NtkPoNum(pNtk) );
Abc_NtkForEachPo( pNtk, pTerm, i )
Abc_ObjAddFanin( Abc_ObjFanin0(pTerm), Abc_ObjFanout(pObj->pCopy,i) );
Abc_ObjAddFanin( Abc_ObjFanin0(pTerm)->pCopy, Abc_ObjFanout(pObj->pCopy,i) );
return;
}
@ -163,8 +164,9 @@ Abc_Ntk_t * Abc_NtkFlattenLogicHierarchy( Abc_Ntk_t * pNtk )
Abc_Ntk_t * pNtkNew;
Abc_Obj_t * pTerm, * pNet;
int i, Counter;
assert( Abc_NtkIsNetlist(pNtk) );
extern Abc_Lib_t * Abc_LibDupBlackboxes( Abc_Lib_t * pLib, Abc_Ntk_t * pNtkSave );
assert( Abc_NtkIsNetlist(pNtk) );
// start the network
pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
// duplicate the name and the spec
@ -193,9 +195,16 @@ Abc_Ntk_t * Abc_NtkFlattenLogicHierarchy( Abc_Ntk_t * pNtk )
// recursively flatten hierarchy, create internal logic, add new PI/PO names if there are black boxes
Counter = -1;
Abc_NtkFlattenLogicHierarchy_rec( pNtkNew, pNtk, &Counter );
printf( "Abc_NtkFlattenLogicHierarchy(): Flattened %d logic instances. Preserved %d black boxes.\n",
printf( "Hierarchy reader flattened %d logic instances. Preserved %d black boxes.\n",
Counter, Abc_NtkBlackboxNum(pNtkNew) );
// pass the design
assert( Vec_PtrEntry(pNtk->pDesign->vModules, 0) == pNtk );
pNtkNew->pDesign = Abc_LibDupBlackboxes( pNtk->pDesign, pNtkNew );
// update the pointers
Abc_NtkForEachBlackbox( pNtkNew, pTerm, i )
pTerm->pData = ((Abc_Ntk_t *)pTerm->pData)->pCopy;
// copy the timing information
// Abc_ManTimeDup( pNtk, pNtkNew );
// duplicate EXDC
@ -328,6 +337,13 @@ Abc_Ntk_t * Abc_NtkInsertNewLogic( Abc_Ntk_t * pNtkH, Abc_Ntk_t * pNtkL )
assert( Abc_NtkWhiteboxNum(pNtkL) == 0 );
assert( Abc_NtkBlackboxNum(pNtkL) == 0 );
if ( Abc_NtkIsSopNetlist(pNtkH) && Abc_NtkIsAigNetlist(pNtkL) )
Abc_NtkSopToAig( pNtkH );
if ( Abc_NtkIsAigNetlist(pNtkH) && Abc_NtkIsSopNetlist(pNtkL) )
Abc_NtkSopToAig( pNtkL );
assert( pNtkH->ntkFunc == pNtkL->ntkFunc );
// prepare the logic network for copying
Abc_NtkCleanCopy( pNtkL );
@ -462,6 +478,276 @@ Abc_Ntk_t * Abc_NtkInsertNewLogic( Abc_Ntk_t * pNtkH, Abc_Ntk_t * pNtkL )
return pNtkNew;
}
/**Function*************************************************************
Synopsis [Assigns name with index.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkConvertAssignName( Abc_Obj_t * pObj, Abc_Obj_t * pNet, int Index )
{
char Suffix[16];
assert( Abc_ObjIsTerm(pObj) );
assert( Abc_ObjIsNet(pNet) );
sprintf( Suffix, "[%d]", Index );
Abc_ObjAssignName( pObj, Abc_ObjName(pNet), Suffix );
}
/**Function*************************************************************
Synopsis [Strashes the BLIF-MV netlist.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Ntk_t * Abc_NtkConvertBlifMv( Abc_Ntk_t * pNtk )
{
char * pSop;
Vec_Ptr_t * vNodes;
Abc_Obj_t * pBits[16];
Abc_Obj_t ** pValues, ** pValuesF;
Abc_Ntk_t * pNtkNew;
Abc_Obj_t * pObj, * pTemp, * pBit, * pFanin, * pNet;
int fUsePositional = 0;
int i, k, v, nValues, Val, Index, Len, nBits, Def;
assert( Abc_NtkIsNetlist(pNtk) );
assert( Abc_NtkHasBlifMv(pNtk) );
// clean the node copy fields
Abc_NtkCleanCopy( pNtk );
// start the network
pNtkNew = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
// duplicate the name and the spec
pNtkNew->pName = Extra_UtilStrsav( pNtk->pName );
// pNtkNew->pSpec = Extra_UtilStrsav( pNtk->pName );
// check temporary assumptions
Abc_NtkForEachNet( pNtk, pObj, i )
assert( Abc_ObjMvVarNum(pObj) < 10 );
// encode the CI nets
if ( fUsePositional )
{
Abc_NtkForEachCi( pNtk, pObj, i )
{
pNet = Abc_ObjFanout0(pObj);
nValues = Abc_ObjMvVarNum(pNet);
pValues = ALLOC( Abc_Obj_t *, nValues );
// create PIs for the values
for ( v = 0; v < nValues; v++ )
{
pValues[v] = Abc_NtkCreatePi( pNtkNew );
Abc_NtkConvertAssignName( pValues[v], pNet, v );
}
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
}
}
else
{
Abc_NtkForEachCi( pNtk, pObj, i )
{
pNet = Abc_ObjFanout0(pObj);
nValues = Abc_ObjMvVarNum(pNet);
pValues = ALLOC( Abc_Obj_t *, nValues );
// create PIs for the encoding bits
nBits = Extra_Base2Log( nValues );
for ( k = 0; k < nBits; k++ )
{
pBits[k] = Abc_NtkCreatePi( pNtkNew );
Abc_NtkConvertAssignName( pBits[k], pNet, k );
}
// encode the values
for ( v = 0; v < nValues; v++ )
{
pValues[v] = Abc_AigConst1(pNtkNew);
for ( k = 0; k < nBits; k++ )
{
pBit = Abc_ObjNotCond( pBits[k], (v&(1<<k)) == 0 );
pValues[v] = Abc_AigAnd( pNtkNew->pManFunc, pValues[v], pBit );
}
}
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
}
}
// process nodes in the topological order
vNodes = Abc_NtkDfs( pNtk, 0 );
Vec_PtrForEachEntry( vNodes, pObj, i )
{
assert( Abc_ObjIsNode(pObj) );
pNet = Abc_ObjFanout0(pObj);
nValues = Abc_ObjMvVarNum(pNet);
pValues = ALLOC( Abc_Obj_t *, nValues );
for ( v = 0; v < nValues; v++ )
pValues[v] = Abc_ObjNot( Abc_AigConst1(pNtkNew) );
// get the BLIF-MV formula
pSop = pObj->pData;
// skip the value line
while ( *pSop++ != '\n' );
// handle the constant
if ( Abc_ObjFaninNum(pObj) == 0 )
{
Index = *pSop-'0';
pValues[Index] = Abc_AigConst1(pNtkNew);
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
continue;
}
/*
// handle the mux
if ( *pSop != 'd' )
{
assert( Abc_ObjFaninNum(pObj) == 3 );
pValuesF = (Abc_Obj_t **)Abc_ObjFanin(pObj,1)->pCopy;
for ( v = 0; v < nValues; v++ )
pValues[v] = pValuesF[v];
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
continue;
}
*/
// detect muxes
Len = strlen(pSop);
for ( k = 0; k < Len; k++ )
if ( *(pSop+k) == '=' )
break;
if ( k < Len )
{
assert( Abc_ObjFaninNum(pObj) == 3 );
pValuesF = (Abc_Obj_t **)Abc_ObjFanin(pObj,1)->pCopy;
for ( v = 0; v < nValues; v++ )
pValues[v] = pValuesF[v];
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
continue;
}
// skip the default line
// assert( *pSop == 'd' );
if ( *pSop == 'd' )
{
Def = *(pSop+1) - '0';
while ( *pSop++ != '\n' );
}
else
Def = -1;
// convert the values
while ( *pSop )
{
// encode the values
pTemp = Abc_AigConst1(pNtkNew);
Abc_ObjForEachFanin( pObj, pFanin, k )
{
if ( *pSop == '-' )
{
pSop += 2;
continue;
}
Val = Abc_ObjMvVarNum(pFanin);
pValuesF = (Abc_Obj_t **)pFanin->pCopy;
Index = *pSop-'0';
assert( Index >= 0 && Index <= 9 && Index < Val );
pTemp = Abc_AigAnd( pNtkNew->pManFunc, pTemp, pValuesF[Index] );
pSop += 2;
}
// get the output value
Index = *pSop-'0';
assert( Index >= 0 && Index <= 9 );
pValues[Index] = Abc_AigOr( pNtkNew->pManFunc, pValues[Index], pTemp );
pSop++;
assert( *pSop == '\n' );
pSop++;
}
// compute the default value
// Def = 0;
if ( Def >= 0 )
{
assert( pValues[Def] == Abc_ObjNot( Abc_AigConst1(pNtkNew) ) );
pValues[Def] = Abc_AigConst1(pNtkNew);
for ( v = 0; v < nValues; v++ )
{
if ( v == Def )
continue;
pValues[Def] = Abc_AigAnd( pNtkNew->pManFunc, pValues[Def], Abc_ObjNot(pValues[v]) );
}
// experiment
// if ( nValues > 2 )
// pValues[Def] = Abc_ObjNot( Abc_AigConst1(pNtkNew) );
}
// save the values in the fanout net
pNet->pCopy = (Abc_Obj_t *)pValues;
}
Vec_PtrFree( vNodes );
// encode the CO nets
if ( fUsePositional )
{
Abc_NtkForEachCo( pNtk, pObj, i )
{
pNet = Abc_ObjFanin0(pObj);
nValues = Abc_ObjMvVarNum(pNet);
pValues = (Abc_Obj_t **)pNet->pCopy;
for ( v = 0; v < nValues; v++ )
{
pTemp = Abc_NtkCreatePo( pNtkNew );
Abc_ObjAddFanin( pTemp, pValues[v] );
Abc_NtkConvertAssignName( pTemp, pNet, v );
}
}
}
else
{
Abc_NtkForEachCo( pNtk, pObj, i )
{
pNet = Abc_ObjFanin0(pObj);
nValues = Abc_ObjMvVarNum(pNet);
pValues = (Abc_Obj_t **)pNet->pCopy;
nBits = Extra_Base2Log( nValues );
for ( k = 0; k < nBits; k++ )
{
pBit = Abc_ObjNot( Abc_AigConst1(pNtkNew) );
for ( v = 0; v < nValues; v++ )
if ( v & (1<<k) )
pBit = Abc_AigOr( pNtkNew->pManFunc, pBit, pValues[v] );
pTemp = Abc_NtkCreatePo( pNtkNew );
Abc_ObjAddFanin( pTemp, pBit );
Abc_NtkConvertAssignName( pTemp, pNet, k );
}
}
}
// cleanup
Abc_NtkForEachObj( pNtk, pObj, i )
if ( pObj->pCopy )
free( pObj->pCopy );
Abc_AigCleanup(pNtkNew->pManFunc);
// check integrity
if ( !Abc_NtkCheck( pNtkNew ) )
{
fprintf( stdout, "Abc_NtkConvertBlifMv(): Network check has failed.\n" );
Abc_NtkDelete( pNtkNew );
return NULL;
}
return pNtkNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////

27
src/base/abc/abcLib.c
View File

@ -81,6 +81,7 @@ void Abc_LibFree( Abc_Lib_t * pLib, Abc_Ntk_t * pNtkSave )
// pNtk->pManFunc = NULL;
if ( pNtk == pNtkSave )
continue;
pNtk->pManFunc = NULL;
Abc_NtkDelete( pNtk );
}
Vec_PtrFree( pLib->vModules );
@ -90,6 +91,32 @@ void Abc_LibFree( Abc_Lib_t * pLib, Abc_Ntk_t * pNtkSave )
free( pLib );
}
/**Function*************************************************************
Synopsis [Frees the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Lib_t * Abc_LibDupBlackboxes( Abc_Lib_t * pLib, Abc_Ntk_t * pNtkSave )
{
Abc_Lib_t * pLibNew;
Abc_Ntk_t * pNtkTemp;
int i;
pLibNew = Abc_LibCreate( pLib->pName );
// pLibNew->pManFunc = pNtkSave->pManFunc;
Vec_PtrPush( pLibNew->vModules, pNtkSave );
Vec_PtrForEachEntry( pLib->vModules, pNtkTemp, i )
if ( Abc_NtkHasBlackbox( pNtkTemp ) )
Vec_PtrPush( pLibNew->vModules, Abc_NtkDup(pNtkTemp) );
return pLibNew;
}
/**Function*************************************************************
Synopsis [Prints the library.]

19
src/base/abc/abcNtk.c
View File

@ -242,15 +242,23 @@ Abc_Ntk_t * Abc_NtkStartRead( char * pName )
***********************************************************************/
void Abc_NtkFinalizeRead( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pBox, * pObj;
Abc_Obj_t * pBox, * pObj, * pTerm;
int i;
if ( Abc_NtkHasBlackbox(pNtk) )
{
pBox = Abc_NtkCreateBlackbox(pNtk);
Abc_NtkForEachPi( pNtk, pObj, i )
Abc_ObjAddFanin( pBox, Abc_ObjFanout0(pObj) );
{
pTerm = Abc_NtkCreateBi(pNtk);
Abc_ObjAddFanin( pTerm, Abc_ObjFanout0(pObj) );
Abc_ObjAddFanin( pBox, pTerm );
}
Abc_NtkForEachPo( pNtk, pObj, i )
Abc_ObjAddFanin( Abc_ObjFanin0(pObj), pBox );
{
pTerm = Abc_NtkCreateBo(pNtk);
Abc_ObjAddFanin( pTerm, pBox );
Abc_ObjAddFanin( Abc_ObjFanin0(pObj), pTerm );
}
return;
}
assert( Abc_NtkIsNetlist(pNtk) );
@ -315,6 +323,7 @@ Abc_Ntk_t * Abc_NtkDup( Abc_Ntk_t * pNtk )
pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
if ( !Abc_NtkCheck( pNtkNew ) )
fprintf( stdout, "Abc_NtkDup(): Network check has failed.\n" );
pNtk->pCopy = pNtkNew;
return pNtkNew;
}
@ -799,8 +808,6 @@ void Abc_NtkDelete( Abc_Ntk_t * pNtk )
free( pObj );
}
FREE( pNtk->pName );
FREE( pNtk->pSpec );
// free the arrays
Vec_PtrFree( pNtk->vPios );
Vec_PtrFree( pNtk->vPis );
@ -852,6 +859,8 @@ void Abc_NtkDelete( Abc_Ntk_t * pNtk )
if ( pAttrMan )
Vec_AttFree( pAttrMan, 1 );
Vec_PtrFree( pNtk->vAttrs );
FREE( pNtk->pName );
FREE( pNtk->pSpec );
free( pNtk );
}

18
src/base/abci/abc.c
View File

@ -2680,6 +2680,7 @@ int Abc_CommandRewrite( Abc_Frame_t * pAbc, int argc, char ** argv )
bool fUseZeros;
bool fVerbose;
bool fVeryVerbose;
bool fPlaceEnable;
// external functions
extern void Rwr_Precompute();
@ -2693,8 +2694,9 @@ int Abc_CommandRewrite( Abc_Frame_t * pAbc, int argc, char ** argv )
fUseZeros = 0;
fVerbose = 0;
fVeryVerbose = 0;
fPlaceEnable = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "lxzvwh" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "lxzvwph" ) ) != EOF )
{
switch ( c )
{
@ -2713,6 +2715,9 @@ int Abc_CommandRewrite( Abc_Frame_t * pAbc, int argc, char ** argv )
case 'w':
fVeryVerbose ^= 1;
break;
case 'p':
fPlaceEnable ^= 1;
break;
case 'h':
goto usage;
default:
@ -2743,7 +2748,7 @@ int Abc_CommandRewrite( Abc_Frame_t * pAbc, int argc, char ** argv )
}
// modify the current network
if ( !Abc_NtkRewrite( pNtk, fUpdateLevel, fUseZeros, fVerbose, fVeryVerbose ) )
if ( !Abc_NtkRewrite( pNtk, fUpdateLevel, fUseZeros, fVerbose, fVeryVerbose, fPlaceEnable ) )
{
fprintf( pErr, "Rewriting has failed.\n" );
return 1;
@ -2751,12 +2756,13 @@ int Abc_CommandRewrite( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
usage:
fprintf( pErr, "usage: rewrite [-lzvwh]\n" );
fprintf( pErr, "usage: rewrite [-lzvwph]\n" );
fprintf( pErr, "\t performs technology-independent rewriting of the AIG\n" );
fprintf( pErr, "\t-l : toggle preserving the number of levels [default = %s]\n", fUpdateLevel? "yes": "no" );
fprintf( pErr, "\t-z : toggle using zero-cost replacements [default = %s]\n", fUseZeros? "yes": "no" );
fprintf( pErr, "\t-v : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" );
fprintf( pErr, "\t-w : toggle printout subgraph statistics [default = %s]\n", fVeryVerbose? "yes": "no" );
fprintf( pErr, "\t-p : toggle placement-aware rewriting [default = %s]\n", fPlaceEnable? "yes": "no" );
fprintf( pErr, "\t-h : print the command usage\n");
return 1;
}
@ -5424,8 +5430,8 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
int nLevels;
// extern Abc_Ntk_t * Abc_NtkNewAig( Abc_Ntk_t * pNtk );
// extern Abc_Ntk_t * Abc_NtkIvy( Abc_Ntk_t * pNtk );
extern void Abc_NtkMaxFlowTest( Abc_Ntk_t * pNtk );
extern int Pr_ManProofTest( char * pFileName );
// extern void Abc_NtkMaxFlowTest( Abc_Ntk_t * pNtk );
// extern int Pr_ManProofTest( char * pFileName );
pNtk = Abc_FrameReadNtk(pAbc);
pOut = Abc_FrameReadOut(pAbc);
@ -5520,7 +5526,7 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
*/
// Abc_NtkMaxFlowTest( pNtk );
Pr_ManProofTest( "trace.cnf" );
// Pr_ManProofTest( "trace.cnf" );
return 0;
usage:

4
src/base/abci/abcIvy.c
View File

@ -525,10 +525,10 @@ int Abc_NtkIvyProve( Abc_Ntk_t ** ppNtk, void * pPars )
if ( pParams->fUseRewriting && Abc_NtkNodeNum(pNtk) > 500 )
{
pParams->fUseRewriting = 0;
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 );
Abc_NtkDelete( pNtkTemp );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
Abc_NtkRefactor( pNtk, 10, 16, 0, 0, 0, 0 );
}

253
src/base/abci/abcPlace.c Normal file
View File

@ -0,0 +1,253 @@
/**CFile****************************************************************
FileName [abcPlace.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Network and node package.]
Synopsis [Interface with a placer.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - June 20, 2005.]
Revision [$Id: abcPlace.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
***********************************************************************/
#include "abc.h"
// placement includes
#include "place_base.h"
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
AbstractCell *abstractCells = NULL;
ConcreteCell *cells = NULL;
ConcreteNet *nets = NULL;
int nAllocSize = 0;
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Creates a new cell.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Abc_PlaceCreateCell( Abc_Obj_t * pObj, int fAnd )
{
assert( cells[pObj->Id].m_id == 0 );
cells[pObj->Id].m_id = pObj->Id;
cells[pObj->Id].m_label = "";
cells[pObj->Id].m_parent = &(abstractCells[fAnd]);
cells[pObj->Id].m_fixed = 0;
addConcreteCell(&(cells[pObj->Id]));
}
/**Function*************************************************************
Synopsis [Updates the net.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Abc_PlaceUpdateNet( Abc_Obj_t * pObj )
{
Abc_Obj_t * pFanout;
int k;
// free the old array of net terminals
if ( nets[pObj->Id].m_terms )
free( nets[pObj->Id].m_terms );
// fill in the net with the new information
nets[pObj->Id].m_id = pObj->Id;
nets[pObj->Id].m_weight = 1.0;
nets[pObj->Id].m_numTerms = Abc_ObjFanoutNum(pObj); //fanout
nets[pObj->Id].m_terms = ALLOC(ConcreteCell*, Abc_ObjFanoutNum(pObj));
Abc_ObjForEachFanout( pObj, pFanout, k )
nets[pObj->Id].m_terms[k] = &(cells[pFanout->Id]);
addConcreteNet(&(nets[pObj->Id]));
}
/**Function*************************************************************
Synopsis [Returns the placement cost of the cut.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
float Abc_PlaceEvaluateCut( Abc_Obj_t * pRoot, Vec_Ptr_t * vFanins )
{
Abc_Obj_t * pObj;
// double x, y;
int i;
Vec_PtrForEachEntry( vFanins, pObj, i )
{
// pObj->Id
}
return 0.0;
}
/**Function*************************************************************
Synopsis [Updates placement after one step of rewriting.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_PlaceUpdate( Vec_Ptr_t * vUpdates, int nNodesOld )
{
Abc_Obj_t * pObj, * pFanin;
int i, k;
Vec_Ptr_t * vCells, * vNets;
// start the arrays of new cells and nets
vCells = Vec_PtrAlloc( 16 );
vNets = Vec_PtrAlloc( 32 );
// go through the modified nodes
Vec_PtrForEachEntry( vUpdates, pObj, i )
{
if ( pObj->Id > nNodesOld ) // pObj is a new node
{
Abc_PlaceCreateCell( pObj, 1 );
Abc_PlaceUpdateNet( pObj );
// add the new cell and its fanin nets to temporary storage
Vec_PtrPush( vCells, &(cells[pObj->Id]) );
Abc_ObjForEachFanin( pObj, pFanin, k )
Vec_PtrPushUnique( vNets, &(nets[pFanin->Id]) );
}
else // pObj is an old node
{
Abc_PlaceUpdateNet( Abc_ObjFanin0(pObj) );
Abc_PlaceUpdateNet( Abc_ObjFanin1(pObj) );
}
}
// update the placement
// fastPlace( Vec_PtrSize(vCells), (ConcreteCell **)Vec_PtrArray(vCells),
// Vec_PtrSize(vNets), (ConcreteNet **)Vec_PtrArray(vNets) );
// clean up
Vec_PtrFree( vCells );
Vec_PtrFree( vNets );
}
/**Function*************************************************************
Synopsis [This procedure is called before the writing start.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_PlaceBegin( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj;
int i;
// allocate and clean internal storage
nAllocSize = 5 * Abc_NtkObjNumMax(pNtk);
cells = REALLOC(ConcreteCell, cells, nAllocSize);
nets = REALLOC(ConcreteNet, nets, nAllocSize);
memset( cells, 0, sizeof(ConcreteCell) * nAllocSize );
memset( nets, 0, sizeof(ConcreteNet) * nAllocSize );
// create AbstractCells
// 1: pad
// 2: and
if (!abstractCells)
abstractCells = ALLOC(AbstractCell,2);
abstractCells[0].m_height = 1.0;
abstractCells[0].m_width = 1.0;
abstractCells[0].m_label = "pio";
abstractCells[0].m_pad = 1;
abstractCells[1].m_height = 1.0;
abstractCells[1].m_width = 1.0;
abstractCells[1].m_label = "and";
abstractCells[1].m_pad = 0;
// input pads
Abc_NtkForEachCi( pNtk, pObj, i )
Abc_PlaceCreateCell( pObj, 0 );
// ouput pads
Abc_NtkForEachCo( pNtk, pObj, i )
Abc_PlaceCreateCell( pObj, 0 );
// AND nodes
Abc_AigForEachAnd( pNtk, pObj, i )
Abc_PlaceCreateCell( pObj, 1 );
// all nets
Abc_NtkForEachObj( pNtk, pObj, i )
{
if ( !Abc_ObjIsCi(pObj) && !Abc_ObjIsNode(pObj) )
continue;
Abc_PlaceUpdateNet( pObj );
}
globalPreplace((float)0.8);
globalPlace();
}
/**Function*************************************************************
Synopsis [This procedure is called after the writing completes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_PlaceEnd( Abc_Ntk_t * pNtk )
{
int i;
// clean up
for ( i = 0; i < nAllocSize; i++ )
FREE( nets[i].m_terms );
FREE( abstractCells );
FREE( cells );
FREE( nets );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////

8
src/base/abci/abcProve.c
View File

@ -133,13 +133,13 @@ int Abc_NtkMiterProve( Abc_Ntk_t ** ppNtk, void * pPars )
break;
*/
/*
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
break;
if ( --Counter == 0 )
break;
*/
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
break;
if ( --Counter == 0 )
@ -328,9 +328,9 @@ void Abc_NtkMiterPrint( Abc_Ntk_t * pNtk, char * pString, int clk, int fVerbose
Abc_Ntk_t * Abc_NtkMiterRwsat( Abc_Ntk_t * pNtk )
{
Abc_Ntk_t * pNtkTemp;
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 ); Abc_NtkDelete( pNtkTemp );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0 );
Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
Abc_NtkRefactor( pNtk, 10, 16, 0, 0, 0, 0 );
return pNtk;
}

86
src/base/abci/abcRewrite.c
View File

@ -36,6 +36,10 @@ static Cut_Man_t * Abc_NtkStartCutManForRewrite( Abc_Ntk_t * pNtk );
static void Abc_NodePrintCuts( Abc_Obj_t * pNode );
static void Abc_ManShowCutCone( Abc_Obj_t * pNode, Vec_Ptr_t * vLeaves );
extern void Abc_PlaceBegin( Abc_Ntk_t * pNtk );
extern void Abc_PlaceEnd( Abc_Ntk_t * pNtk );
extern void Abc_PlaceUpdate( Vec_Ptr_t * vUpdates, int nNodesOld );
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
@ -51,18 +55,28 @@ static void Abc_ManShowCutCone( Abc_Obj_t * pNode, Vec_Ptr_t * vLeaves );
SeeAlso []
***********************************************************************/
int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose )
int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose, int fPlaceEnable )
{
ProgressBar * pProgress;
Cut_Man_t * pManCut;
Rwr_Man_t * pManRwr;
Abc_Obj_t * pNode;
int i, nNodes, nGain;
Vec_Ptr_t * vUpdates = NULL;
Dec_Graph_t * pGraph;
int i, nNodes, nGain, fCompl;
int clk, clkStart = clock();
assert( Abc_NtkIsStrash(pNtk) );
// cleanup the AIG
Abc_AigCleanup(pNtk->pManFunc);
// start placement package
if ( fPlaceEnable )
{
Abc_PlaceBegin( pNtk );
vUpdates = Abc_AigUpdateStart( pNtk->pManFunc );
}
// start the rewriting manager
pManRwr = Rwr_ManStart( 0 );
if ( pManRwr == NULL )
@ -88,61 +102,37 @@ Rwr_ManAddTimeCuts( pManRwr, clock() - clk );
// stop if all nodes have been tried once
if ( i >= nNodes )
break;
// skip the constant node
// if ( Abc_NodeIsConst(pNode) )
// continue;
// skip persistant nodes
if ( Abc_NodeIsPersistant(pNode) )
continue;
// skip the nodes with many fanouts
if ( Abc_ObjFanoutNum(pNode) > 1000 )
continue;
//printf( "*******Node %d: \n", pNode->Id );
// for each cut, try to resynthesize it
nGain = Rwr_NodeRewrite( pManRwr, pManCut, pNode, fUpdateLevel, fUseZeros );
if ( nGain > 0 || nGain == 0 && fUseZeros )
{
// extern void Abc_RwrExpWithCut( Abc_Obj_t * pNode, Vec_Ptr_t * vLeaves );
nGain = Rwr_NodeRewrite( pManRwr, pManCut, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
if ( !(nGain > 0 || nGain == 0 && fUseZeros) )
continue;
// if we end up here, a rewriting step is accepted
Dec_Graph_t * pGraph = Rwr_ManReadDecs(pManRwr);
int fCompl = Rwr_ManReadCompl(pManRwr);
// get hold of the new subgraph to be added to the AIG
pGraph = Rwr_ManReadDecs(pManRwr);
fCompl = Rwr_ManReadCompl(pManRwr);
// Abc_RwrExpWithCut( pNode, Rwr_ManReadLeaves(pManRwr) );
// reset the array of the changed nodes
if ( fPlaceEnable )
Abc_AigUpdateReset( pNtk->pManFunc );
/*
{
Abc_Obj_t * pObj;
int i;
printf( "USING: (" );
Vec_PtrForEachEntry( Rwr_ManReadLeaves(pManRwr), pObj, i )
printf( "%d ", Abc_ObjFanoutNum(Abc_ObjRegular(pObj)) );
printf( ") Gain = %d.\n", nGain );
}
*/
// if ( nGain > 0 )
// Abc_ManShowCutCone( pNode, Rwr_ManReadLeaves(pManRwr) );
/*
if ( nGain > 0 )
{ // print stats on the MFFC
extern void Abc_NodeMffsConeSuppPrint( Abc_Obj_t * pNode );
printf( "Node %6d : Gain = %4d ", pNode->Id, nGain );
Abc_NodeMffsConeSuppPrint( pNode );
}
*/
// complement the FF if needed
if ( fCompl ) Dec_GraphComplement( pGraph );
// complement the FF if needed
if ( fCompl ) Dec_GraphComplement( pGraph );
clk = clock();
Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, clock() - clk );
if ( fCompl ) Dec_GraphComplement( pGraph );
// {
// extern int s_TotalChanges;
// s_TotalChanges++;
// }
}
if ( fCompl ) Dec_GraphComplement( pGraph );
// use the array of changed nodes to update placement
if ( fPlaceEnable )
Abc_PlaceUpdate( vUpdates, nNodes );
}
Extra_ProgressBarStop( pProgress );
Rwr_ManAddTimeTotal( pManRwr, clock() - clkStart );
@ -156,6 +146,14 @@ Rwr_ManAddTimeTotal( pManRwr, clock() - clkStart );
Rwr_ManStop( pManRwr );
Cut_ManStop( pManCut );
pNtk->pManCut = NULL;
// start placement package
if ( fPlaceEnable )
{
Abc_PlaceEnd( pNtk );
Abc_AigUpdateStop( pNtk->pManFunc );
}
// put the nodes into the DFS order and reassign their IDs
Abc_NtkReassignIds( pNtk );
// Abc_AigCheckFaninOrder( pNtk->pManFunc );

1
src/base/abci/module.make
View File

@ -26,6 +26,7 @@ SRC += src/base/abci/abc.c \
src/base/abci/abcNtbdd.c \
src/base/abci/abcOdc.c \
src/base/abci/abcOrder.c \
src/base/abci/abcPlace.c \
src/base/abci/abcPrint.c \
src/base/abci/abcProve.c \
src/base/abci/abcReconv.c \

62
src/base/io/io.c
View File

@ -26,7 +26,6 @@
////////////////////////////////////////////////////////////////////////
static int IoCommandRead ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadHie ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadAiger ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadBaf ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadBlif ( Abc_Frame_t * pAbc, int argc, char **argv );
@ -76,7 +75,6 @@ extern Abc_Lib_t * Ver_ParseFile( char * pFileName, Abc_Lib_t * pGateLib, int fC
void Io_Init( Abc_Frame_t * pAbc )
{
Cmd_CommandAdd( pAbc, "I/O", "read", IoCommandRead, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_hie", IoCommandReadHie, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_aiger", IoCommandReadAiger, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_baf", IoCommandReadBaf, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_blif", IoCommandReadBlif, 1 );
@ -178,61 +176,6 @@ usage:
return 1;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int IoCommandReadHie( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Abc_Ntk_t * pNtk;
char * pFileName;
int fCheck;
int c;
fCheck = 1;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "ch" ) ) != EOF )
{
switch ( c )
{
case 'c':
fCheck ^= 1;
break;
case 'h':
goto usage;
default:
goto usage;
}
}
if ( argc != globalUtilOptind + 1 )
goto usage;
// get the input file name
pFileName = argv[globalUtilOptind];
// read the file using the corresponding file reader
pNtk = Io_ReadHie( pFileName, Io_ReadFileType(pFileName), fCheck );
if ( pNtk == NULL )
return 0;
// replace the current network
Abc_FrameReplaceCurrentNetwork( pAbc, pNtk );
return 0;
usage:
fprintf( pAbc->Err, "usage: read_hie [-ch] <file>\n" );
fprintf( pAbc->Err, "\t reads hierarchical design represented in BLIF or BLIF-MV\n" );
fprintf( pAbc->Err, "\t by calling the parser that matches the extension of <file>\n" );
fprintf( pAbc->Err, "\t-c : toggle network check after reading [default = %s]\n", fCheck? "yes":"no" );
fprintf( pAbc->Err, "\t-h : prints the command summary\n" );
fprintf( pAbc->Err, "\tfile : the name of a file to read\n" );
return 1;
}
/**Function*************************************************************
Synopsis []
@ -388,7 +331,8 @@ int IoCommandReadBlif( Abc_Frame_t * pAbc, int argc, char ** argv )
if ( fReadAsAig )
pNtk = Io_ReadBlifAsAig( pFileName, fCheck );
else
pNtk = Io_Read( pFileName, IO_FILE_BLIF, fCheck );
// pNtk = Io_Read( pFileName, IO_FILE_BLIF, fCheck );
pNtk = Io_ReadBlif( pFileName, fCheck );
if ( pNtk == NULL )
return 1;
// replace the current network
@ -1704,7 +1648,7 @@ int IoCommandWriteVerLib( Abc_Frame_t * pAbc, int argc, char **argv )
fprintf( pAbc->Out, "Verilog library is not specified.\n" );
return 0;
}
Io_WriteVerilogLibrary( pLibrary, pFileName );
// Io_WriteVerilogLibrary( pLibrary, pFileName );
return 0;
usage:

1
src/base/io/io.h
View File

@ -119,7 +119,6 @@ extern void Io_WriteVerilog( Abc_Ntk_t * pNtk, char * FileName );
extern Io_FileType_t Io_ReadFileType( char * pFileName );
extern Abc_Ntk_t * Io_ReadNetlist( char * pFileName, Io_FileType_t FileType, int fCheck );
extern Abc_Ntk_t * Io_Read( char * pFileName, Io_FileType_t FileType, int fCheck );
extern Abc_Ntk_t * Io_ReadHie( char * pFileName, Io_FileType_t FileType, int fCheck );
extern void Io_Write( Abc_Ntk_t * pNtk, char * pFileName, Io_FileType_t FileType );
extern void Io_WriteHie( Abc_Ntk_t * pNtk, char * pBaseName, char * pFileName );
extern Abc_Obj_t * Io_ReadCreatePi( Abc_Ntk_t * pNtk, char * pName );

5
src/base/io/ioReadBlifMv.c
View File

@ -186,9 +186,10 @@ Abc_Ntk_t * Io_ReadBlifMv( char * pFileName, int fBlifMv, int fCheck )
assert( Vec_PtrSize(pDesign->vModules) > 0 );
if ( Vec_PtrSize(pDesign->vModules) == 1 )
{
printf( "Warning: The design is not hierarchical.\n" );
// printf( "Warning: The design is not hierarchical.\n" );
Abc_LibFree( pDesign, pNtk );
pNtk->pDesign = NULL;
pNtk->pSpec = Extra_UtilStrsav( pFileName );
}
else
Abc_NtkIsAcyclicHierarchy( pNtk );
@ -1303,7 +1304,7 @@ static int Io_MvParseLineNamesMv( Io_MvMod_t * p, char * pLine, int fReset )
// split names line into tokens
Io_MvSplitIntoTokens( vTokens, pLine, '\0' );
if ( fReset )
assert( !strcmp(Vec_PtrEntry(vTokens,0), "r") );
assert( !strcmp(Vec_PtrEntry(vTokens,0), "r") || !strcmp(Vec_PtrEntry(vTokens,0), "reset") );
else
assert( !strcmp(Vec_PtrEntry(vTokens,0), "names") || !strcmp(Vec_PtrEntry(vTokens,0), "table") );
// find the number of inputs and outputs

11
src/base/io/ioReadVerilog.c
View File

@ -45,6 +45,7 @@ Abc_Ntk_t * Io_ReadVerilog( char * pFileName, int fCheck )
{
Abc_Ntk_t * pNtk;
Abc_Lib_t * pDesign;
int i;
// parse the verilog file
pDesign = Ver_ParseFile( pFileName, NULL, 1, fCheck );
@ -60,12 +61,20 @@ Abc_Ntk_t * Io_ReadVerilog( char * pFileName, int fCheck )
assert( Vec_PtrSize(pDesign->vModules) > 0 );
if ( Vec_PtrSize(pDesign->vModules) == 1 )
{
printf( "Warning: The design is not hierarchical.\n" );
// printf( "Warning: The design is not hierarchical.\n" );
Abc_LibFree( pDesign, pNtk );
pNtk->pDesign = NULL;
pNtk->pSpec = Extra_UtilStrsav( pFileName );
}
else
{
// bring the root model to the beginning
for ( i = Vec_PtrSize(pDesign->vModules) - 2; i >= 0; i-- )
Vec_PtrWriteEntry(pDesign->vModules, i+1, Vec_PtrEntry(pDesign->vModules, i) );
Vec_PtrWriteEntry(pDesign->vModules, 0, pNtk );
// check that there is no cyclic dependency
Abc_NtkIsAcyclicHierarchy( pNtk );
}
return pNtk;
}

73
src/base/io/ioUtil.c
View File

@ -123,7 +123,10 @@ Abc_Ntk_t * Io_ReadNetlist( char * pFileName, Io_FileType_t FileType, int fCheck
}
// read the new netlist
if ( FileType == IO_FILE_BLIF )
pNtk = Io_ReadBlif( pFileName, fCheck );
// pNtk = Io_ReadBlif( pFileName, fCheck );
pNtk = Io_ReadBlifMv( pFileName, 0, fCheck );
else if ( Io_ReadFileType(pFileName) == IO_FILE_BLIFMV )
pNtk = Io_ReadBlifMv( pFileName, 1, fCheck );
else if ( FileType == IO_FILE_BENCH )
pNtk = Io_ReadBench( pFileName, fCheck );
else if ( FileType == IO_FILE_EDIF )
@ -144,16 +147,12 @@ Abc_Ntk_t * Io_ReadNetlist( char * pFileName, Io_FileType_t FileType, int fCheck
fprintf( stdout, "Reading network from file has failed.\n" );
return NULL;
}
if ( Abc_NtkBlackboxNum(pNtk) || Abc_NtkBlackboxNum(pNtk) )
{
fprintf( stdout, "The network contains hierarchy. Use \"read_hie\".\n" );
Abc_NtkDelete( pNtk );
return NULL;
}
if ( Abc_NtkBlackboxNum(pNtk) || Abc_NtkWhiteboxNum(pNtk) )
fprintf( stdout, "Warning: The network contains hierarchy.\n" );
return pNtk;
}
/**Function*************************************************************
Synopsis [Read the network from a file.]
@ -174,6 +173,51 @@ Abc_Ntk_t * Io_Read( char * pFileName, Io_FileType_t FileType, int fCheck )
return NULL;
if ( !Abc_NtkIsNetlist(pNtk) )
return pNtk;
// consider the case of BLIF-MV
if ( Io_ReadFileType(pFileName) == IO_FILE_BLIFMV )
{
extern Abc_Ntk_t * Abc_NtkConvertBlifMv( Abc_Ntk_t * pNtk );
Abc_NtkPrintStats( stdout, pNtk, 0 );
/*
{
FILE * pFile = fopen( "_temp_.mv", "w" );
Io_NtkWriteBlifMv( pFile, pNtk );
fclose( pFile );
}
*/
pNtk = Abc_NtkConvertBlifMv( pTemp = pNtk );
Abc_NtkDelete( pTemp );
if ( pNtk == NULL )
{
fprintf( stdout, "Converting BLIF-MV has failed.\n" );
return NULL;
}
return pNtk;
}
// flatten logic hierarchy
assert( Abc_NtkIsNetlist(pNtk) );
if ( Abc_NtkWhiteboxNum(pNtk) > 0 )
{
pNtk = Abc_NtkFlattenLogicHierarchy( pTemp = pNtk );
Abc_NtkDelete( pTemp );
if ( pNtk == NULL )
{
fprintf( stdout, "Flattening logic hierarchy has failed.\n" );
return NULL;
}
}
// convert blackboxes
if ( Abc_NtkBlackboxNum(pNtk) > 0 )
{
printf( "Hierarchy reader converted %d blackboxes.\n", Abc_NtkBlackboxNum(pNtk) );
pNtk = Abc_NtkConvertBlackboxes( pTemp = pNtk );
Abc_NtkDelete( pTemp );
if ( pNtk == NULL )
{
fprintf( stdout, "Converting blackboxes has failed.\n" );
return NULL;
}
}
// convert the netlist into the logic network
pNtk = Abc_NtkNetlistToLogic( pTemp = pNtk );
Abc_NtkDelete( pTemp );
@ -230,7 +274,7 @@ Abc_Ntk_t * Io_ReadHie( char * pFileName, Io_FileType_t FileType, int fCheck )
// convert blackboxes
if ( Abc_NtkBlackboxNum(pNtk) > 0 )
{
printf( "Hierarchical parser converted %d blackboxes.\n", Abc_NtkBlackboxNum(pNtk) );
printf( "Hierarchy reader converted %d blackboxes.\n", Abc_NtkBlackboxNum(pNtk) );
pNtk = Abc_NtkConvertBlackboxes( pTemp = pNtk );
Abc_NtkDelete( pTemp );
if ( pNtk == NULL )
@ -389,6 +433,8 @@ void Io_WriteHie( Abc_Ntk_t * pNtk, char * pBaseName, char * pFileName )
assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsLogic(pNtk) );
if ( Io_ReadFileType(pBaseName) == IO_FILE_BLIF )
pNtkBase = Io_ReadBlifMv( pBaseName, 0, 1 );
else if ( Io_ReadFileType(pBaseName) == IO_FILE_VERILOG )
pNtkBase = Io_ReadVerilog( pBaseName, 1 );
else
fprintf( stderr, "Unknown input file format.\n" );
if ( pNtkBase == NULL )
@ -405,6 +451,15 @@ void Io_WriteHie( Abc_Ntk_t * pNtk, char * pBaseName, char * pFileName )
// reintroduce the boxes into the netlist
if ( Abc_NtkBlackboxNum(pNtkBase) > 0 )
{
// bring the current network to the same representation
if ( Abc_NtkIsLogic(pNtk) )
{
if ( Abc_NtkIsSopNetlist(pNtkBase) )
Abc_NtkLogicToSop( pNtk, 0 );
else if ( Abc_NtkIsAigNetlist(pNtkBase) )
Abc_NtkLogicToAig( pNtk );
}
// derive the netlist
pNtkResult = Abc_NtkLogicToNetlist( pNtk, 0 );
pNtkResult = Abc_NtkInsertNewLogic( pNtkBase, pNtkTemp = pNtkResult );
Abc_NtkDelete( pNtkTemp );

2
src/base/io/ioWriteAiger.c
View File

@ -160,7 +160,7 @@ void Io_WriteAiger( Abc_Ntk_t * pNtk, char * pFileName )
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL )
{
fprintf( stdout, "Io_WriteBaf(): Cannot open the output file \"%s\".\n", pFileName );
fprintf( stdout, "Io_WriteAiger(): Cannot open the output file \"%s\".\n", pFileName );
return;
}

46
src/base/io/ioWriteBlif.c
View File

@ -30,6 +30,7 @@ static void Io_NtkWrite( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
static void Io_NtkWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
static void Io_NtkWritePis( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
static void Io_NtkWritePos( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
static void Io_NtkWriteSubckt( FILE * pFile, Abc_Obj_t * pNode );
static void Io_NtkWriteAsserts( FILE * pFile, Abc_Ntk_t * pNtk );
static void Io_NtkWriteNodeGate( FILE * pFile, Abc_Obj_t * pNode );
static void Io_NtkWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode );
@ -194,6 +195,16 @@ void Io_NtkWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches )
fprintf( pFile, "\n" );
}
// write the subcircuits
assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
if ( Abc_NtkBlackboxNum(pNtk) > 0 )
{
fprintf( pFile, "\n" );
Abc_NtkForEachBlackbox( pNtk, pNode, i )
Io_NtkWriteSubckt( pFile, pNode );
fprintf( pFile, "\n" );
}
// write each internal node
pProgress = Extra_ProgressBarStart( stdout, Abc_NtkObjNumMax(pNtk) );
Abc_NtkForEachNode( pNtk, pNode, i )
@ -371,6 +382,41 @@ void Io_NtkWriteAsserts( FILE * pFile, Abc_Ntk_t * pNtk )
}
}
/**Function*************************************************************
Synopsis [Write the latch into a file.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Io_NtkWriteSubckt( FILE * pFile, Abc_Obj_t * pNode )
{
Abc_Ntk_t * pModel = pNode->pData;
Abc_Obj_t * pTerm;
int i;
// write the subcircuit
// fprintf( pFile, ".subckt %s %s", Abc_NtkName(pModel), Abc_ObjName(pNode) );
fprintf( pFile, ".subckt %s", Abc_NtkName(pModel) );
// write pairs of the formal=actual names
Abc_NtkForEachPi( pModel, pTerm, i )
{
fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
pTerm = Abc_ObjFanin( pNode, i );
fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
}
Abc_NtkForEachPo( pModel, pTerm, i )
{
fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
pTerm = Abc_ObjFanout( pNode, i );
fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
}
fprintf( pFile, "\n" );
}
/**Function*************************************************************
Synopsis [Write the latch into a file.]

2
src/base/io/ioWriteBlifMv.c
View File

@ -26,7 +26,7 @@
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
static void Io_NtkWriteBlifMv( FILE * pFile, Abc_Ntk_t * pNtk );
void Io_NtkWriteBlifMv( FILE * pFile, Abc_Ntk_t * pNtk );
static void Io_NtkWriteBlifMvOne( FILE * pFile, Abc_Ntk_t * pNtk );
static void Io_NtkWriteBlifMvPis( FILE * pFile, Abc_Ntk_t * pNtk );
static void Io_NtkWriteBlifMvPos( FILE * pFile, Abc_Ntk_t * pNtk );

56
src/base/ver/verCore.c
View File

@ -66,7 +66,7 @@ static Abc_Obj_t * Ver_ParseCreateInv( Abc_Ntk_t * pNtk, Abc_Obj_t * pNet );
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [File parser.]
@ -396,15 +396,15 @@ int Ver_ParseModule( Ver_Man_t * pMan )
else
Abc_ObjAddFanin( pNet, Abc_NtkCreateNodeConst1(pNtk) );
// fix the dangling nets
Abc_NtkFinalizeRead( pNtk );
// check the functionality to blackbox if insides are not defined
if ( Abc_NtkNodeNum(pNtk) == 0 && Abc_NtkBoxNum(pNtk) == 0 )
{
pNtk->ntkFunc = ABC_FUNC_BLACKBOX;
pNtk->pManFunc = NULL;
}
// fix the dangling nets
Abc_NtkFinalizeRead( pNtk );
return 1;
}
@ -435,18 +435,43 @@ int Ver_ParseSignal( Ver_Man_t * pMan, Ver_SignalType_t SigType )
if ( pWord[0] == '[' && !pMan->fNameLast )
{
Lower = atoi( pWord + 1 );
while ( *pWord && *pWord != ':' )
// find the splitter
while ( *pWord && *pWord != ':' && *pWord != ']' )
pWord++;
if ( *pWord == 0 )
{
sprintf( pMan->sError, "Cannot find closing bracket in this line." );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
if ( *pWord == ']' )
Upper = Lower;
else
{
Upper = atoi( pWord + 1 );
if ( Lower > Upper )
i = Lower, Lower = Upper, Upper = i;
// get the signal name
pWord = Ver_ParseGetName( pMan );
if ( pWord == NULL )
return 0;
if ( Lower > Upper )
i = Lower, Lower = Upper, Upper = i;
// find the closing paranthesis
while ( *pWord && *pWord != ']' )
pWord++;
if ( *pWord == 0 )
{
sprintf( pMan->sError, "Cannot find closing bracket in this line." );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
assert( *pWord == ']' );
}
// check the case of no space between bracket and the next word
if ( *(pWord+1) != 0 )
pWord++;
else
{
// get the signal name
pWord = Ver_ParseGetName( pMan );
if ( pWord == NULL )
return 0;
}
for ( i = Lower; i <= Upper; i++ )
{
sprintf( Buffer, "%s[%d]", pWord, i );
@ -559,7 +584,11 @@ int Ver_ParseAssign( Ver_Man_t * pMan )
else
pEquation = Ver_StreamGetWord( p, ",;" );
if ( pEquation == NULL )
{
sprintf( pMan->sError, "Cannot read the equation for %s.", Abc_ObjName(pNet) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
// parse the formula
if ( fReduction )
@ -969,7 +998,10 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtkGate )
memset( pPolarity, 0, nBytes );
}
// create box to represent this gate
pNode = Abc_NtkCreateBlackbox( pMan->pNtkCur );
if ( Abc_NtkHasBlackbox(pNtkGate) )
pNode = Abc_NtkCreateBlackbox( pMan->pNtkCur );
else
pNode = Abc_NtkCreateWhitebox( pMan->pNtkCur );
pNode->pNext = (Abc_Obj_t *)pPolarity;
pNode->pData = pNtkGate;
// connect to fanin nets

23
src/base/ver/verStream.c
View File

@ -307,9 +307,6 @@ void Ver_StreamSkipChars( Ver_Stream_t * p, char * pCharsToSkip )
// skip the symbols
for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
{
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
// skip symbols as long as they are in the list
for ( pTemp = pCharsToSkip; *pTemp; pTemp++ )
if ( *pChar == *pTemp )
@ -319,6 +316,9 @@ void Ver_StreamSkipChars( Ver_Stream_t * p, char * pCharsToSkip )
p->pBufferCur = pChar;
return;
}
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
}
// the file is finished or the last part continued
// through VER_OFFSET_SIZE chars till the end of the buffer
@ -352,19 +352,18 @@ void Ver_StreamSkipToChars( Ver_Stream_t * p, char * pCharsToStop )
// skip the symbols
for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
{
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
// skip symbols as long as they are NOT in the list
for ( pTemp = pCharsToStop; *pTemp; pTemp++ )
if ( *pChar == *pTemp )
break;
if ( *pTemp == 0 ) // pChar is not found in the list
{
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
continue;
}
// the symbol is found - move position and return
if ( *pChar == '\n' )
p->nLineCounter--;
// update buffer
p->pBufferCur = pChar;
return;
}
@ -403,9 +402,6 @@ char * Ver_StreamGetWord( Ver_Stream_t * p, char * pCharsToStop )
p->nChars = 0;
for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
{
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
// skip symbols as long as they are NOT in the list
for ( pTemp = pCharsToStop; *pTemp; pTemp++ )
if ( *pChar == *pTemp )
@ -415,6 +411,9 @@ char * Ver_StreamGetWord( Ver_Stream_t * p, char * pCharsToStop )
p->pChars[p->nChars++] = *pChar;
if ( p->nChars == VER_WORD_SIZE )
return NULL;
// count the lines
if ( *pChar == '\n' )
p->nLineCounter++;
continue;
}
// the symbol is found - move the position, set the word end, return the word

2
src/opt/rwr/rwr.h
View File

@ -125,7 +125,7 @@ static inline Rwr_Node_t * Rwr_NotCond( Rwr_Node_t * p, int c ) { return (Rwr_N
/*=== rwrDec.c ========================================================*/
extern void Rwr_ManPreprocess( Rwr_Man_t * p );
/*=== rwrEva.c ========================================================*/
extern int Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros );
extern int Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros, int fPlaceEnable );
extern void Rwr_ScoresClean( Rwr_Man_t * p );
extern void Rwr_ScoresReport( Rwr_Man_t * p );
/*=== rwrLib.c ========================================================*/

70
src/opt/rwr/rwrEva.c
View File

@ -25,7 +25,7 @@
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
static Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest );
static Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest, int fPlaceEnable );
static int Rwr_CutIsBoolean( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves );
static int Rwr_CutCountNumNodes( Abc_Obj_t * pObj, Cut_Cut_t * pCut );
static int Rwr_NodeGetDepth_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves );
@ -52,7 +52,7 @@ static int Rwr_NodeGetDepth_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves );
SeeAlso []
***********************************************************************/
int Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros )
int Rwr_NodeRewrite( Rwr_Man_t * p, Cut_Man_t * pManCut, Abc_Obj_t * pNode, int fUpdateLevel, int fUseZeros, int fPlaceEnable )
{
int fVeryVerbose = 0;
Dec_Graph_t * pGraph;
@ -83,7 +83,6 @@ clk = clock();
// consider only 4-input cuts
if ( pCut->nLeaves < 4 )
continue;
// if ( pNode->Id == 82 )
// Cut_CutPrint( pCut, 0 ), printf( "\n" );
// get the fanin permutation
@ -138,7 +137,7 @@ p->timeMffc += clock() - clk2;
// evaluate the cut
clk2 = clock();
pGraph = Rwr_CutEvaluate( p, pNode, pCut, p->vFaninsCur, nNodesSaved, Required, &GainCur );
pGraph = Rwr_CutEvaluate( p, pNode, pCut, p->vFaninsCur, nNodesSaved, Required, &GainCur, fPlaceEnable );
p->timeEval += clock() - clk2;
// check if the cut is better than the current best one
@ -228,19 +227,21 @@ p->timeRes += clock() - clk;
SeeAlso []
***********************************************************************/
Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest )
Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest, int fPlaceEnable )
{
Vec_Ptr_t * vSubgraphs;
Dec_Graph_t * pGraphBest, * pGraphCur;
Rwr_Node_t * pNode, * pFanin;
int nNodesAdded, GainBest, i, k;
unsigned uTruth;
float CostBest, CostCur;
// find the matching class of subgraphs
uTruth = 0xFFFF & *Cut_CutReadTruth(pCut);
vSubgraphs = Vec_VecEntry( p->vClasses, p->pMap[uTruth] );
p->nSubgraphs += vSubgraphs->nSize;
// determine the best subgraph
GainBest = -1;
CostBest = ABC_INFINITY;
Vec_PtrForEachEntry( vSubgraphs, pNode, i )
{
// get the current graph
@ -253,22 +254,57 @@ Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCu
if ( nNodesAdded == -1 )
continue;
assert( nNodesSaved >= nNodesAdded );
// count the gain at this node
if ( GainBest < nNodesSaved - nNodesAdded )
// evaluate the cut
if ( fPlaceEnable )
{
GainBest = nNodesSaved - nNodesAdded;
pGraphBest = pGraphCur;
extern float Abc_PlaceEvaluateCut( Abc_Obj_t * pRoot, Vec_Ptr_t * vFanins );
// score the graph
if ( GainBest > 0 )
float Alpha = 0.5; // ???
float PlaceCost;
// get the placement cost of the cut
PlaceCost = Abc_PlaceEvaluateCut( pRoot, vFaninsCur );
// get the weigted cost of the cut
CostCur = nNodesSaved - nNodesAdded + Alpha * PlaceCost;
// do not allow uphill moves
if ( nNodesSaved - nNodesAdded < 0 )
continue;
// decide what cut to use
if ( CostBest > CostCur )
{
pNode->nScore++;
pNode->nGain += GainBest;
pNode->nAdded += nNodesAdded;
}
GainBest = nNodesSaved - nNodesAdded; // pure node cost
CostBest = CostCur; // cost with placement
pGraphBest = pGraphCur; // subgraph to be used for rewriting
// if ( GainBest > 0 )
// printf( "%d %d ", nNodesSaved, nNodesAdded );
// score the graph
if ( nNodesSaved - nNodesAdded > 0 )
{
pNode->nScore++;
pNode->nGain += GainBest;
pNode->nAdded += nNodesAdded;
}
}
}
else
{
// count the gain at this node
if ( GainBest < nNodesSaved - nNodesAdded )
{
GainBest = nNodesSaved - nNodesAdded;
pGraphBest = pGraphCur;
// score the graph
if ( nNodesSaved - nNodesAdded > 0 )
{
pNode->nScore++;
pNode->nGain += GainBest;
pNode->nAdded += nNodesAdded;
}
}
}
}
if ( GainBest == -1 )

35
src/phys/place/1.txt Normal file
View File

@ -0,0 +1,35 @@
Volume in drive C is IBM_PRELOAD
Volume Serial Number is 20EA-F780
Directory of C:\_projects\abc\src\phys\place
02/16/2007 11:01 AM <DIR> .
02/16/2007 11:01 AM <DIR> ..
01/23/2007 10:02 PM 165 1.c
02/16/2007 11:01 AM 0 1.txt
02/10/2007 05:52 PM 1,103,488 ac97_emap.fastplace.pl
02/09/2007 04:37 PM 362,675 ac97_emap.initial.pl
02/09/2007 03:34 PM 1,247,692 ac97_emap.nets
02/09/2007 03:34 PM 294,862 ac97_emap.nodes
02/13/2007 12:19 AM 670,459 ac97_emap.pl
02/10/2007 05:52 PM 1,184 hpwl
02/10/2007 01:52 AM 551 libhmetis.h
02/13/2007 12:25 AM 625 Makefile
02/13/2007 12:16 AM 9,552 place_base.c
02/16/2007 10:29 AM 3,801 place_base.h
02/13/2007 12:08 AM 8,175 place_bin.c
02/13/2007 12:16 AM 9,263 place_genqp.c
02/13/2007 12:08 AM 4,950 place_gordian.c
02/13/2007 12:18 AM 1,886 place_gordian.h
02/13/2007 12:08 AM 514 place_legalize.c
02/13/2007 12:08 AM 4,900 place_pads.c
02/13/2007 12:17 AM 36,942 place_partition.c
02/13/2007 12:08 AM 29,189 place_qpsolver.c
02/13/2007 12:08 AM 4,882 place_qpsolver.h
02/13/2007 12:08 AM 9,454 place_test.c
02/12/2007 05:01 PM 1,577 README
02/10/2007 04:26 PM 114 test.nets
02/10/2007 04:25 PM 112 test.nodes
02/11/2007 03:31 PM 130 test.pl
26 File(s) 3,807,142 bytes
2 Dir(s) 1,486,884,864 bytes free

30
src/phys/place/Makefile Normal file
View File

@ -0,0 +1,30 @@
TARGETS = place_test BookshelfView.class
CFLAGS = -g -pedantic -Wall
STATIC_LIBS = libhmetis.a
DYNAMIC_LIBS = -lm
OBJECTS = place_test.o place_qpsolver.o place_base.o place_pads.o place_genqp.o place_gordian.o \
place_partition.o place_legalize.o place_bin.o
# For hMetis free code, uncomment the following lines
#
# CFLAGS = -g -pedantic -Wall -DNO_HMETIS
# STATIC_LIBS =
all: $(TARGETS)
%.o: %.c *.h
gcc $(CFLAGS) -c -o $@ $<
place_test: $(OBJECTS)
gcc *.o $(STATIC_LIBS) $(DYNAMIC_LIBS) -o place_test
BookshelfView.class: BookshelfView.java
javac BookshelfView.java
clean:
rm -rf *.o place_test *.class *~

50
src/phys/place/README Normal file
View File

@ -0,0 +1,50 @@
/*===================================================================*/
//
// GORDIAN-like placement package
//
// Aaron P. Hurst (ahurst@eecs.berkeley.edu)
// Addl code from Philip Chong (pchong@cadence.com)
// hMetis partitioner (www.cs.umn.edu/~metis)
//
/*===================================================================*/
1. Requirements
An i386 Linux system (though others will certainly work with some tweaks).
A standard ANSI C development platform.
The following are optional, but useful:
- hMetis partitioner. This can be obtained from (www.cs.umn.edu/~metis)
Place (links to) the files "libhmetis.a" and "libhtmetis.h" in this directory.
Otherwise, #define NO_HMETIS in the file "place_gordian.h"
- Java SDK, if compiling BookshelfView is desired.
- Perl, if additional script utilities are desired.
2. Descriptions of contents:
place_base.h contains the basic data structures and "external" API.
place_gordian.h contains the "internal" API and configuration options.
There are also several utilities:
i) place_test
Reads a netlist description in GSRC Bookshelf format, performs global placement,
and rewrites the placement file. An example usage:
./place_test ac97_emap.nodes ac97_emap.nets ac97_emap.pl
ii) BookshelfView
A simple Java GUI to view the resulting placements. It has been tested with
Java 5 and 6. Usage:
java BookshelfView ac97_emap.nodes ac97_emap.pl
iii) hpwl
A perl script to print the half-perimeter wirelength of a placement. Usage:
./hpwl ac97_emap.nets ac97_emal.pl

16989
src/phys/place/ac97_emap.fastplace.pl Normal file
View File

File diff suppressed because it is too large Load Diff

16972
src/phys/place/ac97_emap.initial.pl Normal file
View File

File diff suppressed because it is too large Load Diff

61818
src/phys/place/ac97_emap.nets Normal file
View File

File diff suppressed because it is too large Load Diff

16973
src/phys/place/ac97_emap.nodes Normal file
View File

File diff suppressed because it is too large Load Diff

16971
src/phys/place/ac97_emap.pl Normal file
View File

File diff suppressed because it is too large Load Diff

57
src/phys/place/hpwl Normal file
View File

@ -0,0 +1,57 @@
#! /usr/bin/perl
$netsfile = shift;
$plfile = shift;
# ------------------------------ read placement
open FILE, $plfile;
while (<FILE>) {
chop;
if (/(\w+)\s+([\-\d\.]+)\s+([\-\d\.]+)\s+\:/) {
$loc{$1} = "$2 $3";
}
}
close FILE;
open FILE, $netsfile;
while (<FILE>) {
chop;
$net = $2 if /NetDegree\s+\:\s+(\d+)\s+(\w+)/;
if (/(\w+)\s+(\w+)\s+\:/) {
$netconn{$net} .= "$1 ";
$cellconn{$1} .= "$net ";
}
}
close FILE;
# ----------------------------- compute HPWL
$hpwl = 0;
foreach $net (keys %netconn) {
@conns = split ' ',$netconn{$net};
$min_x = $min_y = 1e12;
$max_x = $max_y = -1e12;
foreach $cell (@conns) {
if (!exists $loc{$cell}) {
print "WARNING: Unknown cell location: $cell\n";
} else {
($x, $y) = split ' ',$loc{$cell};
$min_x = $x if $x < $min_x;
$min_y = $y if $y < $min_y;
$max_x = $x if $x > $max_x;
$max_y = $y if $y > $max_y;
}
}
if ($min_x eq 1e12 or $min_y eq 1e12 or
$max_x eq -1e12 or $max_y eq -1e12) {
print "WARNING: Unbounded box\n";
} else {
$hpwl = $hpwl + $max_x - $min_x + $max_y - $min_y;
}
}
print "HPWL = ";
printf "%e",$hpwl;
print "\n";

31
src/phys/place/libhmetis.h Normal file
View File

@ -0,0 +1,31 @@
// A. Hurst ahurst@eecs.berkeley.edu
#ifndef LIBHMETIS_H_
#define LIBHMETIS_H_
void HMETIS_PartRecursive(int nvtxs,
int nhedges,
int *vwgts,
int *eptr,
int *eind,
int *hewgts,
int nparts,
int nbfactor,
int *options,
int *part,
int *edgecnt );
void HMETIS_PartKway(int nvtxs,
int nhedges,
int *vwgts,
int *eptr,
int *eind,
int *hewgts,
int nparts,
int nbfactor,
int *options,
int *part,
int *edgecnt );
#endif

8
src/phys/place/module.make Normal file
View File

@ -0,0 +1,8 @@
SRC += src/phys/place/place_base.c \
src/phys/place/place_bin.c \
src/phys/place/place_genqp.c \
src/phys/place/place_gordian.c \
src/phys/place/place_legalize.c \
src/phys/place/place_pads.c \
src/phys/place/place_partition.c \
src/phys/place/place_qpsolver.c

340
src/phys/place/place_base.c Normal file
View File

@ -0,0 +1,340 @@
/*===================================================================*/
//
// place_base.c
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
#include <string.h>
#include "place_base.h"
#include "place_gordian.h"
// --------------------------------------------------------------------
// Global variables
//
// --------------------------------------------------------------------
int g_place_numCells = 0;
int g_place_numNets = 0;
float g_place_rowHeight = 1.0;
Rect g_place_coreBounds;
Rect g_place_padBounds;
ConcreteCell **g_place_concreteCells = NULL;
int g_place_concreteCellsSize = 0;
ConcreteNet **g_place_concreteNets = NULL;
int g_place_concreteNetsSize = 0;
// --------------------------------------------------------------------
// getNetBBox()
//
/// \brief Returns the bounding box of a net.
//
// --------------------------------------------------------------------
Rect getNetBBox(const ConcreteNet *net) {
int t;
Rect r;
assert(net);
r.x = r.y = INT_MAX;
r.w = r.h = -INT_MAX;
for(t=0; t<net->m_numTerms; t++) {
r.x = net->m_terms[t]->m_x < r.x ? net->m_terms[t]->m_x : r.x;
r.y = net->m_terms[t]->m_y < r.y ? net->m_terms[t]->m_y : r.y;
r.w = net->m_terms[t]->m_x > r.w ? net->m_terms[t]->m_x : r.w;
r.h = net->m_terms[t]->m_y > r.h ? net->m_terms[t]->m_y : r.h;
}
r.w -= r.x; r.h -= r.y;
return r;
}
// --------------------------------------------------------------------
// getNetWirelength()
//
/// \brief Returns the half-perimeter wirelength of a net.
//
// --------------------------------------------------------------------
float getNetWirelength(const ConcreteNet *net) {
Rect r;
assert(net);
r = getNetBBox(net);
return r.w+r.h;
}
// --------------------------------------------------------------------
// getTotalWirelength()
//
/// \brief Returns the total HPWL of all nets.
//
// --------------------------------------------------------------------
float getTotalWirelength() {
float r = 0;
int n;
for(n=0; n<g_place_numNets; n++) if (g_place_concreteNets[n])
r += getNetWirelength(g_place_concreteNets[n]);
return r;
}
// --------------------------------------------------------------------
// getCellArea()
//
// --------------------------------------------------------------------
float getCellArea(const ConcreteCell *cell) {
assert(cell);
return cell->m_parent->m_width*cell->m_parent->m_height;
}
// --------------------------------------------------------------------
// addConcreteNet()
//
/// \brief Adds a net to the placement database.
///
/// The net object must already be allocated and the ID must be set
/// appropriately.
//
// --------------------------------------------------------------------
void addConcreteNet(ConcreteNet *net) {
assert(net);
assert(net->m_id >= 0);
if (net->m_id >= g_place_concreteNetsSize) {
g_place_concreteNetsSize *= 1.5;
g_place_concreteNetsSize += 20;
g_place_concreteNets = (ConcreteNet**)realloc(g_place_concreteNets,
sizeof(ConcreteNet*)*g_place_concreteNetsSize);
assert(g_place_concreteNets);
}
if (net->m_id >= g_place_numNets) {
memset(&(g_place_concreteNets[g_place_numNets]), 0,
sizeof(ConcreteNet*)*(net->m_id+1-g_place_numNets));
g_place_numNets = net->m_id+1;
}
g_place_concreteNets[net->m_id] = net;
}
// --------------------------------------------------------------------
// delConcreteNet()
//
/// Does not deallocate memory.
// --------------------------------------------------------------------
void delConcreteNet(ConcreteNet *net) {
assert(net);
g_place_concreteNets[net->m_id] = 0;
while(!g_place_concreteNets[g_place_numNets-1]) g_place_numNets--;
}
// --------------------------------------------------------------------
// addConcreteCell()
//
/// The cell object must already be allocated and the ID must be set
/// appropriately.
//
// --------------------------------------------------------------------
void addConcreteCell(ConcreteCell *cell) {
assert(cell);
assert(cell->m_id >= 0);
if (cell->m_id >= g_place_concreteCellsSize) {
g_place_concreteCellsSize *= 1.5;
g_place_concreteCellsSize += 20;
g_place_concreteCells = (ConcreteCell**)realloc(g_place_concreteCells,
sizeof(ConcreteCell*)*g_place_concreteCellsSize);
assert(g_place_concreteCells);
}
if (cell->m_id >= g_place_numCells) {
memset(&(g_place_concreteCells[g_place_numCells]), 0,
sizeof(ConcreteCell*)*(cell->m_id+1-g_place_numCells));
g_place_numCells = cell->m_id+1;
}
g_place_concreteCells[cell->m_id] = cell;
}
// --------------------------------------------------------------------
// delCellFromPartition()
//
// --------------------------------------------------------------------
void delCellFromPartition(ConcreteCell *cell, Partition *p) {
int c;
bool found = false;
assert(cell);
assert(p);
for(c=0; c<p->m_numMembers; c++)
if (p->m_members[c] == cell) {
p->m_members[c] = 0;
p->m_area -= getCellArea(cell);
found = true;
break;
}
if (!found) return;
if (!p->m_leaf) {
delCellFromPartition(cell, p->m_sub1);
delCellFromPartition(cell, p->m_sub2);
}
}
// --------------------------------------------------------------------
// delConcreteCell()
//
/// \brief Removes a cell from the placement database.
///
/// Does not deallocate memory.
///
/// Important: does not modify nets that may point to this
/// cell. If these are connections are not removed, segmentation faults
/// and other nasty errors will occur.
//
// --------------------------------------------------------------------
void delConcreteCell(ConcreteCell *cell) {
assert(cell);
g_place_concreteCells[cell->m_id] = 0;
while(!g_place_concreteCells[g_place_numCells-1]) g_place_numCells--;
if (g_place_rootPartition) delCellFromPartition(cell, g_place_rootPartition);
}
// --------------------------------------------------------------------
// netSortByX...
//
/// \brief Sorts nets by position of one of its corners.
//
/// These are for use with qsort().
///
/// Can tolerate pointers to NULL objects.
///
// --------------------------------------------------------------------
int netSortByL(const void *a, const void *b) {
const ConcreteNet *pa = *(const ConcreteNet **)a;
const ConcreteNet *pb = *(const ConcreteNet **)b;
Rect ba, bb;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
ba = getNetBBox(pa), bb = getNetBBox(pb);
if (ba.x < bb.x) return -1;
if (ba.x > bb.x) return 1;
return 0;
}
int netSortByR(const void *a, const void *b) {
const ConcreteNet *pa = *(const ConcreteNet **)a;
const ConcreteNet *pb = *(const ConcreteNet **)b;
Rect ba, bb;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
ba = getNetBBox(pa), bb = getNetBBox(pb);
if (ba.x + ba.w < bb.x + bb.w) return -1;
if (ba.x + ba.w > bb.x + bb.w) return 1;
return 0;
}
int netSortByB(const void *a, const void *b) {
const ConcreteNet *pa = *(const ConcreteNet **)a;
const ConcreteNet *pb = *(const ConcreteNet **)b;
Rect ba, bb;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
ba = getNetBBox(pa), bb = getNetBBox(pb);
if (ba.y + ba.h < bb.y + bb.h) return -1;
if (ba.y + ba.h > bb.y + bb.h) return 1;
return 0;
}
int netSortByT(const void *a, const void *b) {
const ConcreteNet *pa = *(const ConcreteNet **)a;
const ConcreteNet *pb = *(const ConcreteNet **)b;
Rect ba, bb;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
ba = getNetBBox(pa), bb = getNetBBox(pb);
if (ba.y < bb.y) return -1;
if (ba.y > bb.y) return 1;
return 0;
}
int netSortByID(const void *a, const void *b) {
const ConcreteNet *pa = *(const ConcreteNet **)a;
const ConcreteNet *pb = *(const ConcreteNet **)b;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
if (pa->m_id < pb->m_id) return -1;
if (pa->m_id > pb->m_id) return 1;
return 0;
}
// --------------------------------------------------------------------
// cellSortByX...
//
/// \brief Sorts cells by either position coordinate.
//
/// These are for use with qsort().
///
/// Can tolerate pointers to NULL objects.
//
// --------------------------------------------------------------------
int cellSortByX(const void *a, const void *b) {
const ConcreteCell *pa = *(const ConcreteCell **)a;
const ConcreteCell *pb = *(const ConcreteCell **)b;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
if (pa->m_x < pb->m_x) return -1;
if (pa->m_x > pb->m_x) return 1;
return 0;
}
int cellSortByY(const void *a, const void *b) {
const ConcreteCell *pa = *(const ConcreteCell **)a;
const ConcreteCell *pb = *(const ConcreteCell **)b;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
if (pa->m_y < pb->m_y) return -1;
if (pa->m_y > pb->m_y) return 1;
return 0;
}
int cellSortByID(const void *a, const void *b) {
const ConcreteCell *pa = *(const ConcreteCell **)a;
const ConcreteCell *pb = *(const ConcreteCell **)b;
if (!pa && !pb) return 0;
else if (!pa) return -1;
else if (!pb) return 1;
if (pa->m_id < pb->m_id) return -1;
if (pa->m_id > pb->m_id) return 1;
return 0;
}

125
src/phys/place/place_base.h Normal file
View File

@ -0,0 +1,125 @@
/*===================================================================*/
//
// place_base.h
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#if !defined(PLACE_BASE_H_)
#define PLACE_BASE_H_
// --------------------------------------------------------------------
// Data structures
//
// --------------------------------------------------------------------
// --- a C++ bool-like type
//typedef char bool;
#ifndef bool
#define bool int
#endif
#define true 1
#define false 0
// --- Rect - rectangle
typedef struct Rect {
float x, y;
float w, h;
} Rect;
// --- AbstractCell - a definition of a cell type
typedef struct AbstractCell {
char *m_label; // string description
float m_width, m_height; // dimensions
bool m_pad; // a pad (external I/O) cell?
} AbstractCell;
// --- ConcreteCell - a design object
typedef struct ConcreteCell {
AbstractCell *m_parent; // cell type
char *m_label; // string description
int m_id; // a unique ID (see below)
bool m_fixed; // position is fixed?
float m_x, m_y; // center of cell
} ConcreteCell;
// --- ConcreteNet - a design net
typedef struct ConcreteNet {
int m_id; // a unique ID (see below)
int m_numTerms; // num. of connected cells
ConcreteCell **m_terms; // connected cells
float m_weight; // relative weight
} ConcreteNet;
// A note about IDs - the IDs are non-nonegative integers. They need not
// be contiguous, but this is certainly a good idea, as they are stored
// in a non-sparse array.
// Cells and nets have separate ID spaces.
// --------------------------------------------------------------------
// Global variable prototypes
//
// --------------------------------------------------------------------
// NOTE: None of these need to be managed externally.
extern int g_place_numCells; // number of cells
extern int g_place_numNets; // number of nets
extern float g_place_rowHeight; // height of placement row
extern Rect g_place_coreBounds; // border of placeable area
// (x,y) = corner
extern Rect g_place_padBounds; // border of total die area
// (x,y) = corner
extern ConcreteCell **g_place_concreteCells; // all concrete cells
extern ConcreteNet **g_place_concreteNets; // all concrete nets
// --------------------------------------------------------------------
// Function prototypes
//
// --------------------------------------------------------------------
void addConcreteNet(ConcreteNet *net);
void addConcreteCell(ConcreteCell *cell);
void delConcreteNet(ConcreteNet *net);
void delConcreteCell(ConcreteCell *cell);
void globalPreplace(float utilization);
void globalPlace();
void globalIncremental();
void globalFixDensity(int numBins, float maxMovement);
float fastUnplace(ConcreteCell *cell); // UNIMPLEMENTED
float fastPlace(int numCells, ConcreteCell *cells []); // UNIMPLEMENTED
float fastEstimate(int numCells, ConcreteCell *cells []); // UNIMPLEMENTED
Rect getNetBBox(const ConcreteNet *net);
float getNetWirelength(const ConcreteNet *net);
float getTotalWirelength();
float getCellArea(const ConcreteCell *cell);
// comparative qsort-style functions
int netSortByL(const void *a, const void *b);
int netSortByR(const void *a, const void *b);
int netSortByB(const void *a, const void *b);
int netSortByT(const void *a, const void *b);
int netSortByID(const void *a, const void *b);
int cellSortByX(const void *a, const void *b);
int cellSortByY(const void *a, const void *b);
int cellSortByID(const void *a, const void *b);
#endif

263
src/phys/place/place_bin.c Normal file
View File

@ -0,0 +1,263 @@
/*===================================================================*/
//
// place_bin.c
//
// Aaron P. Hurst, 2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include "place_base.h"
// --------------------------------------------------------------------
// Global variables
//
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// Function prototypes and local data structures
//
// --------------------------------------------------------------------
void spreadDensityX(int numBins, float maxMovement);
void spreadDensityY(int numBins, float maxMovement);
// --------------------------------------------------------------------
// globalFixDensity()
//
/// Doesn't deal well with fixed cells in the core area.
// --------------------------------------------------------------------
void globalFixDensity(int numBins, float maxMovement) {
printf("QCLN-10 : \tbin-based density correction\n");
spreadDensityX(numBins, maxMovement);
// spreadDensityY(numBins, maxMovement);
}
// --------------------------------------------------------------------
// spreadDensityX()
//
// --------------------------------------------------------------------
void spreadDensityX(int numBins, float maxMovement) {
int c, c2, c3, x, y;
float totalArea = 0;
int moveableCells = 0;
float yBinArea = 0, yCumArea = 0;
int yBinStart = 0, yBinCount = 0;
int xBinCount, xBinStart;
float xBinArea, xCumArea;
float lastOldEdge;
float lastNewEdge;
float curOldEdge, curNewEdge;
float stretch, w;
ConcreteCell *xCell, *yCell;
ConcreteCell **binCells;
ConcreteCell **allCells;
binCells = (ConcreteCell **)malloc(sizeof(ConcreteCell*)*g_place_numCells);
allCells = (ConcreteCell **)malloc(sizeof(ConcreteCell*)*g_place_numCells);
for(c=0; c<g_place_numCells; c++) if (g_place_concreteCells[c]) {
ConcreteCell *cell = g_place_concreteCells[c];
if (!cell->m_fixed && !cell->m_parent->m_pad) {
allCells[moveableCells++] = cell;
totalArea += getCellArea(cell);
}
}
// spread X
qsort(allCells, moveableCells, sizeof(ConcreteCell*), cellSortByY);
y = 0;
// for each y-bin...
for(c=0; c<moveableCells; c++) {
yCell = allCells[c];
yBinArea += getCellArea(yCell);
yCumArea += getCellArea(yCell);
yBinCount++;
// have we filled up a y-bin?
if (yCumArea >= totalArea*(y+1)/numBins && yBinArea > 0) {
memcpy(binCells, &(allCells[yBinStart]), sizeof(ConcreteCell*)*yBinCount);
qsort(binCells, yBinCount, sizeof(ConcreteCell*), cellSortByX);
// printf("y-bin %d count=%d area=%f\n",y,yBinCount, yBinArea);
x = 0;
xBinCount = 0, xBinStart = 0;
xBinArea = 0, xCumArea = 0;
lastOldEdge = g_place_coreBounds.x;
lastNewEdge = g_place_coreBounds.x;
// for each x-bin...
for(c2=0; c2<yBinCount; c2++) {
xCell = binCells[c2];
xBinArea += getCellArea(xCell);
xCumArea += getCellArea(xCell);
xBinCount++;
curOldEdge = xCell->m_x;
// have we filled up an x-bin?
if (xCumArea >= yBinArea*(x+1)/numBins && xBinArea > 0) {
curNewEdge = lastNewEdge + g_place_coreBounds.w*xBinArea/yBinArea;
if (curNewEdge > g_place_coreBounds.x+g_place_coreBounds.w)
curNewEdge = g_place_coreBounds.x+g_place_coreBounds.w;
if ((curNewEdge-curOldEdge)>maxMovement) curNewEdge = curOldEdge + maxMovement;
if ((curOldEdge-curNewEdge)>maxMovement) curNewEdge = curOldEdge - maxMovement;
stretch = (curNewEdge-lastNewEdge)/(curOldEdge-lastOldEdge);
// stretch!
for(c3=xBinStart; c3<xBinStart+xBinCount; c3++) {
binCells[c3]->m_x = lastNewEdge+(binCells[c3]->m_x-lastOldEdge)*stretch;
// force within core
w = binCells[c3]->m_parent->m_width*0.5;
if (binCells[c3]->m_x-w < g_place_coreBounds.x)
binCells[c3]->m_x = g_place_coreBounds.x+w;
if (binCells[c3]->m_x+w > g_place_coreBounds.x+g_place_coreBounds.w)
binCells[c3]->m_x = g_place_coreBounds.x+g_place_coreBounds.w-w;
}
lastOldEdge = curOldEdge;
lastNewEdge = curNewEdge;
x++;
xBinCount = 0;
xBinArea = 0;
xBinStart = c2+1;
}
}
y++;
yBinCount = 0;
yBinArea = 0;
yBinStart = c+1;
}
}
free(binCells);
free(allCells);
}
// --------------------------------------------------------------------
// spreadDensityY()
//
// --------------------------------------------------------------------
void spreadDensityY(int numBins, float maxMovement) {
int c, c2, c3, x, y;
float totalArea = 0;
int moveableCells = 0;
float xBinArea = 0, xCumArea = 0;
int xBinStart = 0, xBinCount = 0;
int yBinCount, yBinStart;
float yBinArea, yCumArea;
float lastOldEdge;
float lastNewEdge;
float curOldEdge, curNewEdge;
float stretch, h;
ConcreteCell *xCell, *yCell;
ConcreteCell **binCells;
ConcreteCell **allCells;
binCells = (ConcreteCell **)malloc(sizeof(ConcreteCell*)*g_place_numCells);
allCells = (ConcreteCell **)malloc(sizeof(ConcreteCell*)*g_place_numCells);
for(c=0; c<g_place_numCells; c++) if (g_place_concreteCells[c]) {
ConcreteCell *cell = g_place_concreteCells[c];
if (!cell->m_fixed && !cell->m_parent->m_pad) {
allCells[moveableCells++] = cell;
totalArea += getCellArea(cell);
}
}
// spread Y
qsort(allCells, moveableCells, sizeof(ConcreteCell*), cellSortByX);
x = 0;
// for each x-bin...
for(c=0; c<moveableCells; c++) {
xCell = allCells[c];
xBinArea += getCellArea(xCell);
xCumArea += getCellArea(xCell);
xBinCount++;
// have we filled up an x-bin?
if (xCumArea >= totalArea*(x+1)/numBins && xBinArea > 0) {
memcpy(binCells, &(allCells[xBinStart]), sizeof(ConcreteCell*)*xBinCount);
qsort(binCells, xBinCount, sizeof(ConcreteCell*), cellSortByY);
// printf("x-bin %d count=%d area=%f\n",y,yBinCount, yBinArea);
y = 0;
yBinCount = 0, yBinStart = 0;
yBinArea = 0, yCumArea = 0;
lastOldEdge = g_place_coreBounds.y;
lastNewEdge = g_place_coreBounds.y;
// for each y-bin...
for(c2=0; c2<xBinCount; c2++) {
yCell = binCells[c2];
yBinArea += getCellArea(yCell);
yCumArea += getCellArea(yCell);
yBinCount++;
curOldEdge = yCell->m_y;
// have we filled up an x-bin?
if (yCumArea >= xBinArea*(y+1)/numBins && yBinArea > 0) {
curNewEdge = lastNewEdge + g_place_coreBounds.h*yBinArea/xBinArea;
if (curNewEdge > g_place_coreBounds.y+g_place_coreBounds.h)
curNewEdge = g_place_coreBounds.y+g_place_coreBounds.h;
if ((curNewEdge-curOldEdge)>maxMovement) curNewEdge = curOldEdge + maxMovement;
if ((curOldEdge-curNewEdge)>maxMovement) curNewEdge = curOldEdge - maxMovement;
stretch = (curNewEdge-lastNewEdge)/(curOldEdge-lastOldEdge);
// stretch!
for(c3=yBinStart; c3<yBinStart+yBinCount; c3++) {
binCells[c3]->m_y = lastNewEdge+(binCells[c3]->m_y-lastOldEdge)*stretch;
// force within core
h = binCells[c3]->m_parent->m_height;
if (binCells[c3]->m_y-h < g_place_coreBounds.y)
binCells[c3]->m_y = g_place_coreBounds.y+h;
if (binCells[c3]->m_y+h > g_place_coreBounds.y+g_place_coreBounds.h)
binCells[c3]->m_y = g_place_coreBounds.y+g_place_coreBounds.h-h;
}
lastOldEdge = curOldEdge;
lastNewEdge = curNewEdge;
y++;
yBinCount = 0;
yBinArea = 0;
yBinStart = c2+1;
}
}
x++;
xBinCount = 0;
xBinArea = 0;
xBinStart = c+1;
}
}
free(binCells);
free(allCells);
}

309
src/phys/place/place_genqp.c Normal file
View File

@ -0,0 +1,309 @@
/*===================================================================*/
//
// place_genqp.c
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "place_base.h"
#include "place_qpsolver.h"
#include "place_gordian.h"
// --------------------------------------------------------------------
// Global variables
//
// --------------------------------------------------------------------
qps_problem_t *g_place_qpProb = NULL;
// --------------------------------------------------------------------
// splitPenalty()
//
/// \brief Returns a weight for all of the edges in the clique for a multipin net.
//
// --------------------------------------------------------------------
float splitPenalty(int pins) {
if (pins > 1) {
return 1.0 + CLIQUE_PENALTY/(pins - 1);
// return pow(pins - 1, CLIQUE_PENALTY);
}
return 1.0 + CLIQUE_PENALTY;
}
// --------------------------------------------------------------------
// constructQuadraticProblem()
//
/// \brief Constructs the matrices necessary to do analytical placement.
//
// --------------------------------------------------------------------
void constructQuadraticProblem() {
int maxConnections = 1;
int ignoreNum = 0;
int n,t,c,c2,p;
ConcreteCell *cell;
ConcreteNet *net;
int *cell_numTerms = calloc(g_place_numCells, sizeof(int));
ConcreteNet ***cell_terms = calloc(g_place_numCells, sizeof(ConcreteNet**));
bool incremental = false;
int nextIndex = 1;
int *seen = calloc(g_place_numCells, sizeof(int));
float weight;
int last_index;
// create problem object
if (!g_place_qpProb) {
g_place_qpProb = malloc(sizeof(qps_problem_t));
g_place_qpProb->area = NULL;
g_place_qpProb->x = NULL;
g_place_qpProb->y = NULL;
g_place_qpProb->fixed = NULL;
g_place_qpProb->connect = NULL;
g_place_qpProb->edge_weight = NULL;
}
// count the maximum possible number of non-sparse entries
for(n=0; n<g_place_numNets; n++) if (g_place_concreteNets[n]) {
ConcreteNet *net = g_place_concreteNets[n];
if (net->m_numTerms > IGNORE_NETSIZE) {
ignoreNum++;
}
else {
maxConnections += net->m_numTerms*(net->m_numTerms-1);
for(t=0; t<net->m_numTerms; t++) {
c = net->m_terms[t]->m_id;
p = ++cell_numTerms[c];
cell_terms[c] = (ConcreteNet**)realloc(cell_terms[c], p*sizeof(ConcreteNet*));
cell_terms[c][p-1] = net;
}
}
}
if(ignoreNum) {
printf("QMAN-10 : \t\t%d large nets ignored\n", ignoreNum);
}
// initialize the data structures
g_place_qpProb->num_cells = g_place_numCells;
maxConnections += g_place_numCells + 1;
g_place_qpProb->area = realloc(g_place_qpProb->area,
sizeof(float)*g_place_numCells);// "area" matrix
g_place_qpProb->edge_weight = realloc(g_place_qpProb->edge_weight,
sizeof(float)*maxConnections); // "weight" matrix
g_place_qpProb->connect = realloc(g_place_qpProb->connect,
sizeof(int)*maxConnections); // "connectivity" matrix
g_place_qpProb->fixed = realloc(g_place_qpProb->fixed,
sizeof(int)*g_place_numCells); // "fixed" matrix
// initialize or keep preexisting locations
if (g_place_qpProb->x != NULL && g_place_qpProb->y != NULL) {
printf("QMAN-10 :\tperforming incremental placement\n");
incremental = true;
}
g_place_qpProb->x = (float*)realloc(g_place_qpProb->x, sizeof(float)*g_place_numCells);
g_place_qpProb->y = (float*)realloc(g_place_qpProb->y, sizeof(float)*g_place_numCells);
// form a row for each cell
// build data
for(c = 0; c < g_place_numCells; c++) if (g_place_concreteCells[c]) {
cell = g_place_concreteCells[c];
// fill in the characteristics for this cell
g_place_qpProb->area[c] = getCellArea(cell);
if (cell->m_fixed || cell->m_parent->m_pad) {
g_place_qpProb->x[c] = cell->m_x;
g_place_qpProb->y[c] = cell->m_y;
g_place_qpProb->fixed[c] = 1;
} else {
if (!incremental) {
g_place_qpProb->x[c] = g_place_coreBounds.x+g_place_coreBounds.w*0.5;
g_place_qpProb->y[c] = g_place_coreBounds.y+g_place_coreBounds.h*0.5;
}
g_place_qpProb->fixed[c] = 0;
}
// update connectivity matrices
last_index = nextIndex;
for(n=0; n<cell_numTerms[c]; n++) {
net = cell_terms[c][n];
weight = net->m_weight / splitPenalty(net->m_numTerms);
for(t=0; t<net->m_numTerms; t++) {
c2 = net->m_terms[t]->m_id;
if (c2 == c) continue;
if (seen[c2] < last_index) {
// not seen
g_place_qpProb->connect[nextIndex-1] = c2;
g_place_qpProb->edge_weight[nextIndex-1] = weight;
seen[c2] = nextIndex;
nextIndex++;
} else {
// seen
g_place_qpProb->edge_weight[seen[c2]-1] += weight;
}
}
}
g_place_qpProb->connect[nextIndex-1] = -1;
g_place_qpProb->edge_weight[nextIndex-1] = -1.0;
nextIndex++;
} else {
// fill in dummy values for connectivity matrices
g_place_qpProb->connect[nextIndex-1] = -1;
g_place_qpProb->edge_weight[nextIndex-1] = -1.0;
nextIndex++;
}
free(cell_numTerms);
free(cell_terms);
free(seen);
}
typedef struct reverseCOG {
float x,y;
Partition *part;
float delta;
} reverseCOG;
// --------------------------------------------------------------------
// generateCoGConstraints()
//
/// \brief Generates center of gravity constraints.
//
// --------------------------------------------------------------------
int generateCoGConstraints(reverseCOG COG_rev[]) {
int numConstraints = 0; // actual num contraints
int cogRevNum = 0;
Partition **stack = malloc(sizeof(Partition*)*g_place_numPartitions*2);
int stackPtr = 0;
Partition *p;
float cgx, cgy;
int next_index = 0, last_constraint = 0;
bool isTrueConstraint = false;
int i, m;
float totarea;
ConcreteCell *cell;
// each partition may give rise to a center-of-gravity constraint
stack[stackPtr] = g_place_rootPartition;
while(stackPtr >= 0) {
p = stack[stackPtr--];
assert(p);
// traverse down the partition tree to leaf nodes-only
if (!p->m_leaf) {
stack[++stackPtr] = p->m_sub1;
stack[++stackPtr] = p->m_sub2;
} else {
/*
cout << "adding a COG constraint for box "
<< p->bounds.x << ","
<< p->bounds.y << " of size"
<< p->bounds.w << "x"
<< p->bounds.h
<< endl;
*/
cgx = p->m_bounds.x + p->m_bounds.w*0.5;
cgy = p->m_bounds.y + p->m_bounds.h*0.5;
COG_rev[cogRevNum].x = cgx;
COG_rev[cogRevNum].y = cgy;
COG_rev[cogRevNum].part = p;
COG_rev[cogRevNum].delta = 0;
cogRevNum++;
}
}
assert(cogRevNum == g_place_numPartitions);
for (i = 0; i < g_place_numPartitions; i++) {
p = COG_rev[i].part;
assert(p);
g_place_qpProb->cog_x[numConstraints] = COG_rev[i].x;
g_place_qpProb->cog_y[numConstraints] = COG_rev[i].y;
totarea = 0.0;
for(m=0; m<p->m_numMembers; m++) if (p->m_members[m]) {
cell = p->m_members[m];
assert(cell);
if (!cell->m_fixed && !cell->m_parent->m_pad) {
isTrueConstraint = true;
}
else {
continue;
}
g_place_qpProb->cog_list[next_index++] = cell->m_id;
totarea += getCellArea(cell);
}
if (totarea == 0.0) {
isTrueConstraint = false;
}
if (isTrueConstraint) {
numConstraints++;
g_place_qpProb->cog_list[next_index++] = -1;
last_constraint = next_index;
}
else {
next_index = last_constraint;
}
}
free(stack);
return --numConstraints;
}
// --------------------------------------------------------------------
// solveQuadraticProblem()
//
/// \brief Calls quadratic solver.
//
// --------------------------------------------------------------------
void solveQuadraticProblem(bool useCOG) {
int c;
reverseCOG *COG_rev = malloc(sizeof(reverseCOG)*g_place_numPartitions);
g_place_qpProb->cog_list = malloc(sizeof(int)*(g_place_numPartitions+g_place_numCells));
g_place_qpProb->cog_x = malloc(sizeof(float)*g_place_numPartitions);
g_place_qpProb->cog_y = malloc(sizeof(float)*g_place_numPartitions);
// memset(g_place_qpProb->x, 0, sizeof(float)*g_place_numCells);
// memset(g_place_qpProb->y, 0, sizeof(float)*g_place_numCells);
qps_init(g_place_qpProb);
if (useCOG)
g_place_qpProb->cog_num = generateCoGConstraints(COG_rev);
else
g_place_qpProb->cog_num = 0;
g_place_qpProb->loop_num = 0;
qps_solve(g_place_qpProb);
qps_clean(g_place_qpProb);
// set the positions
for(c = 0; c < g_place_numCells; c++) if (g_place_concreteCells[c]) {
g_place_concreteCells[c]->m_x = g_place_qpProb->x[c];
g_place_concreteCells[c]->m_y = g_place_qpProb->y[c];
}
// clean up
free(g_place_qpProb->cog_list);
free(g_place_qpProb->cog_x);
free(g_place_qpProb->cog_y);
free(COG_rev);
}

160
src/phys/place/place_gordian.c Normal file
View File

@ -0,0 +1,160 @@
/*===================================================================*/
//
// place_gordian.c
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <limits.h>
#include "place_gordian.h"
#include "place_base.h"
// --------------------------------------------------------------------
// Global variables
//
// --------------------------------------------------------------------
int g_place_numPartitions;
// --------------------------------------------------------------------
// globalPlace()
//
/// \brief Performs analytic placement using a GORDIAN-like algorithm.
//
/// Updates the positions of all non-fixed non-pad cells.
///
// --------------------------------------------------------------------
void globalPlace() {
bool completionFlag = false;
int iteration = 0;
printf("PLAC-10 : Global placement (wirelength-driven Gordian)\n");
initPartitioning();
// build matrices representing interconnections
printf("QMAN-00 : \tconstructing initial quadratic problem...\n");
constructQuadraticProblem();
// iterate placement until termination condition is met
while(!completionFlag) {
printf("QMAN-01 : \titeration %d numPartitions = %d\n",iteration,g_place_numPartitions);
// do the global optimization in each direction
printf("QMAN-01 : \t\tglobal optimization\n");
solveQuadraticProblem(!IGNORE_COG);
// -------- PARTITIONING BASED CELL SPREADING ------
// bisection
printf("QMAN-01 : \t\tpartition refinement\n");
if (REALLOCATE_PARTITIONS) reallocPartitions();
completionFlag |= refinePartitions();
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
iteration++;
}
// final global optimization
printf("QMAN-02 : \t\tfinal pass\n");
if (FINAL_REALLOCATE_PARTITIONS) reallocPartitions();
solveQuadraticProblem(!IGNORE_COG);
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
// clean up
sanitizePlacement();
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
globalFixDensity(25, g_place_rowHeight*5);
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
}
// --------------------------------------------------------------------
// globalIncremental()
//
/// \brief Performs analytic placement using a GORDIAN-like algorithm.
//
/// Requires a valid set of partitions.
///
// --------------------------------------------------------------------
void globalIncremental() {
if (!g_place_rootPartition) {
printf("WARNING: Can not perform incremental placement\n");
globalPlace();
return;
}
printf("PLAC-10 : Incremental global placement\n");
incrementalPartition();
printf("QMAN-00 : \tconstructing initial quadratic problem...\n");
constructQuadraticProblem();
solveQuadraticProblem(!IGNORE_COG);
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
// clean up
sanitizePlacement();
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
globalFixDensity(25, g_place_rowHeight*5);
printf("QMAN-01 : \t\twirelength = %e\n", getTotalWirelength());
}
// --------------------------------------------------------------------
// sanitizePlacement()
//
/// \brief Moves any cells that are outside of the core bounds to the nearest location within.
//
// --------------------------------------------------------------------
void sanitizePlacement() {
int c;
float order_width = g_place_rowHeight;
float x, y, edge, w, h;
printf("QCLN-10 : \tsanitizing placement\n");
for(c=0; c<g_place_numCells; c++) if (g_place_concreteCells[c]) {
ConcreteCell *cell = g_place_concreteCells[c];
if (cell->m_fixed || cell->m_parent->m_pad) {
continue;
}
// the new locations of the cells will be distributed within
// a small margin inside the border so that ordering is preserved
order_width = g_place_rowHeight;
x = cell->m_x, y = cell->m_y,
w = cell->m_parent->m_width, h = cell->m_parent->m_height;
if ((edge=x-w*0.5) < g_place_coreBounds.x) {
x = g_place_coreBounds.x+w*0.5 +
order_width/(1.0+g_place_coreBounds.x-edge);
}
else if ((edge=x+w*0.5) > g_place_coreBounds.x+g_place_coreBounds.w) {
x = g_place_coreBounds.x+g_place_coreBounds.w-w*0.5 -
order_width/(1.0+edge-g_place_coreBounds.x-g_place_coreBounds.w);
}
if ((edge=y-h*0.5) < g_place_coreBounds.y) {
y = g_place_coreBounds.y+h*0.5 +
order_width/(1.0+g_place_coreBounds.y-edge);
}
else if ((edge=y+h*0.5) > g_place_coreBounds.y+g_place_coreBounds.h) {
y = g_place_coreBounds.y+g_place_coreBounds.h-h*0.5 -
order_width/(1.0+edge-g_place_coreBounds.x-g_place_coreBounds.w);
}
cell->m_x = x;
cell->m_y = y;
}
}

78
src/phys/place/place_gordian.h Normal file
View File

@ -0,0 +1,78 @@
/*===================================================================*/
//
// place_gordian.h
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#if !defined(PLACE_GORDIAN_H_)
#define PLACE_GORDIAN_H_
#include "place_base.h"
#include "place_qpsolver.h"
// Parameters for analytic placement
#define CLIQUE_PENALTY 1.0
#define IGNORE_NETSIZE 20
// Parameters for partitioning
#define LARGEST_FINAL_SIZE 20
#define PARTITION_AREA_ONLY true
#define REALLOCATE_PARTITIONS false
#define FINAL_REALLOCATE_PARTITIONS false
#define IGNORE_COG false
#define MAX_PARTITION_NONSYMMETRY 0.30
// Parameters for re-partitioning
#define REPARTITION_LEVEL_DEPTH 4
#define REPARTITION_TARGET_FRACTION 0.15
#define REPARTITION_FM false
#define REPARTITION_HMETIS true
// Parameters for F-M re-partitioning
#define FM_MAX_BIN 10
#define FM_MAX_PASSES 10
extern int g_place_numPartitions;
extern qps_problem_t *g_place_qpProb;
typedef struct Partition {
int m_numMembers;
ConcreteCell **m_members;
Rect m_bounds;
bool m_done,
m_leaf,
m_vertical;
float m_area;
int m_level;
struct Partition *m_sub1, *m_sub2;
} Partition;
extern Partition *g_place_rootPartition;
void initPartitioning();
void incrementalPartition();
bool refinePartitions();
void reallocPartitions();
bool refinePartition(Partition *p);
void resizePartition(Partition *p);
void reallocPartition(Partition *p);
void repartitionHMetis(Partition *parent);
void repartitionFM(Partition *parent);
void partitionScanlineMincut(Partition *parent);
void partitionEqualArea(Partition *parent);
void sanitizePlacement();
void constructQuadraticProblem();
void solveQuadraticProblem(bool useCOG);
#endif

23
src/phys/place/place_legalize.c Normal file
View File

@ -0,0 +1,23 @@
/*===================================================================*/
//
// place_legalize.c
//
// Aaron P. Hurst, 2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <limits.h>
#include <assert.h>
#include "place_base.h"
// --------------------------------------------------------------------
// legalize()
//
// --------------------------------------------------------------------
void legalize() {
// UNIMPLEMENTED
}

141
src/phys/place/place_pads.c Normal file
View File

@ -0,0 +1,141 @@
/*===================================================================*/
//
// place_pads.c
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include "place_base.h"
// --------------------------------------------------------------------
// globalPreplace()
//
/// \brief Place pad ring, leaving a core area to meet a desired utilization.
//
/// Sets the position of pads that aren't already fixed.
///
/// Computes g_place_coreBounds and g_place_padBounds. Determines
/// g_place_rowHeight.
//
// --------------------------------------------------------------------
void globalPreplace(float utilization) {
int i, c, h, numRows;
float coreArea = 0, totalArea = 0;
int padCount = 0;
float area;
ConcreteCell **padCells = NULL;
AbstractCell *padType = NULL;
ConcreteCell *cell;
float nextPos;
int remainingPads, northPads, southPads, eastPads, westPads;
printf("PLAC-00 : Placing IO pads\n");;
// identify the pads and compute the total core area
g_place_coreBounds.x = g_place_coreBounds.y = 0;
g_place_coreBounds.w = g_place_coreBounds.h = -INT_MAX;
for(c=0; c<g_place_numCells; c++) if (g_place_concreteCells[c]) {
cell = g_place_concreteCells[c];
area = getCellArea(cell);
if (cell->m_parent->m_pad) {
padType = cell->m_parent;
} else {
coreArea += area;
g_place_rowHeight = cell->m_parent->m_height;
}
if (cell->m_fixed) {
g_place_coreBounds.x = g_place_coreBounds.x < cell->m_x ? g_place_coreBounds.x : cell->m_x;
g_place_coreBounds.y = g_place_coreBounds.y < cell->m_y ? g_place_coreBounds.y : cell->m_y;
g_place_coreBounds.w = g_place_coreBounds.w > cell->m_x ? g_place_coreBounds.w : cell->m_x;
g_place_coreBounds.h = g_place_coreBounds.h > cell->m_y ? g_place_coreBounds.h : cell->m_y;
} else if (cell->m_parent->m_pad) {
padCells = realloc(padCells, sizeof(ConcreteCell **)*(padCount+1));
padCells[padCount++] = cell;
}
totalArea += area;
}
if (!padType) {
printf("ERROR: No pad cells\n");
exit(1);
}
g_place_padBounds.w -= g_place_padBounds.x;
g_place_padBounds.h -= g_place_padBounds.y;
coreArea /= utilization;
// create the design boundaries
numRows = sqrt(coreArea)/g_place_rowHeight+1;
h = numRows * g_place_rowHeight;
g_place_coreBounds.h = g_place_coreBounds.h > h ? g_place_coreBounds.h : h;
g_place_coreBounds.w = g_place_coreBounds.w > coreArea/g_place_coreBounds.h ?
g_place_coreBounds.w : coreArea/g_place_coreBounds.h;
// increase the dimensions by the width of the padring
g_place_padBounds = g_place_coreBounds;
if (padCount) {
printf("PLAC-05 : \tpreplacing %d pad cells\n", padCount);
g_place_padBounds.x -= padType->m_width;
g_place_padBounds.y -= padType->m_height;
g_place_padBounds.w = g_place_coreBounds.w+2*padType->m_width;
g_place_padBounds.h = g_place_coreBounds.h+2*padType->m_height;
}
printf("PLAC-05 : \tplaceable rows : %d\n", numRows);
printf("PLAC-05 : \tcore dimensions : %.0fx%.0f\n",
g_place_coreBounds.w, g_place_coreBounds.h);
printf("PLAC-05 : \tchip dimensions : %.0fx%.0f\n",
g_place_padBounds.w, g_place_padBounds.h);
remainingPads = padCount;
c = 0;
// north pads
northPads = remainingPads/4; remainingPads -= northPads;
nextPos = 0;
for(i=0; i<northPads; i++) {
cell = padCells[c++];
cell->m_x = g_place_padBounds.x+cell->m_parent->m_width*0.5 + nextPos;
cell->m_y = g_place_padBounds.y+cell->m_parent->m_height*0.5;
nextPos += (g_place_padBounds.w-padType->m_width) / northPads;
}
// south pads
southPads = remainingPads/3; remainingPads -= southPads;
nextPos = 0;
for(i=0; i<southPads; i++) {
cell = padCells[c++];
cell->m_x = g_place_padBounds.w+g_place_padBounds.x-cell->m_parent->m_width*0.5 - nextPos;
cell->m_y = g_place_padBounds.h+g_place_padBounds.y-cell->m_parent->m_height*0.5;
nextPos += (g_place_padBounds.w-2*padType->m_width) / southPads;
}
// east pads
eastPads = remainingPads/2; remainingPads -= eastPads;
nextPos = 0;
for(i=0; i<eastPads; i++) {
cell = padCells[c++];
cell->m_x = g_place_padBounds.w+g_place_padBounds.x-cell->m_parent->m_width*0.5;
cell->m_y = g_place_padBounds.y+cell->m_parent->m_height*0.5 + nextPos;
nextPos += (g_place_padBounds.h-padType->m_height) / eastPads;
}
// west pads
westPads = remainingPads;
nextPos = 0;
for(i=0; i<westPads; i++) {
cell = padCells[c++];
cell->m_x = g_place_padBounds.x+cell->m_parent->m_width*0.5;
cell->m_y = g_place_padBounds.h+g_place_padBounds.y-cell->m_parent->m_height*0.5 - nextPos;
nextPos += (g_place_padBounds.h-padType->m_height) / westPads;
}
}

1135
src/phys/place/place_partition.c Normal file
View File

File diff suppressed because it is too large Load Diff

1270
src/phys/place/place_qpsolver.c Normal file
View File

File diff suppressed because it is too large Load Diff

140
src/phys/place/place_qpsolver.h Normal file
View File

@ -0,0 +1,140 @@
/*===================================================================*/
//
// place_qpsolver.h
//
// Philip Chong
// pchong@cadence.com
//
/*===================================================================*/
#if !defined(_QPS_H)
#define _QPS_H
#include <stdio.h>
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
typedef float qps_float_t;
typedef struct qps_problem {
/* Basic stuff */
int num_cells; /* Total number of cells (both fixed and
floating) to be placed. */
int *connect; /* Connectivity array. Must contain at least
num_cells elements with value -1. The
entries which precede the first element
with value -1 are the indices of the cells
which connect to cell 0; the entries
which lie between the first and second
elements with value -1 are the indices of
the cells which connect to cell 1; etc.
Example: cells 0 and 1 are connected
together, and 1 and 2 are connected as
well. *connect = { 1, -1, 0, 2, -1, 1, -1
}. */
qps_float_t *edge_weight; /* Same structure as connectivity array, but
giving the weights assigned to each edge
instead. */
qps_float_t *x; /* num_cells element array which contains the
x-coordinates of the cells. This is used
for the initial values in the iterative
solution of floating cells, and for the
fixed location of fixed cells. */
qps_float_t *y; /* num_cells element array of
y-coordinates. */
int *fixed; /* num_cells element array with value 1 if
corresponding cell is fixed, 0 if
floating. */
qps_float_t f; /* return value for sum-of-square
wirelengths. */
/* COG stuff */
int cog_num; /* Number of COG constraints. */
int *cog_list; /* Array indicating for each COG constraint
which cells belong to that constraint.
Format is similar to c array: there must
be at least cog_num elements with value
-1. The entries of cog_list preceding the
first -1 element are the indices of the
cells which belong to the first COG
constraint; etc. Example: cells 0 and 1
belong to one COG constraint, cells 4 and
5 belong to another. *cog_list= { 0, 1,
-1, 4, 5, -1 }. */
qps_float_t *cog_x; /* cog_num element array whose values are the
x-coordinates for the corresponding COG
constraints. */
qps_float_t *cog_y; /* cog_num element array whose values are the
y-coordinates for the corresponding COG
constraints. */
qps_float_t *area; /* num_cells element array whose values are
the areas for the corresponding cells;
only useful with COG constraints. */
/* Loop constraint stuff */
int loop_num; /* Number of loop constraints. */
int *loop_list; /* Array with list of cells for each loop
constraint. Format is similar to cog_list.
*/
qps_float_t *loop_max; /* loop_num element array indicating maximum
distance for each loop. */
qps_float_t *loop_penalty; /* loop_num element array indicating penalty
for each loop. */
int loop_k; /* Current iteration for loop optimization. */
int loop_done; /* Done flag for loop optimization. */
int loop_fail;
/* max_x/max_y stuff */
qps_float_t max_x; /* max x location; only used in
constrained optimization. */
qps_float_t max_y; /* max y location; only used in
constrained optimization. */
int max_enable; /* Set to 1 after qps_init() to enable
max_x/max_y. */
int max_done; /* Done flag for max optimization. */
/* Private stuff */
int *priv_ii;
int *priv_cc, *priv_cr;
qps_float_t *priv_cw, *priv_ct;
int priv_cm;
int *priv_gt;
int *priv_la;
int priv_lm;
qps_float_t *priv_gm, *priv_gw;
qps_float_t *priv_g, *priv_h, *priv_xi;
qps_float_t *priv_tp, *priv_tp2;
int priv_n;
qps_float_t *priv_cp;
qps_float_t priv_f;
qps_float_t *priv_lt;
qps_float_t *priv_pcg, *priv_pcgt;
qps_float_t priv_fmax;
qps_float_t priv_fprev;
qps_float_t priv_fopt;
qps_float_t priv_eps;
int priv_pn;
qps_float_t *priv_mxl, *priv_mxh, *priv_myl, *priv_myh;
int priv_ik;
FILE *priv_fp;
} qps_problem_t;
/* call qps_init() as soon as the qps_problem_t has been set up */
/* this initializes some private data structures */
extern void qps_init(qps_problem_t *);
/* call qps_solve() to solve the given qp problem */
extern void qps_solve(qps_problem_t *);
/* call qps_clean() when finished with the qps_problem_t */
/* this discards the private data structures assigned by qps_init() */
extern void qps_clean(qps_problem_t *);
#if defined(__cplusplus)
}
#endif /* __cplusplus */
#endif /* _QPS_H */

360
src/phys/place/place_test.c Normal file
View File

@ -0,0 +1,360 @@
/*===================================================================*/
//
// place_test.c
//
// Aaron P. Hurst, 2003-2007
// ahurst@eecs.berkeley.edu
//
/*===================================================================*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "place_base.h"
// --------------------------------------------------------------------
// Hash type/functions
//
// --------------------------------------------------------------------
struct hash_element {
ConcreteCell *obj;
struct hash_element *next;
} hash_element;
int hash_string(int hash_max, const char *str) {
unsigned int hash = 0;
int p;
for(p = 0; p<strlen(str); p++)
hash += str[p]*p;
return hash % hash_max;
}
void hash_add(struct hash_element **hash, int hash_max,
ConcreteCell *cell) {
int key = hash_string(hash_max, cell->m_label);
// printf("adding %s key = %d\n", cell->m_label, key);
struct hash_element *element = malloc(sizeof(struct hash_element));
assert(element);
element->obj = cell;
element->next = hash[key];
hash[key] = element;
}
ConcreteCell *hash_find(struct hash_element **hash, int hash_max, const char *str) {
int key = hash_string(hash_max, str);
// printf("looking for %s key = %d\n", str, key);
struct hash_element *next = hash[key];
while(next) {
if (!strcmp(str, next->obj->m_label))
return next->obj;
next = next->next;
}
return 0;
}
// --------------------------------------------------------------------
// Global variables
//
// --------------------------------------------------------------------
struct hash_element **hash_cellname;
int numCells = 0, numNets = 0;
AbstractCell *abstractCells;
ConcreteCell *concreteCells;
ConcreteNet *concreteNets;
// --------------------------------------------------------------------
// Function implementations
//
// --------------------------------------------------------------------
void readBookshelfNets(char *filename) {
char *tok;
char buf[1024];
const char *DELIMITERS = " \n\t:";
int id = 0;
int t;
ConcreteCell *cell;
FILE *netsFile = fopen(filename, "r");
if (!netsFile) {
printf("ERROR: Could not open .nets file\n");
exit(1);
}
// line 1 : version
while (fgets(buf, 1024, netsFile) && (buf[0] == '\n' || buf[0] == '#'));
// line 2 : number of nets
while (fgets(buf, 1024, netsFile) && (buf[0] == '\n' || buf[0] == '#'));
tok = strtok(buf, DELIMITERS);
tok = strtok(NULL, DELIMITERS);
numNets = atoi(tok);
printf("READ-20 : number of nets = %d\n", numNets);
concreteNets = malloc(sizeof(ConcreteNet)*numNets);
// line 3 : number of pins
while (fgets(buf, 1024, netsFile) && (buf[0] == '\n' || buf[0] == '#'));
// line XXX : net definitions
while(fgets(buf, 1024, netsFile)) {
if (buf[0] == '\n' || buf[0] == '#') continue;
concreteNets[id].m_id = id;
concreteNets[id].m_weight = 1.0;
tok = strtok(buf, DELIMITERS);
if (!!strcmp(tok, "NetDegree")) {
printf("%s\n",buf);
printf("ERROR: Incorrect format in .nets file\n");
exit(1);
}
tok = strtok(NULL, DELIMITERS);
concreteNets[id].m_numTerms = atoi(tok);
if (concreteNets[id].m_numTerms < 0 ||
concreteNets[id].m_numTerms > 100000) {
printf("ERROR: Bad net degree\n");
exit(1);
}
concreteNets[id].m_terms = malloc(sizeof(ConcreteCell*)*
concreteNets[id].m_numTerms);
// read terms
t = 0;
while(t < concreteNets[id].m_numTerms &&
fgets(buf, 1024, netsFile)) {
if (buf[0] == '\n' || buf[0] == '#') continue;
// cell name
tok = strtok(buf, DELIMITERS);
cell = hash_find(hash_cellname, numCells, tok);
if (!cell) {
printf("ERROR: Could not find cell %s in .nodes file\n", tok);
exit(1);
}
concreteNets[id].m_terms[t] = cell;
t++;
}
// add!
addConcreteNet(&(concreteNets[id]));
id++;
}
fclose(netsFile);
}
void readBookshelfNodes(char *filename) {
char *tok;
char buf[1024];
const char *DELIMITERS = " \n\t:";
int id = 0;
FILE *nodesFile = fopen(filename, "r");
if (!nodesFile) {
printf("ERROR: Could not open .nodes file\n");
exit(1);
}
// line 1 : version
while (fgets(buf, 1024, nodesFile) && (buf[0] == '\n' || buf[0] == '#'));
// line 2 : num nodes
while (fgets(buf, 1024, nodesFile) && (buf[0] == '\n' || buf[0] == '#'));
tok = strtok(buf, DELIMITERS);
tok = strtok(NULL, DELIMITERS);
numCells = atoi(tok);
printf("READ-10 : number of cells = %d\n", numCells);
concreteCells = malloc(sizeof(ConcreteCell)*numCells);
abstractCells = malloc(sizeof(AbstractCell)*numCells);
hash_cellname = calloc(numCells, sizeof(struct hash_element*));
// line 3 : num terminals
while (fgets(buf, 1024, nodesFile) && (buf[0] == '\n' || buf[0] == '#'));
// line XXX : cell definitions
while(fgets(buf, 1024, nodesFile)) {
if (buf[0] == '\n' || buf[0] == '#') continue;
tok = strtok(buf, DELIMITERS);
concreteCells[id].m_id = id;;
// label
concreteCells[id].m_parent = &(abstractCells[id]);
concreteCells[id].m_label = malloc(sizeof(char)*strlen(tok)+1);
strcpy(concreteCells[id].m_label, tok);
abstractCells[id].m_label = concreteCells[id].m_label;
hash_add(hash_cellname, numCells,
&(concreteCells[id]));
// dimensions
tok = strtok(NULL, DELIMITERS);
abstractCells[id].m_width = atof(tok);
tok = strtok(NULL, DELIMITERS);
abstractCells[id].m_height = atof(tok);
tok = strtok(NULL, DELIMITERS);
// terminal
abstractCells[id].m_pad = tok && !strcmp(tok, "terminal");
// add!
addConcreteCell(&(concreteCells[id]));
// DEBUG
/*
printf("\"%s\" : %f x %f\n", concreteCells[id].m_label,
abstractCells[id].m_width,
abstractCells[id].m_height);
*/
id++;
}
fclose(nodesFile);
}
void readBookshelfPlacement(char *filename) {
char *tok;
char buf[1024];
const char *DELIMITERS = " \n\t:";
ConcreteCell *cell;
FILE *plFile = fopen(filename, "r");
FILE *netsFile = fopen(filename, "r");
if (!plFile) {
printf("ERROR: Could not open .pl file\n");
exit(1);
}
if (!netsFile) {
printf("ERROR: Could not open .nets file\n");
exit(1);
}
// line 1 : version
while (fgets(buf, 1024, plFile) && (buf[0] == '\n' || buf[0] == '#'));
// line XXX : placement definitions
while(fgets(buf, 1024, plFile)) {
if (buf[0] == '\n' || buf[0] == '#') continue;
tok = strtok(buf, DELIMITERS);
// cell name
cell = hash_find(hash_cellname, numCells, tok);
if (!cell) {
printf("ERROR: Could not find cell %s in .nodes file\n",tok);
exit(1);
}
// position
tok = strtok(NULL, DELIMITERS);
cell->m_x = atof(tok);
tok = strtok(NULL, DELIMITERS);
cell->m_y = atof(tok);
// hfixed
cell->m_fixed = strtok(NULL, DELIMITERS) &&
(tok = strtok(NULL, DELIMITERS)) &&
!strcmp(tok, "\\FIXED");
}
fclose(plFile);
}
void writeBookshelfPlacement(char *filename) {
int c = 0;
FILE *plFile = fopen(filename, "w");
if (!plFile) {
printf("ERROR: Could not open .pl file\n");
exit(1);
}
fprintf(plFile, "UCLA pl 1.0\n");
for(c=0; c<numCells; c++) {
fprintf(plFile, "%s %f %f : N %s\n",
concreteCells[c].m_label,
concreteCells[c].m_x,
concreteCells[c].m_y,
(concreteCells[c].m_fixed ? "\\FIXED" : ""));
}
fclose(plFile);
}
// deletes all connections to a cell
void delNetConnections(ConcreteCell *cell) {
int n, t, t2, count = 0;
ConcreteCell **old = malloc(sizeof(ConcreteCell*)*g_place_numCells);
for(n=0; n<g_place_numNets; n++) if (g_place_concreteNets[n]) {
ConcreteNet *net = g_place_concreteNets[n];
count = 0;
for(t=0; t<net->m_numTerms; t++)
if (net->m_terms[t] == cell) count++;
if (count) {
memcpy(old, net->m_terms, sizeof(ConcreteCell*)*net->m_numTerms);
net->m_terms = realloc(net->m_terms,
sizeof(ConcreteCell*)*(net->m_numTerms-count));
t2 = 0;
for(t=0; t<net->m_numTerms; t++)
if (old[t] != cell) net->m_terms[t2++] = old[t];
net->m_numTerms -= count;
}
}
free(old);
}
int main(int argc, char **argv) {
if (argc != 4) {
printf("Usage: %s [nodes] [nets] [pl]\n", argv[0]);
exit(1);
}
readBookshelfNodes(argv[1]);
readBookshelfNets(argv[2]);
readBookshelfPlacement(argv[3]);
globalPreplace(0.8);
globalPlace();
// DEBUG net/cell removal/addition
/*
int i;
for(i=1000; i<2000; i++) {
delConcreteNet(g_place_concreteNets[i]);
delNetConnections(g_place_concreteCells[i]);
delConcreteCell(g_place_concreteCells[i]);
}
ConcreteCell newCell[2];
newCell[0].m_id = g_place_numCells+1;
newCell[0].m_x = 1000;
newCell[0].m_y = 1000;
newCell[0].m_fixed = false;
newCell[0].m_parent = &(abstractCells[1000]);
newCell[0].m_label = " ";
addConcreteCell(&newCell[0]);
newCell[1].m_id = g_place_numCells+3;
newCell[1].m_x = 1000;
newCell[1].m_y = 1000;
newCell[1].m_fixed = false;
newCell[1].m_parent = &(abstractCells[1000]);
newCell[1].m_label = " ";
addConcreteCell(&newCell[1]);
*/
globalIncremental();
writeBookshelfPlacement(argv[3]);
free(hash_cellname);
return 0;
}

9
src/phys/place/test.nets Normal file
View File

@ -0,0 +1,9 @@
UCLA nets 1.0
NumNets : 2
NumPins : 4
NetDegree 2 :
0 pin : 0 0
3 pin : 0 0
NetDegree 2 :
2 pin : 0 0
3 pin : 0 0

7
src/phys/place/test.nodes Normal file
View File

@ -0,0 +1,7 @@
UCLA nodes 1.0
NumNodes : 4
NumTerminals : 3
0 1.0 1.0 terminal
1 1.0 1.0 terminal
2 1.0 1.0 terminal
3 1.0 1.0

5
src/phys/place/test.pl Normal file
View File

@ -0,0 +1,5 @@
UCLA pl 1.0
0 0.000000 0.000000 : N \FIXED
1 5.000000 5.000000 : N \FIXED
2 0.000000 5.000000 : N \FIXED
3 4.500000 2.500000 : N

5
src/sat/bsat/satSolver.h
View File

@ -46,12 +46,17 @@ static const bool false = 0;
typedef int lit;
typedef char lbool;
#ifndef SINT64
#define SINT64
#ifdef _WIN32
typedef signed __int64 sint64; // compatible with MS VS 6.0
#else
typedef long long sint64;
#endif
#endif
static const int var_Undef = -1;
static const lit lit_Undef = -2;

5
src/sat/fraig/fraig.h
View File

@ -27,12 +27,17 @@ extern "C" {
/// INCLUDES ///
////////////////////////////////////////////////////////////////////////
#ifndef SINT64
#define SINT64
#ifdef _WIN32
typedef signed __int64 sint64; // compatible with MS VS 6.0
#else
typedef long long sint64;
#endif
#endif
////////////////////////////////////////////////////////////////////////
/// PARAMETERS ///
////////////////////////////////////////////////////////////////////////