summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile3
-rw-r--r--scripts/abc.rc147
-rw-r--r--scripts/abc_common.py2007
-rw-r--r--scripts/main.py431
-rw-r--r--scripts/multi_prove.sh14
-rw-r--r--scripts/new_abc_commands.py257
-rw-r--r--scripts/niklas.py191
-rw-r--r--scripts/par.py8151
-rw-r--r--scripts/simple.sh14
-rw-r--r--scripts/simple_bip.sh14
-rw-r--r--scripts/simple_liveness.sh14
-rw-r--r--scripts/simple_sat.sh14
-rw-r--r--scripts/super_prove.sh14
-rw-r--r--src/base/main/mainReal.c33
-rw-r--r--src/base/main/mainUtils.c17
-rw-r--r--src/misc/util/utilSignal.c4
-rw-r--r--src/python/abc.sh78
-rw-r--r--src/python/abcpy_test.py54
-rw-r--r--src/python/build.txt32
-rw-r--r--src/python/getch.py37
-rw-r--r--src/python/module.make92
-rw-r--r--src/python/package.py176
-rw-r--r--src/python/pyabc.i1319
-rw-r--r--src/python/pyabc_split.py412
-rw-r--r--src/python/reachx_cmd.py108
-rw-r--r--src/python/redirect.py111
-rw-r--r--src/python/setup.py67
27 files changed, 1 insertions, 13810 deletions
diff --git a/Makefile b/Makefile
index e964bcdb..cd1d0edd 100644
--- a/Makefile
+++ b/Makefile
@@ -29,8 +29,7 @@ MODULES := \
src/proof/pdr src/proof/abs src/proof/live src/proof/ssc src/proof/int \
src/proof/cec src/proof/dch src/proof/fraig src/proof/fra src/proof/ssw \
src/aig/aig src/aig/saig src/aig/gia src/aig/ioa src/aig/ivy src/aig/hop \
- src/aig/miniaig \
- src/python
+ src/aig/miniaig
all: $(PROG)
default: $(PROG)
diff --git a/scripts/abc.rc b/scripts/abc.rc
deleted file mode 100644
index 365a49ca..00000000
--- a/scripts/abc.rc
+++ /dev/null
@@ -1,147 +0,0 @@
-# reachx
-python new_abc_commands.py
-python -c "import reachx_cmd"
-
-
-# global parameters
-set check # checks intermediate networks
-#set checkfio # prints warnings when fanins/fanouts are duplicated
-#unset checkread # does not check new networks after reading from file
-#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
-
-# program names for internal calls
-set dotwin dot.exe
-set dotunix dot
-set gsviewwin gsview32.exe
-set gsviewunix gv
-set siswin sis.exe
-set sisunix sis
-set mvsiswin mvsis.exe
-set mvsisunix mvsis
-set capowin MetaPl-Capo10.1-Win32.exe
-set capounix MetaPl-Capo10.1
-set gnuplotwin wgnuplot.exe
-set gnuplotunix gnuplot
-
-# Niklas Een's commands
-#load_plugin C:\_projects\abc\lib\bip_win.exe "BIP"
-#load_plugin /hd/common/pyabc/bip "BIP"
-
-# standard aliases
-alias hi history
-alias b balance
-alias cg clockgate
-alias cl cleanup
-alias clp collapse
-alias cs care_set
-alias esd ext_seq_dcs
-alias f fraig
-alias fs fraig_sweep
-alias fsto fraig_store
-alias fres fraig_restore
-alias fr fretime
-alias ft fraig_trust
-alias ic indcut
-alias lp lutpack
-alias pcon print_cone
-alias pd print_dsd
-alias pex print_exdc -d
-alias pf print_factor
-alias pfan print_fanio
-alias pg print_gates
-alias pl print_level
-alias plat print_latch
-alias pio print_io
-alias pk print_kmap
-alias pm print_miter
-alias ps print_stats
-alias psb print_stats -b
-alias psu print_supp
-alias psy print_symm
-alias pun print_unate
-alias q quit
-alias r read
-alias ra read_aiger
-alias r3 retime -M 3
-alias r3f retime -M 3 -f
-alias r3b retime -M 3 -b
-alias ren renode
-alias rh read_hie
-alias ri read_init
-alias rl read_blif
-alias rb read_bench
-alias ret retime
-alias dret dretime
-alias rp read_pla
-alias rt read_truth
-alias rv read_verilog
-alias rvl read_verlib
-alias rsup read_super mcnc5_old.super
-alias rlib read_library
-alias rlibc read_library cadence.genlib
-alias rty read_liberty
-alias rlut read_lut
-alias rw rewrite
-alias rwz rewrite -z
-alias rf refactor
-alias rfz refactor -z
-alias re restructure
-alias rez restructure -z
-alias rs resub
-alias rsz resub -z
-alias sa set autoexec ps
-alias scl scleanup
-alias sif if -s
-alias so source -x
-alias st strash
-alias sw sweep
-alias ssw ssweep
-alias tr0 trace_start
-alias tr1 trace_check
-alias trt "r c.blif; st; tr0; b; tr1"
-alias u undo
-alias w write
-alias wa write_aiger
-alias wb write_bench
-alias wc write_cnf
-alias wh write_hie
-alias wl write_blif
-alias wp write_pla
-alias wv write_verilog
-
-# standard scripts
-alias resyn "b; rw; rwz; b; rwz; b"
-alias resyn2 "b; rw; rf; b; rw; rwz; b; rfz; rwz; b"
-alias resyn2a "b; rw; b; rw; rwz; b; rwz; b"
-alias resyn3 "b; rs; rs -K 6; b; rsz; rsz -K 6; b; rsz -K 5; b"
-alias compress "b -l; rw -l; rwz -l; b -l; rwz -l; b -l"
-alias compress2 "b -l; rw -l; rf -l; b -l; rw -l; rwz -l; b -l; rfz -l; rwz -l; b -l"
-alias choice "fraig_store; resyn; fraig_store; resyn2; fraig_store; fraig_restore"
-alias choice2 "fraig_store; balance; fraig_store; resyn; fraig_store; resyn2; fraig_store; resyn2; fraig_store; fraig_restore"
-alias rwsat "st; rw -l; b -l; rw -l; rf -l"
-alias drwsat2 "st; drw; b -l; drw; drf; ifraig -C 20; drw; b -l; drw; drf"
-alias share "st; multi -m; fx; resyn2"
-alias addinit "read_init; undc; strash; zero"
-alias blif2aig "undc; strash; zero"
-alias v2p "&vta_gla; &ps; &gla_derive; &put; w 1.aig; pdr -v"
-alias g2p "&ps; &gla_derive; &put; w 2.aig; pdr -v"
-
-# resubstitution scripts for the IWLS paper
-alias src_rw "st; rw -l; rwz -l; rwz -l"
-alias src_rs "st; rs -K 6 -N 2 -l; rs -K 9 -N 2 -l; rs -K 12 -N 2 -l"
-alias src_rws "st; rw -l; rs -K 6 -N 2 -l; rwz -l; rs -K 9 -N 2 -l; rwz -l; rs -K 12 -N 2 -l"
-alias resyn2rs "b; rs -K 6; rw; rs -K 6 -N 2; rf; rs -K 8; b; rs -K 8 -N 2; rw; rs -K 10; rwz; rs -K 10 -N 2; b; rs -K 12; rfz; rs -K 12 -N 2; rwz; b"
-alias compress2rs "b -l; rs -K 6 -l; rw -l; rs -K 6 -N 2 -l; rf -l; rs -K 8 -l; b -l; rs -K 8 -N 2 -l; rw -l; rs -K 10 -l; rwz -l; rs -K 10 -N 2 -l; b -l; rs -K 12 -l; rfz -l; rs -K 12 -N 2 -l; rwz -l; b -l"
-
-# use this script to convert 1-valued and DC-valued flops for an AIG
-alias fix_aig "logic; undc; strash; zero"
-
-# use this script to convert 1-valued and DC-valued flops for a logic network coming from BLIF
-alias fix_blif "undc; strash; zero"
-
-# lazy man's synthesis
-alias recadd3 "st; rec_add3; b; rec_add3; dc2; rec_add3; if -K 8; bidec; st; rec_add3; dc2; rec_add3; if -g -K 6; st; rec_add3"
-
-
diff --git a/scripts/abc_common.py b/scripts/abc_common.py
deleted file mode 100644
index df2b731b..00000000
--- a/scripts/abc_common.py
+++ /dev/null
@@ -1,2007 +0,0 @@
-from pyabc import *
-import pyabc_split
-import par
-import redirect
-import sys
-import os
-import time
-import math
-
-
-global G_C,G_T,latches_before_abs,latches_before_pba,n_pos_before,x_factor
-
-"""
-The functions that are currently available from module _abc are:
-
-int n_ands();
-int n_pis();
-int n_pos();
-int n_latches();
-int n_bmc_frames();
-int prob_status(); 1 = unsat, 0 = sat, -1 = unsolved
-
-int run_command(char* cmd);
-
-bool has_comb_model();
-bool has_seq_model();
-bool is_true_cex();
-bool is_valid_cex();
- return 1 if the number of PIs in the current network and in the current counter-example are equal
-int n_cex_pis();
- return the number of PIs in the current counter-example
-int n_cex_regs();
- return the number of flops in the current counter-example
-int cex_po();
- returns the zero-based output PO number that is SAT by cex
-int cex_frame();
- return the zero-based frame number where the outputs is SAT
-The last four APIs return -1, if the counter-example is not defined.
-"""
-
-#global variables
-
-stackno_gabs = stackno_gore = stackno_greg= 0
-STATUS_UNKNOWN = -1
-STATUS_SAT = 0
-STATUS_UNSAT = 1
-RESULT = ('SAT' , 'SAT', 'UNSAT', 'UNDECIDED', 'UNDECIDED,', 'UNDCIDED' )
-Sat_reg = 0
-Sat_true = 1
-Unsat = 2
-Undecided_reduction = 3
-Undecided_no_reduction = 4
-Error = 5
-Restart = 6
-xfi = x_factor = 1 #set this to higher for larger problems or if you want to try harder during abstraction
-max_bmc = -1
-last_time = 0
-
-# Function definitions:
-# simple functions: ________________________________________________________________________
-# set_globals, abc, q, x, has_any_model, is_sat, is_unsat, push, pop
-
-# ALIASES
-def p():
- return prove()
-
-def ps():
- print_circuit_stats()
-
-def n_real_inputs():
- """This gives the number of 'real' inputs. This is determined by trimming away inputs that
- have no connection to the logic. This is done by the ABC alias 'trm', which changes the current
- circuit. In some applications we do not want to change the circuit, but just to know how may inputs
- would go away if we did this. So the current circuit is saved and then restored afterwards."""
- abc('w %s_savetempreal.aig; logic; trim; st'%f_name)
- n = n_pis()
- abc('r %s_savetempreal.aig'%f_name)
- return n
-
-def long(t):
- if t<20:
- t = t
- else:
- t = 20+(t-20)/3
- return max(10,t)
-
-def rif():
- """Not used"""
- global f_name
- print 'Type in the name of the aig file to be read in'
- s = raw_input()
- if s[-5:] == '.blif':
- f_name = s[:-5]
- else:
- f_name = s
- s = s+'.blif'
- run_command(s)
- x('st;constr -i')
- print_circuit_stats()
- a = n_ands()
- f = max(1,30000/a)
- f = min (f,16)
- x('scorr -c -F %d'%f)
- x('fold')
- print_circuit_stats()
- x('w %s_c.aig'%f_name)
-
-def abc(cmd):
- abc_redirect_all(cmd)
-
-
-def abc_redirect( cmd, dst = redirect.null_file, src = sys.stdout ):
- """This is our main way of calling an ABC function. Redirect, means that we suppress any output from ABC"""
- with redirect.redirect( dst, src ):
- return run_command( cmd )
-
-
-def abc_redirect_all( cmd ):
- """This is our main way of calling an ABC function. Redirect, means that we suppress any output from ABC, including error printouts"""
- with redirect.redirect( redirect.null_file, sys.stdout ):
- with redirect.redirect( redirect.null_file, sys.stderr ):
- return run_command( cmd )
-
-def set_globals():
- """This sets global parameters that are used to limit the resources used by all the operations
- bmc, interpolation BDDs, abstract etc. There is a global factor 'x_factor' that can
- control all of the various resource limiting parameters"""
- global G_C,G_T,x_factor
- nl=n_latches()
- na=n_ands()
- np = n_pis()
- #G_C = min(500000,(3*na+500*(nl+np)))
- G_C = x_factor * min(100000,(3*na+500*(nl+np)))
- #G_T = min(250,G_C/2000)
- G_T = x_factor * min(75,G_C/2000)
- G_T = max(1,G_T)
- #print('Global values: BMC conflicts = %d, Max time = %d sec.'%(G_C,G_T))
-
-def a():
- """this puts the system into direct abc input mode"""
- print "Entering ABC direct-input mode. Type q to quit ABC-mode"
- n = 0
- while True:
- print ' abc %d> '%n,
- n = n+1
- s = raw_input()
- if s == "q":
- break
- run_command(s)
-
-def set_fname(name):
- """ Another way to set an f_name, but currently this is not used"""
- global f_name
- s = name
- if s[-4:] == '.aig':
- f_name = s[:-4]
- else:
- f_name = s
- s = s+'.aig'
- #read in file
- run_command(s)
- #print_circuit_stats()
-
-def read_file_quiet(fname=None):
- """This is the main program used for reading in a new circuit. The global file name is stored (f_name)
- Sometimes we want to know the initial starting name. The file name can have the .aig extension left off
- and it will assume that the .aig extension is implied. This should not be used for .blif files.
- Any time we want to process a new circuit, we should use this since otherwise we would not have the
- correct f_name."""
- global max_bmc, f_name, d_name, initial_f_name, x_factor, init_initial_f_name
- x_factor = 1
- max_bmc = -1
-
- if fname is None:
- print 'Type in the name of the aig file to be read in'
- s = raw_input()
- else:
- s = fname
-
- if s[-4:] == '.aig':
- f_name = s[:-4]
- else:
- f_name = s
- s = s+'.aig'
-
- run_command(s)
- initial_f_name = f_name
- init_initial_f_name = f_name
-
-def read_file():
- read_file_quiet()
- print_circuit_stats()
-
-def rf():
- read_file()
-
-
-def write_file(s):
- """this is the main method for writing the current circuit to an AIG file on disk.
- It manages the name of the file, by giving an extension (s). The file name 'f_name'
- keeps increasing as more extensions are written. A typical sequence is
- name, name_smp, name_smp_abs, name_smp_abs_spec, name_smp_abs_spec_final"""
- global f_name
- """Writes out the current file as an aig file using f_name appended with argument"""
- f_name = '%s_%s'%(f_name,s)
- ss = '%s.aig'%(f_name)
- print 'WRITING %s: '%ss,
- print_circuit_stats()
- abc('w '+ss)
-
-def wf():
- """Not used"""
- print 'input type of file to be written'
- s = raw_input()
- write_file(s)
-
-def bmc_depth():
- """ Finds the number of BMC frames that the latest operation has used. The operation could be BMC, reachability
- interpolation, abstract, speculate. max_bmc is continually increased. It reflects the maximum depth of any version of the circuit
- including g ones, for which it is known that there is not cex out to that depth."""
- global max_bmc
- b = n_bmc_frames()
- max_bmc = max(b,max_bmc)
- return max_bmc
-
-def set_max_bmc(b):
- """ Keeps increasing max_bmc which is the maximum number of time frames for
- which the current circuit is known to be UNSAT for"""
- global max_bmc
- max_bmc = max(b,max_bmc)
-
-def print_circuit_stats():
- """Stardard way of outputting statistice about the current circuit"""
- global max_bmc
- i = n_pis()
- o = n_pos()
- l = n_latches()
- a = n_ands()
- b = max(max_bmc,bmc_depth())
- c = cex_frame()
- if b>= 0:
- if c>=0:
- print 'PIs = %d, POs = %d, FF = %d, ANDs = %d, max depth = %d, CEX depth = %d'%(i,o,l,a,b,c)
- else:
- print 'PIs = %d, POs = %d, FF = %d, ANDs = %d, max depth = %d'%(i,o,l,a,b)
- else:
- if c>=0:
- print 'PIs = %d, POs = %d, FF = %d, ANDs = %d, CEX depth = %d'%(i,o,l,a,c)
- else:
- print 'PIs = %d, POs = %d, FF = %d, ANDs = %d'%(i,o,l,a)
-
-def q():
- exit()
-
-def x(s):
- """execute an ABC command"""
- print "RUNNING: ", s
- run_command(s)
-
-def has_any_model():
- """ check if a satisfying assignment has been found"""
- res = has_comb_model() or has_seq_model()
- return res
-
-def is_unsat():
- if prob_status() == 1:
- return True
- else:
- return False
-
-def is_sat():
- if prob_status() == 0:
- return True
- else:
- return False
-
-def wc(file):
- """writes <file> so that costraints are preserved explicitly"""
- abc('&get;&w %s'%file)
-
-def rc(file):
- """reads <file> so that if constraints are explicit, it will preserve them"""
- abc('&r %s;&put'%file)
-
-
-
-def fast_int(n):
- """This is used to eliminate easy-to-prove outputs. Arg n is conflict limit to be used
- in the interpolation routine. Typically n = 1 or 10"""
- n_po = n_pos()
- abc('int -k -C %d'%n)
- print 'Reduced POs from %d to %d'%(n_po,n_pos())
-
-def refine_with_cex():
- """Refines the greg (which contains the original problem with the set of FF's that have been abstracted).
- This generates a new abstraction (gabs) and modifies the greg file to reflect which regs are in the
- current abstraction"""
- global f_name
- print 'CEX in frame %d for output %d'%(cex_frame(),cex_po())
- abc('&r %s_greg.aig; &abs_refine; &w %s_greg.aig'%(f_name,f_name))
- return
-
-def generate_abs(n):
- """generates an abstracted model (gabs) from the greg file. The gabs file is automatically
- generated in the & space by &abs_derive. We store it away using the f_name of the problem
- being solved at the moment. The f_name keeps changing with an extension given by the latest
- operation done - e.g. smp, abs, spec, final, group. """
- global f_name
- #we have a cex and we use this generate a new gabs file
- abc('&r %s_greg.aig; &abs_derive; &put; w %s_gabs.aig'%(f_name,f_name)) # do we still need the gabs file
- if n == 1:
- print 'New abstraction: ',
- print_circuit_stats()
- return
-
-
-#more complex functions: ________________________________________________________
-#, abstract, pba, speculate, final_verify, dprove3
-
-
-def simplify():
- """Our standard simplification of logic routine. What it does depende on the problem size.
- For large problems, we use the &methods which use a simple circuit based SAT solver. Also problem
- size dictates the level of k-step induction done in 'scorr' The stongest simplification is done if
- n_ands < 20000. Then it used the clause based solver and k-step induction where |k| depends
- on the problem size """
- # set_globals()
-## print 'simplify initial ',
-## ps()
- #abc('w t.aig')
- n=n_ands()
- abc('scl')
- if n > 40000:
- abc('&get;&scl;&put')
- n = n_ands()
- if n < 100000:
- abc("&dc2;&put;dr;&get;&lcorr;&dc2;&put;dr;&get;&scorr;&fraig;&dc2;&put;dr")
- run_command('ps')
- print '.',
- n = n_ands()
- if n<60000:
- abc("&get;&scorr -F 2;&put;dc2rs")
- print '.',
- #ps()
- else:
- abc("dc2rs")
- print '.',
- #ps()
- n = n_ands()
- n = n_ands()
- if n <= 40000:
- print '.',
- #ps()
- if n > 30000:
- abc("dc2rs")
- print '.',
-## else:
-## abc("scorr -F 2;dc2rs")
-## print '.',
-## ps()
- n = max(1,n_ands())
- #ps()
- if n < 30000:
- abc('scl;rw;dr;lcorr;rw;dr')
- m = int(min( 60000/n, 16))
- #print 'm = %d'%m
- if m >= 1:
- j = 1
- while j <= m:
- set_size()
- #print 'j - %d'%j
- #abc('scl;dr;dc2;scorr -C 5000 -F %d'%j)
- if j<8:
- abc('dc2')
- else:
- abc('dc2rs')
- abc('scorr -C 5000 -F %d'%j)
- if check_size():
- break
- j = 2*j
- #ps()
- continue
- print '.',
-
-
-def iterate_simulation(latches_before):
- """Subroutine of 'abstract' which does the refinement of the abstracted model,
- using counterexamples found by simulation. Simulation is controlled by the amount
- of memory it might use. At first wide but shallow simulation is done, bollowed by
- successively more narrow but deeper simulation"""
- global x_factor, f_name
-## print 'RUNNING simulation iteratively'
- f = 5
- w = 255
- for k in range(9):
- f = min(f *2, 3500)
- w = max(((w+1)/2)-1,1)
- print '.',
- abc('sim -m -F %d -W %d'%(f,w))
- if not is_sat():
- continue
- while True:
- refine_with_cex()
- if is_sat():
- print 'cex failed to refine abstraction '
- return Sat_true
- generate_abs(0)
- latches_after = n_latches()
- print 'Latches increased to %d'%latches_after
- if latches_after >= .99*latches_before:
- abc('r %s_savetempabs.aig'%f_name)
- print "No reduction!."
- return Undecided_no_reduction
- abc('sim -m -F %d -W %d'%(f,w))
- if not is_sat():
- break
-
-def simulate():
- """Simulation is controlled by the amount
- of memory it might use. At first wide but shallow simulation is done, bollowed by
- successively more narrow but deeper simulation"""
- global x_factor, f_name
-## print 'RUNNING simulation iteratively'
- f = 5
- w = 255
- for k in range(9):
- f = min(f *2, 3500)
- w = max(((w+1)/2)-1,1)
- print '.',
- abc('sim -m -F %d -W %d'%(f,w))
- if is_sat():
- print 'cex found in frame %d'%cex_frame()
- return 'SAT'
- return 'UNDECIDED'
-
-
-def iterate_abstraction_refinement(latches_before,NBF):
- """Subroutine of 'abstract' which does the refinement of the abstracted model,
- using counterexamples found by BMC or BDD reachability"""
- global x_factor, f_name
- if NBF == -1:
- F = 2000
- else:
- F = 2*NBF
- print '\nIterating BMC/PDR'
- always_reach = 0
- cexf = 0
- reach_failed = 0
- while True:
- #print 'Generating problem abstraction'
- generate_abs(1)
- set_globals()
- latches_after = n_latches()
- if latches_after >= .98*latches_before:
-## print 'No reduction'
-## abc('r &s_savetemp.aig'%f_name)
- break
- ri = n_real_inputs() # No. of inputs after trm
- nlri = n_latches()+ri
- #reach_allowed = ((nlri<150) or (((cexf>250))&(nlri<300)))
- reach_allowed = ((nlri<75) or (((cexf>250))&(nlri<300)))
- pdr_allowed = True
- bmc = False
- t = max(1,G_T)
- if not F == -1:
- F = int(1.5*max_bmc)
- if (((reach_allowed or pdr_allowed ) and not reach_failed)):
- #cmd = 'reach -B 200000 -F 3500 -T %f'%t
- #cmd = 'reachx -e %d -t %d'%(int(long(t)),max(10,int(t)))
- #cmd = 'reachx -t %d'%max(10,int(t))
- cmd = '&get;,pdr -vt=%f'%t
- else:
- #cmd = 'bmc3 -C %d -T %f -F %d'%(G_C,t,F)
- bmc = True
- cmd = '&get;,bmc -vt=%f'%(t)
- #cmd = '&get;,pdr -vt=%f'%(t)
- print '\n***RUNNING %s'%cmd
- #run_command(cmd)
- last_bmc = max_bmc
- abc(cmd)
- if prob_status() == 1:
- #print 'Depth reached %d frames, '%n_bmc_frames()
- print 'UNSAT'
- return Unsat
- cexf = cex_frame()
- #print 'cex depth = %d'%cexf
- #set_max_bmc(cexf -1)
- if ((not is_sat()) ):
- reach_failed = 1 # if ever reach failed, then we should not try it again on more refined models
- if is_sat():
- #print 'CEX in frame %d for output %d'%(cex_frame(),cex_po())
- #set_max_bmc(cexf-1)
- refine_with_cex() # if cex can't refine, status is set to Sat_true
- if is_sat():
- print 'cex did not refine. Implies true_sat'
- return Sat_true
- else:
- print "No CEX found in %d frames"%n_bmc_frames()
- set_max_bmc(n_bmc_frames())
- if bmc:
- break
- elif max_bmc> 1.2*last_bmc: # if pdr increased significantly over abs, the assume OK
- break
- else:
- continue
- latches_after = n_latches()
- if latches_after >= .98*latches_before:
- abc('r %s_savetempabs.aig'%f_name)
- print "No reduction!"
- return Undecided_no_reduction
- else:
- print 'Latches reduced from %d to %d'%(latches_before, n_latches())
- return Undecided_reduction
-
-
-def abstract():
- """ abstracts using N Een's method 3 - cex/proof based abstraction. The result is further refined using
- simulation, BMC or BDD reachability"""
- global G_C, G_T, latches_before_abs, x_factor
- set_globals()
- latches_before_abs = n_latches()
- abc('w %s_savetempabs.aig'%f_name)
- print 'Start: ',
- print_circuit_stats()
- c = 1.5*G_C
- #t = max(1,1.25*G_T)
- t = 2*max(1,1.25*G_T)
- s = min(max(3,c/30000),10) # stability between 3 and 10
- time = max(1,.01*G_T)
- abc('&get;,bmc -vt=%f'%time)
- print 'BMC went %d frames'%n_bmc_frames()
- set_max_bmc(bmc_depth())
- f = max(2*max_bmc,20)
- b = min(max(10,max_bmc),200)
- cmd = '&get;,abs -bob=%d -stable=%d -timeout=%f -vt=%f -depth=%d'%(b,s,t,t,f)
- print ' Running %s'%cmd
- run_command(cmd)
- if is_sat():
- print 'Found true counterexample in frame %d'%cex_frame()
- return Sat_true
- NBF = bmc_depth()
- print 'Abstraction good to %d frames'%n_bmc_frames()
- set_max_bmc(NBF)
- abc('&w %s_greg.aig; &abs_derive; &put; w %s_gabs.aig'%(f_name,f_name))
-## print 'First abstraction: ',
-## print_circuit_stats()
- latches_after = n_latches()
- #if latches_before_abs == latches_after:
- if latches_after >= .98*latches_before_abs:
- abc('r %s_savetempabs.aig'%f_name)
- print "No reduction!"
- return Undecided_no_reduction
- # refinement loop
- if (n_ands() + n_latches() + n_pis()) < 15000:
- print '\n***Running simulation iteratively'
- for i in range(5):
- result = iterate_simulation(latches_before_abs)
- if result == Restart:
- return result
- if result == Sat_true:
- return result
- result = iterate_abstraction_refinement(latches_before_abs, NBF)
- #if the result is 'Restart' we return and the calling routine increase
- #x_factor to try one more time.
- return result
-
-def absv(n,v):
- """This is a version of 'abstract' which can control the methods used in Een's abstraction code (method = n)
- as well as whether we want to view the output of this (v = 1)"""
- global G_C, G_T, latches_before_abs, x_factor
- #input_x_factor()
- #x_factor = 3
- set_globals()
- latches_before_abs = n_latches()
- print 'Start: ',
- print_circuit_stats()
- c = 1.5*G_C
- t = max(1,1.25*G_T)
- s = min(max(3,c/30000),10) # stability between 3 and 10
- if max_bmc == -1:
- time = max(1,.01*G_T)
- #abc('bmc3 -C %d -T %f -F 165'%(.01*G_C, time))
- abc('&get;,bmc -vt=%f'%time)
- set_max_bmc(bmc_depth())
- f = min(250,1.5*max_bmc)
- f = max(20, f)
- f = 10*f
- b = x_factor*20
- if not n == 0:
- b = 10
- b = max(b,max_bmc+2)
- b = b*2**(x_factor-1)
- b = 2*b
- print 'Neen abstraction params: Method #%d, %d conflicts, %d stable, %f sec.'%(n,c/3,s,t)
- if v == 1:
- run_command('&get; &abs_newstart -v -B %f -A %d -C %d -S %d -V %f'%(b,n,c/3,s,t))
- else:
- abc('&get; &abs_newstart -v -B %f -A %d -C %d -S %d -T %f'%(b,n,c/3,s,t))
- set_max_bmc(n_bmc_frames())
- print 'Abstraction good to %d'%n_bmc_frames()
- abc('&w %s_greg.aig; &abs_derive; &put; w %s_gabs.aig'%(f_name,f_name))
- print 'Final abstraction: ',
- print_circuit_stats()
- latches_after = n_latches()
- if latches_after >= .98*latches_before_abs:
- print "No reduction!"
- return Undecided_no_reduction
- return Undecided_reduction
-
-def spec():
- """Main speculative reduction routine. Finds candidate sequential equivalences and refines them by simulation, BMC, or reachability
- using any cex found. """
- input_x_factor()
- global G_C,G_T,n_pos_before, x_factor, n_latches_before
- set_globals()
- n_pos_before = n_pos()
- n_latches_before = n_latches()
- set_globals()
- t = max(1,.5*G_T)
- r = max(1,int(t))
- print '\n***Running &equiv2 with C = %d, T = %f sec., F = %d -S 1 -R %d'%(G_C,t,200,r)
- abc("&get; &equiv2 -C %d -F 200 -T %f -S 1 -R %d; &semi -F 50; &speci -F 20 -C 1000;&srm; r gsrm.aig; w %s_gsrm.aig; &w %s_gore.aig"%((G_C),t,r,f_name,f_name))
- print 'Initial speculation: ',
- print_circuit_stats()
- print 'Speculation good to %d frames'%n_bmc_frames()
- return
-
-def speculate():
- """Main speculative reduction routine. Finds candidate sequential equivalences and refines them by simulation, BMC, or reachability
- using any cex found. """
-
- global G_C,G_T,n_pos_before, x_factor, n_latches_before
- set_globals()
- n_pos_before = n_pos()
-
- def refine_with_cex():
- """Refines the gore file to reflect equivalences that go away because of cex"""
- global f_name
- print 'CEX in frame %d for output %d'%(cex_frame(),cex_po())
- abc('&r %s_gore.aig; &resim -m; &w %s_gore.aig'%(f_name,f_name))
- #abc('&r %s_gore.aig; &equiv2 -vx ; &w %s_gore.aig'%(f_name,f_name))
- return
-
- def generate_srm(n):
- """generates a speculated reduced model (srm) from the gore file"""
- global f_name
- pos = n_pos()
- ab = n_ands()
- abc('&r %s_gore.aig; &srm ; r gsrm.aig; w %s_gsrm.aig'%(f_name,f_name)) #do we still need to write the gsrm file
- if n == 0:
- if ((pos == n_pos()) and (ab == n_ands())):
- print 'Failed to refine'
- return 'failed'
- if n == 1:
- print 'Spec. Red. Miter: ',
- print_circuit_stats()
- return 'OK'
-
- def run_simulation(n):
- f = 5
- w = (256/n)-1
- for k in range(9):
- f = min(f * 2, 3500)
- w = max(((w+1)/2)-1,1)
- print '.',
- #generate_srm(0)
- abc('sim -m -F %d -W %d'%(f,w))
- if not is_sat():
- continue
- if cex_po() < n_pos_before:
- print 'Sim found true cex: Output = %d, Frame = %d'%(cex_po(),cex_frame())
- return Sat_true
- refine_with_cex()
- if n_pos_before == n_pos():
- return Undecided_no_reduction
- while True:
- result = generate_srm(0)
- if result == 'failed':
- return Sat_true
- abc('sim -m -F %d -W %d'%(f,w))
- if not is_sat():
- break
- if cex_po() < n_pos_before:
- print 'Sim found true cex: Output = %d, Frame = %d'%(cex_po(),cex_frame())
- return Sat_true
- refine_with_cex()
- if n_pos_before == n_pos():
- return Undecided_no_reduction
- return Undecided_no_reduction
-
- n_pos_before = n_pos()
- n_latches_before = n_latches()
- set_globals()
- t = max(1,.5*G_T)
- r = max(1,int(t))
- abc('write spec_temp.aig')
- print '\n***Running &equiv2 with C = %d, T = %f sec., F = %d -S 1 -R %d'%(G_C,t,200,r)
-## abc("&get; &equiv2 -C %d -F 200 -T %f -S 1 -R %d; &semi -F 50; &speci -F 20 -C 1000;&srm; r gsrm.aig; w %s_gsrm.aig; &w %s_gore.aig"%((G_C),t,r,f_name,f_name))
- abc("&get; &equiv2 -C %d -F 200 -T %f -S 1 -R %d; &semi -W 63 -S 5 -C 500 -F 500; &speci -F 200 -C 5000;&srm; r gsrm.aig; w %s_gsrm.aig; &w %s_gore.aig"%((G_C),t,r,f_name,f_name))
- print 'Initial speculation: ',
- print_circuit_stats()
- #print 'Speculation good to %d frames'%n_bmc_frames()
- #simplify()
- if n_pos_before == n_pos():
- print 'No new outputs. Quitting speculate'
- return Undecided_no_reduction # return result is unknown
- if is_sat():
- #print '\nWARNING: if an abstraction was done, need to refine it further\n'
- return Sat_true
- if n_latches() > .98*n_latches_before:
- pre_simp()
- if n_latches() > .98*n_latches_before:
- print 'Quitting speculation - not enough gain'
- abc('r spec_temp.aig')
- return Undecided_no_reduction # not worth it
- k = n_ands() + n_latches() + n_pis()
- n = 0
- if k < 15000:
- n = 1
- elif k < 30000:
- n = 2
- elif k < 60000:
- n = 4
- elif k < 120000:
- n = 8
- if n > 0: # simulation can run out of memory for too large designs, so be careful
- print '\n***RUNNING simulation iteratively'
- for i in range(5):
- result = run_simulation(n)
- if result == Sat_true:
- return result
- simp_sw = 1
- int_sw = 1
- reach_sw = 0
- cexf = 0
- reach_failed = 0
- init = 1
- run_command('write temptemp.aig')
- print '\nIterating BMC or BDD reachability'
- while True: # now try real hard to get the last cex.
- set_globals()
- if not init:
- set_size()
- result = generate_srm(1)
- if check_size() == True:
- print 'Failed to refine'
- return Error
- if result == 'failed':
- return Sat_true
- if simp_sw == 1:
- na = n_ands()
- simplify()
- if n_ands() > .7*na: #if not significant reduction, stop simplification
- simp_sw = 0
- if n_latches() == 0:
- return check_sat()
- init = 0 # make it so that next time it is not the first time through
- time = max(1,G_T/(5*n_pos()))
- if int_sw ==1:
- npo = n_pos()
- if n_pos() > .5*npo: # if not sufficient reduction, turn this off
- int_sw = 0
- if is_sat(): #if fast interpolation found a cex
- cexf = cex_frame()
- set_max_bmc(cexf - 1)
- if cex_po() < n_pos_before:
- print 'Int found true cex: Output = %d, Frame = %d'%(cex_po(),cex_frame())
- return Sat_true
- refine_with_cex()
- if ((n_pos_before == n_pos()) or (n_latches_before == n_latches())):
- abc('r temp_spec.aig')
- return Undecided_no_reduction
- if is_sat():
- print '1. cex failed to refine abstraction'
- return Sat_true
- continue
- else:
- if n_latches() == 0:
- return check_sat()
- ri = n_real_inputs() #seeing how many inputs would trm get rid of
- nlri = n_latches() + ri
- reach_allowed = ((nlri<75) or (((cexf>250)) and (nlri<300)))
- pdr_allowed = True
- bmc = False
- if (((reach_allowed or pdr_allowed ) and not reach_failed)):
- t = max(1,1.2*G_T)
- f = max(3500, 2*max_bmc)
- #cmd = 'reachx -t %d'%max(10,int(t))
- cmd ='&get;,pdr -vt=%f'%t
- else:
- t = max(1,1.5*G_T)
- if max_bmc == -1:
- f = 200
- else:
- f = max_bmc
- f = int(1.5*f)
- #cmd = 'bmc3 -C %d -T %f -F %f'%(1.5*G_C,1.2*t,f)
- bmc = True
- cmd = '&get;,bmc -vt=%f'%(1.2*t)
- print '\n***Running %s'%cmd
- last_bmc = max_bmc
- abc(cmd)
- #run_command(cmd)
- if is_sat():
- cexf = cex_frame()
- #set_max_bmc(cexf - 1)
- #This is a temporary fix since reachx always reports cex_ps = 0
- if ((cex_po() < n_pos_before) and (cmd[:4] == '&get')):
- print 'BMC/PDR found true cex: Output = %d, Frame = %d'%(cex_po(),cex_frame())
- return Sat_true
- #End of temporary fix
- refine_with_cex()#change the number of equivalences
- if n_pos_before == n_pos():
- return Undecided_no_reduction
- continue
- else:
- set_max_bmc(n_bmc_frames())
- if prob_status() == 1:
- #print 'Convergence reached in %d frames'%n_bmc_frames()
- return Unsat
- print 'No cex found in %d frames'%n_bmc_frames()
- if bmc:
- break
- elif max_bmc > 1.2*last_bmc:
- break
- else:
- reach_failed = 1
- init = 1
- continue
- if n_pos_before == n_pos():
- return Undecided_no_reduction
- else:
- return Undecided_reduction
-
-def set_size():
- """Stores the problem size of the current design. Size is defined as (PIs, POs, ANDS, FF, max_bmc)"""
- global npi, npo, nands, nff, nmd
- npi = n_pis()
- npo = n_pos()
- nands = n_ands()
- nff = n_latches()
- nmd = max_bmc
-
-def check_size():
- """Assumes the problem size has been set by set_size before some operation. This checks if the size was changed
- Size is defined as (PIs, POs, ANDS, FF, max_bmc)
- Returns TRUE is size is the same"""
- global npi, npo, nands, nff, nmd
- result = ((npi == n_pis()) and (npo == n_pos()) and (nands == n_ands()) and (nff == n_latches()) and (nmd == max_bmc))
-## if result == 1:
-## print 'Size unchanged'
- return result
-
-def inferior_size():
- """Assumes the problem size has been set by set_size beore some operation.
- This checks if the new size is inferior (larger) to the old one
- Size is defined as (PIs, POs, ANDS, FF)"""
- global npi, npo, nands, nff
- result = ((npi < n_pis()) or (npo < n_pos()) or (nands < n_ands()) )
- return result
-
-def quick_verify(n):
- """Low resource version of final_verify n = 1 means to do an initial simplification first"""
- abc('trm')
- if n == 1:
- simplify()
- if n_latches == 0:
- return check_sat()
- abc('trm')
- if is_sat():
- return Sat_true
- print 'After trimming: ',
- print_circuit_stats()
- #try_rpm()
- set_globals()
- t = max(1,.4*G_T)
- print ' Running PDR for %d sec '%(t)
- abc('&get;,pdr -vt=%f'%(t*.8))
- status = get_status()
- if not status == Unsat:
- print 'PDR went to %d frames, '%n_bmc_frames(),
- print RESULT[status]
- return status #temporary
- if status <= Unsat:
- return status
- N = bmc_depth()
- c = max(G_C/10, 1000)
- t = max(1,.4*G_T)
- print ' RUNNING interpolation with %d conflicts, max %d sec and 100 frames'%(c,t)
- #abc('int -v -F 100 -C %d -T %f'%(c,t))
- abc(',imc -vt=%f '%t)
- status = get_status()
- if status <= Unsat:
- print 'Interpolation went to %d frames, '%n_bmc_frames(),
- print RESULT[status]
- return status
- L = n_latches()
- I = n_real_inputs()
- if ( ((I+L<200)&(N>100)) or (I+L<125) or L < 51 ): #heuristic that if bmc went deep, then reachability might also
- t = max(1,.4*G_T)
- cmd = 'reachx -t %d'%max(10,int(t))
- print ' Running %s'%cmd
- abc(cmd)
- status = get_status()
- if status <= Unsat:
- print 'Reachability went to %d frames, '%n_bmc_frames()
- print RESULT[status]
- return status
- print 'BDD reachability aborted'
- simplify() #why is this here
- if n_latches() == 0:
- print 'Simplified to 0 FF'
- return check_sat()
- set_max_bmc(bmc_depth()) # doesn't do anything
- print 'No success, max_depth = %d'%max_bmc
- return Undecided_reduction
-
-def get_status():
- """this simply translates the problem status encoding done by ABC (-1,0,1)=(undecided,SAT,UNSAT) into the status code used by our python code."""
- status = prob_status() #interrogates ABC for the current status of the problem.
- # 0 = SAT
- if status == 1:
- status = Unsat
- if status == -1: #undecided
- status = Undecided_no_reduction
- return status
-
-def try_rpm():
- """rpm is a cheap way of doing reparameterization and is an abstraction method, so may introduce false cex's.
- It finds a minimum cut between the PIs and the main sequential logic and replaces this cut by free inputs.
- A quick BMC is then done, and if no cex is found, we assume the abstraction is valid. Otherwise we revert back
- to the original problem before rpm was tried."""
- global x_factor
- if n_ands() > 30000:
- return
- set_globals()
- pis_before = n_pis()
- abc('w %s_savetemp.aig'%f_name)
- abc('rpm')
- result = 0
- if n_pis() < .5*pis_before:
- bmc_before = bmc_depth()
- #print 'running quick bmc to see if rpm is OK'
- t = max(1,.1*G_T)
- #abc('bmc3 -C %d, -T %f'%(.1*G_C, t))
- abc('&get;,bmc -vt=%f'%t)
- if is_sat(): #rpm made it sat by bmc test, so undo rpm
- abc('r %s_savetemp.aig'%f_name)
- else:
- abc('trm')
- print 'WARNING: rpm reduced PIs to %d. May make SAT.'%n_pis()
- result = 1
- else:
- abc('r %s_savetemp.aig'%f_name)
- return result
-
-def final_verify():
- """This is the final method for verifying anything is nothing else has worked. It first tries BDD reachability
- if the problem is small enough. If this aborts or if the problem is too large, then interpolation is called."""
- global x_factor
- set_globals()
-## simplify()
-## if n_latches() == 0:
-## return check_sat()
-## abc('trm')
- #rpm_result = try_rpm()
- set_globals()
- N = bmc_depth()
- L = n_latches()
- I = n_real_inputs()
- #try_induction(G_C)
- c = max(G_C/5, 1000)
- t = max(1,G_T)
- print '\n***Running PDR for %d sec'%(t)
- abc('&get;,pdr -vt=%f'%(t*.8))
- status = get_status()
- if status <= Unsat:
- print 'PDR went to %d frames, '%n_bmc_frames(),
- print RESULT[status]
- return status
- if ( ((I+L<250)&(N>100)) or (I+L<200) or (L<51) ): #heuristic that if bmc went deep, then reachability might also
- t = max(1,1.5*G_T)
- #cmd = 'reach -v -B 1000000 -F 10000 -T %f'%t
- #cmd = 'reachx -e %d'%int(long(t))
- #cmd = 'reachx -e %d -t %d'%(int(long(t)),max(10,int(t)))
- cmd = 'reachx -t %d'%max(10,int(t))
- print '\n***Running %s'%cmd
- abc(cmd)
- status = get_status()
- if status <= Unsat:
- print 'Reachability went to %d frames, '%n_bmc_frames(),
- print RESULT[status]
- return status
- print 'BDD reachability aborted'
- return status #temporary
- #f = max(100, bmc_depth())
- print '\n***RUNNING interpolation with %d conflicts, %d sec, max 100 frames'%(c,t)
- #abc('int -v -F 100 -C %d -T %f'%(c,t))
- abc(',imc -vt=%f '%t)
- status = get_status()
- if status <= Unsat:
- print 'Interpolation went to %d frames, '%n_bmc_frames(),
- print RESULT[status]
- return status
- t = max(1,G_T)
- simplify()
- if n_latches() == 0:
- return check_sat()
- print 'Undecided'
- return Undecided_reduction
-
-def check_sat():
- """This is called if all the FF have disappeared, but there is still some logic left. In this case,
- the remaining logic may be UNSAT, which is usually the case, but this has to be proved. The ABC command 'dsat' is used fro combinational problems"""
-## if n_ands() == 0:
-## return Unsat
- abc('orpos;dsat -C %d'%G_C)
- if is_sat():
- return Sat_true
- elif is_unsat():
- return Unsat
- else:
- return Undecided_no_reduction
-
-def try_era(s):
- """era is explicit state enumeration that ABC has. It only works if the number of PIs is small,
- but there are cases where it works and nothing else does"""
- if n_pis() > 12:
- return
- cmd = '&get;&era -mv -S %d;&put'%s
- print 'Running %s'%cmd
- run_command(cmd)
-
-def try_induction(C):
- """Sometimes proving the property directly using induction works but not very often.
- For 'ind' to work, it must have only 1 output, so all outputs are or'ed together temporarily"""
- return Undecided_reduction
- print '\n***Running induction'
- abc('w %s_temp.aig'%f_name)
- abc('orpos; ind -uv -C %d -F 10'%C)
- abc('r %s_savetemp.aig'%f_name)
- status = prob_status()
- if not status == 1:
- return Undecided_reduction
- print 'Induction succeeded'
- return Unsat
-
-def final_verify_recur(K):
- """During prove we make backups as we go. These backups have increasing abstractions done, which can cause
- non-verification by allowing false counterexamples. If an abstraction fails with a cex, we can back up to
- the previous design before the last abstraction and try to proceed from there. K is the backup number we
- start with and this decreases as the backups fails. For each backup, we just try final_verify.
- If ever we back up to 0, which is the backup just after simplify, we then try speculate on this. This often works
- well if the problem is a SEC problem where there are a lot of equivalences across the two designs."""
- for j in range(K):
- i = K-(j+1)
- if i == 0: #don't try final verify on original
- status = 3
- break
- print '\nVerifying backup number %d:'%i,
- abc('r %s_backup_%d.aig'%(initial_f_name,i))
- print_circuit_stats()
- status = final_verify()
- if status >= Unsat:
- return status
- if i > 0:
- print 'SAT returned, Running less abstract backup'
- continue
- break
- if ((i == 0) and (status > Unsat) and (n_ands() > 0)):
- print '\n***Running speculate on initial backup number %d:'%i,
- abc('r %s_backup_%d.aig'%(initial_f_name,i))
- ps()
- if n_ands() < 20000:
- status = speculate()
- if ((status <= Unsat) or (status == Error)):
- return status
- status = final_verify()
- if status == Unsat:
- return status
- else:
- return Undecided_reduction
-
-
-def smp():
- pre_simp()
- write_file('smp')
-
-def pre_simp():
- """This uses a set of simplification algorithms which preprocesses a design.
- Includes forward retiming, quick simp, signal correspondence with constraints, trimming away
- PIs, and strong simplify"""
-## print "Trying BMC for 2 sec."
-## abc("&get; ,bmc -vt=2")
-## if is_sat():
-## return Sat_true
- set_globals()
- if n_latches == 0:
- return check_sat()
- #print '\n*** Running forward'
- try_forward()
- #print \n*** Running quick simp'
- quick_simp()
- #print 'Running_scorr_constr'
- status = try_scorr_constr()
- #status = 3
- #print 'Running trm'
- if ((n_ands() > 0) or (n_latches()>0)):
- abc('trm')
- print 'Forward, quick_simp, scorr_constr,: ',
- print_circuit_stats()
- if n_latches() == 0:
- return check_sat()
- status = process_status(status)
- if status <= Unsat:
- return status
- simplify()
- print 'Simplify: ',
- print_circuit_stats()
- #abc('w temp_simp.aig')
- if n_latches() == 0:
- return check_sat()
- try_phase()
- if n_latches() == 0:
- return check_sat()
- #abc('trm')
- if ((n_ands() > 0) or (n_latches()>0)):
- abc('trm')
- status = process_status(status)
- if status <= Unsat:
- return status
- status = try_scorr_constr()
- abc('trm')
- return process_status(status)
-
-def try_scorr_constr():
- set_size()
- abc('w %s_savetemp.aig'%f_name)
- status = scorr_constr()
- if inferior_size():
- abc('r %s_savetemp.aig'%f_name)
- return status
-
-def process(status):
- """Checks if there are no FF and if so checks if the remaining combinational
- problem is UNSAT"""
- if n_latches() == 0:
- return check_sat()
- return status
-
-def try_phase():
- """Tries phase abstraction. ABC returns the maximum clock phase it found using n_phases.
- Then unnrolling is tried up to that phase and the unrolled model is quickly
- simplified (with retiming to see if there is a significant reduction.
- If not, then revert back to original"""
- n = n_phases()
- if ((n == 1) or (n_ands() > 40000)):
- return
- print 'Number of possible phases = %d'%n
- abc('w %s_savetemp.aig'%f_name)
- na = n_ands()
- nl = n_latches()
- ni = n_pis()
- no = n_pos()
- cost_init = (1*n_pis())+(2*n_latches())+1*n_ands()
- cost_min = cost_init
- cost = cost_init
- abc('w %s_best.aig'%f_name)
- for j in range(4):
- abc('r %s_savetemp.aig'%f_name)
- p = 2**(j+1)
- if p > n:
- break
- abc('phase -F %d'%p)
- if na == n_ands():
- break
- abc('scl;rw')
- if n_latches() > nl: #why would this ever happen
- break
- #print_circuit_stats()
- abc('rw;lcorr;trm')
- #print_circuit_stats()
- cost = (1*n_pis())+(2*n_latches())+1*n_ands()
- if cost < cost_min:
- cost_min = cost
- abc('w %s_best.aig'%f_name)
- else:
- break
- if cost < cost_init:
- abc('r %s_best.aig'%f_name)
- simplify()
- abc('trm')
- print 'Phase abstraction obtained :',
- print_circuit_stats()
- return
- abc('r %s_savetemp.aig'%f_name)
- return
-
-def try_forward():
- """Attempts most forward retiming, and latch correspondence there. If attempt fails to help simplify, then we revert back to the original design
- This can be effective for equivalence checking problems where synthesis used retiming"""
- abc('w %s_savetemp.aig'%f_name)
- if n_ands() < 30000:
- abc('dr')
- abc('lcorr')
- nl = n_latches()
- na = n_ands()
- abc('w %s_savetemp0.aig'%f_name)
- abc('r %s_savetemp.aig'%f_name)
- abc('dr -m')
- abc('lcorr')
- abc('dr')
- if ((n_latches() <= nl) and (n_ands() < na)):
- print 'Forward retiming reduced size to: ',
- print_circuit_stats()
- return
- else:
- abc('r %s_savetemp0.aig'%f_name)
- return
- return
-
-def quick_simp():
- """A few quick ways to simplify a problem before more expensive methods are applied.
- Uses & commands if problem is large. These commands use the new circuit based SAT solver"""
- na = n_ands()
- if na < 30000:
- abc('scl;rw')
- elif na < 80000:
- abc('&get;&scl;&put;rw')
-
-def scorr_constr():
- """Extracts implicit constraints and uses them in signal correspondence
- Constraints that are found are folded back when done"""
- na = max(1,n_ands())
- if ((na > 40000) or n_pos()>1):
- return Undecided_no_reduction
- f = 40000/na
- f = min(f,16)
- n_pos_before = n_pos()
- f = 1 #temporary until bug fixed.
- abc('w %s_savetemp.aig'%f_name)
- if n_ands() < 3000:
- cmd = 'unfold -a -F 2'
- else:
- cmd = 'unfold'
- abc(cmd)
- if ((n_ands() > na) or (n_pos() == n_pos_before)):
- abc('r %s_savetemp.aig'%f_name)
- return Undecided_no_reduction
- print_circuit_stats()
- print 'Number of constraints = %d'%(n_pos() - n_pos_before)
- abc('scorr -c -F %d'%f)
- abc('fold')
- return Undecided_no_reduction
-
-def process_status(status):
- """ if there are no FF, the problem is combinational and we still have to check if UNSAT"""
- if n_latches() == 0:
- return check_sat()
- return status
-
-def input_x_factor():
- """Sets the global x_factor according to user input"""
- global x_factor, xfi
- print 'Type in x_factor:',
- xfi = x_factor = input()
- print 'x_factor set to %f'%x_factor
-
-def prove(a):
- """Proves all the outputs together. If ever an abstraction was done then if SAT is returned,
- we make RESULT return "undecided".
- If a == 1 do not run speculate"""
- global x_factor,xfi,f_name
- x = time.clock()
- max_bmc = -1
- K = 0
- print 'Initial: ',
- print_circuit_stats()
- x_factor = xfi
- print 'x_factor = %f'%x_factor
- print '\n***Running pre_simp'
- set_globals()
- if n_latches() > 0:
- status = pre_simp()
- else:
- status = check_sat()
- if ((status <= Unsat) or (n_latches() == 0)):
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- if n_ands() == 0:
- #abc('bmc3 -T 2')
- abc('&get;,bmc -vt=2')
- if is_sat():
- return 'SAT'
- abc('trm')
- write_file('smp')
- abc('w %s_backup_%d.aig'%(initial_f_name,K))
- K = K +1
- set_globals()
-## if ((n_ands() < 30000) and (a == 1) and (n_latches() < 300)):
- if ((n_ands() < 30000) and (n_latches() < 300)):
- print '\n***Running quick_verify'
- status = quick_verify(0)
- if status <= Unsat:
- if not status == Unsat:
- print 'CEX in frame %d'%cex_frame()
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- if n_ands() == 0:
- #abc('bmc3 -T 2')
- abc('&get;,bmc -vt=2')
- if is_sat():
- return 'SAT'
- print'\n***Running abstract'
- nl_b = n_latches()
- status = abstract()
- abc('trm')
- write_file('abs')
- status = process_status(status)
- if ((status <= Unsat) or status == Error):
- if status < Unsat:
- print 'CEX in frame %d'%cex_frame()
-## status = final_verify_recur(K)
-## write_file('final')
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- abc('w %s_backup_%d.aig'%(initial_f_name,K))
- K = K +1
- if ((n_ands() > 20000) or (a == 1)):
- print 'Speculation skipped because either too large or already done'
- K = 2
- elif n_ands() == 0:
- print 'Speculation skipped because no AND nodes'
- K = 2
- else:
- print '\n***Running speculate'
- status = speculate()
- abc('trm')
- write_file('spec')
- status = process_status(status)
- if status == Unsat:
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- if ((status < Unsat) or (status == Error)):
- print 'CEX in frame %d'%cex_frame()
- K = K-1 #if spec found a true cex, then result of abstract was wrong
- else:
- abc('w %s_backup_%d.aig'%(initial_f_name,K))
- K = K +1
- status = final_verify_recur(K)
- abc('trm')
- write_file('final')
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
-
-def prove_g_pos(a):
- """Proves the outputs clustered by a parameter a.
- a is the disallowed increase in latch support Clusters must be contiguous
- If a = 0 then outputs are proved individually. Clustering is done from last to first
- Output 0 is attempted to be proved inductively using other outputs as constraints.
- Proved outputs are removed if all the outputs have not been proved.
- If ever one of the proofs returns SAT, we stop and do not try any other outputs."""
- global f_name, max_bmc,x_factor
- x = time.clock()
- #input_x_factor()
- init_f_name = f_name
- #fast_int(1)
- print 'Beginning prove_g_pos'
- prove_all_ind()
- print 'Number of outputs reduced to %d by induction and fast interpolation'%n_pos()
- print '\n************Running second level prove****************\n'
- try_rpm()
- result = prove(1) # 1 here means do not try speculate.
- #result = prove_0_ind()
- if result == 'UNSAT':
- print 'Second prove returned UNSAT'
- return result
- if result == 'SAT':
- print 'CEX found'
- return result
- print '\n********** Proving each output separately ************'
- prove_all_ind()
- print 'Number of outputs reduced to %d by induction and fast interpolation'%n_pos()
- f_name = init_f_name
- abc('w %s_osavetemp.aig'%f_name)
- n = n_pos()
- print 'Number of outputs = %d'%n
- #count = 0
- pos_proved = []
- J = 0
- jnext = n-1
- while jnext >= 0:
- max_bmc = -1
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- #Do in reverse order
- jnext_old = jnext
- if a == 0: # do not group
- extract(jnext,jnext)
- jnext = jnext -1
- else:
- jnext = group(a,jnext)
- if jnext_old > jnext+1:
- print '\nProving outputs [%d-%d]'%(jnext + 1,jnext_old)
- else:
- print '\nProving output %d'%(jnext_old)
- #ps()
- #fast_int(1)
- f_name = f_name + '_%d'%jnext_old
- result = prove_1()
- if result == 'UNSAT':
- if jnext_old > jnext+1:
- print '\n******** PROVED OUTPUTS [%d-%d] ******** \n\n'%(jnext+1,jnext_old)
- else:
- print '\n******** PROVED OUTPUT %d ******** \n\n'%(jnext_old)
- pos_proved = pos_proved + range(jnext +1,jnext_old+1)
- continue
- if result == 'SAT':
- print 'One of output in (%d to %d) is SAT'%(jnext + 1,jnext_old)
- return result
- else:
- print '\n******** UNDECIDED on OUTPUTS %d thru %d ******** \n\n'%(jnext+1,jnext_old)
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- if not len(pos_proved) == n:
- print 'Eliminating %d proved outputs'%(len(pos_proved))
- remove(pos_proved)
- abc('trm')
- write_file('group')
- result = 'UNDECIDED'
- else:
- print 'Proved all outputs. The problem is proved UNSAT'
- result = 'UNSAT'
- print 'Total time for prove_g_pos = %f sec.'%(time.clock() - x)
- return result
-
-def prove_pos():
- """
- Proved outputs are removed if all the outputs have not been proved.
- If ever one of the proofs returns SAT, we stop and do not try any other outputs."""
- global f_name, max_bmc,x_factor
- x = time.clock()
- #input_x_factor()
- init_f_name = f_name
- #fast_int(1)
- print 'Beginning prove_pos'
- prove_all_ind()
- print 'Number of outputs reduced to %d by induction and fast interpolation'%n_pos()
- print '\n********** Proving each output separately ************'
- f_name = init_f_name
- abc('w %s_osavetemp.aig'%f_name)
- n = n_pos()
- print 'Number of outputs = %d'%n
- #count = 0
- pos_proved = []
- pos_disproved = []
- J = 0
- jnext = n-1
- while jnext >= 0:
- max_bmc = -1
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- #Do in reverse order
- jnext_old = jnext
- extract(jnext,jnext)
- jnext = jnext -1
- print '\nProving output %d'%(jnext_old)
- f_name = f_name + '_%d'%jnext_old
- result = prove_1()
- if result == 'UNSAT':
- print '\n******** PROVED OUTPUT %d ******** \n\n'%(jnext_old)
- pos_proved = pos_proved + range(jnext +1,jnext_old+1)
- continue
- if result == 'SAT':
- print '\n******** DISPROVED OUTPUT %d ******** \n\n'%(jnext_old)
- pos_disproved = pos_disproved + range(jnext +1,jnext_old+1)
- continue
- else:
- print '\n******** UNDECIDED on OUTPUT %d ******** \n\n'%(jnext_old)
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- list = pos_proved + pos_disproved
- print 'Proved the following outputs: %s'%pos_proved
- print 'Disproved the following outputs: %s'%pos_disproved
- if not len(list) == n:
- print 'Eliminating %d resolved outputs'%(len(list))
- remove(list)
- abc('trm')
- write_file('group')
- result = 'UNRESOLVED'
- else:
- print 'Proved or disproved all outputs. The problem is proved RESOLVED'
- result = 'RESOLVED'
- print 'Total time for prove_pos = %f sec.'%(time.clock() - x)
- return result
-
-
-def prove_g_pos_split():
- """like prove_g_pos but quits when any output is undecided"""
- global f_name, max_bmc,x_factor
- x = time.clock()
- #input_x_factor()
- init_f_name = f_name
- #fast_int(1)
- print 'Beginning prove_g_pos_split'
- prove_all_ind()
- print 'Number of outputs reduced to %d by induction and fast interpolation'%n_pos()
- try_rpm()
- print '\n********** Proving each output separately ************'
- f_name = init_f_name
- abc('w %s_osavetemp.aig'%f_name)
- n = n_pos()
- print 'Number of outputs = %d'%n
- pos_proved = []
- J = 0
- jnext = n-1
- while jnext >= 0:
- max_bmc = -1
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- jnext_old = jnext
- extract(jnext,jnext)
- jnext = jnext -1
- print '\nProving output %d'%(jnext_old)
- f_name = f_name + '_%d'%jnext_old
- result = prove_1()
- if result == 'UNSAT':
- if jnext_old > jnext+1:
- print '\n******** PROVED OUTPUTS [%d-%d] ******** \n\n'%(jnext+1,jnext_old)
- else:
- print '\n******** PROVED OUTPUT %d ******** \n\n'%(jnext_old)
- pos_proved = pos_proved + range(jnext +1,jnext_old+1)
- continue
- if result == 'SAT':
- print 'One of output in (%d to %d) is SAT'%(jnext + 1,jnext_old)
- return result
- else:
- print '\n******** UNDECIDED on OUTPUTS %d thru %d ******** \n\n'%(jnext+1,jnext_old)
- print 'Eliminating %d proved outputs'%(len(pos_proved))
- # remove outputs proved and return
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- remove(pos_proved)
- abc('trm')
- write_file('group')
- return 'UNDECIDED'
- f_name = init_f_name
- abc('r %s_osavetemp.aig'%f_name)
- if not len(pos_proved) == n:
- print 'Eliminating %d proved outputs'%(len(pos_proved))
- remove(pos_proved)
- abc('trm')
- write_file('group')
- result = 'UNDECIDED'
- else:
- print 'Proved all outputs. The problem is proved UNSAT'
- result = 'UNSAT'
- print 'Total time = %f sec.'%(time.clock() - x)
- return result
-
-
-
-def group(a,n):
- """Groups together outputs beginning at output n and any contiguous preceeding output
- that does not increase the latch support by a or more"""
- global f_name, max_bmc
- nlt = n_latches()
- extract(n,n)
- nli = n_latches()
- if n == 0:
- return n-1
- for J in range(1,n+1):
- abc('r %s_osavetemp.aig'%f_name)
- j = n-J
- #print 'Running %d to %d'%(j,n)
- extract(j,n)
- #print 'n_latches = %d'%n_latches()
- #if n_latches() >= nli + (nlt - nli)/2:
- if n_latches() == nli:
- continue
- if n_latches() > nli+a:
- break
- abc('r %s_osavetemp.aig'%f_name)
-## if j == 1:
-## j = j-1
- print 'extracting [%d-%d]'%(j,n)
- extract(j,n)
- ps()
- return j-1
-
-def extract(n1,n2):
- """Extracts outputs n1 through n2"""
- no = n_pos()
- if n2 > no:
- return 'range exceeds number of POs'
- abc('cone -s -O %d -R %d'%(n1, 1+n2-n1))
- abc('scl')
-
-def prove_0_ind():
- """Uses all other outputs as constraints to try to prove output 0 by induction"""
- abc('w %s_osavetemp.aig'%f_name)
- #ps()
- abc('constr -N %d'%(n_pos()-1))
- #ps()
- abc('fold')
- #ps()
- abc('ind -u -C 1000000 -F 20')
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- return status
-
-def remove(list):
- """Removes outputs in list"""
- zero(list)
- abc('&get;&trim;&put')
- #fast_int(1)
-
-def zero(list):
- """Zeros out POs in list"""
- for j in list:
- run_command('zeropo -N %d'%j)
-
-def sp():
- """Alias for super_prove"""
- print 'Executing super_prove'
- result = super_prove()
- return result
-
-def super_prove():
- """Main proof technique now. Does original prove and if after speculation there are multiple output left
- if will try to prove each output separately, in reverse order. It will quit at the first output that fails
- to be proved, or any output that is proved SAT"""
- global max_bmc, init_initial_f_name, initial_f_name
- init_initial_f_name = initial_f_name
- if x_factor > 1:
- print 'x_factor = %d'%x_factor
- input_x_factor()
- max_bmc = -1
- x = time.clock()
- print "Trying BMC for 2 sec."
- abc("&get; ,bmc -vt=2")
- if is_sat():
- print 'Total time taken by super_prove = %f sec.'%(time.clock() - x)
- return 'SAT'
- result = prove(0)
- if ((result[:3] == 'UND') and (n_latches() == 0)):
- return result
- k = 1
- print result
- if not result[:3] == 'UND':
- print 'Total time taken by super_prove = %f sec.'%(time.clock() - x)
- return result
- if n_pos() > 1:
- result = prove_g_pos(0)
- print result
- if result == 'UNSAT':
- print 'Total time taken by super_prove = %f sec.'%(time.clock() - x)
- return result
- if result == 'SAT':
- k = 0 #Don't try to prove UNSAT on an abstraction that had SAT
- # should go back to backup 1 since probably spec was bad.
- y = time.clock()
- result = BMC_VER_result(k)
- print 'Total time taken by last gasp verification = %f sec.'%(time.clock() - y)
- print 'Total time for %s = %f sec.'%(init_initial_f_name,(time.clock() - x))
- return result
-
-def reachm(t):
- x = time.clock()
- run_command('&get;&reach -vcs -T %d;&put'%t)
- print 'Time = %f'%(time.clock() - x)
-
-def reachx(t):
- x = time.clock()
- run_command('reachx -t %d'%t)
- print 'Time = %f'%(time.clock() - x)
-
-def BMC_VER_result(n):
- global init_initial_f_name
- #print init_initial_f_name
- xt = time.clock()
- result = 5
- T = 150
- if n == 0:
- abc('r %s_smp.aig'%init_initial_f_name)
- print '\n***Running proof on initial simplified circuit\n',
- ps()
- else:
- print '\n***Running proof on final unproved circuit'
- ps()
- print ' Running PDR for %d sec'%T
- abc('&get;,pdr -vt=%d'%(T*.8))
- result = get_status()
- if result == Unsat:
- return 'UNSAT'
- if result > Unsat: #still undefined
- if (n_pis()+n_latches() < 250):
- print ' Running Reachability for 150 sec.'
- abc('reachx -t 150')
- #run_command('&get;&reach -vcs -T %d'%T)
- result = get_status()
- if result == Unsat:
- return 'UNSAT'
- if ((result > Unsat) and n ==1):
- print ' Running interpolation for %f sec.'%T
- abc(',imc -vt=%f'%T)
- result = get_status()
- if result == Unsat:
- return 'UNSAT'
- # if n=1 we are trying to prove result on abstracted circuit. If still undefined, then probably does
- # not make sense to try pdr, reach, int on original simplified circuit, only BMC here.
- if n == 1:
- abc('r %s_smp.aig'%init_initial_f_name) #check if the initial circuit was SAT
- #print 'Reading %s_smp'%init_initial_f_name,
- #run_command('bmc3 -v -T %d -F 200000 -C 1000000'%T)
- print '***Running BMC on initial simplified circuit'
- ps()
- print '\n'
- abc('&get;,bmc -vt=%f'%T)
- result = get_status()
- if result < Unsat:
- result = 'SAT'
- print ' CEX found in frame %d'%cex_frame()
- else:
- result = 'UNDECIDED'
- print 'Additional time taken by BMC/PDR/Reach = %f sec.'%(time.clock() - xt)
- return result
-
-def try_split():
- abc('w %s_savetemp.aig'%f_name)
- na = n_ands()
- split(3)
- if n_ands()> 2*na:
- abc('r %s_savetemp.aig'%f_name)
-
-
-def time_diff():
- global last_time
- new_time = time.clock()
- diff = new_time - last_time
- last_time = new_time
- result = 'Lapsed time = %.2f sec.'%diff
- return result
-
-def prove_all_ind():
- """Tries to prove output k by induction, using other outputs as constraints. If ever an output is proved
- it is set to 0 so it can't be used in proving another output to break circularity.
- Finally all zero'ed ooutputs are removed. """
- N = n_pos()
- remove_0_pos()
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- #abc('r %s_osavetemp.aig'%f_name)
- abc('swappos -N %d'%j)
- remove_0_pos() #may not have to do this if constr works well with 0'ed outputs
- abc('constr -N %d'%(n_pos()-1))
- abc('fold')
- n = max(1,n_ands())
- f = max(1,min(40000/n,16))
- f = int(f)
- abc('ind -u -C 10000 -F %d'%f)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- remove_0_pos()
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def prove_all_pdr(t):
- """Tries to prove output k by PDR. If ever an output is proved
- it is set to 0. Finally all zero'ed ooutputs are removed. """
- N = n_pos()
- remove_0_pos()
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- #abc('r %s_osavetemp.aig'%f_name)
- abc('cone -O %d -s'%j)
- abc('scl')
- abc('&get;,pdr -vt=%d'%t)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- remove_0_pos()
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-
-def remove_0_pos():
- abc('&get; &trim; &put')
-
-
-def prove_all_ind2():
- """Tries to prove output k by induction, using outputs > k as constraints. Removes proved outputs from POs."""
- abc('w %s_osavetemp.aig'%f_name)
- plist = []
- list = range(n_pos())
-## if r == 1:
-## list.reverse()
- for j in list:
- abc('r %s_osavetemp.aig'%f_name)
- extract(j,n_pos())
- abc('constr -N %d'%(n_pos()-1))
- abc('fold')
- n = max(1,n_ands())
- f = max(1,min(40000/n,16))
- f = int(f)
- abc('ind -u -C 10000 -F %d'%f)
- status = get_status()
- if status == Unsat:
- plist = plist + [j]
- print '-',
-## else:
-## status = pdr(1)
-## if status == Unsat:
-## print '+',
-## plist = plist + [j]
- print '%d'%j,
- print '\nOutputs proved = ',
- print plist
- abc('r %s_osavetemp.aig'%f_name)
- remove(plist) #remove the outputs proved
-## #the following did not work because abc command constr, allows only last set of outputs to be constraints
-## abc('w %s_osavetemp.aig'%f_name)
-## plist = []
-## list = range(n_pos())
-## list.reverse()
-## for j in list:
-## abc('r %s_osavetemp.aig'%f_name)
-## extract(j,n_pos())
-## abc('constr -N %d'%(n_pos()-1))
-## abc('fold')
-## n = max(1,n_ands())
-## f = max(1,min(40000/n,16))
-## f = int(f)
-## abc('ind -u -C 10000 -F %d'%f)
-## status = get_status()
-## if status == Unsat:
-## plist = plist + [j]
-## print '-',
-#### else:
-#### status = pdr(1)
-#### if status == Unsat:
-#### print '+',
-#### plist = plist + [j]
-## print '%d'%j,
-## print '\nOutputs proved = ',
-## print plist.reverse
-## abc('r %s_osavetemp.aig'%f_name)
-## remove(plist) #remove the outputs proved
-## return status
-
-def pdr(t):
- abc('&get; ,pdr -vt=%f'%t)
- result = get_status()
-
-def split(n):
- abc('orpos;&get')
- abc('&posplit -v -N %d;&put;dc2;trm'%n)
-
-def keep_splitting():
- for j in range(5):
- split(5+j)
- no = n_pos()
- status = prove_g_pos_split(0)
- if status <= Unsat:
- return status
- if no == n_pos():
- return Undecided
-
-def drill(n):
- run_command('&get; &reach -vcs -H 5 -S %d -T 50 -C 40'%n)
-
-def prove_1():
- """Proves all the outputs together. If ever an abstraction was done then if SAT is returned,
- we make RESULT return "undecided".
- """
- a = 1
- global x_factor,xfi,f_name
- x = time.clock()
- max_bmc = -1
- K = 0
- print 'Initial: ',
- print_circuit_stats()
- x_factor = xfi
- print 'x_factor = %f'%x_factor
- print '\n***Running pre_simp'
- set_globals()
- status = pre_simp()
- if ((status <= Unsat) or (n_latches == 0)):
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- abc('trm')
- write_file('smp')
- abc('w %s_backup_%d.aig'%(initial_f_name,K))
- K = K +1
- set_globals()
- if ((n_ands() < 30000) and (a == 1) and (n_latches() < 300)):
- print '\n***Running quick_verify'
- status = quick_verify(0)
- if status <= Unsat:
- if not status == Unsat:
- print 'CEX in frame %d'%cex_frame()
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- print'\n***Running abstract'
- nl_b = n_latches()
- status = abstract()
- abc('trm')
- write_file('abs')
- status = process_status(status)
- if ((status <= Unsat) or status == Error):
- if status < Unsat:
- print 'CEX in frame %d'%cex_frame()
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
- abc('w %s_backup_%d.aig'%(initial_f_name,K))
- status = final_verify_recur(2)
- abc('trm')
- write_file('final')
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return RESULT[status]
-
-def qprove():
- global x_factor
- x = time.clock()
- x_factor = 3
- print '\n*********pre_simp**********\n'
- pre_simp()
- print '\n*********absv**********\n'
- result = absv(3,1)
- x_factor = 2
- print '\n*********absv**********\n'
- result = absv(3,1)
- print '\n*********speculate**********\n'
- result = speculate()
- if result <= Unsat:
- return RESULT[result]
- print '\n*********absv**********\n'
- result = absv(3,1)
- print '\n*********prove_pos**********\n'
- result = prove_pos()
- if result == 'UNDECIDED':
- print '\n*********BMC_VER_result**********\n'
- result = BMC_VER_result(1)
- print 'Time for proof = %f sec.'%(time.clock() - x)
- return result
-
-def pre_reduce():
- x = time.clock()
- pre_simp()
- write_file('smp')
- abstract()
- write_file('abs')
- print 'Time = %f'%(time.clock() - x)
-
-
-#PARALLEL FUNCTIONS
-""" funcs should look like
-funcs = [defer(abc)('&get;,bmc -vt=50;&put'),defer(super_prove)()]
-After this is executed funcs becomes a special list of lambda functions
-which are given to abc_split_all to be executed as in fork below.
-It has been set up so that each of the functions works on the current aig and
-possibly transforms it. The new aig and status is always read into the master when done
-
-"""
-
-def fork(funcs):
- """ runs funcs in parallel"""
- for i,res in pyabc_split.abc_split_all(funcs):
- status = prob_status()
- if not status == -1:
- print i,status
- ps()
- break
- else:
- print i,status
- ps()
- continue
- return status
-
-def handler_s(res):
- """ This serial handler returns True if the problem is solved by the first returning function,
- in which case, the problem is replaced by the new aig and status.
- """
- if not res == -1:
- #replace_prob()
- print ('UNSAT','SAT')[res]
- return True
- else:
- return False
-
diff --git a/scripts/main.py b/scripts/main.py
deleted file mode 100644
index 8f8a8721..00000000
--- a/scripts/main.py
+++ /dev/null
@@ -1,431 +0,0 @@
-import os
-import time
-from datetime import *
-##import par
-##from abc_common import *
-import abc_common
-
-#this makes par the dominant module insteat of abc_common
-from par import *
-
-import sys
-import math
-import time
-from pyabc_split import *
-##import pdb
-##from IPython.Debugger import Tracer; debug_here = Tracer()
-
-
-#x('source ../../abc.rc')
-#abc_common.x('source ../../abc.rc')
-
-def scorriter():
- """ apply scorr with increasing conflicts up to 100"""
- x('time')
- run_command('r p_0.aig')
- n = 20
- while n < 1000:
- print_circuit_stats()
- run_command('scorr -C %d'%n)
- x('ind -C %d'%1000)
- if is_unsat():
- print 'n = %d'%n
- break
- n = 2*n
- x('time')
-
-def simplifyq():
- # set_globals()
- n=n_ands()
- if n > 30000:
- if n<45000:
- abc("&get;&scl;&dc2;&put;dr;&get;&lcorr;&dc2;&put;dr;&get;&scorr;&fraig;&dc2;&put;dr;&get;&scorr -F 2;&dc2;&put;w temp.aig")
- else:
- abc("&get;&scl;&dc2;&put;dr;&get;&lcorr;&dc2;&put;dr;&get;&scorr;&fraig;&dc2;&put;dr;&get;&dc2;&put;w temp.aig")
- n = n_ands()
- if n < 30000:
- if n > 15000:
- abc("scl;rw;dr;lcorr;rw;dr;scorr;fraig;dc2;dr;dc2rs;w temp.aig")
- else:
- abc("scl;rw;dr;lcorr;rw;dr;scorr;fraig;dc2;dr;scorr -F 2;dc2rs;w temp.aig")
- if n < 10000:
- m = min( 30000/n, 8 )
- if m > 2:
- abc( "scorr -F %d"%m)
- run_command("ps")
-
-def constraints():
- """Determine if a set of files in a set of
- directories has constraints and print out the results."""
- for s in directories:
- print("\ndirectory is "+s)
- jj=eval(s)
- print(jj)
- for j in range(len(jj)):
- x("\nr ../DIR/%s/p_%smp.aig"%(s,jj[j]))
- print("structural:")
- x('constr -s')
- print("inductive constraints:")
- x('constr ')
-
-def help(s):
- run_command('%s -h'%s)
-
-def strip():
- """Strip out each output of a multi-output example and write it
- into a separate file"""
- os.chdir('../DIR')
- abc('r p_all_smp.aig')
- po = n_pos()
- print_circuit_stats()
- for j in range(po):
- abc('r p_all_smp.aig')
- abc('cone -s -O %d'%j)
- abc('scl;rw;trm')
- abc('w p_%d.aig'%j)
- print_circuit_stats()
-
-def fn_def(f,n):
- filename = f.__code__.co_filename
- firstline = f.__code__.co_firstlineno
- lines = open(filename, "r").readlines()
- print "".join(lines[firstline : n+firstline])
-
-def lst(list,match):
- result = []
- for j in range(len(list)):
- if list[j][-len(match):] == match:
- result.append(list[j])
- return result
-
-def lste(list,match,excp):
- result = []
- for j in range(len(list)):
- if list[j][-len(match):] == match:
- if excp in list[j]:
- continue
- result.append(list[j])
- return result
-
-def blif2aig():
- """ converts blif files into aig files"""
- #os.chdir('../ibm-web')
- list_all = os.listdir('.')
- l_blif = lst(list_all,'.blif')
- for j in range(len(l_blif)):
- name = l_blif[j][:-5]
- print '%s '%name,
- abc('r %s.blif'%name)
- abc('st')
- abc('fold')
- abc('w %s.aig'%name)
- ps()
-
-def la():
- return list_aig('')
-
-def list_aig(s=''):
- """ prnts out the sizes of aig files"""
- #os.chdir('../ibm-web')
- list_all = os.listdir('.')
- dir = lst(list_all,'.aig')
- dir.sort()
- result = []
- for j in range(len(dir)):
- name = dir[j][:-4]
- if not s_in_s(s,name):
- continue
- print '%s '%name,
- abc('r %s.aig'%name)
- ps()
- result = result + [name]
- return result
-
-def list_original():
- list_dir = os.listdir('.')
- list_dir.sort()
- out = []
- for i in range(len(list_dir)):
- name = '%s/original.aig'%list_dir[i]
- if os.access('%s'%name,os.R_OK):
- abc('r %s;&ps'%name)
- if n_latches() > 0 and n_pos() > 1:
- size = str(sizeof())
- print list_dir[i],
- ps()
- out = out + ['%s: %s'%(list_dir[i],size)]
- return out
-
-def list_size(s=''):
- """ prnts out the sizes of aig files. Leaves .aig as part of name"""
- #os.chdir('../ibm-web')
- list_all = os.listdir('.')
- dir = lst(list_all,'.aig')
- dir.sort()
- result = []
- for j in range(len(dir)):
-## name = dir[j][:-4]
- name = dir[j] #leaves .aig as part of name
- if not s_in_s(s,name):
- continue
- print '%s '%name,
-## abc('r %s.aig'%name)
- abc('r %s'%name)
- ps()
- result = result + [name[:-4]] #takes .aig off of name
- return result
-
-def rename(l=[]):
- for j in range(len(l)):
- name = l[j]
- name1 = name +'.aig'
- name2 = name[:-4]+'simp.aig' #take off _smp and put on simp
- os.rename(name1,name2)
-
-
-def list_blif(s=''):
- """ prnts out the sizes of aig files"""
- #os.chdir('../ibm-web')
- list_all = os.listdir('.')
- dir = lst(list_all,'.blif')
- dir.sort()
- result = []
- for j in range(len(dir)):
- name = dir[j][:-5]
- if not s_in_s(s,name):
- continue
- print '%s: '%name,
- abc('read_blif %s.blif'%name)
- run_command('ps')
- abc('st;zero;w %s.aig'%name)
- result = result + [name]
- return result
-
-def s_in_s(s1,s2):
- ls1 = len(s1)
- l = 1+len(s2)- ls1
- if l< 0:
- return False
- else:
- for j in range(l):
- if s1 == s2[j:j+ls1]:
- return True
- else:
- continue
- return False
-
-
-def convert_ibm():
- """ converts blif files (with constraints?) into aig files"""
- os.chdir('../ibm-web')
- list_ibm = os.listdir('.')
- l_blif = lst(list_ibm,'.blif')
- for j in range(len(l_blif)):
- name = l_blif[j][:-5]
- run_command('read_blif %s.blif'%name)
- abc('undc')
- abc('st -i')
- abc('zero')
- run_command('w %s.aig'%name)
- """if a<100000000:
- f = min(8,max(1,40000/a))
- #run_command('scorr -c -F %d'%f)
- #print 'Result of scorr -F %d: '%f,
- print_circuit_stats()
- run_command('w p_%d.aig'%j)"""
-
-def cl():
- cleanup()
-
-def cleanup():
- list = os.listdir('.')
- for j in range(len(list)):
- name = list[j]
- if ((s_in_s('_smp',name)) or (s_in_s('_save', name)) or (s_in_s('_backup', name)) or (s_in_s('_osave', name))
- or (s_in_s('_best', name)) or (s_in_s('_gsrm', name)) or (s_in_s('gore', name)) or
- (s_in_s('_bip', name)) or (s_in_s('sm0', name)) or (s_in_s('gabs', name))
- or (s_in_s('temp', name)) or (s_in_s('__', name)) or (s_in_s('greg', name)) or (s_in_s('tf2', name))
- or (s_in_s('gsrm', name)) or (s_in_s('_rpm', name )) or (s_in_s('gsyn', name)) or (s_in_s('beforerpm', name))
- or (s_in_s('afterrpm', name)) or (s_in_s('initabs', name)) or (s_in_s('_init', name))
- or (s_in_s('_osave', name)) or (s_in_s('tt_', name)) or (s_in_s('_before', name)) or (s_in_s('_after', name))
- or (s_in_s('_and', name)) or (s_in_s('_spec', name)) or (s_in_s('temp.a', name))
- or (s_in_s('_sync', name)) or (s_in_s('_old', name)) or (s_in_s('_cone_', name)) or (s_in_s('_abs', name))
- or (s_in_s('_vabs', name)) or (s_in_s('_gla', name)) or (s_in_s('vabs', name)) or (s_in_s('_mp2', name))
- or (s_in_s('_sc1', name)) or (s_in_s('_sc2', name)) or (s_in_s('_after', name))
- or (s_in_s('_before', name)) or (s_in_s('_aigs_', name)) or (s_in_s('_cex.', name))
- or (s_in_s('_bmc1', name)) or (s_in_s('_p0_', name)) or (s_in_s('_p1_', name))
- or (s_in_s('_unsolv', name)) or (s_in_s('_iso1', name))
- ):
- os.remove(name)
-
-def simp_mbi():
- os.chdir('../mbi')
- list_ibm = os.listdir('.')
- l_aig = lst(list_ibm,'.aig')
- for j in range(len(l_aig)):
- name = l_aig[j][:-4]
- run_command('r %s.aig'%name)
- run_command('st')
- print '\n%s: '%name
- print_circuit_stats()
- quick_simp()
- scorr_comp()
- simplify()
- run_command('w %s_smp.aig'%name)
-
-def strip_names():
- os.chdir('../mbi')
- list_ibm = os.listdir('.')
- l_aig = lst(list_ibm,'.aig')
- for j in range(len(l_aig)):
- name = l_aig[j][:-4]
- run_command('r %s.aig'%name)
- run_command('st')
- print '\n%s: '%name
- print_circuit_stats()
- quick_simp()
- scorr_comp()
- simplify()
- run_command('w %s_smp.aig'%name)
-
-
-def map_ibm():
- os.chdir('../ibmmike2')
- list_ibm = os.listdir('.')
- l_blif = lst(list_ibm,'.blif')
- result = []
- print len(l_blif)
- for j in range(len(l_blif)):
- name = l_blif[j][:-5]
- result.append('%s = %d'%(name,j))
- return result
-
-
-def absn(a,c,s):
- """ testing Niklas abstraction with various conflict limits
- a= method (0 - regular cba,
- 1 - pure pba,
- 2 - cba with pba at the end,
- 3 cba and pba interleaved at each step
- c = conflict limit
- s = No. of stable steps without cex"""
- global G_C, G_T, latches_before_abs, x_factor, f_name
- set_globals()
- latches_before_abs = n_latches()
- print 'Start: ',
- print_circuit_stats()
- print 'Een abstraction params: Method #%d, %d conflicts, %d stable'%(a,c,s)
- run_command('&get; &abs_newstart -v -A %d -C %d -S %d'%(a,c,s))
- bmcdepth = n_bmc_frames()
- print 'BMC depth = %d'%n_bmc_frames()
- abc('&w absn_greg.aig; &abs_derive; &put; w absn_gabs.aig')
- print 'Final abstraction: ',
- print_circuit_stats()
- write_file('absn')
- return "Done"
-
-def time_stamp():
- d=datetime.today()
- s = d.strftime('%m.%d.%y-%X')
- return s
-
-def apply_sp(list):
- global m_trace
- s = time_stamp()
- out_name = "%s-traces.txt"%s
- print out_name
- if os.access(out_name,os.R_OK):
- os.remove(out_name)
- f = open(out_name,'w')
- print f
- for j in range(len(list)):
- name = list[j]
- print '\n\n**** %s ****\n'%name
- f.write('\n\n****%s ****'%name)
- read_file_quiet(name)
- result = super_prove()
- trace = result[1]
- s = str(trace)
- f.write('\n\n')
- f.write(s)
- f.flush()
- f.close()
-
-def xfiles():
- global f_name
- #output = sys.stdout
- #iterate over all ESS files
- #saveout = sys.stdout
- #output = open("ibm_log.txt",'w')
- # sys.stdout = output
- os.chdir('../ess/f58m')
- print 'Directories are %s'%directories
- for s in directories:
- sss= '../%s'%s
- os.chdir(sss)
- print "\nDirectory is %s\n"%s
- jj=eval(s)
- print (jj)
- run_command('time')
- for j in range(len(jj)):
- print ' '
- set_fname('p_%dsmp23'%jj[j])#file f_name.aig is read in
- print 'p_%dsmp23'%jj[j]
- run_command('time')
- result = dprove3(1)
- print result
- run_command('time')
- run_command('time')
- os.chdir('../../python')
- #sys.stdout = saveout
- #output.close()
-
-def sublist(L,I):
- z = []
- for i in range(len(I)):
- s = L[I[i]],
- s = list(s)
- z = z + s
- return z
-
-def s2l(s):
- """ takes the string s divided by '\n' and makess a list of items"""
- result = []
- while len(s)>2:
- j = s.find('\n')
- result.append(s[:j])
- s = s[j+1:]
- return result
-
-def select(lst, s):
- result = []
- print lst
- for j in range(len(lst)):
- if s in lst[j]:
- s1 = lst[j]
- k = s1.find(':')
- s1 = s1[:k]
- result.append(s1)
- return result
-
-def process_result(name):
- f = open(name,'r')
- s = f.read()
- f.close()
- lst = s2l(s)
- result = select(lst,'Timeout')
- return result
-
-
-def main():
- stackno = 0
- if len(sys.argv) != 2:
- print "usage: %s <aig filename>"%sys.argv[0]
- sys.exit(1)
- aig_filename = sys.argv[1]
- x("source ../../abc.rc")
- read(aig_filename)
- dprove3(1)
-# a test to whether the script is being called from the command line
-if __name__=="__main__":
- main()
diff --git a/scripts/multi_prove.sh b/scripts/multi_prove.sh
deleted file mode 100644
index 4729d179..00000000
--- a/scripts/multi_prove.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/multi_prove_aiger $*"
diff --git a/scripts/new_abc_commands.py b/scripts/new_abc_commands.py
deleted file mode 100644
index 22718f07..00000000
--- a/scripts/new_abc_commands.py
+++ /dev/null
@@ -1,257 +0,0 @@
-import sys
-import os
-import pyabc
-import par
-import tempfile
-import shutil
-import redirect
-import optparse
-
-from contextlib import contextmanager
-
-def read_cmd(args):
- if len(args)==2:
- par.read_file_quiet(args[1])
- else:
- par.read_file()
- return 0
-
-pyabc.add_abc_command(read_cmd, "ZPython", "/rf", 0)
-
-def chdir_cmd(args):
- os.chdir( args[1] )
- return 0
-
-pyabc.add_abc_command(chdir_cmd, "ZPython", "/cd", 0)
-
-def pwd_cmd(args):
- print os.getcwd()
- return 0
-
-pyabc.add_abc_command(pwd_cmd, "ZPython", "/pwd", 0)
-
-def ls_cmd(args):
- os.system("ls " + " ".join(args[1:]))
- return 0
-
-pyabc.add_abc_command(ls_cmd, "ZPython", "/ls", 0)
-
-pushd_temp_stack = []
-
-def pushdtemp_cmd(args):
- tmpdir = tempfile.mkdtemp()
- pushd_temp_stack.append( (os.getcwd(), tmpdir) )
- os.chdir(tmpdir)
- return 0
-
-pyabc.add_abc_command(pushdtemp_cmd, "ZPython", "/pushdtemp", 0)
-
-def popdtemp_cmd(args):
- prev, temp = pushd_temp_stack.pop()
- os.chdir(prev)
- shutil.rmtree(temp, ignore_errors=True)
- return 0
-
-pyabc.add_abc_command(popdtemp_cmd, "ZPython", "/popdtemp", 0)
-
-pushredirect_stack = []
-
-def push_redirect_cmd(args):
- fdout = redirect.start_redirect( redirect.null_file, sys.stdout)
- pushredirect_stack.append( (sys.stdout, fdout) )
-
- fderr = redirect.start_redirect( redirect.null_file, sys.stderr)
- pushredirect_stack.append( (sys.stderr, fderr) )
-
- return 0
-
-pyabc.add_abc_command(push_redirect_cmd, "ZPython", "/pushredirect", 0)
-
-def pop_redirect_cmd(args):
- err, fderr = pushredirect_stack.pop()
- redirect.end_redirect(err, fderr)
-
- out, fdout = pushredirect_stack.pop()
- redirect.end_redirect(out, fdout)
-
- return 0
-
-pyabc.add_abc_command(pop_redirect_cmd, "ZPython", "/popredirect", 0)
-
-def print_aiger_result(args):
- status = pyabc.prob_status()
-
- if status==1:
- print 0
- elif status==0:
- print 1
- else:
- print 2
-
- return 0
-
-pyabc.add_abc_command(print_aiger_result, "ZPython", "/print_aiger_result", 0)
-
-@contextmanager
-def replace_report_result(multi):
-
- def report_result(po, result):
-
- print "REPORT RESULT: ", po, result
-
- print >> stdout, "%d"%result
- print >> stdout, "b%d"%po
- print >> stdout, "."
-
- def report_liveness_result(po, result):
-
- print "REPORT RESULT: ", po, result
-
- print >> stdout, "%d"%result
- print >> stdout, "j%d"%po
- print >> stdout, "."
-
- def report_bmc_depth(depth):
-
- if not multi:
- print "REPORT BMC DEPTH:", depth
- print >> stdout, "u%d"%depth
-
- with redirect.save_stdout() as stdout:
-
- old_report_result = par.report_result
- par.report_result = report_result
-
- #old_report_liveness_result = par.report_liveness_result
- par.report_liveness_result = report_liveness_result
-
- old_report_bmc_depth = par.report_bmc_depth
- par.report_bmc_depth = report_bmc_depth
-
- try:
- yield
- finally:
- par.report_result = old_report_result
- #~ par.report_liveness_result = report_liveness_result
- par.report_bmc_depth = old_report_bmc_depth
-
-def proof_command_wrapper_internal(prooffunc, category_name, command_name, change, multi=False):
-
- def wrapper(argv):
-
- usage = "usage: %prog [options] <aig_file>"
-
- parser = optparse.OptionParser(usage, prog=command_name)
-
- parser.add_option("-n", "--no_redirect", dest="noisy", action="store_true", default=False, help="don't redirect output")
- parser.add_option("-d", "--current_dir", dest="current_dir", action="store_true", default=False, help="stay in current directory")
-
- options, args = parser.parse_args(argv)
-
- if len(args) != 2:
- parser.print_usage()
- return 0
-
- aig_filename = os.path.abspath(args[1])
-
- with replace_report_result(multi):
-
- if not options.noisy:
- pyabc.run_command('/pushredirect')
-
- if not options.current_dir:
- pyabc.run_command('/pushdtemp')
-
- try:
- for d in os.environ['PATH'].split(':'):
- bip = os.path.join(d, 'bip')
- if os.path.exists(bip):
- pyabc.run_command("load_plugin %s Bip"%bip)
- break
-
- basename = os.path.basename( aig_filename )
- shutil.copyfile(aig_filename, basename)
- aig_filename = basename
-
- result = prooffunc(aig_filename)
-
- par.cex_list = []
- except:
- result = None
-
- if not multi:
-
- if result=="SAT":
- par.report_result(0,1)
- elif result=="UNSAT":
- par.report_result(0,0)
- elif type(result)==list and len(result)>0 and result[0] == "SAT":
- par.report_result(0,1)
- elif type(result)==list and len(result)>0 and result[0] == "UNSAT":
- par.report_result(0,0)
- else:
- par.report_result(0,2)
-
- if not options.current_dir:
- pyabc.run_command('/popdtemp')
-
- if not options.noisy:
- pyabc.run_command('/popredirect')
-
- return 0
-
- pyabc.add_abc_command(wrapper, category_name, command_name, change)
-
-def proof_command_wrapper(prooffunc, category_name, command_name, change, multi=False):
- def pf(aig_filename):
- par.read_file_quiet(aig_filename)
- return prooffunc()
- return proof_command_wrapper_internal(pf, category_name, command_name, change, multi)
-
-proof_command_wrapper(par.sp, 'HWMCC13', '/super_prove_aiger', 0)
-proof_command_wrapper(par.simple, 'HWMCC13', '/simple_aiger', 0)
-proof_command_wrapper(par.simple_bip, 'HWMCC13', '/simple_bip_aiger', 0)
-proof_command_wrapper(par.simple_sat, 'HWMCC13', '/simple_sat_aiger', 0)
-proof_command_wrapper(par.mp, 'HWMCC13', '/multi_prove_aiger', 0, multi=True)
-
-def simple_liveness_prooffunc(aig_filename):
-
- import niklas
- from pyaig import utils
-
- def simplify(aiger_in, aiger_out):
-
- with niklas.temp_file_names(2, suffix='.aig') as tmp:
-
- saved = utils.save_po_info(aiger_in, tmp[0])
-
- par.read_file_quiet(tmp[0])
-
- par.pre_simp()
-
- pyabc.run_command( 'write_aiger %s'%tmp[1] )
-
- utils.restore_po_info( saved, tmp[1], aiger_out )
-
- return True
-
- def report_result(id, res):
-
- if res and 'result' in res:
- result = res['result']
- if result=='proved':
- par.report_liveness_result(id, 0)
- return True
- elif result=='failed':
- par.report_liveness_result(id, 1)
- return True
-
- return False
-
- try:
- niklas.run_niklas_multi(aig_filename, simplify=simplify, report_result=report_result)
- except:
- import traceback
- traceback.print_exc()
-
-proof_command_wrapper_internal( simple_liveness_prooffunc, "HWMCC13", "/simple_liveness_aiger", 0, multi=True)
diff --git a/scripts/niklas.py b/scripts/niklas.py
deleted file mode 100644
index 882bd0a7..00000000
--- a/scripts/niklas.py
+++ /dev/null
@@ -1,191 +0,0 @@
-import os
-import sys
-import time
-import tempfile
-import subprocess
-
-from contextlib import contextmanager
-
-import pyabc
-import pyabc_split
-
-@contextmanager
-def temp_file_names(N, suffix=""):
-
- files = []
-
- try:
-
- for i in xrange(N):
- files.append( tempfile.NamedTemporaryFile(suffix=suffix) )
-
- yield [ f.name for f in files ]
-
- finally:
- for f in files:
- f.close()
-
-def parse_bip_status(status):
-
- res = {}
-
- for line in open(status, 'r'):
-
- line = line.strip()
-
- colon = line.find(':')
-
- if colon < 0:
- continue
-
- field = line[:colon]
- data = line[colon+2:]
-
- res[field] = data
-
- return res
-
-def run_bip(args, aiger):
-
- import redirect
- with redirect.redirect():
-
- with temp_file_names(1) as tmpnames:
-
- args = [
- 'bip',
- '-abc',
- '-input=%s'%aiger,
- '-output=%s'%tmpnames[0],
- ] + args;
-
- rc = subprocess.call(args, preexec_fn=pyabc._set_death_signal)
-
- if rc!=0:
- return None
-
- return parse_bip_status(tmpnames[0])
-
-from pyaig import AIG, read_aiger, write_aiger, utils
-
-def run_niklas_single(aiger, simplify, report_result, timeout=None):
-
- orig_args = [
- [ ',live', '-k=l2s', '-eng=treb-abs' ],
- [ ',live', '-k=inc' ],
- [ ',live', '-k=l2s', '-eng=bmc' ],
- ]
-
- simplified_args = [
- [ ',live', '-k=inc' ],
- [ ',live', '-k=l2s', '-eng=bmc' ],
- [ ',live', '-k=l2s', '-eng=treb' ],
- ]
-
- with temp_file_names(1, suffix='.aig') as simple_aiger:
-
- orig_funcs = [ pyabc_split.defer(run_bip)(a, aiger) for a in orig_args ]
- simplified_funcs = [ pyabc_split.defer(run_bip)(a, simple_aiger[0]) for a in simplified_args ]
-
- with pyabc_split.make_splitter() as splitter:
-
- sleep_id = splitter.fork_one( lambda : time.sleep(timeout ) ) if timeout else None
-
- ids = splitter.fork_all( orig_funcs )
- kill_if_simplified = ids[1:]
-
- simplifier_id = splitter.fork_one( pyabc_split.defer(simplify)(aiger, simple_aiger[0]) )
-
- for id, res in splitter:
-
- print 'NIKLAS: process %d finished with'%id, res
-
- if id == sleep_id:
- print 'NIKLAS: timeout'
- return False
-
- elif id == simplifier_id:
- print 'NIKLAS: simplify ended'
- if not res:
- continue
- print 'NIKLAS: killing'
- splitter.kill(kill_if_simplified)
- splitter.fork_all( simplified_funcs )
- continue
-
- elif report_result(res):
- print 'NIKLAS: RESULT'
- return True
-
- return False
-
-def run_niklas_multi(aiger, simplify, report_result):
-
- with open(aiger, 'r') as fin:
- aig = read_aiger( fin )
-
- n_j_pos = aig.n_justice()
- assert n_j_pos > 0
-
- if n_j_pos==1:
- return run_niklas_single( aiger, simplify, report_result=lambda res: report_result(0, res) )
-
- with temp_file_names(n_j_pos, suffix='.aig') as single_aiger:
-
- def extract(j_po):
- with open(single_aiger[j_po], 'w') as fout:
- write_aiger(utils.extract_justice_po(aig, j_po), fout)
-
- for _ in pyabc_split.split_all_full( [pyabc_split.defer(extract)(i) for i in xrange(n_j_pos) ] ):
- pass
-
- unsolved = set( xrange(n_j_pos) )
-
- timeout = 1
-
- while unsolved:
- for j_po in sorted(unsolved):
- if run_niklas_single( single_aiger[j_po], simplify, report_result=lambda res: report_result(j_po, res), timeout=timeout ):
- unsolved.remove(j_po)
- timeout *= 2
-
- return not unsolved
-
-if __name__ == "__main__":
-
- def simplify(aiger_in, aiger_out):
-
- with temp_file_names(2, suffix='.aig') as tmp:
-
- saved = utils.save_po_info(aiger_in, tmp[0])
-
- pyabc.run_command( 'read_aiger %s'%tmp[0] )
- pyabc.run_command( 'dc2 ; dc2 ; dc2 ; dc2' )
- pyabc.run_command( 'write_aiger %s'%tmp[1] )
-
- utils.restore_po_info( saved, tmp[1], aiger_out )
-
- return True
-
- def report_result(id, res):
-
- if res and 'result' in res:
- result = res['result']
- if result=='proved':
- print "PROVED: ", id
- return True
- elif result=='failed':
- print "FAILED:", id
- return True
-
- return False
-
- aiger = "test.aig"
-
- while True:
- try:
- run_niklas_multi(aiger, simplify=simplify, report_result=report_result)
- except:
- import traceback
- traceback.print_exc()
-
diff --git a/scripts/par.py b/scripts/par.py
deleted file mode 100644
index 110c5677..00000000
--- a/scripts/par.py
+++ /dev/null
@@ -1,8151 +0,0 @@
-from pyabc import *
-import pyabc_split
-import redirect
-import sys
-import os
-import time
-import math
-import main
-import filecmp
-
-
-global G_C,G_T,latches_before_abs,latches_before_pba,n_pos_before,x_factor,methods,last_winner
-global last_cex,JV,JP, cex_list,max_bmc, last_cx, pord_on, trim_allowed, temp_dec, abs_ratio, ifbip
-global if_no_bip, gabs, gla, sec_options,last_gasp_time, abs_ref_time, bmcs1, total_spec_refine_time
-global last_gap
-
-"""
-The functions that are currently available from module _abc are:
-
-int n_ands();
-int n_pis();
-int n_pos();
-int n_latches();
-int n_bmc_frames();
-int prob_status(); 1 = unsat, 0 = sat, -1 = unsolved
-int cex_get()
-int cex_put()
-int run_command(char* cmd);
-int n_nodes();
-int n_levels();
-
-bool has_comb_model();
-bool has_seq_model();
-bool is_true_cex();
-bool is_valid_cex();
- return 1 if the number of PIs in the current network and in the current counter-example are equal
-int n_cex_pis();
- return the number of PIs in the current counter-example
-int n_cex_regs();
- return the number of flops in the current counter-example
-int cex_po();
- returns the zero-based output PO number that is SAT by cex
-int cex_frame();
- return the zero-based frame number where the outputs is SAT
-The last four APIs return -1, if the counter-example is not defined.
-"""
-#global variables
-#________________________________________________
-stackno_gabs = stackno_gore = stackno_greg= 0
-STATUS_UNKNOWN = -1
-STATUS_SAT = 0
-STATUS_UNSAT = 1
-RESULT = ('SAT', 'SAT', 'UNSAT', 'UNDECIDED', 'UNDECIDED', 'ERROR')
-Sat = Sat_reg = 0
-Sat_true = 1
-Unsat = 2
-Undecided = Undecided_reduction = 3
-Undecided_no_reduction = 4
-Error = 5
-Restart = 6
-xfi = x_factor = 1 #set this to higher for larger problems or if you want to try harder during abstraction
-max_bmc = -1
-last_time = 0
-j_last = 0
-seed = 113
-init_simp = 1
-temp_dec = True
-ifpord1 = 1
-K_backup = init_time = 0
-last_verify_time = 20
-last_cex = last_winner = 'None'
-last_cx = 0
-trim_allowed = True
-pord_on = False
-sec_sw = False
-sec_options = ''
-cex_list = []
-TERM = 'USL'
-last_gasp_time = 10000
-last_gasp_time = 500
-last_gasp_time = 900 #set to conform to hwmcc12
-use_pms = True
-
-#gabs = False #use the gate refinement method after vta
-#abs_time = 100
-
-####################################
-#default abstraction methods
-gabs = False #False = use gla refinement, True = use reg refinement.
-gla = True #use gla_abs instead of vta_abs
-##abs_time = 10000 #number of sec before initial abstraction terminates.
-abs_time = 150
-abs_time = 5000
-abs_time = 500
-abs_time = 100
-abs_ref_time = 50 #number of sec. allowed for abstraction refinement.
-total_spec_refine_time = 150
-ifbip = 0 # sets the abtraction method to vta or gla, If = 1 then uses ,abs
-if_no_bip = False #True sets it up so it can't use bip and reachx commands.
-abs_ratio = .5 #this controls when abstraction is too big and gives up
-#####################################
-
-def abstr_a(t1=200,t2=200,absr=0):
- global abs_time, abs_ref_time, abs_ratio
- if not absr == 0:
- abs_ratio_old = abs_ratio
- abs_ratio = absr
- abs_time = t1
- abs_ref_time = t2
- abstracta(False)
- if not absr == 0:
- abs_ratio = abs_ratio_old
-
-t_init = 2 #initial time for poor man's concurrency.
-
-def set_global(s=''):
- global G_C,G_T,latches_before_abs,latches_before_pba,n_pos_before,x_factor,methods,last_winner
- global last_cex,JV,JP, cex_list,max_bmc, last_cx, pord_on, trim_allowed, temp_dec, abs_ratio, ifbip
- global if_no_bip, gabs, gla, sec_options,last_gasp_time,abs_ref_time, abs_time,use_pms
- exec(s)
-
-
-methods = ['PDR', 'INTRP', 'BMC', 'SIM', 'REACHX',
- 'PRE_SIMP', 'simple', 'PDRM', 'REACHM', 'BMC3','Min_Retime',
- 'For_Retime','REACHP','REACHN','PDR_sd','prove_part_2',
- 'prove_part_3','verify','sleep','PDRM_sd','prove_part_1',
- 'run_parallel','INTRPb', 'INTRPm', 'REACHY', 'REACHYc','RareSim','simplify', 'speculate',
- 'quick_sec', 'BMC_J', 'BMC2', 'extract -a', 'extract', 'PDRa', 'par_scorr', 'dsat', 'iprove']
-#'0.PDR', '1.INTERPOLATION', '2.BMC', '3.SIMULATION',
-#'4.REACHX', '5.PRE_SIMP', '6.simple', '7.PDRM', '8.REACHM', 9.BMC3'
-# 10. Min_ret, 11. For_ret, 12. REACHP, 13. REACHN 14. PDRseed 15.prove_part_2,
-#16.prove_part_3, 17.verify, 18.sleep, 19.PDRMm, 20.prove_part_1,
-#21.run_parallel, 22.INTRP_bwd, 23. Interp_m 24. REACHY 25. REACHYc 26. Rarity Sim 27. simplify
-#28. speculate, 29. quick_sec, 30 bmc3 -S, 31. BMC2 32. extract -a 33. extract 34. pdr_abstract
-#35 par_scorr, 36. dsat, 37. iprove
-win_list = [(0,.1),(1,.1),(2,.1),(3,.1),(4,.1),(5,-1),(6,-1),(7,.1)]
-FUNCS = ["(pyabc_split.defer(pdr)(t))",
-## "(pyabc_split.defer(abc)('&get;,pdr -vt=%f'%t))",
- "(pyabc_split.defer(intrp)(t))",
-## "(pyabc_split.defer(abc)('&get;,imc -vt=%f'%(t)))",
-## "(pyabc_split.defer(abc)('&get;,imc-sofa -vt=%f'%(t)))",
- "(pyabc_split.defer(bmc)(t))",
-## "(pyabc_split.defer(abc)('&get;,bmc -vt=%f'%t))",
- "(pyabc_split.defer(simulate)(t))",
- "(pyabc_split.defer(reachx)(t))",
-## "(pyabc_split.defer(abc)('reachx -t %d'%t))",
- "(pyabc_split.defer(pre_simp)())",
-## "(pyabc_split.defer(super_prove)(2))",
- "(pyabc_split.defer(simple)(t))",
- "(pyabc_split.defer(pdrm)(t))",
- "(pyabc_split.defer(abc)('&get;&reachm -vcs -T %d'%t))",
- "(pyabc_split.defer(bmc3)(t))",
-## "(pyabc_split.defer(abc)('bmc3 -C 1000000 -T %f'%t))",
- "(pyabc_split.defer(abc)('dretime;&get;&lcorr;&dc2;&scorr;&put;dretime'))",
- "(pyabc_split.defer(abc)('dretime -m;&get;&lcorr;&dc2;&scorr;&put;dretime'))",
- "(pyabc_split.defer(abc)('&get;&reachp -vr -T %d'%t))",
- "(pyabc_split.defer(abc)('&get;&reachn -vr -T %d'%t))",
-## "(pyabc_split.defer(abc)('&get;,pdr -vt=%f -seed=521'%t))",
- "(pyabc_split.defer(pdrseed)(t))",
- "(pyabc_split.defer(prove_part_2)())",
- "(pyabc_split.defer(prove_part_3)())",
- "(pyabc_split.defer(verify)(JV,t))",
- "(pyabc_split.defer(sleep)(t))",
- "(pyabc_split.defer(pdrmm)(t))",
- "(pyabc_split.defer(prove_part_1)())",
- "(pyabc_split.defer(run_parallel)(JP,t,'TERM'))",
- "(pyabc_split.defer(abc)('&get;,imc -bwd -vt=%f'%t))",
-## "(pyabc_split.defer(abc)('int -C 1000000 -F 10000 -K 2 -T %f'%t))",
- "(pyabc_split.defer(intrpm)(t))",
-## "(pyabc_split.defer(abc)('int -C 1000000 -F 10000 -K 1 -T %f'%t))",
- "(pyabc_split.defer(reachy)(t))",
-## "(pyabc_split.defer(abc)('&get;&reachy -v -T %d'%t))",
- "(pyabc_split.defer(abc)('&get;&reachy -cv -T %d'%t))",
- "(pyabc_split.defer(simulate2)(t))",
- "(pyabc_split.defer(simplify)())",
- "(pyabc_split.defer(speculate)())",
- "(pyabc_split.defer(quick_sec)(t))",
- "(pyabc_split.defer(bmc_j)(t))",
-## "(pyabc_split.defer(abc)('bmc2 -C 1000000 -T %f'%t))",
- "(pyabc_split.defer(bmc2)(t))",
- "(pyabc_split.defer(extractax)('a'))",
- "(pyabc_split.defer(extractax)())",
- "(pyabc_split.defer(pdra)(t))",
- "(pyabc_split.defer(pscorr)(t))",
- "(pyabc_split.defer(dsat)(t))",
- "(pyabc_split.defer(iprove)(t))"
- ]
-## "(pyabc_split.defer(abc)('bmc3 -C 1000000 -T %f -S %d'%(t,int(1.5*max_bmc))))"
-#note: interp given 1/2 the time.
-
-## Similar engines below listed in the order of priority, high to low.
-allreachs = [4,8,12,13,24,25]
-allreachs = [24,4]
-reachs = [24]
-##allpdrs = [14,7,34,19,0]
-allpdrs = [34,7,14,19,0]
-allpdrs2 = [34,7,14,19,0]
-pdrs = [34,7,14,0]
-allbmcs = [9,30,2,31]
-exbmcs = [2,9,31]
-bmcs = [9,30]
-bmcs1 = [9]
-allintrps = [23,1,22]
-bestintrps = [23]
-##intrps = [23,1]
-intrps = [23,1] #putting ,imc-sofa first for now to test
-allsims = [26,3]
-sims = [26]
-allslps = [18]
-slps = [18]
-imc1 = [1]
-pre = [5]
-combs = [36,37]
-
-JVprove = [7,23,4,24]
-JV = pdrs+intrps+bmcs+sims #sets what is run in parallel '17. verify' above
-JP = JV + [27] # sets what is run in '21. run_parallel' above 27 simplify should be last because it can't time out.
-#_____________________________________________________________
-
-
-# Function definitions:
-# simple functions: ________________________________________________________________________
-# set_globals, abc, q, x, has_any_model, is_sat, is_unsat, push, pop
-
-# ALIASES
-
-def initialize():
- global xfi, max_bmc, last_time,j_last, seed, init_simp, K_backup, last_verify_time
- global init_time, last_cex, last_winner, trim_allowed, t_init, sec_options, sec_sw
- global n_pos_before, n_pos_proved, last_cx, pord_on, temp_dec, abs_time, gabs, gla,m_trace
- global smp_trace,hist,init_initial_f_name, skip_spec, t_iter_start,last_simp, final_all, scorr_T_done
- global last_gap
- xfi = x_factor = 1 #set this to higher for larger problems or if you want to try harder during abstraction
- max_bmc = -1
- last_time = 0
- j_last = 0
- seed = 113
- init_simp = 1
- temp_dec = True
- K_backup = init_time = 0
- last_verify_time = 20
- last_cex = last_winner = 'None'
- last_cx = 0
- trim_allowed = True
- pord_on = False
- t_init = 2 #this will start sweep time in find_cex_par to 2*t_init here
- sec_sw = False
- sec_options = ''
- smp_trace = m_trace = []
- cex_list = []
- n_pos_before = n_pos()
- n_pos_proved = 0
- abs_time = 150
- abs_ref_time = 50 #number of sec. allowed for abstraction refinement.
- total_spec_refine_time = 150
- abs_ratio = .5
- hist = []
- skip_spec = False
- t_iter_start = 0
- inf = 10000000
- last_simp = [inf,inf,inf,inf]
- final_all = 1
- scorr_T_done = 0
- last_gap = 0
-## abs_time = 100
-## gabs = False
-## abs_time = 500
-## gabs = True
-
-
-
-def set_abs_method():
- """ controls the way we do abstraction, 0 = no bip, 1 = old way, 2 use new bip and -dwr
- see absab()
- """
- global ifbip, abs_time,gabs,gla,if_no_bip
- print 'current values ifbip = %d, abs_time = %d'%(ifbip,abs_time)
- print 'Set method of abstraction: \n0 = vta for 500 and gla refin., \n1 = old way, \n2 = ,abs and -dwr, \n3 = vta for 100 followed by gla refine.,\n4 = vta for 500 then gla refine. but no bip methods gla refine., \n5 = gla and gla refine.'
- s = raw_input()
- s = remove_spaces(s)
- if s == '1': #use the old way with ,abs but no dwr
- ifbip = 1 #old way
- abs_time = 100
- if_no_bip = False
- gabs = True
- gla = False
- elif s == '0':#use vta and gla refinement
- ifbip = 0
- abs_time = 500
- if_no_bip = False
- gabs = False
- gla = False
- elif s == '2': #use ,abc -dwr
- ifbip = 2
- abs_time = 100
- if_no_bip = False
- gabs = True #use register refinement
- gla = False
- elif s == '3': #use vta and gla refinement
- ifbip = 0
- abs_time = 100
- if_no_bip = False
- gabs = False
- gla = False
- elif s == '4': #use vta, gla refine. and no bip
- ifbip = 0
- abs_time = 100
- if_no_bip = True
- gabs = True
- gla = False
- elif s == '5': #use gla and gla_refinement
- ifbip = 0
- abs_time = 100
- if_no_bip = False
- gabs = False
- gla = True
- #should make any of the methods able to us no bip
- print 'ifbip = %d, abs_time = %d, gabs = %d, if_no_bip = %d, gla = %d'%(ifbip,abs_time,gabs,if_no_bip,gla)
-
-def ps():
- print_circuit_stats()
-
-def iprove(t=100):
- abc('iprove')
-
-def dsat(t=100):
- abc('dsat')
-
-def n_real_inputs():
- """This gives the number of 'real' inputs. This is determined by trimming away inputs that
- have no connection to the logic. This is done by the ABC alias 'trm', which changes the current
- circuit. In some applications we do not want to change the circuit, but just to know how may inputs
- would go away if we did this. So the current circuit is saved and then restored afterwards."""
-## abc('w %s_savetempreal.aig; logic; trim; st ;addpi'%f_name)
- abc('w %s_savetempreal.aig'%f_name)
- with redirect.redirect( redirect.null_file, sys.stdout ):
-## with redirect.redirect( redirect.null_file, sys.stderr ):
- reparam()
- n = n_pis()
- abc('r %s_savetempreal.aig'%f_name)
- return n
-
-def timer(t):
- btime = time.clock()
- time.sleep(t)
- print t
- return time.clock() - btime
-
-def sleep(t):
-## print 'Sleep time = %d'%t
- time.sleep(t)
- return Undecided
-
-def abc(cmd):
- abc_redirect_all(cmd)
-
-def abc_redirect( cmd, dst = redirect.null_file, src = sys.stdout ):
- """This is our main way of calling an ABC function. Redirect, means that we suppress any output from ABC"""
- with redirect.redirect( dst, src ):
- return run_command( cmd )
-
-def abc_redirect_all( cmd ):
- """This is our main way of calling an ABC function. Redirect, means that we suppress any output from ABC, including error printouts"""
- with redirect.redirect( redirect.null_file, sys.stdout ):
- with redirect.redirect( redirect.null_file, sys.stderr ):
- return run_command( cmd )
-
-##def convert(t):
-## t = int(t*100)
-## return str(float(t)/100)
-
-def set_engines(N=0):
- """
- Called only when read_file is called.
- Sets the MC engines that are used in verification according to
- if there are 4 or 8 processors. if if_no_bip = 1, we will not use any bip and reachx engines
- """
- global reachs,pdrs,sims,intrps,bmcs,n_proc,abs_ratio,ifbip,bmcs1, if_no_bip, allpdrs,allbmcs
- bmcs1 = [9] #BMC3
- #for HWMCC we want to set N = 8
- N = 8
- if N == 0:
- N = n_proc = 1+os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"])
-## N = n_proc = 8 ### simulate 4 processors for HWMCC - turn this off a hwmcc.
- else:
- n_proc = N
-## print 'n_proc = %d'%n_proc
- if N <= 1:
- reachs = [24]
- pdrs = [7]
-## bmcs = [30]
- bmcs = [9]
- intrps = []
- sims = []
- slps = [18]
- elif N <= 2:
- reachs = [24]
- pdrs = [7]
- bmcs = [30]
- intrps = []
- sims = []
- slps = [18]
- elif N <= 4:
- reachs = [24] #reachy
- pdrs = [7,34] #prdm pdr_abstract
- if if_no_bip:
- allpdrs = pdrs = [7,19] #pdrm pdrmm
- bmcs = [9,30] #bmc3 bmc3 -S
- intrps = [23] #unterp_m
- sims = [26] #Rarity_sim
- slps = [18] #sleep
-# 0.PDR, 1.INTERPOLATION, 2.BMC, 3.SIMULATION,
-# 4.REACHX, 5.PRE_SIMP, 6.simple, 7.PDRM, 8.REACHM, 9.BMC3
-# 10.Min_ret, 11.For_ret, 12.REACHP, 13.REACHN 14.PDRseed 15.prove_part_2,
-# 16.prove_part_3, 17.verify, 18.sleep, 19.PDRMm, 20.prove_part_1,
-# 21.run_parallel, 22.INTRP_bwd, 23.Interp_m 24.REACHY 25.REACHYc 26.Rarity Sim 27.simplify
-# 28.speculate, 29.quick_sec, 30.bmc3 -S, 31.BMC2 32.extract -a 33.extract 34.pdr_abstract
-# 35.par_scorr, 36.dsat, 37.iprove
-
-# BIPS = 0.PDR, 1.INTERPOLATION, 2.BMC, 14.PDRseed, 22.INTRP_bwd, 34.pdr_abstract
-# also reparam which uses ,reparam
-
- elif N <= 8: #used for HWMCC
- reachs = [24] #REACHY
- allpdrs = pdrs = [7,34,14] #PDRM pdr_abstract PDR_seed
- intrps = [23,1] #Interp_m
- allbmcs = bmcs = [9,30,31] #BMC3 bmc3 -S
- if if_no_bip:
- allpdrs = pdrs = [7,19] #PDRM PDRMm
- intrps = allintrps = [23] #Interp_m
- bmcs = allbmcs = [2]
- sims = [26] #Rarity_Sim
- slps = [18] #sleep
- else:
- reachs = [24,4] #REACHY REACHX
- pdrs = [7,34,14,19,0] #PDRM pdr_abstract PDR_seed PDRMm PDR
- intrps = [23,1] #Interp_m INTERPOLATION
- bmcs = allbmcs
- if if_no_bip:
- allpdrs = pdrs = [7,19] #PDRM PDRMm
- intrps = allintrps = [23] #Interp_m
- reachs = [24] #REACHY
- bmcs = [9,30] #BMC3 bmc3 -S
- sims = [26] #Rarity_Sim
- slps = [18] #sleep
-
-def set_globals():
- """This sets global parameters that are used to limit the resources used by all the operations
- bmc, interpolation BDDs, abstract etc. There is a global factor 'x_factor' that can
- control all of the various resource limiting parameters"""
- global G_C,G_T,x_factor
- nl=n_latches()
- na=n_ands()
- np = n_pis()
- #G_C = min(500000,(3*na+500*(nl+np)))
- G_C = x_factor * min(100000,(3*na+500*(nl+np)))
- #G_T = min(250,G_C/2000)
- G_T = x_factor * min(75,G_C/2000)
- G_T = max(1,G_T)
- #print('Global values: BMC conflicts = %d, Max time = %d sec.'%(G_C,G_T))
-
-def a():
- """this puts the system into direct abc input mode"""
- print "Entering ABC direct-input mode. Type q to quit ABC-mode"
- n = 0
- while True:
- print ' abc %d> '%n,
- n = n+1
- s = raw_input()
- if s == "q":
- break
- run_command(s)
-
-def remove_spaces(s):
- y = ''
- for t in s:
- if not t == ' ':
- y = y + t
- return y
-
-def seq_name(f):
- names = []
- f = f + '_'
- names = []
- while len(f)>0:
- j = f.find('_')
- if j == -1:
- break
- names = names + [f[:j]]
-## print names
- f = f[j+1:]
-## print f
- return names
-
-def revert(f,n):
- l = seq_name(f)
- for j in range(n):
- if len(l)>0:
- l.pop()
- name = construct(l)
- return name
-
-def n_eff_pos():
- N=n_pos()
- l=len(list_0_pos())
- return N-l
-
-def construct(l):
- ll = l
- name = ''
- while len(l)>0:
- name = '_'+ll.pop()+name
- return name[1:]
-
-def process_sat():
- l = seq_name(f_name)
-
-def add_trace(s):
- global m_trace
- m_trace = m_trace + [s]
-
-def read_file_quiet_i(fname=None):
- """ this preserves t_inter_start and is called internally by some functons."""
- global t_iter_start
- ts = t_iter_start
- read_file_quiet(fname)
- t_iter_start = ts
-
-def read_file_quiet(fname=None):
- """This is the main program used for reading in a new circuit. The global file name is stored (f_name)
- Sometimes we want to know the initial starting name. The file name can have the .aig extension left off
- and it will assume that the .aig extension is implied. This should not be used for .blif files.
- Any time we want to process a new circuit, we should use this since otherwise we would not have the
- correct f_name."""
- global max_bmc, f_name, d_name, initial_f_name, x_factor, init_initial_f_name, win_list,seed, sec_options
- global win_list, init_simp, po_map, aigs, hist, init_initial_f_name
- abc('fraig_restore') #clear out any residual fraig_store
- set_engines() #temporary
- init_simp = 1
- win_list = [(0,.1),(1,.1),(2,.1),(3,.1),(4,.1),(5,-1),(6,-1),(7,.1)] #initialize winning engine list
- po_map = range(n_pos())
- initialize()
-## x_factor = 1
-## seed = 223
-## max_bmc = -1
- if fname is None:
- print 'Type in the name of the aig file to be read in'
- s = raw_input()
- s = remove_spaces(s)
-## print s
- else:
- s = fname
- if s[-4:] == '.aig':
- f_name = s[:-4]
- elif s[-5:] == '.blif':
- f_name = s[:-5]
- else:
- f_name = s
- s = s+'.aig'
-## run_command(s)
-## print s
- if s[-4:] == '.aig':
-## run_command('&r %s;&put'%s) #warning: changes names to generic ones.
- run_command('r %s'%s)
- run_command('zero')
- else: #this is a blif file
- run_command('r %s'%s)
- abc('st;&get;&put') #changes names to generic ones for doing cec later.
- run_command('zero;w %s.aig'%f_name)
- set_globals()
- hist = []
- init_initial_f_name = initial_f_name = f_name
- run_command('fold') #only does something if some of the outputs are constraints.
- aigs_pp('push','initial')
- #aigs = create push/pop history of aigs
- #aigs.push() put the initial aig on the aig list.
- print 'Initial f_name = %s'%f_name
- abc('addpi') #only does something if there are no PIs
- #check_pos() #this removes constant outputs with a warning -
- #needed when using iso. Need another fix for using iso.
- ps()
- return
-
-def aigs_pp(op='push', typ='reparam'):
- global hist,init_initial_f_name
-## print hist
- if op == 'push':
- hist.append(typ)
- abc('w %s_aigs_%d.aig'%(init_initial_f_name,len(hist)))
- if op == 'pop':
- abc('cexsave') #protect current cex from a read
- abc('r %s_aigs_%d.aig'%(init_initial_f_name,len(hist)))
- abc('cexload')
- typ = hist.pop()
-## print hist
- return typ
-
-def scl():
- abc('&get;&scl;&put')
- ps()
-
-def cex_trim_g(F_init=0,tail=0,m=''):
- abc('w %s_cex.aig'%f_name)
- N=cex_frame()
- G = N - tail
- F = F_init
- abc('cexsave')
- while True:
- print 'F = %d, G = %d'%(F,G)
- abc('r %s_cex.aig'%f_name)
- abc('cexload')
- if m == '':
- abc('cexcut -F %d -G %d'%(F,G))
- else:
- abc('cexcut -m -F %d -G %d'%(F,G))
-## abc('drw')
-## ps()
- res = run_parallel(slps+bmcs,20)
-## run_command('bmc2 -v -T 20')
-## if is_sat(): #got a shortening of cex
- if not res == Undecided:
- Nb = cex_frame() #size of shortcut
- abc('cexmerge -F %d -G %d'%(F,G))
- abc('r %s_cex.aig'%f_name)
- abc('cexload')
- abc('testcex -a')
- if cex_po() <0:
- return 'ERROR2'
- Nt=cex_frame() #current cex length
- print 'Cex length reduced from %d to %d'%(N,Nt)
- return
- F = F + (G-F)/2
-## G = N - i*delta
- if F >= G:
- return
-
-def cex_trim(factor=1):
- t_begin = time.time()
- abc('w %s_cex.aig'%f_name)
- N=cex_frame()
- inc = min(N/10,100)
- F = 0
- G = inc
- abc('cexsave')
- abc('cexcut -n -F %d -G %d'%(F,G))
- run_command('bmc2 -v -F %d -T 5'%(.9*inc))
- inc = max(int(factor*n_bmc_frames()),2)
- F = N - inc
- G = N
- print 'inc = %d'%inc
- while True:
- abc('r %s_cex.aig'%f_name)
- abc('cexload')
- abc('cexcut -n -F %d -G %d'%(F,G))
-## abc('drw')
-## ps()
-## run_command('bmc2 -v -F %d -T 20'%(.9*inc))
- run_parallel(slps+bmcs,10)
- if not is_sat():
- abc('cex_load') #leave current cex in buffer
- Nb = inc
- else:
- Nb = cex_frame() #size of shortcut
- abc('cexmerge -F %d -G %d'%(F,G))
- abc('r %s_cex.aig'%f_name)
- abc('cexload')
- abc('testcex -a')
- if cex_po() <0:
- return 'ERROR2'
-## abc('cexload')
- Nt=cex_frame() #current cex length
- print 'Cex length = %d'%Nt
- G=F
- F = max(0,F - inc)
- print 'F = %d, G = %d'%(F,G)
- if G <= 2:
- abc('cexload')
- print 'Time: %0.2f'%(time.time() - t_begin)
- return
-
-
-def read_file():
- global win_list, init_simp, po_map
- read_file_quiet()
-## ps()
-## init_simp = 1
-## win_list = [(0,.1),(1,.1),(2,.1),(3,.1),(4,.1),(5,-1),(6,-1),(7,.1)] #initialize winning engine list
-## po_map = range(n_pos())
-
-def rf():
-## set_engines(4) #temporary
- read_file()
- abc('zero')
-
-def write_file(s):
- """this is the main method for writing the current circuit to an AIG file on disk.
- It manages the name of the file, by giving an extension (s). The file name 'f_name'
- keeps increasing as more extensions are written. A typical sequence is
- name, name_smp, name_smp_abs, name_smp_abs_spec, name_smp_abs_spec_final"""
- global f_name
- """Writes out the current file as an aig file using f_name appended with argument"""
- f_name = '%s_%s'%(f_name,s)
- ss = '%s.aig'%(f_name)
- print 'WRITING %s: '%ss,
- ps()
- abc('w '+ss)
-
-def bmc_depth():
- """ Finds the number of BMC frames that the latest operation has used. The operation could be BMC, reachability
- interpolation, abstract, speculate. max_bmc is continually increased. It reflects the maximum depth of any version of the circuit
- including g ones, for which it is known that there is not cex out to that depth."""
- global max_bmc
- c = cex_frame()
- if c > 0:
- b = c-1
- else:
- b = n_bmc_frames()
- if b > max_bmc:
- max_bmc = b
- report_bmc_depth(max_bmc)
- return max_bmc
-
-def null_status():
- """ resets the status to the default values but note that the &space is changed"""
- abc('&get;&put')
-
-def set_max_bmc(b):
- """ Keeps increasing max_bmc which is the maximum number of time frames for
- which the current circuit is known to be UNSAT for"""
- global max_bmc
- if b > max_bmc:
- max_bmc = b
- report_bmc_depth(max_bmc)
-
-def report_bmc_depth(m):
- print 'u%d'%m
-
-def print_circuit_stats():
- """Stardard way of outputting statistice about the current circuit"""
- global max_bmc
- i = n_pis()
- o = n_pos()
- l = n_latches()
- a = n_ands()
- s='ANDs'
- if a == -1:
- a = n_nodes()
- s = 'Nodes'
-## b = max(max_bmc,bmc_depth()) # don't want to do this because bmc_depth can change max_bmc
- b = max_bmc
- c = cex_frame()
- if b>= 0:
- if c>=0:
- print 'PIs=%d,POs=%d,FF=%d,%s=%d,max depth=%d,CEX depth=%d'%(i,o,l,s,a,b,c)
- elif is_unsat():
- print 'PIs=%d,POs=%d,FF=%d,%s=%d,max depth = infinity'%(i,o,l,s,a)
- else:
- print 'PIs=%d,POs=%d,FF=%d,%s=%d,max depth=%d'%(i,o,l,s,a,b)
- else:
- if c>=0:
- print 'PIs=%d,POs=%d,FF=%d,%s=%d,CEX depth=%d'%(i,o,l,s,a,c)
- else:
- print 'PIs=%d,POs=%d,FF=%d,%s=%d'%(i,o,l,s,a)
-
-def is_unsat():
- if prob_status() == 1:
- return True
- else:
- return False
-
-def is_sat():
- if prob_status() == 0:
- return True
- else:
- return False
-
-def wc(file):
- """writes <file> so that costraints are preserved explicitly"""
- abc('&get;&w %s'%file)
-
-def rc(file):
- """reads <file> so that if constraints are explicit, it will preserve them"""
- abc('&r -s %s;&put'%file)
-
-#more complex functions: ________________________________________________________
-#, abstract, pba, speculate, final_verify, dprove3
-
-def timer(s):
- btime = time.clock()
- abc(s)
- print 'time = %0.2f'%(time.clock() - btime)
-
-def med_simp():
- x = time.time()
- abc("&get;&scl;&dc2;&lcorr;&dc2;&scorr;&fraig;&dc2;&put;dretime")
- #abc("dc2rs")
- ps()
- print 'time = %0.2f'%(time.time() - x)
-
-def simplify_old(M=0):
- """Our standard simplification of logic routine. What it does depende on the problem size.
- For large problems, we use the &methods which use a simple circuit based SAT solver. Also problem
- size dictates the level of k-step induction done in 'scorr' The stongest simplification is done if
- n_ands < 20000. Then it used the clause based solver and k-step induction where |k| depends
- on the problem size """
- set_globals()
- abc('&get;&scl;&lcorr;&put')
- p_40 = False
- n =n_ands()
- if n >= 70000 and not '_smp' in f_name:
-## abc('&get;&scorr -C 0;&put')
- scorr_T(30)
- ps()
- n =n_ands()
- if n >= 100000:
- abc('&get;&scorr -k;&put')
- ps()
- if (70000 < n and n < 150000):
-## print '1'
- p_40 = True
- abc("&get;&dc2;&put;dretime;&get;&lcorr;&dc2;&put;dretime;&get;&scorr;&fraig;&dc2;&put;dretime")
-## print 2'
- ps()
- n = n_ands()
-## if n<60000:
- if n < 80000:
- abc("&get;&scorr -F 2;&put;dc2rs")
- ps()
- else: # n between 60K and 100K
- abc("dc2rs")
- ps()
- n = n_ands()
-## if (30000 < n and n <= 40000):
- if (60000 < n and n <= 70000):
- if not p_40:
- abc("&get;&dc2;&put;dretime;&get;&lcorr;&dc2;&put;dretime;&get;&scorr;&fraig;&dc2;&put;dretime")
- abc("&get;&scorr -F 2;&put;dc2rs")
- ps()
- else:
- abc("dc2rs")
- ps()
- n = n_ands()
-## if n <= 60000:
- if n <= 70000:
- abc('scl -m;drw;dretime;lcorr;drw;dretime')
- ps()
- nn = max(1,n)
- m = int(min( 70000/nn, 16))
- if M > 0:
- m = M
- if m >= 1:
- j = 1
- while j <= m:
- set_size()
- if j<8:
- abc('dc2')
- else:
- abc('dc2rs')
- abc('scorr -C 1000 -F %d'%j) #was 5000 temporarily 1000
- if check_size():
- break
- j = 2*j
- print 'ANDs=%d,'%n_ands(),
- if n_ands() >= .98 * nands:
- break
- continue
- if not check_size():
- print '\n'
- return get_status()
-
-def simplify(M=0,N=0):
- """Our standard simplification of logic routine. What it does depende on the problem size.
- For large problems, we use the &methods which use a simple circuit based SAT solver. Also problem
- size dictates the level of k-step induction done in 'scorr' The stongest simplification is done if
- n_ands < 20000. Then it used the clause based solver and k-step induction where |k| depends
- on the problem size
- Does not change #PIs.
- """
- global smp_trace
- set_globals()
- smp_trace = smp_trace + ['&scl;&lcorr']
- abc('&get;&scl;&lcorr;&put')
- p_40 = False
- n =n_ands()
- if N == 0 and n >= 70000 and not '_smp' in f_name:
-## abc('&get;&scorr -C 0;&put')
-## print 'Trying scorr_T'
- scorr_T(30)
- ps()
- n =n_ands()
- if n >= 100000:
- smp_trace = smp_trace + ['&scorr']
- abc('&get;&scorr -k;&put')
- ps()
- if (70000 < n and n < 150000):
- p_40 = True
- smp_trace = smp_trace + ['&dc2;dretime;&lcorr;&dc2;dretime;&scorr;&fraig;&dc2;dretime']
- abc("&get;&dc2;&put;dretime;&get;&lcorr;&dc2;&put;dretime;&get;&scorr;&fraig;&dc2;&put;dretime")
- ps()
- n = n_ands()
-## if (30000 < n and n <= 40000):
- if (60000 < n and n <= 70000):
- if not p_40:
- smp_trace = smp_trace + ['&dc2;dretime;&lcorr;&dc2;dretime;&scorr;&fraig;&dc2;dretime']
- abc("&get;&dc2;&put;dretime;&get;&lcorr;&dc2;&put;dretime;&get;&scorr;&fraig;&dc2;&put;dretime")
- smp_trace = smp_trace + ['&scorr -F 2;dc2rs']
- abc("&get;&scorr -F 2;&put;dc2rs")
- ps()
- else:
- abc("dc2rs")
- smp_trace = smp_trace + ['dc2rs']
- ps()
- n = n_ands()
-## if n <= 60000:
- if n <= 70000:
- smp_trace = smp_trace + ['scl -m;drw;dretime;lcorr;drw;dretime']
- abc('scl -m;drw;dretime;lcorr;drw;dretime')
- ps()
- nn = max(1,n)
- m = int(min( 70000/nn, 16))
- if M > 0:
- m = M
- if N == 0 and m >= 1:
- j = 1
- while j <= m:
- set_size()
- if j<8:
- abc('dc2')
- else:
- abc('dc2rs')
- smp_trace = smp_trace + ['scorr -F %d'%j]
- abc('scorr -C 1000 -F %d'%j) #was 5000 temporarily 1000
- if check_size():
- break
- j = 2*j
- print 'ANDs=%d,'%n_ands(),
- if n_ands() >= .98 * nands:
- break
- continue
- if not check_size():
- print '\n'
- return get_status()
-
-def simulate2(t=900):
- """Does rarity simulation. Simulation is restricted by the amount
- of memory it might use. At first wide but shallow simulation is done, followed by
- successively more narrow but deeper simulation.
- seed is globally initiallized to 113 when a new design is read in"""
- global x_factor, f_name, tme, seed
- btime = time.clock()
- tt = time.time()
- diff = 0
- while True:
- f = 20
- w = 64
- b = 16
- r = 700
- for k in range(9): #this controls how deep we go
- f = min(f*2, 3500)
- w = max(((w+1)/2)-1,1)
- abc('sim3 -F %d -W %d -N %d -R %d -B %d'%(f,w,seed,r,b))
- seed = seed+23
- if is_sat():
-## print 'RareSim time = %0.2f at frame %d'%((time.time() - tt),cex_frame())
- return 'SAT'
- if ((time.clock()-btime) > t):
- return 'UNDECIDED'
-
-def simulate(t=900):
- abc('&get')
- result = eq_simulate(t)
- return result
-
-def eq_simulate(t):
- """Simulation is restricted by the amount
- of memory it might use. At first wide but shallow simulation is done, followed by
- successively more narrow but deeper simulation. The aig to be simulated must be in the & space
- If there are equivalences, it will refine them. Otherwise it is a normal similation
- seed is globally initiallized to 113 when a new design is read in"""
- global x_factor, f_name, tme, seed
- btime = time.clock()
- diff = 0
- while True:
- f = 5
- w = 255
- for k in range(9):
- f = min(f *2, 3500)
- r = f/20
- w = max(((w+1)/2)-1,1)
-## abc('&sim3 -R %d -W %d -N %d'%(r,w,seed))
- abc('&sim -F %d -W %d -N %d'%(f,w,seed))
- seed = seed+23
- if is_sat():
- return 'SAT'
- if ((time.clock()-btime) > t):
- return 'UNDECIDED'
-
-def generate_abs(n):
- """generates an abstracted model (gabs) from the greg file or gla. The gabs file is automatically
- generated in the & space by &abs_derive or gla_derive. We store it away using the f_name of the problem
- being solved at the moment. The f_name keeps changing with an extension given by the latest
- operation done - e.g. smp, abs, spec, final, group. """
- global f_name
- #we have a cex and we use this generate a new gabs (gla) file
- if gabs: #use the register refinement method
- abc('&r -s %s_greg.aig; &abs_derive; &put; w %s_gabs.aig'%(f_name,f_name)) # do we still need the gabs file
- else: #use the gate refinement method
- run_command('&r -s %s_gla.aig; &gla_derive; &put'%f_name)
- if n_ands() < 2000:
- run_command('scl;scorr;dretime')
- run_command('w %s_gabs.aig'%f_name)
- if n == 1:
- #print 'New abstraction: ',
- ps()
- return
-
-def refine_with_cex():
- """Refines the greg or gla file (which contains the original problem with the set of FF's or gates
- that have been abstracted).
- This uses the current cex to modify the greg or gla file to reflect which regs(gates) are in the
- new current abstraction"""
- global f_name
- if gabs:
- abc('&r -s %s_greg.aig;&w %s_greg_before.aig'%(f_name,f_name))
- run_command('&abs_refine -s; &w %s_greg.aig'%f_name)
- else:
- run_command('&r -s %s_gla.aig;&w %s_gla_before.aig'%(f_name,f_name))
- run_command('&gla_refine; &w %s_gla.aig'%f_name)
- return
-
-def refine_with_cex_suffix():
- """Refines the greg or gla file (which contains the original problem with the set of FF's or gates
- that have been abstracted).
- This uses the current cex to modify the greg or gla file to reflect which regs(gates) are in the
- new current abstraction"""
- global f_name
- return Undecided_no_reduction
- t = 5
- cexf = cex_frame()
- suf = .9*cexf
- run_command('write_status %s_temp.status'%f_name)
- ub = int(cexf -min(10, .02*cexf))
- lb = int(min(10,.02*cexf))
- suf = int(.5*(ub-lb))
- if_last = 0
- N = 0
- while True:
- N = N+1
- tt = time.time()
- run_command('read_status %s_temp.status'%f_name)
- print 'Refining using suffix %d with time = %d'%(suf,t)
- run_command('&r -s %s_gla.aig;&w %s_gla_before.aig'%(f_name,f_name))
- F = create_funcs([18],t) #create a timer function with timeout = t
- F = F + [eval('(pyabc_split.defer(abc)("&gla_refine -F %d; &w %s_gla.aig"))'%(suf,f_name))]
- for i,res in pyabc_split.abc_split_all(F): #need to do a binary search
- if i == 0: #timeout
- lb = int(suf)
- dec = 'increasing'
- break
- elif same_abs(): #suffix did not refine - need to decrease suf
- ub = int(suf)
- dec = 'decreasing'
- break
- else: #refinement happened
- print 'refinement happened.'
- return
- print 'ub = %.2f, lb = %.2f, suf = %.2f'%(ub,lb,suf)
- suf = int(lb+.5*(ub-lb))
- if (ub-lb)< (max(1.1,min(10,.02*cexf))) or if_last or N >=4: # not refining in time allowed, give up
- print '(ub-lb) = %0.2f'%(ub-lb)
- print 'could not refine in resources allowed'
- return Undecided_no_reduction
-
-def same_abs():
- run_command('r %s_gabs.aig'%f_name)
- set_size()
-## ps()
- run_command('&r -s %s_gla.aig; &gla_derive; &put'%f_name)
- if n_ands() < 2000:
- run_command('scl;scorr;dretime')
-## ps()
- return check_size()
-
-def abstraction_refinement(latches_before,NBF,ratio=.75):
- """Subroutine of 'abstract' which does the refinement of the abstracted model,
- using counterexamples found by BMC, BDD reachability, etc"""
- global x_factor, f_name, last_verify_time, x, win_list, last_winner, last_cex, t_init, j_last, sweep_time
- global cex_list, last_cx, abs_ref_time
- sweep_time = 2
- T1 = time.time()
- if NBF == -1:
- F = 2000
- else:
- F = 2*NBF
- print '\nIterating abstraction refinement'
- add_trace('abstraction refinement')
- J = slps+intrps+pdrs+bmcs+sims
- J=modify_methods(J)
- print sublist(methods,J)
- last_verify_time = t = x_factor*max(50,max(1,2.5*G_T))
-## t = 1000 #temporary
- t = abs_time
- initial_verify_time = last_verify_time = t
- reg_verify = True
- print 'Verify time set to %d'%last_verify_time
- while True: #cex based refinement
- generate_abs(1) #generate new gabs file from refined greg or gla file
- set_globals()
- latches_after = n_latches()
- if small_abs(ratio):
- print 'abstraction too large'
- return Undecided_no_reduction
- if (time.time() - T1)> abs_ref_time:
- print 'abstraction time ran out'
- break
- t = last_verify_time
- yy = time.time()
- abc('w %s_beforerpm.aig'%f_name)
- rep_change = reparam() #new - must do reconcile after to make cex compatible
-## if rep_change:
-## add_trace('reparam')
- abc('w %s_afterrpm.aig'%f_name)
-## if reg_verify:
- status = verify(J,t)
- print 'status = ',
- print status
-## else:
-## status = pord_1_2(t)
-###############
- if status[0] == Sat_true:
- print 'Found true cex'
- reconcile_a(rep_change)
-## add_trace('SAT by %s'%status[1])
- return Sat_true
- if status[0] == Unsat:
-## add_trace('UNSAT by %s'%status[1])
- return Unsat
- if status[0] == Sat:
-## add_trace('SAT by %s'%status[1])
- abc('write_status %s_after.status'%f_name)
- reconcile_a(rep_change) # makes the cex compatible with original before reparam and puts original in work space
- abc('write_status %s_before.status'%f_name)
- if gabs: #global variable
- refine_with_cex()
- else:
- result = refine_with_cex_suffix()
- if result == Sat:
- return Sat
-## result = refine_with_cex()
- if result == Undecided_no_reduction:
- return result
- if is_sat(): # if cex can't refine, status is set to Sat_true
- print 'Found true cex in output %d'%cex_po()
- return Sat_true
- else:
- continue
- else:
- break
- print '**** Latches reduced from %d to %d'%(latches_before, n_latches())
- return Undecided_reduction
-
-def small_abs(ratio=.75):
- """ tests is the abstraction is too large"""
-## return ((rel_cost_t([pis_before_abs,latches_before_abs, ands_before_abs])> -.1)
-## or (n_latches() >= ratio*latches_before_abs))
- return (n_latches() >= ratio*latches_before_abs)
-
-##def abstract(if_bip=True):
-## global ratio
-## if if_bip:
-## return abstractb(True) #old method using abstraction refinement
-## else:
-## return abstractb(False) #not using bip and reachx
-
-def abstractb():
- """ abstracts using N Een's method 3 - cex/proof based abstraction. The result is further refined using
- simulation, BMC or BDD reachability. abs_ratio is the the limit for accepting an abstraction"""
- global G_C, G_T, latches_before_abs, x_factor, last_verify_time, x, win_list, j_last, sims
- global latches_before_abs, ands_before_abs, pis_before_abs, abs_ratio
- if ifbip < 1:
- print 'using ,abs in old way'
- tt = time.time()
- j_last = 0
- set_globals()
- #win_list = []
- latches_before_abs = n_latches()
- ands_before_abs = n_ands()
- pis_before_abs = n_real_inputs()
- abc('w %s_before_abs.aig'%f_name)
- print 'Start: ',
- ps()
- funcs = [eval('(pyabc_split.defer(initial_abstract)())')]
- # fork off BMC3 and PDRm along with initial abstraction
- t = 10000 #want to run as long as initial abstract takes.
-## J = sims+pdrs+bmcs+intrps
- J = slps+pdrs+bmcs+intrps
- J = modify_methods(J,1)
-## if n_latches() < 80:
-## J = J + [4]
- funcs = create_funcs(J,t) + funcs
- mtds = sublist(methods,J) + ['initial_abstract'] #important that initial_abstract goes last
- m,result = fork_last(funcs,mtds)
- if is_sat():
- print 'Found true counterexample in frame %d'%cex_frame()
- return Sat_true
- if is_unsat():
- return Unsat
-## set_max_bmc(NBF)
- NBF = bmc_depth()
- print 'Abstraction good to %d frames'%max_bmc
- #note when things are done in parallel, the &aig is not restored!!!
- abc('&r -s %s_greg.aig; &w initial_greg.aig; &abs_derive; &put; w initial_gabs.aig; w %s_gabs.aig'%(f_name,f_name))
- set_max_bmc(NBF)
- print 'Initial abstraction: ',
- ps()
- abc('w %s_init_abs.aig'%f_name)
- latches_after = n_latches()
-## if latches_after >= .90*latches_before_abs: #the following should match similar statement
-## if ((rel_cost_t([pis_before_abs, latches_before_abs, ands_before_abs])> -.1) or
-## (latches_after >= .75*latches_before_abs)):
- if small_abs(abs_ratio):
- abc('r %s_before_abs.aig'%f_name)
- print "Too little reduction!"
- print 'Abstract time wasted = %0.2f'%(time.time()-tt)
- return Undecided_no_reduction
- sims_old = sims
- sims=sims[:1] #make it so that rarity sim is not used since it can't find a cex
- result = abstraction_refinement(latches_before_abs, NBF,abs_ratio)
- sims = sims_old
- if result <= Unsat:
- return result
-## if n_latches() >= .90*latches_before_abs:
-## if ((rel_cost_t([pis_before_abs, latches_before_abs, ands_before_abs])> -.1) or (latches_after >= .90*latches_before_abs)):
-## if rel_cost_t([pis_before_abs,latches_before_abs, ands_before_abs])> -.1:
- if small_abs(abs_ratio) or result == Undecided_no_reduction: #r is ratio of final to initial latches in abstraction. If greater then True
- abc('r %s_before_abs.aig'%f_name) #restore original file before abstract.
- print "Too little reduction! ",
- print 'Abstract time wasted = %0.2f'%(time.time()-tt)
- result = Undecided_no_reduction
- return result
- #new
- else:
- write_file('abs') #this is only written if it was not solved and some change happened.
- print 'Abstract time = %0.2f'%(time.time()-tt)
- return result
-
-def initial_abstract_old():
- global G_C, G_T, latches_before_abs, x_factor, last_verify_time, x, win_list
- set_globals()
- time = max(1,.1*G_T)
- abc('&get;,bmc -vt=%f'%time)
- set_max_bmc(bmc_depth())
- c = 2*G_C
- f = max(2*max_bmc,20)
- b = min(max(10,max_bmc),200)
- t = x_factor*max(1,2*G_T)
- s = min(max(3,c/30000),10) # stability between 3 and 10
- cmd = '&get;,abs -bob=%d -stable=%d -timeout=%d -vt=%d -depth=%d'%(b,s,t,t,f)
-## print cmd
- print 'Running initial_abstract with bob=%d,stable=%d,time=%d,depth=%d'%(b,s,t,f)
- abc(cmd)
- abc('&w %s_greg.aig'%f_name)
-## ps()
-
-def initial_abstract(t=100):
- global G_C, G_T, latches_before_abs, x_factor, last_verify_time, x, win_list, max_bmc, ifbip
- set_globals()
- time = max(1,.1*G_T)
- time = min(time,t)
- abc('&get;,bmc -vt=%f'%time)
- set_max_bmc(bmc_depth())
- c = 2*G_C
- f = max(2*max_bmc,20)
- b = min(max(10,max_bmc),200)
- t1 = x_factor*max(1,2*G_T)
- t = max(t1,t)
- s = min(max(3,c/30000),10) # stability between 3 and 10
- cmd = '&get;,abs -bob=%d -stable=%d -timeout=%d -vt=%d -depth=%d'%(b,s,t,t,f)
- if ifbip == 2:
- cmd = '&get;,abs -bob=%d -stable=%d -timeout=%d -vt=%d -depth=%d -dwr=%s_vabs'%(b,s,t,t,f,f_name)
- print 'Using -dwr=%s_vabs'%f_name
-## print cmd
- print 'Running initial_abstract with bob=%d,stable=%d,time=%d,depth=%d'%(b,s,t,f)
- abc(cmd)
- bmc_depth()
-## pba_loop(max_bmc+1)
- abc('&w %s_greg.aig'%f_name)
- return max_bmc
-
-def abs_m():
- set_globals()
- y = time.time()
- nl = n_abs_latches() #initial set of latches
- c = 2*G_C
- t = x_factor*max(1,2*G_T) #total time
- bmd = bmc_depth()
- if bmd < 0:
- abc('bmc3 -T 2') #get initial depth estimate
- bmd = bmc_depth()
- f = bmd
- abc('&get')
- y = time.time()
- cmd = '&abs_cba -v -C %d -T %0.2f -F %d'%(c,.8*t,bmd) #initial absraction
-## print '\n%s'%cmd
- abc(cmd)
- b_old = b = n_bmc_frames()
- f = min(2*bmd,max(bmd,1.6*b))
- print 'cba: latches = %d, depth = %d'%(n_abs_latches(),b)
-## print n_bmc_frames()
- while True:
- if (time.time() - y) > .9*t:
- break
- nal = n_abs_latches()
- cmd = '&abs_cba -v -C %d -T %0.2f -F %d'%(c,.8*t,f) #f is 2*bmd and is the maximum number of frames allowed
-## print '\n%s'%cmd
- abc(cmd)
-## print n_bmc_frames()
- b_old = b
- b = n_bmc_frames()
- nal_old = nal
- nal = n_abs_latches() #nal - nal_old is the number of latches added by cba
- #b - b_old is the additional time frames added by cba
- f = min(2*bmd,max(bmd,1.6*b)) #may be this should just be bmd
- f = max(f,1.5*bmd)
- print 'cba: latches = %d, depth = %d'%(nal,b)
- if ((nal == nal_old) and (b >= 1.5*b_old) and b >= 1.5*bmd):
- """
- Went at least bmd depth and saw too many frames without a cex
- (ideally should know how many frames without a cex)
- """
- print 'Too many frames without cex'
- break
- if b > b_old: #if increased depth
- continue
- if nal > .9*nl: # try to minimize latches
-## cmd = '&abs_pba -v -S %d -F %d -T %0.2f'%(b,b+2,.2*t)
- cmd = '&abs_pba -v -F %d -T %0.2f'%(b+2,.2*t)
-## print '\n%s'%cmd
- abc(cmd)
- b = n_bmc_frames()
- nal_old = nal
- nal = n_abs_latches()
- print 'pba: latches = %d, depth = %d'%(nal,b)
-## print n_bmc_frames()
- if nal_old < nal: #if latches increased there was a cex
- continue
- if nal > .9*nl: # if still too big
- return
- continue
-## b = n_bmc_frames()
- cmd = '&abs_pba -v -F %d -T %0.2f'%(b+2,.2*t)
-## print '\n%s'%cmd
- abc(cmd)
- b = n_bmc_frames()
- print 'pba: latches = %d, depth = %d'%(n_abs_latches(),b)
-## print n_bmc_frames()
- print 'Total time = %0.2f'%(time.time()-y)
-
-def n_abs_latches():
- abc('&w pba_temp.aig') #save the &space
- abc('&abs_derive;&put')
- abc('&r -s pba_temp.aig')
- return n_latches()
-
-def pba_loop(F):
- n = n_abs_latches()
- while True:
- run_command('&abs_pba -v -C 0 -F %d'%F)
- abc('&w pba_temp.aig')
- abc('&abs_derive;&put')
- abc('&r -s pba_temp.aig')
- N = n_latches()
-## if n == N or n == N+1:
-## break
-## elif N > n:
- if N > n:
- print 'cex found'
- break
-
-def ssm(options=''):
- """ Now this should be the same as super_prove(1) """
- y = time.time()
- result = prove_part_1() # simplify first
- if result == 'UNDECIDED':
- result = ss(options)
- print 'Total time taken on file %s by function ssm(%s) = %d sec.'%(initial_f_name,options,(time.time() - y))
- return result
-
-def ssmg():
- return ssm('g')
-def ssmf():
- return ssm('f')
-
-
-def ss(options=''):
- """
- Alias for super_sec
- This is the preferred command if the problem (miter) is suspected to be a SEC problem
- """
- global max_bmc, init_initial_f_name, initial_f_name,win_list, last_verify_time, sec_options
- sec_options = options
- print '\n*************Executing speculate************'
- y = time.time()
- abc('scl')
- result = speculate()
- # if result is 1 then it is a real SAT since we did not do anything before
- if result > 2: #save the result and read in with /rf so that files are initialized correctly
- if not '_spec' in f_name:
- write_file('spec') #make sure we do not overwrite original file
- read_file_quiet_i('%s'%f_name) #this resets f_name and initial_f_name etc.
- print '\n*************Executing super_prove ************'
- print 'New f_name = %s'%f_name
- result = sp()
- if result[0] == 'SAT':
- result = 'UNDECIDED' #because speculation was done initially.
- elif result[0] == 1:
- result = 'SAT'
- else:
- result = RESULT[result]
- print 'Total time taken on file %s by function ss(%s) = %d sec.'%(initial_f_name,options,(time.time() - y))
- return result
-
-def quick_sec(t):
-## fb_name = f_name[:-3]+'New'
-## abc('&get;&miter -s %s.aig;&put'%fb_name)
-## abc('w %s.%s_miter.aig'%(f_name,fb_name))
- quick_simp()
- verify(slps+ pdrs+bmcs+intrps,t)
- if is_unsat():
- return 'UNSAT'
- if is_sat():
- return 'SAT'
- else:
- return'UNDECIDED'
-
-def pre_sec():
- """ put files to be compared into Old and New aigs. Simplify, but
- turn off reparameterization so that PIs in Old and New match after simplification.
- """
- global trim_allowed
-## trim_allowed = False
-## print 'trim allowed = ',trim_allowed
- print 'First file: ',
- read_file_quiet_i() #note - reads into & space and then does &put
- ps()
- prs(False)
- ps()
- abc('&w Old.aig')
- print 'Second file: ',
- read_file_quiet_i()
- ps()
- prs(False)
- ps()
- abc('&w New.aig')
-
-def cec():
- print 'Type in the name of the aig file to be compared against'
- s = raw_input()
- s = remove_spaces(s)
- if not 'aig' in s:
- s = s+'.aig'
- run_command("&get;&cec -v %s"%s)
-
-def sec(B_part,options):
- """
- Use this for AB filtering and not sup_sec
- Use pp_sec to make easy names for A and B, namely Old and New.
- This assumes that the original aig (renamed A_name below) is already read into the working space.
- Then we form a miter using &miter between two circuits, A_name, and B_name.
- We then do speculate immediately. Optionally we could simplify A and B
- and then form the miter and start from there. The only difference in speculate
- is that &srm2 is used, which only looks at equivalences where one comes from A and
- one from B. Options are -a and -b which says use only flops in A or in B or both. The
- switch sec_sw controls what speculate does when it generates the SRM.
- """
- global f_name,sec_sw, A_name, B_name, sec_options
- yy = time.time()
- A_name = f_name # Just makes it so that we can refer to A_name later in &srm2
- B_name = B_part
- run_command('&get; &miter -s %s.aig; &put'%B_name)
-## abc('orpos')
- f_name = A_name+'_'+B_name+'_miter' # reflect that we are working on a miter.
- abc('w %s.aig'%f_name)
- print 'Miter = ',
- ps()
- sec_options = options
- if sec_options == 'ab':
- sec_options = 'l' #it will be changed to 'ab' after &equiv
- sec_sw = True
- result = speculate()
- sec_options = ''
- sec_sw = False
- if result <= Unsat:
- result = RESULT[result]
- else:
- result = sp()
- if result[0] == 'SAT':
- result = 'UNDECIDED'
- print 'Total time = %d'%(time.time() - yy)
- return result
-
-def filter(opts):
- global A_name,B_name
-## print 'Filtering with options = %s'%opts
- """ This is for filter which effectively only recognizes options -f -g"""
- if (opts == '' or opts == 'l'): #if 'l' this is used only for initial &equiv2 to get initial equiv creation
- return
- print 'filter = %s '%opts,
- if opts == 'ab':
- print A_name ,
- print B_name
-## run_command('&ps')
- run_command('&filter -f %s.aig %s.aig'%(A_name,B_name))
- return
-#### if not opts == 'f':
-#### opts = 'g'
-## print 'filter = %
- run_command('&filter -%s'%opts)
-
-def check_if_spec_first():
- global sec_sw, A_name, B_name, sec_options, po_map
- set_globals()
- t = max(1,.5*G_T)
- r = max(1,int(t))
- abc('w check_save.aig')
- abc('&w check_and.aig')
- abc("&get; &equiv3 -v -F 20 -T %f -R %d"%(t,5*r))
- filter('g')
- abc("&srm -A %s_gsrm.aig; r %s_gsrm.aig"%(f_name,f_name))
- print 'Estimated # POs = %d for initial speculation'%n_pos()
- result = n_pos() > max(50,.25*n_latches())
- abc('r check_save.aig')
- abc('&r -s check_and.aig')
- return result
-
-def initial_speculate(sec_opt=''):
- global sec_sw, A_name, B_name, sec_options, po_map
- set_globals()
- if sec_options == '':
- sec_options = sec_opt
- # 1000 - 15, 5000 - 25, 10000 - 30, 50000 - 50
- na = n_ands()
-## t = max(1,G_T)
- if na < 1000:
- t =20
- elif na < 5000:
- t = 20 + ((na-1000)/4000)*20
- elif na < 10000:
- t = 40 + ((na-5000)/5000)*20
- elif na < 50000:
- t = 60 + ((na-40000)/40000)*15
- else:
- t = 75
- r = max(1,int(t))
- rounds = 30*r
- print 'Initial sec_options = %s'%sec_options
-## if sec_options == 'l':
-## cmd = "&get; &equiv3 -lv -F 20 -T %f -R %d -S %d"%(3*t,rounds,rounds/20)
-## else:
-## cmd = "&get; &equiv3 -v -F 20 -T %f -R %d -S %d"%(3*t,rounds,rounds/20)
- cmd = "&get; &equiv3 -v -F 20 -T %d -R %d -S %d"%(int(t),0,0) #####XXX
- print cmd
- abc(cmd)
-## print 'AND space after &equiv3: ',
-## run_command('&ps')
- if (sec_options == 'l'):
- if sec_sw:
- sec_options = 'ab'
- else:
- sec_options = 'f'
-## print 'A_name: ',
-## run_command('r %s.aig;ps'%A_name)
-## print 'B_name: ',
-## run_command('r %s.aig;ps'%B_name)
- print 'filtering'
- filter(sec_options)
- abc('&w initial_gore.aig')
-## print 'Running &srm'
- if sec_sw:
- print 'miter: ',
- run_command('&ps')
- print 'A_name: ',
- run_command('r %s.aig;ps'%A_name)
- print 'B_name: ',
- run_command('r %s.aig;ps'%B_name)
- cmd = "&srm2 -%s %s.aig %s.aig; r gsrm.aig; w %s_gsrm.aig; &w %s_gore.aig"%(sec_options,A_name,B_name,f_name,f_name)
- abc(cmd)
- po_map = range(n_pos())
- return sec_options
- else:
-## abc('&r %s_gore.aig; &srm ; r gsrm.aig; w %s_gsrm.aig'%(f_name,f_name))
- cmd = "&srm -A %s_gsrm.aig; r %s_gsrm.aig; &w %s_gore.aig"%(f_name,f_name,f_name)
- print 'Running %s'%cmd
- abc(cmd)
- print 'done with &srm'
- po_map = range(n_pos())
- if sec_options == '' or sec_options == 'g':
-## if n_pos() > 10000:###temp
- if n_eff_pos() > 1000: ##### Temporary
- sec_options = 'g'
- print 'sec_options set to %s'%'g'
- abc('&r -s %s_gore.aig'%f_name)
- filter(sec_options)
-## print 'Running &srm'
- cmd = "&srm -A %s_gsrm.aig; r %s_gsrm.aig; &w %s_gore.aig"%(f_name,f_name,f_name)
-## print 'Running %s'%cmd
- abc(cmd)
- po_map = range(n_pos())
- if n_eff_pos() > 500:
-## if n_pos() > 20000:####temp
- sec_options = 'f'
- print 'sec_options set to %s'%'f'
- abc('&r -s %s_gore.aig'%f_name)
- filter(sec_options)
- print 'Running &srm'
- cmd = "&srm -A %s_gsrm.aig; r %s_gsrm.aig; &w %s_gore.aig"%(f_name,f_name,f_name)
- print 'Running %s'%cmd
- abc(cmd)
- po_map = range(n_pos())
- return sec_options
-
-## if n_pos() > 2000:
-## return sec_options
-
-
-def test_against_original():
- '''tests whether we have a cex hitting an original PO'''
- abc('&w %s_save.aig'%f_name) #we preserve whatever was in the & space
- abc('&r -s %s_gore.aig'%f_name) #This is the original
- abc('testcex') #test the cex against the &space
- PO = cex_po()
-## print 'test_against original gives PO = %d'%PO
- abc('&r -s %s_save.aig'%f_name)
- if PO > -1:
-## print 'cex fails an original PO'
- return True
- else:
- abc('write_status %s_status.status'%f_name)
- return False
-
-def set_cex_po(n=0):
- """
- if cex falsifies a non-real PO return that PO first,
- else see if cex_po is one of the original, then take it next
- else return -1 which means that the cex is not valid and hence an error.
- parameter n = 1 means test the &-space
- """
- global n_pos_before, n_pos_proved #these refer to real POs
- if n == 0:
- abc('testcex -a -O %d'%(n_pos_before-n_pos_proved)) #test regular AIG space
- else:
- abc('testcex -O %d'%(n_pos_before-n_pos_proved)) #test the &-AIG
- PO = cex_po()
-## print 'cex_po = %d, n_pos_before = %d, n_pos_proved = %d'%(PO, n_pos_before, n_pos_proved)
- if PO >= (n_pos_before - n_pos_proved): #cex_po is not an original
-## print '1. cex PO = %d'%PO
- return PO # after original so take it.
- if n == 0:
- abc('testcex -a') #test regular
- else:
- abc('testcex') #test &space
- PO = cex_po()
- print '2. cex PO = %d'%PO
- cx = cex_get()
- if PO > -1:
- if test_against_original(): #this double checks that it is really an original PO
- cex_put(cx)
- print 'test_against_original was valid'
- return PO
- else:
- print '1. PO is not valid'
- return -1 #error
- if PO < 0 or PO >= (n_pos_before - n_pos_proved): # not a valid cex because already tested outside original.
-## print 'cex_po = %d, n_pos_before = %d, n_pos_proved = %d'%(PO, n_pos_before, n_pos_proved)
- print '2. PO is not valid'
- PO = -1 #error
-## print '3. cex PO = %d'%PO
- return PO
-
-def cex_stats():
- print 'cex_pis = %d, cex_regs = %d, cex_po = %d, cex_frame = %d'%(n_cex_pis(),n_cex_regs(),cex_po(),cex_frame())
-
-def speculate(t=0):
- """Main speculative reduction routine. Finds candidate sequential equivalences and refines them by simulation, BMC, or reachability
- using any cex found. """
- global G_C,G_T,n_pos_before, x_factor, n_latches_before, last_verify_time, trim_allowed, n_pos_before
- global t_init, j_last, sec_sw, A_name, B_name, sec_options, po_map, sweep_time, sims, cex_list, n_pos_proved,ifpord1
- global last_cx, total_spec_refine_time, skip_spec
-## print 'sec_options = %s'%sec_options
- if skip_spec:
- return Undecided_no_reduction
- add_trace('speculate')
- if t > 0:
- total_spec_refine_time = t
- abc('scl') #make sure no dangling flops
- abc('orpos')
- last_cx = 0
- ifpord1 = 1
- initial_po_size = last_srm_po_size = n_pos()
- initial_sizes = [n_pis(),n_pos(),n_latches(),n_ands()]
- if sec_sw:
- print 'A_name = %s, B_name = %s, f_name = %s, sec_options = %s'%(A_name, B_name, f_name, sec_options)
- elif n_ands()> 36000 and sec_options == '':
-## add_trace('sec options g')
- sec_options = 'g'
- print 'sec_options set to "g"'
-## add_trace('sec_options ="g"')
-
- def refine_with_cex():
- """Refines the gore file to reflect equivalences that go away because of cex"""
- global f_name
- abc('write_status %s_before_refine.status'%f_name)
- abc('&r -s %s_gore.aig; &resim -m'%f_name)
-## run_command('&ps')
-## cex_stats()
- filter(sec_options)
- run_command('&w %s_gore.aig'%f_name)
- return
-
- def refine_without_cex(L=[]):
- """removes the POs in the current SRM in the list L. Alters the equivalence classes in the
- gore file accordingly.
- """
- global f_name
- if L == []:
- return
- print 'Entered refine_without_cex'
- abc('write_status %s_before_refine.status'%f_name)
- create_abc_array(L)
- print 'wrote array'
- abc('&r -s %s_gore.aig; &equiv_filter'%f_name)
- print 'filtered gore using L'
- filter(sec_options)
- print 'filtered with %s'%sec_options
- run_command('&w %s_gore.aig'%f_name)
- return
-
-
- def set_cex(lst):
- """ assumes only one in lst """
- for j in range(len(lst)):
- cx = lst[j]
- if cx == None:
- continue
- else:
- cex_put(cx)
- break
- def retry(t):
- add_trace('retrying')
- print 'retrying winner cex which did not refine'
- abc('r %s_gsrm_before.aig'%f_name) #restore previous gsrm
- abc('w %s_beforerpm.aig'%f_name)
- rep_change = reparam() #must be paired with reconcile below if cex
- if rep_change:
- add_trace('reparam')
- abc('w %s_afterrpm.aig'%f_name)
- if last_winner == 'RareSim':
- simulate2(t)
- elif last_winner == 'PDR':
- pdr(t)
- elif last_winner == 'BMC':
- bmc(t)
- elif last_winner == 'INTRP':
- intrp(t)
- elif last_winner == 'PDRM':
- pdrm(t)
- elif last_winner == 'BMC3':
- bmc3(t)
- elif last_winner == 'PDR_sd':
- pdrseed(t)
- elif last_winner == 'PDRM_sd':
- pdrmm(t)
- elif last_winner == 'INTRPm':
- intrpm(t)
- elif last_winner == 'REACHY':
- reachy(t)
- elif last_winner == 'BMC_J':
- bmc_j(t)
- elif last_winner == 'PDRa':
- pdra(t)
- else:
- reconcile(rep_change)
- return False
- reconcile(rep_change)
- if not is_sat():
- return False
- abc('&r -s %s_gore_before.aig ;&w %s_gore.aig'%(f_name,f_name)) #restore old gore file
- return True
-
- def generate_srm():
- """generates a speculated reduced model (srm) from the gore file"""
- global f_name, po_map, sec_sw, A_name, B_name, sec_options, n_pos_proved
-## print 'Generating'
- pos = n_pos()
- ab = n_ands()
- abc('w %s_oldsrm.aig'%f_name) #save for later purposes
- if sec_sw:
- run_command('&r -s %s_gore.aig; &srm2 -%s %s.aig %s.aig; r gsrm.aig; w %s_gsrm.aig'%(f_name,sec_options,A_name,B_name,f_name))
- else:
- abc('&r -s %s_gore.aig; &srm -A %s_gsrm.aig ; r %s_gsrm.aig'%(f_name,f_name,f_name)) #do we still need to write the gsrm file
-## ps()
- po_map = range(n_pos())
- ps()
- n_pos_proved = 0
- return 'OK'
-
- n_pos_before = n_pos()
- n_pos_proved = 0
- n_latches_before = n_latches()
- set_globals()
-## t = max(1,.5*G_T)#irrelevant
-## r = max(1,int(t))
- t = 1000
- j_last = 0
- J = slps+sims+pdrs+bmcs+intrps
- J = modify_methods(J,1)
- print 'sec_options = %s'%sec_options
- funcs = [eval('(pyabc_split.defer(initial_speculate)("%s"))'%sec_options)]
- funcs = create_funcs(J,10000)+funcs #want other functins to run until initial speculate stops
- mtds = sublist(methods,J) + ['initial_speculate'] #important that initial_speculate goes last
- print mtds
- res = fork_last(funcs,mtds)
- print 'init_spec return = ',
- print res
- if res[1] in ['f','g','']:
- sec_options = res[1]
- add_trace('sec_options = %s'%sec_options)
- add_trace('Number of POs: %d'%n_pos())
-## ps()
- if is_unsat():
- return Unsat
- if is_sat():
- return Sat_true
- if n_pos_before == n_pos():
- print 'No new outputs. Quitting speculate'
- add_trace('de_speculate')
- return Undecided_no_reduction # return result is unknown
- if n_eff_pos() > 1999000:
- print 'Too many POs'
- add_trace('de_speculate')
- return Undecided_no_reduction
- print 'Initial speculation: ',
- ps()
- abc('w %s_initial_gsrm.aig'%f_name)
- if n_pos() > 1000:
- print 'Too many new outputs. Quitting speculate'
- add_trace('de_speculate')
- return Undecided_no_reduction # return result is unknown
- if n_pos() <= n_pos_before + 2:
- print 'Too few new outputs. Quitting speculate'
- add_trace('de_speculate')
- return Undecided_no_reduction # return result is unknown
- if n_latches() == 0:
- return check_sat()
- if use_pms:
- p,q,r=par_multi_sat(0)
- q = indices(r,1)
- print sumsize(r)
- if count_less(r,1) < .25*len(r):
- print 'too many POs are already SAT'
- add_trace('de_speculate')
- return Undecided_no_reduction
- if sec_options == 'l' and sec_sw:
- sec_options = 'ab' #finished with initial speculate with the 'l' option
- print "sec_options set to 'ab'"
- elif sec_options == 'l':
- sec_options = 'f'
- print "sec_options set to 'f'"
- po_map = range(n_pos()) #we need this because the initial_speculate is done in parallel and po_map is not passed back.
- npi = n_pis()
- set_globals()
- if is_sat():
- return Sat_true
- simp_sw = init = True
- add_trace('speculative refinement')
- print '\nIterating speculation refinement'
- sims_old = sims
- sims = sims[:1]
- J = slps+sims+pdrs+intrps+bmcs
- J = modify_methods(J)
-## print sublist(methods,J)
- t = max(50,max(1,2*G_T))
- last_verify_time = t
- ### temp
- last_verify_time = total_spec_refine_time
- ###
- print 'Verify time set to %d'%last_verify_time
- reg_verify = True
- ref_time = time.time()
- sweep_time = 2
- ifpord1=1
- par_verify = re_try = False
-## total_spec_refine_time = 150
- while True: ##################### refinement loop
- set_globals()
- yy = time.time()
- time_used = (yy-ref_time)
- print 'Time_used = %0.2f'%time_used
- if time_used > total_spec_refine_time:
- print 'Allotted speculation refinement time is exceeded'
- add_trace('de_speculate')
- return Undecided_no_reduction
- if not init:
- abc('r %s_gsrm.aig'%f_name) #this is done only to set the size of the previous gsrm.
- abc('w %s_gsrm_before.aig'%f_name)
- set_size()
- result = generate_srm()
- if n_pos() <= n_pos_before + 1: #heuristic that if only have one equivalence, then not worth it
- abc('r %s.aig'%f_name) #revert to previous aig
- sims = sims_old
- print 'UNDECIDED'
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- add_trace('de_speculate')
- return Undecided_no_reduction
- last_srm_po_size = n_pos()
- yy = time.time()
- # if the size of the gsrm did not change after generating a new gsrm
- # and if the cex is valid for the gsrm, then the only way this can happen is if
- # the cex_po is an original one.
- if check_size(): #same size before and after
- if check_cex(): #valid cex failed to refine possibly
- if 0 <= cex_po() and cex_po() < (n_pos_before - n_pos_proved): #original PO
- print 'Found cex in original output number = %d'%cex_po()
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Sat_true
- elif check_same_gsrm(f_name): #if two gsrms are same, then failed to refine
- print 'CEX failed to refine'
- add_trace('de_speculate')
- return Error
- else:
- print 'not a valid cex'
- print 'Last winner = %s'%last_winner
- print 're_try = %d'%re_try
- if re_try:
- add_trace('de_speculate')
- return Error #abort speculation
- re_try = True
- else:
- re_try = False # just got a valid refinement so reset.
- if n_latches() == 0:
- print 'Number of latches reduced to 0'
- print 'CEX refined incorrectly'
- abc('r %s.aig'%f_name) #revert to previous aig
- sims = sims_old
- add_trace('de_speculate')
- return Error
- init = False # make it so that next time it is not the first time through
- if not t == last_verify_time: # heuristic that if increased last verify time,
- # then try pord_all
- t = last_verify_time
- if reg_verify:
- t_init = (time.time() - yy)/2 #start poor man's concurrency at last cex fime found
- t_init = min(10,t_init)
- t = last_verify_time
- print 'Verify time set to %d'%t
- if not re_try:
-## abc('w %s_beforerpm.aig'%f_name)
-## rep_change = reparam() #must be paired with reconcile below if cex
-#### if rep_change:
-#### add_trace('reparam')
-## abc('w %s_afterrpm.aig'%f_name)
- rep_change = False #TEMP
- if reg_verify:
- if par_verify:
- S,L_sat_POs,s = par_multi_sat(120)
- L_sat_POs = indices(s,1)
-## L_sat_POs = L[1]
- L=[]
- for j in range(len(L_sat_POs)): #eliminate any of the original POs
- if L_sat_POs[j] >= (n_pos_before-n_pos_proved):
- L=L+[L_sat_POs[j]]
- L_sat_POs = L
- print L
- if not L_sat_POs == []:
- ress = [1,[['multi_sat']]]
- add_trace(['multi_sat'])
- else:
- reg_verify = False
- ress = pord_1_2(t)
- add_trace(ress[1])
- else:
- ttt = time.time() #find time it takes to find a cex
- ress = verify(J,t)
- t_last_verify = time.time() - ttt
- else:
- ress = pord_1_2(t)
-## print ress
- add_trace(ress[1])
- result = ress[0]
-## add_trace(ress[1])
- else:
- if not retry(100):
- add_trace('de_speculate')
- return Error
- result = get_status()
-## print result
- if result == Unsat:
- add_trace('UNSAT by %s'%ress[1])
- print 'UNSAT'
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Unsat
- if result < Unsat:
- abc('&r -s %s_gore.aig;&w %s_gore_before.aig'%(f_name,f_name)) #we are making sure that none of the original POs fail
- if par_verify:
- refine_without_cex(L_sat_POs)
- print 'refining without cex done'
- continue
- if not reg_verify:
- set_cex(cex_list)
-## if not re_try:
-#### rec = reconcile(rep_change) #end of pairing with reparam()TEMP
-#### if rec == 'error':
-#### add_trace('de_speculate')
-#### return Error
-## assert (npi == n_cex_pis()),'ERROR: #pi = %d, #cex_pi = %d'%(npi,n_cex_pis())
- abc('&r -s %s_gore.aig;&w %s_gore_before.aig'%(f_name,f_name)) #we are making sure that none of the original POs fail
- if reg_verify:
- PO = set_cex_po(0) #testing the regular space
- else:
- abc('&r -s %s_gsrm.aig'%f_name)
- PO = set_cex_po(1) # test against the &space.
- print 'cex_PO is %d, '%PO,
- if (-1 < PO and PO < (n_pos_before-n_pos_proved)):
- print 'Found cex in original output = %d'%cex_po()
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Sat_true
- if PO == -1:
- add_trace('de_speculate')
- return Error
- refine_with_cex() #change the number of equivalences
- if not par_verify and t_last_verify > 2500:
- par_verify = True #switch to finding many POs at a time
- continue
- elif (is_unsat() or n_pos() == 0):
- print 'UNSAT'
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Unsat
- else: #if undecided, record last verification time
- print 'Refinement returned undecided in %d sec.'%t
- last_verify_time = t
- #########################added
- if reg_verify: #try one last time with parallel POs cex detection (find_cex_par) if not already tried
- abc('r %s_beforerpm.aig'%f_name) # to continue refinement, need to restore original
- t_init = min(last_verify_time,(time.time() - yy)/2) #start poor man's concurrency at last cex fime found
- t_init = min(10,t_init)
- reg_verify = False
- t = last_verify_time # = 2*last_verify_time
- abc('w %s_beforerpm.aig'%f_name)
- rep_change = reparam() #must be paired with reconcile()below
- abc('w %s_afterrpm.aig'%f_name)
- ress = pord_1_2(t) #main call to verification
- print ress
- result = ress[0]
- add_trace(ress[1])
- if result == Unsat:
- print 'UNSAT'
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Unsat
- if is_sat() or result == Sat:
-## assert result == get_status(),'result: %d, status: %d'%(result,get_status())
- print 'result: %d, status: %d'%(result,get_status())
- set_cex(cex_list)
- rec = reconcile(rep_change)
- if rec == 'error':
- add_trace('de_speculate')
- return Error
- abc('&r -s %s_gsrm.aig'%f_name)
- PO = set_cex_po(1) #testing the & space
- if (-1 < PO and PO < (n_pos_before-n_pos_proved)):
- print 'Found cex in original output = %d'%cex_po()
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
- return Sat_true
- if PO == -1:
- add_trace('de_speculate')
- return Error
- refine_with_cex() #change the number of equivalences
- continue
- else: #if undecided, record last verification time
- last_verify_time = t
- print 'UNDECIDED'
- break
- ################### added
- else:
- break
- sims = sims_old
- print 'UNDECIDED'
- print 'Refinement time = %0.2f'%(time.time() - ref_time)
-## if last_srm_po_size == initial_po_size: #essentially nothing happened. last_srm_po_size will be # POs in last srm.
- if initial_sizes == [n_pis(),n_pos(),n_latches(),n_ands()]:
- abc('r %s.aig'%f_name)
- add_trace('de_speculate')
- return Undecided_no_reduction #thus do not write spec file
- else: #file was changed, so some speculation happened. If we find a cex later, need to know this.
- write_file('spec')
- return Undecided_reduction
-
-def simple_sat(t=900):
- """
- aimed at trying harder to prove SAT
- """
- y = time.time()
- bmcs2 = [9,31]
- bmcs2 = [9,30]
- J = allbmcs+pdrs+sims+[5]
-## J = modify_methods(J)
-## J = [14,2,7,9,30,31,26,5] #5 is pre_simp
- funcs = create_funcs(J,t)
- mtds =sublist(methods,J)
- print mtds
- fork_last(funcs,mtds)
- result = get_status()
- if result > Unsat:
- write_file('smp')
- result = verify(slps+allbmcs+pdrs+sims,t)
- print 'Time for simple_sat = %0.2f'%(time.time()-y)
- report_bmc_depth(max(max_bmc,n_bmc_frames()))
- return [RESULT[result[0]]] + [result[1]]
-
-def simple(t=10000,no_simp=0):
- y = time.time()
-## pre_simp()
- if not no_simp:
- prove_part_1()
- if is_sat():
- return ['SAT']+['pre_simp']
- if is_unsat():
- return ['UNSAT']+['pre_simp']
- if n_latches() == 0:
- return [RESULT[check_sat()]]+['pre_simp']
-## J = slps+sims+bmcs+pdrs+intrps+pre
- J = slps+sims+allbmcs+allpdrs+intrps
- J = modify_methods(J)
- result = verify(J,t)
-## add_pord('%s by %s'%(result[0],result[1])
- return [RESULT[result[0]]] + [result[1]]
-
-def simple_bip(t=1000):
- y = time.time()
- J = [0,14,1,2,30,5] #5 is pre_simp
- funcs = create_funcs(J,t)
- mtds =sublist(methods,J)
- fork_last(funcs,mtds)
- result = get_status()
- if result > Unsat:
- write_file('smp')
- result = verify(slps+[0,14,1,2,30],t)
- print 'Time for simple_bip = %0.2f'%(time.time()-y)
- return RESULT[result]
-
-def check_same_gsrm(f):
-## return False #disable the temporarily until can figure out why this is there
- """checks gsrm miters before and after refinement and if equal there is an error"""
- global f_name
- abc('r %s_gsrm.aig'%f)
-## ps()
- run_command('miter -c %s_gsrm_before.aig'%f)
-## ps()
- abc('&get; ,bmc -timeout=5')
- result = True #if the same
- if is_sat(): #if different
- result = False
- abc('r %s_gsrm.aig'%f)
-## ps()
- return result
-
-def check_cex():
- """ check if the last cex still asserts one of the outputs.
- If it does then we have an error"""
- global f_name
- abc('read_status %s_before_refine.status'%f_name)
- abc('&r -s %s_gsrm_before.aig'%f_name)
-## abc('&r %s_gsrm.aig'%f_name)
- run_command('testcex') #test the cex against the &-space aig.
-## print 'cex po = %d'%cex_po()
- return cex_po() >=0
-
-def set_size():
- """Stores the problem size of the current design.
- Size is defined as (PIs, POs, ANDS, FF)"""
- global npi, npo, nands, nff, nmd
- npi = n_pis()
- npo = n_pos()
- nands = n_ands()
- nff = n_latches()
- nmd = max_bmc
- #print npi,npo,nands,nff
-
-def check_size():
- """Assumes the problem size has been set by set_size before some operation.
- This checks if the size was changed
- Size is defined as (PIs, POs, ANDS, FF, max_bmc)
- Returns TRUE is size is the same"""
- global npi, npo, nands, nff, nmd
- #print n_pis(),n_pos(),n_ands(),n_latches()
- result = ((npi == n_pis()) and (npo == n_pos()) and (nands == n_ands()) and (nff == n_latches()) )
- return result
-
-def inferior_size():
- """Assumes the problem size has been set by set_size beore some operation.
- This checks if the new size is inferior (larger) to the old one
- Size is defined as (PIs, POs, ANDS, FF)"""
- global npi, npo, nands, nff
- result = ((npi < n_pis()) or (npo < n_pos()) or (nands < n_ands()) )
- return result
-
-##def quick_verify(n):
-## """Low resource version of final_verify n = 1 means to do an initial
-## simplification first. Also more time is allocated if n =1"""
-## global last_verify_time
-## trim()
-## if n == 1:
-## simplify()
-## if n_latches == 0:
-## return check_sat()
-## trim()
-## if is_sat():
-## return Sat_true
-## #print 'After trimming: ',
-## #ps()
-## set_globals()
-## last_verify_time = t = max(1,.4*G_T)
-## if n == 1:
-## last_verify_time = t = max(1,2*G_T)
-## print 'Verify time set to %d '%last_verify_time
-## J = [18] + intrps+bmcs+pdrs+sims
-## status = verify(J,t)
-## return status
-
-def process_status(status):
- """ if there are no FF, the problem is combinational and we still have to check if UNSAT"""
- if n_latches() == 0:
- return check_sat()
- return status
-
-def get_status():
- """this simply translates the problem status encoding done by ABC
- (-1,0,1)=(undecided,SAT,UNSAT) into the status code used by our
- python code. -1,0,1 => 3,0,2
- """
- if n_latches() == 0:
- return check_sat()
- status = prob_status() #interrogates ABC for the current status of the problem.
- # 0 = SAT i.e. Sat_reg = 0 so does not have to be changed.
- if status == 1:
- status = Unsat
- if status == -1: #undecided
- status = Undecided
- return status
-
-def two_temp(t=20):
- tt = time.time()
- abc('tempor;scl;drw;&get;&rpm;&put;tempor;scl;drw;&get;&rpm;&put;scorr')
- print 'Time for two_temp = %.2f'%(time.time()-tt)
- return get_status()
-
-def reparam_m():
- """eliminates PIs which if used in abstraction or speculation must be restored by
- reconcile and the cex made compatible with file beforerpm
- Uses the &-space
- """
- abc('w %s_temp.aig'%f_name)
- n = n_pis()
- t1 = time.time()
-## abc('&get;,reparam -aig=%s_rpm.aig; r %s_rpm.aig'%(f_name,f_name))
- abc('&get;&rpm;&put')
- tm = (time.time() - t1)
- if n_pis() == 0:
- print 'Number of PIs reduced to 0. Added a dummy PI'
- abc('addpi')
- nn = n_pis()
- if nn < n:
- print 'Reparam_m: PIs %d => %d, time = %.2f'%(n,nn,tm)
- rep_change = True
- else:
- abc('r %s_temp.aig'%f_name)
- rep_change = False
- return rep_change
-
-def reparam_e():
- """eliminates PIs which if used in abstraction or speculation must be restored by
- reconcile and the cex made compatible with file beforerpm
- Uses the &-space
- """
- abc('w %s_temp.aig'%f_name)
- n = n_pis()
- t1 = time.time()
- abc('&get;,reparam -aig=%s_rpm.aig; r %s_rpm.aig'%(f_name,f_name))
-## abc('&get;&rpm;&put')
- tm =(time.time() - t1)
- if n_pis() == 0:
- print 'Number of PIs reduced to 0. Added a dummy PI'
- abc('addpi')
- nn = n_pis()
- if nn < n:
- print 'Reparam_e: PIs %d => %d, time = %.2f'%(n,nn,tm)
- rep_change = True
- else:
- abc('r %s_temp.aig'%f_name)
- rep_change = False
- return rep_change
-
-def reparam():
-## abc('w %s_temp.aig'%f_name)
-## res = reparam_e()
-## res = reparam_m()
- res = reparam_e()
- return res
-
-##def try_and_rpm():
-## abc('w %s_temp.aig'%f_name)
-## n = n_pis()
-## t1 = time.time()
-## abc('&get;&rpm;&put')
-## print 'time &rpm = %.2f'%(time.time() - t1)
-## if n_pis() == 0:
-## print '&rpm: Number of PIs reduced to 0. Added a dummy PI'
-## abc('addpi')
-## nn = n_pis()
-## if nn < n:
-## print '&rpm: Reparam: PIs %d => %d'%(n,nn)
-#### rep_change = True
-## abc('r %s_temp.aig'%f_name)
-#### else:
-#### abc('r %s_temp.aig'%f_name)
-#### return False
-
-def reconcile(rep_change):
- """used to make current cex compatible with file before reparam() was done.
- However, the cex may have come
- from extracting a single output and verifying this.
- Then the cex_po is 0 but the PO it fails could be anything.
- So testcex rectifies this."""
- global n_pos_before, n_pos_proved
-## print 'rep_change = %s'%rep_change
- if rep_change == False:
- return
- abc('&r -s %s_beforerpm.aig; &w tt_before.aig'%f_name)
- abc('write_status %s_after.status;write_status tt_after.status'%f_name)
- abc('&r -s %s_afterrpm.aig;&w tt_after.aig'%f_name)
- POa = set_cex_po(1) #this should set cex_po() to correct PO. A 1 here means it uses &space to check
- abc('reconcile %s_beforerpm.aig %s_afterrpm.aig'%(f_name,f_name))
- # reconcile modifies cex and restores work AIG to beforerpm
- abc('write_status %s_before.status;write_status tt_before.status'%f_name)
- POb = set_cex_po()#does not make sense if we are in absstraction refinement
- if POa != POb:
- abc('&r -s %s_beforerpm.aig; &w tt_before.aig'%f_name)
- abc('&r -s %s_afterrpm.aig; &w tt_after.aig'%f_name)
- print 'cex PO afterrpm = %d not = cex PO beforerpm = %d'%(POa,POb)
- if POa < 0: #'cex did not assert any output'
- return 'error'
-
-def reconcile_a(rep_change):
- """ This is the reconcile used in abstraction refinement
- used to make current cex compatible with file before reparam() was done.
- However, the cex may have come
- from extracting a single output and verifying this.
- Then the cex_po is 0 but the PO it fails could be anything.
- So testcex rectifies this."""
- global n_pos_before, n_pos_proved
-## print 'rep_change = %s'%rep_change
- if rep_change == False:
- return
- abc('&r -s %s_beforerpm.aig; &w tt_before.aig'%f_name)
- abc('write_status %s_after.status;write_status tt_after.status'%f_name)
- abc('&r -s %s_afterrpm.aig;&w tt_after.aig'%f_name)
- POa = set_cex_po(1) #this should set cex_po() to correct PO. A 1 here means it uses &space to check
- abc('reconcile %s_beforerpm.aig %s_afterrpm.aig'%(f_name,f_name))
- # reconcile modifies cex and restores work AIG to beforerpm
- abc('write_status %s_before.status;write_status tt_before.status'%f_name)
- if POa < 0: #'cex did not assert any output'
- return 'error'
-
-def reconcile_all(lst, rep_change):
- """reconciles the list of cex's"""
- global f_name, n_pos_before, n_pos_proved
- if rep_change == False:
- return lst
- list = []
- for j in range(len(lst)):
- cx = lst[j]
- if cx == None:
- continue
- cex_put(cx)
- reconcile(rep_change)
- list = list + [cex_get()]
- return list
-
-
-##def try_rpm():
-## """rpm is a cheap way of doing reparameterization and is an abstraction method, so may introduce false cex's.
-## It finds a minimum cut between the PIs and the main sequential logic and replaces this cut by free inputs.
-## A quick BMC is then done, and if no cex is found, we assume the abstraction is valid. Otherwise we revert back
-## to the original problem before rpm was tried."""
-## global x_factor
-## if n_ands() > 30000:
-## return
-## set_globals()
-## pis_before = n_pis()
-## abc('w %s_savetemp.aig'%f_name)
-## abc('rpm')
-## result = 0
-## if n_pis() < .5*pis_before:
-## bmc_before = bmc_depth()
-## #print 'running quick bmc to see if rpm is OK'
-## t = max(1,.1*G_T)
-## #abc('bmc3 -C %d, -T %f'%(.1*G_C, t))
-## abc('&get;,bmc -vt=%f'%t)
-## if is_sat(): #rpm made it sat by bmc test, so undo rpm
-## abc('r %s_savetemp.aig'%f_name)
-## else:
-## trim()
-## print 'WARNING: rpm reduced PIs to %d. May make SAT.'%n_pis()
-## result = 1
-## else:
-## abc('r %s_savetemp.aig'%f_name)
-## return result
-
-def verify(J,t):
- """This method is used for finding a cex during refinement, but can also
- be used for proving the property. t is the maximum time to be used by
- each engine J is the list of methods to run in parallel. See FUNCS for list"""
- global x_factor, final_verify_time, last_verify_time, methods
- set_globals()
- t = int(max(1,t))
- J = modify_methods(J)
- mtds = sublist(methods,J)
- print mtds
- #print J,t
- F = create_funcs(J,t)
- (m,result) = fork_break(F,mtds,'US') #FORK here
-## result = fork_break(F,mtds,'US') #FORK here
- print result
-## assert result[0] == get_status(),'result: %d, status: %d'%(result[0],get_status())
- return result
-
-def dsat_all(t=100,c=100000):
- print 't=%d,c=%d'%(t,c)
- N = n_pos()
- abc('&get')
- J = range(N)
- ttt = time.time()
- J.reverse()
- abc('w %s_temp.aig'%f_name)
- for j in J:
- tt = time.time()
- abc('r %s.aig'%f_name)
- run_command('cone -O %d; dc2; dsat -C %d'%(j,c))
- if is_unsat():
- print 'Output %d is %s'%(j,RESULT[2]),
- else:
- print 'Output %d is %s'%(j,RESULT[3]),
- T = time.time() -tt
- print 'time = %0.2f'%T
- if time.time() - tt > t:
- break
- print 'Total time = %0.2f'%(time.time() - ttt)
-
-def check_sat(t=900):
- """This is called if all the FF have disappeared, but there is still some logic left. In this case,
- the remaining logic may be UNSAT, which is usually the case, but this has to be proved. The ABC command 'dsat' is used fro combinational problems"""
- global smp_trace
- if not n_latches() == 0:
- print 'circuit is not combinational'
- return Undecided
-## print 'Circuit is combinational - checking with dsat'
- abc('&get') #save the current circuit
- abc('orpos')
- J = combs+slps
- mtds = sublist(methods,J)
-## print mtds
- F = create_funcs(J,t)
- (m,result) = fork_last(F,mtds) #FORK here
-## print '%s: '%mtds[m],
-## smp_trace = smp_trace + ['%s'%mtds[m]]
- if is_sat():
- abc('&put')
- if n_pos() == 1:
- return Sat_true
- else:
- return Undecided_no_reduction #some POs could be unsat.
- elif is_unsat():
- return Unsat
- else:
- abc('&put') #restore
- return Undecided_no_reduction
-
-def try_era(s):
- """era is explicit state enumeration that ABC has. It only works if the number of PIs is small,
- but there are cases where it works and nothing else does"""
- if n_pis() > 12:
- return
- cmd = '&get;&era -mv -S %d;&put'%s
- print 'Running %s'%cmd
- run_command(cmd)
-
-def try_induction(C):
- """Sometimes proving the property directly using induction works but not very often.
- For 'ind' to work, it must have only 1 output, so all outputs are or'ed together temporarily"""
- return Undecided_reduction
- print '\n***Running induction'
- abc('w %s_temp.aig'%f_name)
- abc('orpos; ind -uv -C %d -F 10'%C)
- abc('r %s_savetemp.aig'%f_name)
- status = prob_status()
- if not status == 1:
- return Undecided_reduction
- print 'Induction succeeded'
- return Unsat
-
-def smp():
- abc('smp')
- write_file('smp')
-
-def dprove():
- abc('dprove -cbjupr')
-
-def trim():
- global trim_allowed,smp_trace
- if not trim_allowed:
- return False
- result = reparam()
- return result
-
-def prs(x=True):
- global trim_allowed, smp_trace
- """ If x is set to False, no reparameterization will be done in pre_simp"""
- global smp_trace
- smp_trace = []
- trim_allowed = x
- print 'trim_allowed = ',trim_allowed
- y = time.time()
- result = pre_simp()
- print 'Time = %0.2f'%(time.time() - y)
- write_file('smp')
- return RESULT[result[0]]
-
-def check_push():
- """save the current aig if it has a different number of latches from last aig on lst"""
- result = False
- n = n_latches()
-## ps()
- abc('&get;cexsave') #save the current aig
-## typ = hist[-1:]
-## print hist
- run_command('r %s_aigs_%d.aig'%(init_initial_f_name,len(hist)))
-## typ = aigs_pp('pop')
-## aigs.pop() #check latches in last aig.
- nn = n_latches()
-## ps()
-## aigs.push() # put back last aig.
-## aigs_pp('push',typ)
- abc('&put;cexload') # restore current aig
-## print 'check_push: current n=%d, previous nn=%d'%(n,nn)
- if not n == nn: #if number of latches changes need to push the current aig so that reconcile can work.
-## aigs.push()
-## print 'n /= nn'
- aigs_pp('push','reparam0') #default is push,reparam
- result = True
- return result
-
-def dump():
- """ get rid of the last aig on the list"""
- abc('&get')
-## aigs.pop()
- aigs_pp('pop')
- abc('&put')
-
-def test_no_simp():
- global last_simp
- ri = float(n_pis())/float(last_simp[0])
- ro = float(n_pos())/float(last_simp[1])
- rl = float(n_latches())/float(last_simp[2])
- ra = float(n_ands())/float(last_simp[3])
- val = min(ri,ro,rl,ra)
- if val < .95:
- print 'simplification worthwhile'
- return False
- print 'simplification not worthwhile'
- return True
-
-def pre_simp(n=0,N=0):
- """This uses a set of simplification algorithms which preprocesses a design.
- Includes forward retiming, quick simp, signal correspondence with constraints, trimming away
- PIs, and strong simplify. If n not 0, then do not do phase abs"""
- global trim_allowed, temp_dec
- global smp_trace, aigs, last_simp
- chk_sat = 0
- smp_trace = []
- while True:
- if n_latches() == 0:
- print 'Circuit is combinational'
- chk_sat = 1
- break
- if test_no_simp():
- break
- ttime = time.time()
- set_globals()
- smp_trace = smp_trace + ['&scl']
- abc('&get; &scl; &put')
- if (n_ands() > 200000 or n_latches() > 50000 or n_pis() > 40000):
- smp_trace = smp_trace + ['scorr_T']
- scorr_T(50)
- ps()
- if ((n_ands() > 0) or (n_latches()>0)):
- res =a_trim()
- if n_latches() == 0:
- break
- status = get_status()
- if (n == 0 and (not '_smp' in f_name) or '_cone' in f_name):
- best_fwrd_min([10,11])
- ps()
- status = try_scorr_constr()
- if ((n_ands() > 0) or (n_latches()>0)):
- res = a_trim()
- if n_latches() == 0:
- break
- status = process_status(status)
- if status <= Unsat:
- last_simp = [n_pis(),n_pos(),n_latches(),n_ands()]
- return [status,smp_trace,hist]
- print 'Starting simplify ',
- simplify(n,N)
- print 'Simplify: ',
- ps()
- if n_latches() == 0:
- break
- if trim_allowed and n == 0:
- t = min(15,.3*G_T)
- if (not '_smp' in f_name) or '_cone' in f_name: #try this only once on a design
- tt = 25
- if n_ands() > 500000:
- tt = 30
- res,F = try_temps(tt)
- if res:
- aigs_pp('push','tempor')
- if n_latches() == 0:
- break
- if n == 0:
- res,N = try_phases()
- if res:
- aigs_pp('push','phase')
- if n_latches() == 0:
- break
- if ((n_ands() > 0) or (n_latches()>0)):
- res = a_trim()
- status = process_status(status)
- print 'Simplification time = %0.2f'%(time.time()-ttime)
- last_simp = [n_pis(),n_pos(),n_latches(),n_ands()]
- return [status, smp_trace,hist]
- last_simp = [n_pis(),n_pos(),n_latches(),n_ands()]
- return [check_sat(),smp_trace,hist]
-
-
-def try_scorr_constr():
- set_size()
- abc('w %s_savetemp.aig'%f_name)
- status = scorr_constr()
- if inferior_size():
- abc('r %s_savetemp.aig'%f_name)
- return status
-
-def factors(n):
- l = [1,]
- nn = n
- while n > 1:
- for i in (2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53):
- if not i <nn:
- break
- if n%i == 0:
- l = l + [i,]
- n = n/i
- if not n == 1:
- l = l + [n,]
- break
- return sorted(l)
-
-def select(x,y):
- z = []
- for i in range(len(x)):
- if x[i]:
- z = z + [y[i],]
- return z
-
-def ok_phases(n):
- """ only try those where the resulting n_ands does not exceed 60000"""
- f = factors(n)
- sp = subproducts(f)
- s = map(lambda m:m*n_ands()< 120000,sp)
- z = select(s,sp)
- return z
-
-def subproducts(ll):
- ss = (product(ll),)
- #print ll
- n = len(ll)
- if n == 1:
- return ss
- for i in range(n):
- kk = drop(i,ll)
- #print kk
- ss = ss+(product(kk),)
- #print ss
- ss = ss+subproducts(kk)
- #print ss
- result =tuple(set(ss))
- #result.sort()
- return tuple(sorted(result))
-
-def product(ll):
- n = len(ll)
- p = 1
- if n == 1:
- return ll[0]
- for i in range(n):
- p = p*ll[i]
- return p
-
-def drop(i,ll):
- return ll[:i]+ll[i+1:]
-
-def try_phases():
-#### print 'entered try_phases ',
-## ps()
- no = n_pos()
- res = try_phase()
-## print 'after try_phase ',
-## ps()
- N = n_pos()/no
- if N > 1:
- res = True
- else:
- res = False
- return res,N
-
-def try_phase():
- """Tries phase abstraction. ABC returns the maximum clock phase it found using n_phases.
- Then unnrolling is tried up to that phase and the unrolled model is quickly
- simplified (with retiming to see if there is a significant reduction.
- If not, then revert back to original"""
- global init_simp, smp_trace,aigs
- n = n_phases()
-## if ((n == 1) or (n_ands() > 45000) or init_simp == 0):
- if ((n == 1) or (n_ands() > 60000)):
- return False
-## init_simp = 0
- res = a_trim()
- print 'Trying phase abstraction - Max phase = %d'%n,
- abc('w %s_phase_temp.aig'%f_name)
- na = n_ands()
- nl = n_latches()
- ni = n_pis()
- no = n_pos()
- z = ok_phases(n)
- print z,
- if len(z) == 1:
- return False
- #p = choose_phase()
- p = z[1]
- abc('phase -F %d'%p)
- if no == n_pos(): #nothing happened because p is not mod period
- print 'Phase %d is incompatible'%p
- abc('r %s_phase_temp.aig'%f_name)
- if len(z)< 3:
- return False
- else:
- p = z[2]
- #print 'Trying phase = %d: '%p,
- abc('phase -F %d'%p)
- if no == n_pos(): #nothing happened because p is not mod period
- print 'Phase %d is incompatible'%p
- abc('r %s_phase_temp.aig'%f_name)
- return False
- else:
- smp_trace = smp_trace + ['phase -F %d'%p]
- abc('r %s_phase_temp.aig'%f_name)
- abc('&get;&frames -o -F %d;&scl;&put'%p)
- else:
- abc('r %s_phase_temp.aig'%f_name)
- abc('&get;&frames -o -F %d;&scl;&put'%p)
- smp_trace = smp_trace + ['phase -F %d'%p]
- print 'Simplifying with %d phases: => '%p,
- smp_trace = smp_trace + ['simplify(1)']
- simplify(1)
-## res = a_trim() #maybe we don't need this because rel_cost uses n_real_inputs
- ps()
- cost = rel_cost([ni,nl,na])
- print 'New relative cost = %f'%(cost)
- if cost < -.01:
- abc('w %s_phase_temp.aig'%f_name)
- if ((n_latches() == 0) or (n_ands() == 0)):
- return True
- if n_phases() == 1: #this bombs out if no latches
- return False
- else:
- result = try_phase()
- return result
- elif len(z)>2: #Try the next eligible phase.
- abc('r %s_phase_temp.aig'%f_name)
- if p == z[2]: #already tried this
- return False
- p = z[2]
- print 'Trying phase = %d: => '%p,
- abc('phase -F %d'%p)
- if no == n_pos(): #nothing happened because p is not mod period
- print 'Phase = %d is not compatible'%p
- return False
- abc('r %s_phase_temp.aig'%f_name)
- abc('&get;&frames -o -F %d;&scl;&put'%p)
- smp_trace = smp_trace + ['phase -F %d'%p]
- print 'Simplify with %d phases: '%p,
- simplify(1)
-## res =a_trim() #maybe we don't need this because rel_cost uses n_real_inputs
- cost = rel_cost([ni,nl,na])
- print 'New relative cost = %f'%(cost)
- if cost < -.01:
- print 'Phase abstraction with %d phases obtained:'%p,
- print_circuit_stats()
- abc('w %s_phase_temp.aig'%f_name)
- if ((n_latches() == 0) or (n_ands() == 0)):
- return True
- if n_phases() == 1: # this bombs out if no latches
- return True
- else:
- result = try_phase()
- return result
- else:
- smp_trace = smp_trace + ['de_phase']
- abc('r %s_phase_temp.aig'%f_name)
- return False
-
-def try_temp(t=15):
- global smp_trace,aigs
- btime = time.clock()
-## res = a_trim() #maybe we don't want this here.
- print'Trying temporal decomposition - for max %0.2f sec. '%(t),
- abc('w %s_best_temp.aig'%f_name)
-## ni = n_pis()
- ni = n_real_inputs()
- nl = n_latches()
- na = n_ands()
- best = [ni,nl,na]
- cost_best = 0
- i_best = 0
- n_done = 0
- print 'best = ',
- print best
- F = create_funcs([18],t) #create a timer function
- F = F + [eval('(pyabc_split.defer(struc_temp)())')]
- F = F + [eval('(pyabc_split.defer(full_temp)())')]
- F = F + [eval('(pyabc_split.defer(two_temp)())')]
- for i,res in pyabc_split.abc_split_all(F):
-## print i,res
- if i == 0:
- break
- if n_latches() == 0:
- return True
- n_done = n_done+1
- cost = rel_cost(best)
- if cost<0:
- nri=n_real_inputs()
- best = (nri,n_latches(),n_ands())
- abc('w %s_best_temp.aig'%f_name)
- i_best = i
- cost_best = cost
- print 'cost = %.2f, best = '%cost,
- print best
-## if i == 1:
-## smp_trace = smp_trace + ['tempor -s']
-## if i == 2:
-## smp_trace = smp_trace + ['tempor']
-## if n_latches == 0:
-## break
- if n_done > 2:
- break
-## cost = rel_cost(best)
- cost = cost_best
- print 'cost = %0.2f'%cost
- abc('r %s_best_temp.aig'%f_name)
-## if cost < -.01:
- if cost<0:
- ps()
- return True
- else:
-## smp_trace = smp_trace + ['de_tempor']
-## abc('r %s_best_temp.aig'%f_name)
- return False
-
-def struc_temp():
- abc('tempor -s;scr')
- result = quick_simp()
- if result == 'UNSAT':
- return Unsat
- elif result == 'SAT':
- return Sat
- return Undecided
-
-def full_temp():
- abc('tempor')
- return simplify()
-
-def try_temps(t=20):
- """ need to modify something to be able to update cex"""
- global smp_trace
- abc('w %s_try_temps.aig'%f_name)
- best = (n_pis(),n_latches(),n_ands())
- npi = n_pis()
- F = 1
- while True:
- res = try_temp(t)
- ps()
- if n_latches() == 0:
- break
- if res == False:
- return False,F
- if ((best == (n_pis(),n_latches(),n_ands())) or n_ands() > .9 * best[2] ):
- break
- else:
- smp_trace = smp_trace + ['tempor']
- best = (n_pis(),n_latches(),n_ands())
- return True,n_pis()/npi
-
-def rel_cost_t(J):
- """ weighted relative costs versus previous stats."""
- if (n_latches() == 0 and J[1]>0):
- return -10
- nli = J[0]+J[1]
- na = J[2]
- if ((nli == 0) or (na == 0)):
- return 100
- nri = n_real_inputs()
- #ri = (float(nri)-float(ni))/float(ni)
- rli = (float(n_latches()+nri)-float(nli))/float(nli)
- ra = (float(n_ands())-float(na))/float(na)
- cost = 10*rli + 1*ra #changed from .5 to 1 on ra
- return cost
-
-def rel_cost(J):
- """ weighted relative costs versus previous stats."""
- global f_name
- if (n_latches() == 0 and J[1]>0):
- return -10
- nri = n_real_inputs()
- ni = J[0]
- nl = J[1]
- na = J[2]
- if (ni == 0 or na == 0 or nl == 0):
- return 100
- ri = (float(nri)-float(ni))/float(ni)
- rl = (float(n_latches())-float(nl))/float(nl)
- ra = (float(n_ands())-float(na))/float(na)
- cost = 1*ri + 5*rl + .25*ra
-## print 'Relative cost = %0.2f'%cost
- return cost
-
-def best_fwrd_min(J,t=30):
- global f_name, methods,smp_trace
- J=[18]+J
- mtds = sublist(methods,J)
- F = create_funcs(J,t)
- (m,result) = fork_best(F,mtds) #FORK here
- print '%s: '%mtds[m],
- smp_trace = smp_trace + ['%s'%mtds[m]]
-
-def try_forward():
- """Attempts most forward retiming, and latch correspondence there. If attempt fails to help simplify, then we revert back to the original design
- This can be effective for equivalence checking problems where synthesis used retiming"""
- abc('w %s_savetemp.aig'%f_name)
- if n_ands() < 30000:
- abc('dr')
- abc('lcorr')
- nl = n_latches()
- na = n_ands()
- abc('w %s_savetemp0.aig'%f_name)
- abc('r %s_savetemp.aig'%f_name)
- abc('dretime -m')
- abc('lcorr')
- abc('dr')
- if ((n_latches() <= nl) and (n_ands() < na)):
- print 'Forward retiming reduced size to: ',
- print_circuit_stats()
- return
- else:
- abc('r %s_savetemp0.aig'%f_name)
- return
- return
-
-def qqsimp():
- abc('&get;&scl;,reparam;&scorr -C 0;&scl;,reparam;&put')
- shrink()
- abc('w %ssimp.aig'%f_name)
- ps()
-
-
-def quick_simp():
- """A few quick ways to simplify a problem before more expensive methods are applied.
- Uses & commands if problem is large. These commands use the new circuit based SAT solver"""
- na = n_ands()
- if na < 60000:
- abc('scl -m;lcorr;drw')
- else:
- abc('&get;&scl;&lcorr;&put')
- if n_ands() < 500000:
- abc('drw')
- print 'Using quick simplification',
- status = process_status(get_status())
- if status <= Unsat:
- result = RESULT[status]
- else:
- ps()
- result = 'UNDECIDED'
- return result
-
-def scorr_constr():
- """Extracts implicit constraints and uses them in signal correspondence
- Constraints that are found are folded back when done"""
- global aigs
- na = max(1,n_ands())
- n_pos_before = n_pos()
- if ((na > 40000) or n_pos()>1):
- return Undecided_no_reduction
- abc('w %s_savetemp.aig'%f_name)
- na = max(1,n_ands())
-## f = 1
- f = 18000/na #**** THIS can create a bug 10/15/11. see below
- f = min(f,4)
- f = max(1,f)
- print 'Looking for constraints - ',
- if n_ands() > 18000:
- cmd = 'unfold -s -F 2'
- else:
- cmd = 'unfold -F %d -C 5000'%f
- abc(cmd)
- if n_pos() == n_pos_before:
- print 'none found'
- return Undecided_no_reduction
- if (n_ands() > na): #no constraints found
- abc('r %s_savetemp.aig'%f_name)
- return Undecided_no_reduction
- na = max(1,n_ands())
- f = 1 #put here until bug is fixed.
- print 'found %d constraints'%((n_pos() - n_pos_before))
- abc('scorr -c -F %d'%f)
- abc('fold')
- res = a_trim()
- print 'Constrained simplification: ',
- ps()
- return Undecided_no_reduction
-
-def a_trim():
- """ this is set up to put the aig on the aigs list if trim was successful"""
-## print 'trimming'
-## print 5.1
- pushed = check_push() #checking if a push is needed and if so do it.
- #It is not needed if flops match previous aig
-## print 5.2
- res = trim()
-## print 5.3
- if res:
- aigs_pp()
-## aigs.push() #store the aig after rpm if it did something
- elif pushed: #since trim did not do anything, we don't need the last push done by check push
- dump() #dump the last aig on the list
-## print 5.4
- return res
-
-def try_scorr_c(f):
- """ Trying multiple frames because current version has a bug."""
- global aigs
- set_globals()
- abc('unfold -F %d'%f)
- abc('scorr -c -F %d'%f)
- abc('fold')
- t = max(1,.1*G_T)
- abc('&get;,bmc3 -vt=%f'%t)
- if is_sat():
- return 0
- else:
- res = a_trim()
- return 1
-
-
-def input_x_factor():
- """Sets the global x_factor according to user input"""
- global x_factor, xfi
- print 'Type in x_factor:',
- xfi = x_factor = input()
- print 'x_factor set to %f'%x_factor
-
-
-def prove(a=0,abs_tried = False):
- """Proves all the outputs together. If ever an abstraction
- was done then if SAT is returned,
- we make RESULT return "undecided".
- is a == 0 do smp and abs first
- If a == 1 do smp and spec first
- if a == 2 do quick simplification instead of full simplification, then abs first, spec second"""
- global x_factor,xfi,f_name, last_verify_time,K_backup, t_init, sec_options, spec_found_cex
- spec_first = False
- max_bmc = -1
- abs_found_cex_after_spec = spec_found_cex_after_abs = False
- if not '_smp' in f_name: #if already simplified, then don't do again
- if a == 2 : #do quick simplification
- result = quick_simp() #does not write 'smp' file
-## print result
- else :
- result = prove_part_1() #do full simplification here
- if ((result == 'SAT') or (result == 'UNSAT')):
- return result
- if n_latches() == 0:
- return 'UNDECIDED'
- if a == 1:
- spec_first = True
- t_init = 2
- abs_found_cex_before_spec = spec_found_cex_before_abs = False
-## First phase
- if spec_first:
- result = prove_part_3() #speculation done here first
- if result == 'UNDECIDED' and abs_tried and n_pos() <= 2:
- add_trace('de_speculate')
- return result
- else:
- abs_tried = True
- result = prove_part_2() #abstraction done here first
- if ((result == 'SAT') or (result == 'UNSAT')):
- return result
-## Second phase
- if spec_first: #did spec already in first phase
- t_init = 2
- abs_tried = True
- result = prove_part_2() #abstraction done here second
- if result == 'SAT':
- abs_found_cex_after_spec = True
- else:
- result = prove_part_3() #speculation done here second
- if result == 'SAT':
- if '_abs' in f_name:
- spec_found_cex_after_abs = True
- else:
- return result
- if result == 'UNSAT':
- return result
- status = get_status()
- if result == 'ERROR':
- status = Error
- if ('_abs' in f_name and spec_found_cex_after_abs): #spec file should not have been written in speculate
- f_name = revert(f_name,1) #it should be as if we never did abstraction.
- add_trace('de_abstract')
- print 'f_name = %s'%f_name
- abc('r %s.aig'%f_name) #restore previous
- t_init = 2
- if not '_rev' in f_name:
- print 'proving speculation first'
- write_file('rev') #maybe can get by with just changing f_name
- print 'f_name = %s'%f_name
- result = prove(1,True) #1 here means do smp and then spec
- if ((result == 'SAT') or (result == 'UNSAT')):
- return result
- elif ('_spec' in f_name and abs_found_cex_after_spec): #abs file should not have been written in abstract
- f_name = revert(f_name,1) #it should be as if we never did speculation.
- add_trace('de_speculate')
- abc('r %s.aig'%f_name) #restore previous
- t_init = 2
- if not '_rev' in f_name:
- print 'proving abstraction first'
- write_file('rev') #maybe can get by with just changing f_name
- result = prove(0)
- if ((result == 'SAT') or (result == 'UNSAT')):
- return result
- else:
- return 'UNDECIDED'
-
-def prove_part_1():
- global x_factor,xfi,f_name, last_verify_time,K_backup,aigs
- print 'Initial: ',
- ps()
- x_factor = xfi
- set_globals()
- if n_latches() > 0:
-## ps()
- res = try_frames_2()
- if res:
- print 'frames_2: ',
- ps()
- aigs_pp('push','phase')
- print '\n***Running pre_simp'
- add_trace('pre_simp')
- result = run_par_simplify()
- status = result[0]
- method = result[1]
- if 'scorr' in method:
- add_trace(method)
- else:
- print '\n***Circuit is combinational, running check_sat'
- add_trace('comb_check')
- status = check_sat()
- if ((status <= Unsat) or (n_latches() == 0)):
- return RESULT[status]
- res =a_trim()
- if not '_smp' in f_name:
- write_file('smp') #need to check that this was not written in pre_simp
- set_globals()
- return RESULT[status]
-
-def run_par_simplify():
- set_globals()
- t = 1000
- funcs = [eval('(pyabc_split.defer(pre_simp)())')]
- J = [35]+pdrs[:3]+bmcs[:3]+intrps[:1]+sims # 35 is par_scorr
- J = modify_methods(J,1)
-## J = J + bestintrps
- funcs = create_funcs(J,t)+ funcs #important that pre_simp goes last
- mtds =sublist(methods,J) + ['pre_simp']
- print mtds
- result = fork_last(funcs,mtds)
- status = get_status()
- return [status] + [result]
-
-def try_frames_2():
- abc('scl')
- nl = n_latches()
- if n_ands()> 35000:
- return
- abc('w %s_temp.aig'%f_name)
- abc('&get;&frames -o -F 2;&scl;&put')
- if n_latches() < .75*nl:
- print 'frames_2: Number of latches reduced to %d'%n_latches()
- add_trace('frames_2')
-## res = reparam()
-## xxxxx handle this
-## if res:
-## aigs.push()
- return True
- abc('r %s_temp.aig'%f_name)
- return False
-
-def prove_part_2(ratio=.75):
- """does the abstraction part of prove"""
- global x_factor,xfi,f_name, last_verify_time,K_backup, trim_allowed,ifbip
- print'\n***Running abstract'
-## print 'ifbip = %d'%ifbip
- status = abstract(ifbip) #ABSTRACTION done here
- status = process_status(status)
- print 'abstract done, status is %s'%str(status)
- result = RESULT[status]
- if status < Unsat:
- print 'CEX in frame %d'%cex_frame()
- return result #if we found a cex we do not want to trim.
- return result
-
-def prove_part_3():
- """does the speculation part of prove"""
- global x_factor,xfi,f_name, last_verify_time,init_initial_f_name
- global max_bmc, sec_options
-## if ((n_ands() > 36000) and sec_options == ''):
-## sec_options = 'g'
-## print 'sec_options set to "g"'
- print '\n***Running speculate on %s: '%f_name,
- ps()
-## add_trace('speculate')
- status = speculate() #SPECULATION done here
- status = process_status(status)
-## print 'speculate done, status is %d'%status
- result = RESULT[status]
- if status < Unsat:
- print 'CEX in frame %d'%cex_frame()
- return result
- return result
-
-def prove_all(dir,t):
- """Prove all aig files in this directory using super_prove and record the results in results.txt
- Not called from any subroutine
- """
-## t = 1000 #This is the timeoout value
- xtime = time.time()
-## dir = main.list_aig('')
- results = []
- f =open('results_%d.txt'%len(dir), 'w')
- for name in dir:
- read_file_quiet_i(name)
- print '\n **** %s:'%name,
- ps()
- F = create_funcs([18,6],t) #create timer function as i = 0 Here is the timer
- for i,res in pyabc_split.abc_split_all(F):
- break
- tt = time.time()
- if i == 0:
- res = 'Timeout'
- str = '%s: %s, time = %0.2f'%(name,res,(tt-xtime))
- if res == 'SAT':
- str = str + ', cex_frame = %d'%cex_frame()
- str = str +'\n'
- f.write(str)
- f.flush()
- results = results + ['%s: %s, time = %0.2f'%(name,res,(tt-xtime))]
- xtime = tt
-## print results
- f.close()
- return results
-
-def remove_pos(lst):
- """Takes a list of pairs where the first part of a pair is the PO number and
- the second is the result 1 = disproved, 2 = proved, 3 = unresolved. Then removes
- the proved and disproved outputs and returns the aig with the unresolved
- outputs"""
- proved = disproved = unresolved = []
- for j in range(len(lst)):
- jj = lst[j]
- if jj[1] == 2:
- proved = proved + [jj[0]]
- if (jj[1] == 1 or (jj[1] == 0)):
- disproved = disproved +[jj[0]]
- if jj[1] > 2:
- unresolved = unresolved +[jj[0]]
- print '%d outputs proved'%len(proved)
- if not proved == []:
- if ((max(proved)>n_pos()-1) or min(proved)< 0):
- print proved
- remove(proved,0)
-
-
-#functions for proving multiple outputs in parallel
-#__________________________________________________
-
-def prove_only(j):
- """ extract the jth output and try to prove it"""
- global max_bmc, init_initial_f_name, initial_f_name, f_name,x
- #abc('w %s__xsavetemp.aig'%f_name)
- extract(j,j)
- set_globals()
- ps()
- print '\nProving output %d'%(j)
- f_name = f_name + '_%d'%j
- result = prove_1()
- #abc('r %s__xsavetemp.aig'%f_name)
- if result == 'UNSAT':
- print '******** PROVED OUTPUT %d ******** '%(j)
- return Unsat
- if result == 'SAT':
- print '******** DISPROVED OUTPUT %d ******** '%(j)
- return Sat
- else:
- print '******** UNDECIDED on OUTPUT %d ******** '%(j)
- return Undecided
-
-def verify_only(j,t):
- """ extract the jth output and try to prove it"""
- global max_bmc, init_initial_f_name, initial_f_name, f_name,x, reachs, last_cex, last_winner, methods
-## ps()
-## print 'Output = %d'%j
- extract(j,j)
-## ps()
- set_globals()
- if n_latches() == 0:
- result = check_sat()
- else:
- f_name = f_name + '_%d'%j
- # make it so that jabc is not used here
- reachs_old = reachs
- reachs = reachs[1:] #just remove jabc from this.
- res = verify(slps+sims+pdrs+bmcs+intrps,t) #keep the number running at the same time as small as possible.
-## res = verify(sims+pdrs+bmcs+intrps,t) #keep the number running at the same time as small as possible.
- reachs = reachs_old
- result = get_status()
- assert res == result,'result: %d, status: %d'%(res,get_status())
- if result > Unsat:
-## print result
-## print '******* %d is undecided ***********'%j
- return result
- elif result == Unsat:
-## print '******** PROVED OUTPUT %d ******** '%(j)
- return result
- elif ((result < Unsat) and (not result == None)):
- print '******** %s DISPROVED OUTPUT %d ******** '%(last_cex,j)
-## print ('writing %d.status'%j), result, get_status()
- abc('write_status %d.status'%j)
- last_winner = last_cex
- return result
- else:
- print '****** %d result is %d'%(j,result)
- return result
-
-def verify_range(j,k,t):
- """ extract the jth thru kth output and try to prove their OR"""
- global max_bmc, init_initial_f_name, initial_f_name, f_name,x, reachs, last_cex, last_winner, methods
- extract(j,k)
- abc('orpos')
- set_globals()
- if n_latches() == 0:
- result = check_sat()
- else:
- f_name = f_name + '_%d'%j
- # make it so that jabc is not used here
- reachs_old = reachs
- reachs = reachs[1:] #just remove jabc from this.
- res = verify(sims+pdrs+bmcs+intrps,t) #keep the number running at the sme time as small as possible.
- reachs = reachs_old
- result = get_status()
- assert res == result,'result: %d, status: %d'%(res,get_status())
- if result > Unsat:
-## print result
-## print '******* %d is undecided ***********'%j
- return result
- elif result == Unsat:
-## print '******** PROVED OUTPUT %d ******** '%(j)
- return result
- elif ((result < Unsat) and (not result == None)):
- print '******** %s DISPROVED OUTPUT %d ******** '%(last_cex,j)
-## print ('writing %d.status'%j), result, get_status()
- abc('write_status %d.status'%j)
- last_winner = last_cex
- return result
- else:
- print '****** %d result is %d'%(j,result)
- return result
-
-def prove_n_par(n,j):
- """prove n outputs in parallel starting at j"""
- F = []
- for i in range(n):
- F = F + [eval('(pyabc_split.defer(prove_only)(%s))'%(j+i))]
- #print S
- #F = eval(S)
- result = []
- print 'Proving outputs %d thru %d in parallel'%(j,j+n-1)
- for i,res in pyabc_split.abc_split_all(F):
- result = result +[(j+i,res)]
- #print result
- return result
-
-def prove_pos_par(t,BREAK):
- """Prove all outputs in parallel and break on BREAK"""
- return run_parallel([],t,BREAK)
-
-def prove_pos_par0(n):
- """ Group n POs grouped and prove in parallel until all outputs have been proved"""
- f_name = initial_f_name
- abc('w %s__xsavetemp.aig'%f_name)
- result = []
- j = 0
- N = n_pos()
- while j < N-n:
- abc('r %s__xsavetemp.aig'%f_name)
- result = result + prove_n_par(n,j)
- j = j+n
- if N > j:
- result = result + prove_n_par(N-j,j)
- abc('r %s__xsavetemp.aig'%initial_f_name)
- ps()
-## print result
- remove_pos(result)
- write_file('group')
- return
-
-def prop_decomp():
- """decompose a single property into multiple ones (only for initial single output),
- by finding single and double literal primes of the outputs."""
- if n_pos()>1:
- return
- run_command('outdec -v -L 2')
- if n_pos()>1:
- ps()
-
-
-def distribute(N,div):
- """
- we are going to verify outputs in groups
- """
- n = N/div
- rem = N - (div * (N/div))
- result = []
- for j in range(div):
- if rem >0:
- result = result +[n+1]
- rem = rem -1
- else:
- result = result + [n]
- return result
-
-
-def extract(n1,n2):
- """Extracts outputs n1 through n2"""
- no = n_pos()
- if n2 > no:
- return 'range exceeds number of POs'
- abc('cone -s -O %d -R %d'%(n1, 1+n2-n1))
-
-def remove_intrps(J):
- global n_proc,ifbip
-## print J
- npr = n_proc
- if 18 in J:
- npr = npr+1
- if len(J) <= npr:
-## print J
- return J
- JJ = []
- alli = [23,1,22] # if_no_bip, then this might need to be changed
- l = len(J)-npr
- alli = alli[l:]
-## J.reverse() #strip off in reverse order.
- for i in J:
- if i in alli:
- continue
- else:
- JJ = JJ+[i]
-## print JJ
- return JJ
-
-def restrict(lst,v=0):
- '''restricts the aig to the POs in the list'''
- #this assumes that there are no const-1 POs. Warning, this will not remove any const-0 POs
- N = n_pos()
- lst1 = lst + [N]
- r_lst = gaps(lst1) #finds POs not in lst
- if len(r_lst) == N:
- return
- remove(r_lst,v)
-
-def remove(lst,v=0):
- """Removes outputs in list
- WARNING will not remove all POs even if in lst
- """
- global po_map
- n_before = n_pos()
- zero(lst,v)
- l=remove_const_pos(v)
- assert len(lst) == (n_before - n_pos()),'Inadvertantly removed some const-0 POs.\nPO_before = %d, n_removed = %d, PO_after = %d'%(n_before, len(lst), n_pos())
- print 'PO_before = %d, n_removed = %d, PO_after = %d'%(n_before, len(lst), n_pos())
-
-
-def zero(list,v=0):
- """Zeros out POs in list"""
- if v == 0:
- cmd = 'zeropo -s -N ' #puts const-0 in PO
- else:
- cmd = 'zeropo -so -N ' #puts const-1 in PO
- for j in list:
- run_command('%s%d'%(cmd,j)) #-s prevents the strash after every zeropo
- abc('st')
-
-def listr_0_pos():
- """ returns a list of const-0 pos and removes them
- """
- L = range(n_pos())
- L.reverse()
- ll = []
- for j in L:
- i = is_const_po(j)
- if i == 0:
- abc('removepo -N %d'%j) #removes const-0 output
-## print 'removed PO %d'%j
- ll = [j] + ll
- return ll
-
-def list_0_pos():
- """ returns a list of const-0 pos and removes them
- """
- abc('w %s_savetemp.aig'%f_name)
- L = range(n_pos())
- L.reverse()
- ll = []
- for j in L:
- i = is_const_po(j)
- if i == 0:
- abc('removepo -N %d'%j) #removes const-0 output
-## print 'removed PO %d'%j
- ll = [j] + ll
- abc('r %s_savetemp.aig'%f_name)
- return ll
-
-def listr_1_pos():
- """ returns a list of const-1 pos and removes them
- """
- L = range(n_pos())
- L.reverse()
- ll = []
- for j in L:
- i = is_const_po(j)
- if i == 1:
- abc('removepo -z -N %d'%j) #removes const-1 output
-## print n_pos()
- ll = [j] + ll
- return ll
-
-
-def mark_const_pos(ll=[]):
- """ creates an indicator of which PO are const-0 and which are const-1
- does not change number of POs
- """
- n=n_pos()
- L = range(n)
- ll = [-1]*n
- for j in L:
- ll[j] = is_const_po(j)
- print sumsize(ind)
- return ind
-
-def remove_const_pos(n=-1):
- global po_map
- """removes the const 0 or 1 pos according to n, but no pis because we might
- get cexs and need the correct number of pis
- """
- if n > -1:
- run_command('&get; &trim -i -V %d; &put'%n) #V is 0 or 1
- else:
- run_command('&get; &trim -i; &put') #removes both constants
-
-def unmap_cex():
- """ aig before trim is put in reg-space and after trim in the &space
- Before and after need to have same number of flops in order o reconcile
- aigs list should be such that if before and after don't match in number of latches,
- then some operation changed the flops and we just update the aig with the new number
- reconcile leaves before aig in reg-space after cex has been updated so cex and aig
- always match
- """
- global aigs,hist
- print hist
-## while not aigs == []:
- while not len(hist) == 0:
- n = n_latches()
- abc('&get') #save the current aig in &-space
- print 'Number of PIs in cex = %d'%n_cex_pis()
- typ = aigs_pp('pop')
- print typ,
- ps()
- if typ == 'phase':
- typ2 =aigs_pp('pop') #gets the aig before phase
- abc('phase -c')
- print 'Number of PIs in cex = %d, Number of frames = %d'%(n_cex_pis(),cex_frame())
- run_command('testcex -a')
- hist = hist + [typ2]
- continue
- if typ == 'tempor':
- typ2 = aigs_pp('pop') #gets the aig before tempor
- abc('tempor -c')
- print 'Number of PIs in cex = %d, Number of frames = %d'%(n_cex_pis(),cex_frame())
- run_command('testcex -a')
- hist = hist + [typ2]
- continue
- if typ == 'reparam':
- nn = n_latches()
- abc('&get') #put 'after' in &space
- typ2 = aigs_pp('pop') #get previous to put before in reg-space
- run_command('reconcile')
- print 'Number of PIs in cex = %d'%n_cex_pis()
-## reconcile(True) #maps the cex from &-space aig to current aig
- run_command('testcex -a')
- if not typ2 == 'reparam0':
- hist = hist + [typ2] #put back (aig iss still there so just have to restore hist
- continue
- #else we just leave the aig updated
- else:
- assert typ == 'initial','type is not initial'
- size = str([n_pis(),n_pos(),n_latches(),n_ands()])
- print 'cex length = %d'%cex_frame()
- tr = ['cex length = %d'%cex_frame()] + ['cex matches original aig = %s'%size]
- print 'cex matches original aig'
- return tr
-## print 'cex matches original aig'
-
-
-def sp(n=0,t=900,check_trace=False):
- """Alias for super_prove, but also resolves cex to initial aig"""
- global initial_f_name
- print 'Executing super_prove'
- result = super_prove(n,t)
- print '%s is done and is %s'%(initial_f_name,result[0])
- print 'sp: ',
- print result
- if result[0] == 'SAT' and check_trace:
- res = unmap_cex()
- result1 = result[1]+ res
- result = ['SAT'] + result1
- report_cex()
- report_bmc_depth(max(max_bmc,n_bmc_frames()))
- return result
-
-def mp():
- multi_prove_iter()
-
-def report_cex():
- abc('write_status %s_cex.status'%init_initial_f_name)
-
-def sumsize(L):
- d = count_less(L,0)
- u = count_less(L,1)-d
- s = count_less(L,2) - (d+u)
- return 'SAT = %d, UNSAT = %d, UNDECIDED = %d'%(s,u,d)
-
-def unmap(L,L2,map):
- mx = max(list(map))
- assert mx <= len(L2),'max of map = %d, length of L2 = %d'%(mx,len(L))
- for j in range(len(map)):
- L[j] = L2[map[j]] #expand results of L2 into L
- return L
-
-def unmap2(L2,map):
- mx = max(list(map))
- assert mx <= len(L2),'max of map = %d, length of L2 = %d'%(mx,len(L))
- L=[-1]*len(map)
- for j in range(len(map)):
- L[j] = L2[map[j]] #expand results of L2 into L
- return L
-
-def create_map(L,N):
- """ map equivalence classes into their representative."""
-## print L
- mapp = [-1]*N
- m = -1
- error = False
- for j in range(len(L)):
- lj = L[j]
- for k in range(len(lj)):
- mapp[lj[k]] = j
-## print lj
- mm = min(lj)
-## print mm
- if not mm == lj[0]: #check if rep is not first on list
- print 'ERROR: rep is not first, mm = %d, lj[0] = %d'%(mm,lj[0])
- error = True
- if mm <= m: #check if iso_classes are in increasing order of representatives.
- print 'ERROR: in iso map mm < m, mm = %d, m = %d'%(mm,m)
- error = True
- m = mm
- assert not error,'ERROR'
- return mapp
-
-
-def weave(L1,lst0,lst1):
- """ interleave values of L1 and with 1's in positions given in lst1,
- and 0's in lst0. It is assumed that these lists are in num order..
- Final list has len = len(L1)+len(lst0)+len(lst1)"""
- L = [-1]*(len(L1)+len(lst0)+len(lst1))
-## print len(L)
- if lst0 == []:
- if lst1 == []:
- return L1
- lst = lst1
- v = 1
- if lst1 == []:
- lst = lst0
- v = 0
- l = k = 0
- for j in range(len(L)):
-## print L
- if j == lst[l]:
- L[j] = v
- if l+1 < len(lst):
- l = l+1
- else: #put in value in L1
- L[j] = L1[k]
- if k+1 < len(L1):
- k = k+1
- return L
-
-def quick_mp(t):
- t1 =time.time()
- l1 = list_0_pos()
- S,l2,s = par_multi_sat(t)
- l2 = indices(s,1)
- remove(l2,1)
- abc('scl')
- simple()
- ps()
- print'time = %0.2f'%(time.time() - t1)
-
-def indices(s,v):
- """return in indices of s that have value v"""
- L = []
- for i in range(len(s)):
- if s[i]== v:
- L = L+[i]
- return L
-
-def expand(s,ind,v):
- """expand s by inserting value v at indices ind"""
- N = len(s)+len(ind)
- ind1 = ind+[N]
- g = gaps(ind1)
- ss = [-1]*N
- for i in ind:
- ss[i] = v
- j = 0
- for i in g: #put original values in ss
- ss[i] = s[j]
- j = j+1
- for j in ind:
- assert ss[j] == v, 'ss = %s, ind = %s'%(str(ss),str(ind))
- return ss
-
-def remove_v(ss,v):
- s = []
- for i in range(len(ss)):
- if ss[i] == v:
- continue
- else:
- s = s + [ss[i]]
- return s
-
-def multi_prove(op='simple',tt=900,n_fast=0, final_map=[]):
- """two phase prove process for multiple output functions"""
- global max_bmc, init_initial_f_name, initial_f_name,win_list, last_verify_time
- global f_name_save,nam_save,_L_last,file_out
- x_init = time.time()
- abc('&get;&scl;,reparam -aig=%s_rpm.aig; r %s_rpm.aig')
- print 'Initial after &scl and reparam = ',
- ps()
- abc('w %s_initial_save.aig'%init_initial_f_name)
- #handle single output case differently
- _L_last = [-1]*n_pos()
- if n_pos() == 1:
- result = sp(2000)
-## abc('w %s_unsolved.aig'%init_initial_f_name)
- rs=result[0]
- if rs == 'SAT':
- report_result(0,1)
- L = [1]
- elif rs == 'UNSAT':
- report_result(0,0)
- L = [0]
- elif rs == 'UNDECIDED':
- report_result(0,-1)
- L = [-1]
- else: #error
- L = [2]
- res = sumsize(L)
- rr = '\n@@@@ Time = %d '%(time.time() - t_iter_start) + res
- print rr
- file_out.write(rr+ '\n')
- file_out.flush()
- return L
-## print 'Removing const-0 POs'
- NNN = n_pos()
- lst0 = listr_0_pos() #remove const-0 POs and record
-## print lst0
- lst0.sort()
- N = n_pos()
- L = [-1]*N
- print 'Removed %d const-0 POs'%len(lst0)
- res = 'SAT = 0, UNSAT = %d, UNDECIDED = %d'%(len(lst0),N)
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- report_L(lst0,0) ##########
- rr = rr + res
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- ttt = n_ands()/1000
- if ttt < 10:
- ttt=10
- elif ttt<20:
- ttt = 20
- elif ttt< 30:
- ttt = 30
- else:
- ttt = 50
- S,lst1,s = par_multi_sat(ttt,1,1,1) #run engines in parallel looking for SAT outputs
- lst1 = indices(s,1)
-## print S,lst1
- #put 0 values into lst0
- lst10 = indices(s,0) #new unsat POs in local indices (with lst0 removed)
- if not lst10 == []:
- print 'lst10 = %s'%str(lst10)
- lst11 = indices(s,1) #local variables
- ss = expand(s,lst0,0) #ss will reflect original indices
- report_s(ss)
- lst0_old = lst0
- lst0 = indices(ss,0) #additional unsat POs added to initial lst0 (in original indices)
- print 'lst0 = %s'%str(lst0)
- assert len(lst0) == len(lst0_old)+len(lst10), 'lst0 = %s, lst0_old = %s, lst10 = %s'%(str(lst0),str(lst0_old),str(lst10))
- sss = remove_v(ss,0) #remove the 0's from ss
- assert len(sss) == len(ss)-len(lst0), 'len(sss) = %d, len(ss) = %d, len(lst0) = %d'%(len(sss),len(ss),len(lst0))
- lst1_1 = indices(sss,1) #The sats now reflect the new local indices.
- #It makes it as if the newly found unsat POs were removed initially
- #done with new code
- assert len(lst1_1) == len(lst1), 'mismatch, lst1 = %d, lst1_1 = %d'%(len(lst1),len(lst1_1))
- lst1 = lst1_1 #lst1 should be in original minus lst0
- print 'Found %d SAT POs'%len(lst1)
- print 'Found %d UNSAT POs'%len(lst10)
- res = 'SAT = %d, UNSAT = %d, UNDECIDED = %d'%(len(lst1),len(lst0),NNN-(len(lst1)+len(lst0)))
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- rr = rr + res
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- N = n_pos()
- print len(lst10),n_pos()
- if not len(lst10) == n_pos() and len(lst10) > 0:
- remove(lst10,1) #remove 0 POs
- print 'Removed %d UNSAT POs'%len(lst10)
- N = n_pos()
- elif len(lst10) == n_pos():
- N = 0 #can't remove all POs. Must proceed as if there are no POs. But all POs are UNSAT.
- print len(lst1),N,S #note: have not removed the lst1 POs.
- if len(lst1) == N or S == 'UNSAT' or N == 0: #all POs are SAT
- L = [0]*N #could just put L as all 1's. If N = 0, all POs are UNSAT and lst1 = []
- for i in range(len(lst1)): #put 1's in SAT POs
- L[lst1[i]]=1
- L = weave(L,lst0,[]) #expand L, and put back 0 in L.
- report_results(L)
- print sumsize(L)
- print 'Time = %.2f'%(time.time() - x_init)
- return L
-## print 'removing them'
- if not len(lst1)== n_pos():
- remove(lst1,1) #here we removed all POs in lst1 (local indices)
- abc('&get;&scl;&put')
- ## lst1 = bmcj_ss_r(2) #find easy cex outputs
- ## write_file('bmc1')
- print 'Removed %d SAT POs'%len(lst1)
- N = n_pos()
- else:
- N = 0
- if N == 1: #this was wrong. Need to report in original indices???
- result = sp(2000)
- rs=result[0]
- #need to find out original index of remaining PO
- if rs == 'SAT':
- v = 1
- elif rs == 'UNSAT':
- v = 0
- elif rs == 'UNDECIDED':
- v = -1
- else: #error should not happen, but be conservative
- v = -1
- L = [v]*N
- L = weave(list(L),[],lst1) #put back 1 in L
- L = weave(list(L),lst0,[]) #put back 0 in L
- report_results(L)
- res = sumsize(L)
- rr = '\n@@@@ Time = %d '%(time.time() - t_iter_start) + res
- print rr
- file_out.write(rr+ '\n')
- file_out.flush()
- return L
- L1 =L = [-1]*N
- if N > 1 and N < 10000 and n_ands() < 500000: #keeps iso in
-## if N > 1 and N < 10000 and False: #temporarily disable iso
- print 'Mapping for first isomorphism: '
- res = iso() #reduces number of POs
- if res == True:
- abc('&get;&scl;&put')
- write_file('iso1')
- leq = eq_classes()
-## print leq
- map1 = create_map(leq,N) #creates map into original
-## print map1
- if not count_less(L,0) == N:
- print L
- L1 = [-1]*n_pos()
-## L1 = pass_down(L,list(L1),map1) # no need to pass down because L will have no values at this point.
- else:
- map1 =range(N)
- else:
- map1 = range(N)
- N = n_pos()
-## print 4
- r = pre_simp() #pre_simp
- write_file('smp1')
- NP = n_pos()/N #if NP > 1 then NP unrollings were done in pre_simp.
- if NP > 1:
- L1 = duplicate_values(L1,NP) # L1 has only -1s here. Put in same valuess for iso POs
- if n_pos() > N:
- assert NP>=2, 'NP not 2, n_pos = %d, N = %d, NP = %d'%(n_pos(),N,NP)
- print 'pre_simp done. NP = %d\n\n'%NP
- #WARNING: if phase abstraction done, then number of POs changed.
- if r[0] == Unsat:
- print 'example is UNSAT'
- L1 = [0]*N #all outputs are UNSAT
- print sumsize(L1)
- print 'unmapping for iso'
- L = unmap(list(L),L1,map1)
- print "putting in easy cex's and easy unsat's"
- L = weave(list(L),[],lst1) #put back 1 in L
- L = weave(list(L),lst0,[]) #put back 0 in L
- print sumsize(L)
- print 'Time = %.2f'%(time.time() - x_init)
- report_results(L)
- return L
- f_name_save = f_name
- nam_save = '%s_initial_save.aig'%f_name
- #########do second iso here
- N = n_pos()
- if N == 1:
- map2 = [0]
- L2=[-1]
-## write_file('1')
-## L = output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP)
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- result = simple(2000,1)
- Ss = rs = result[0]
- if rs == 'SAT':
- L2 = [1]
- if rs == 'UNSAT':
- L2 = [0]
- else:
-## if False and N < 10000: #temp disable iso
- if N < 10000 and n_ands() < 500000:
- print 'Mapping for second isomorphism: '
- res = iso() #second iso - changes number of POs
- if res == True:
- abc('&get;&scl;&put')
- map2 = create_map(eq_classes(),N) #creates map into previous
- else:
- map2 = range(n_pos())
- else:
- map2 = range(n_pos())
- write_file('iso2')
- print 'entering par_multi_sat'
- S,lbmc,s = par_multi_sat(2*ttt,1,1,1) #look for SAT POs
- lmbc = indices(s,1)
- print 'par_multi_sat ended'
- if len(lmbc)>0:
- print 'found %d SAT POs'%len(lmbc)
- L2 = s
-## #first mprove for 10-20 sec.
- ps()
- print 'Before first mprove2, L2 = %s'%sumsize(L2)
- DL = output2(list(L2),map1,map2,lst0,lst1,NP) #reporting intermediate results
-## DDL = output3(range(len(L2)),map1,map2,lst0,lst1,NP)
-## print 'DDL = %s'%str(DDL)
- if n_fast == 1:
- abc('w %s_unsolved.aig'%init_initial_f_name)
- return DL
- NN=n_ands()
- #create timeout time for first mprove2
- ttt = 10
- if NN >30000:
- ttt = 15
- if NN > 50000:
- ttt = 20
- abc('w %s_before_mprove2.aig'%f_name)
- print '%s_before_mprove2.aig written'%f_name
- print 'L2 = %s'%str(L2)
- print 'Entering first mprove2 for %d sec.'%ttt,
- Ss,L2 = mprove2(list(L2),op,ttt,1) #populates L2 with results
-## print Ss,L2
- if Ss == 'SAT':
- print 'At least one PO is SAT'
- if Ss == 'ALL_SOLVED':
- if count_less(L2,0)>0:
- print 'ERROR'
-## L = output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP) # final report of results.
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- return L
- print 'After first mprove2: %s'%sumsize(L2)
- time_left = tt - (time.time()-x_init)
- N = count_less(L2,0)
- if N > 0 and n_fast == 0:
-## output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP) #reporting new intermediate results
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- t = max(100,time_left/N)
- t_all = 100
- S = sumsize(L2)
- T = '%.2f'%(time.time() - x_init)
- print '%s in time = %s'%(S,T)
- abc('w %s_unsolved.aig'%init_initial_f_name)
- N = n_pos()
- ttime = 100
- J = slps+intrps+pdrs+bmcs+sims
- #do each output for ttime sec.
- Nn = count_less(L2,0)
-## assert N == len(L2),'n_pos() = %d, len(L2) = %d'%(N,len(L2))
- if Nn > 0:
- found_sat = 0
- print 'final_all = %d, Ss = %s'%(final_all,str(Ss))
- if final_all and not Ss == 'SAT':
- print 'Trying to prove all %d remaining POs at once with super_prove'%Nn
- remove_proved_pos(L2)
- result = super_prove()
- if result[0] == 'UNSAT': #all remaining POs are UNSAT
- for i in range(len(L2)):
- if L2[i] < 0:
- L2[i] = 0
-## L = output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP) # final report of results.
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- return L
- if result == 'SAT':
- found_sat = 1
- if found_sat or not final_all or Ss == 'SAT':
- print 'Trying each remaining PO for %d sec.'%ttime
- found_sat = 0
-## ttime = 10
- for i in range(N):
- if L2[i] > -1:
- continue
- print '\n**** cone %d ****'%i
- abc('r %s_unsolved.aig'%init_initial_f_name)
- abc('cone -s -O %d'%i)
- abc('&get;&scl;&lcorr;&put')
- result = verify(J,ttime)
- r = result[0]
- if r > 2:
- continue
- elif r == 2:
- L2[i] = 0
- else:
- L2[i] = 1
- found_sat = 1
-## output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP)
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- if Ss == 'SAT' and found_sat: #previous solve_all was SAT and found at least 1 PO SAT
- abc('r %s_unsolved.aig'%init_initial_f_name)
- if not count_less(L2,0) == 0:
- remove_proved_pos(L2)
- simplify()
- write_file('save')
- result = simple(2000,1)
- if_found = False
- if result[0] == 'UNSAT':
- for i in range(N):
- if L2[i] == -1:
- L2[i] = 0
- elif result[0] == 'SAT' and n_pos() == 1:
- for i in range(N):
- if L2[i] == -1:
- if if_found == True:
- print 'Error: more that 1 UNDECIDED remained in L2'
- break
- L2[i] = 1
- if_found = True
- else:
- if result[0] == 'SAT':
- print 'at least 1 unsolved PO is SAT'
-## L = output(list(L),list(L1),L2,map1,map2,lst0,lst1,NP) # final report of results.
- L = output2(list(L2),map1,map2,lst0,lst1,NP)
- return L
-
-def create_unsolved(L):
- abc('r %s_initial_save.aig'%init_initial_f_name)
- lst = []
- assert len(L) == n_pos(),'lengths of L and n_pos = %d,%d'%(len(L),n_pos())
- for i in range(len(L)):
- if L[i] > -1: #solved PO
- lst = lst + [i]
- assert max(lst) < n_pos(), 'error in lengths'
- assert count_less(L,0) == n_pos() - len(lst),'mismatch'
- remove(lst,-1) # remove solved
-
-def multi_prove_iter():
- global t_iter_start,file_out,ff_name
- ff_name = init_initial_f_name
- file_out = open('%s_time_results.txt'%init_initial_f_name, 'w') #
- t_iter_start = time.time()
- L = multi_prove()
- d = count_less(L,0)
- u = count_less(L,1)-d
- s = count_less(L,2) - (d+u)
- rr = '\n@@@@@ %s: Final time = %.2f '%(init_initial_f_name,(time.time() - t_iter_start))
- rr = rr + 'SAT = %d, UNSAT = %d, UNDECIDED = %d '%(s,u,d)
- print rr
- file_out.write(rr)
- res = PO_results(L)
- file_out.write(res)
-## print res
- file_out.flush()
- file_out.close()
- #at this point could restrict to SAT(UNSAT) POs and invoke solver to verify all POs are SAT(UNSAT)
- return
-
-def restrict_v(L,v):
- """ L is a list of 0,1,-1"""
- lst = []
- for j in range(len(L)):
- if L[j] == v:
- lst = lst + [j]
- restrict(lst)
- return lst
-
-def PO_results(L):
- global ff_name
- S=U=UD=[]
- for j in range(len(L)):
- ll = L[j]
- if ll == -1:
- UD = UD + [j]
- elif ll == 0:
- U = U + [j]
- elif ll == 1:
- S = S + [j]
- else:
- print 'error, L contains a non -1,0,1'
- res = "[[SAT = %s], [UNSAT = %s], [UNDECIDED = %s]"%(str(S),str(U),str(UD))
- #restore initial unsolved POs
- abc('r %s.aig'%ff_name)
- if not UD == []:
- restrict(UD,0)
- abc('w %s_UNSOLVED.aig'%ff_name)
- print 'Unsolved POs restored as %s_UNSOLVED.aig'%ff_name
- else:
- print 'All POs were solved'
- abc('r %s.aig'%ff_name) #what if original had constraints.
- abc('fold')
- if not U == []:
- restrict(U,1) #we use 1 here because do not want to remove const-0 POs which should be in U
- abc('w %s_UNSAT.aig'%ff_name)
- print 'Unsat POs restored as %s_UNSAT.aig'%ff_name
- abc('r %s.aig'%ff_name)
- abc('fold')
- if not S == []:
- restrict(S,0)
- abc('w %s_SAT.aig'%ff_name)
- print 'Sat POs restored as %s_SAT.aig'%ff_name
- return res
-
-def syn3():
- t = time.clock()
- run_command('&get;&b; &jf -K 6; &b; &jf -K 4; &b;&put')
- ps()
- print 'time = %.2f'%(time.clock() - t)
-
-def syn4():
- t = time.clock()
- abc('&get;&b; &jf -K 7; &fx; &b; &jf -K 5; &fx; &b;&put')
- ps()
- print 'time = %.2f'%(time.clock() - t)
-
-
-def solve_parts(n):
- global t_iter_start,file_out
- r=range(n)
- r.reverse()
- name = init_initial_f_name
- results = []
- for i in r:
- file_out.write('\n@@@@ Starting part%d: \n'%i)
- file_out.flush()
- abc('r %s_part%d.aig'%(name,i))
- print '\nPart%d: '%i
- L = multi_prove()
- rr = '\n@@@@ Time = %.2f '%(time.time() - t_iter_start)
- rr = rr + 'Part%d: '%i
- ssl = sumsize(L)
- rr = rr + ssl
- results = results + [[ssl]]
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- return results
-
-def cp(n=10):
- return chop_prove(n)
-
-def chop_prove(n=10,t=100):
- global t_iter_start,file_out
- tm = time.time()
- abc('w %s_chop_temp.aig'%f_name)
- N = max(5,n_pos()/n)
- J = 0
- total = []
- np = n_pos()
- while J < np:
- abc('r %s_chop_temp.aig'%f_name)
- E = J+N-1
- R = N
- if E > np-1:
- R = N - (E - (np -1))
- abc('cone -s -O %d -R %d'%(J,R))
- npp = n_pos()
- print '\n\n***** solving outputs %d to %d *****'%(J,(J+R-1))
- f_map = str([J]*R + range(R))
- funcs = create_funcs(slps,t)
- funcs = funcs + [eval('(pyabc_split.defer(mp)(simple,%s,1,%s))'%(t,f_map))] #1 means do fast mp
-## funcs = funcs + [eval('(pyabc_split.defer(sp)())')]
- for i,res in pyabc_split.abc_split_all(funcs):
- print 'Method %d returned first with result = %s'%(i,res)
- if i == 0:
- res = 'SAT = 0, UNSAT = 0, UNDECIDED = %d'%npp
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- rr = rr + 'chop%d: '%i
- rr = rr + res
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- break
- if i == 1:
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- rr = rr + 'chop%d: '%i
- rr = rr + res
- file_out.write(rr + '\n')
- file_out.flush()
-## print res
- break
- else:
- if res == 'UNSAT':
- res = 'SAT = 0, UNSAT = %d, UNDECIDED = 0'%npp
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- rr = rr + 'chop%d: '%i
- rr = rr + res
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- break
- else:
- res = 'SAT = 0, UNSAT = 0, UNDECIDED = %d'%npp
- rr = '\n@@@@ Time = %.2f: '%(time.time() - t_iter_start)
- rr = rr + 'chop%d: '%i
- rr = rr + res
- print rr
- file_out.write(rr + '\n')
- file_out.flush()
- break
-## print res
- total = total + [[res]]
- print total
- J = J + R
- c = get_counts(total)
- tm = time.time() - tm
- rr = '\n@@@@ Total time for chop = %.2f, SAT = %d, UNSAT = %d, UNDECIDED = %d'%(tm,c[0],c[1],c[2])
- file_out.write(rr + '\n')
- file_out.flush()
- print rr
- return total
-
-def get_counts(L):
- s=u=d=0
- for i in range(len(L)):
- li = L[i][0]
-## print li
- j1=li.find('=')
- j2 = li.find(',')
- num = int(li[j1+1:j2])
- s = s+num
- li = li[j2+1:]
- j1=li.find('=')
- j2 = li.find(',')
- num = int(li[j1+1:j2])
- u = u+num
- li = li[j2+1:]
- j1=li.find('=')
- j2 = li.find(',')
- num = int(li[j1+1:])
- d = d+num
- return [s,u,d]
-
-
-def output(L,L1,L2,map1,map2,lst0,lst1,NP,final_map=[]):
- global t_iter_start
- print_all(L,L1,L2,map1,map2,lst0,lst1,NP,final_map=[])
- #print 'L = %s, L1 = %s, L2 = %s'%(sumsize(L),sumsize(L1),sumsize(L2))
- L1 = unmap(list(L1),L2,map2)
- print 'L1 after map2 = %s'%sumsize(L1)
- if NP > 1: #an unrolling was done
- L1 = check_and_trim_L(NP,list(L1))#map into reduced size before unrolling was done by phase.
- print 'L1 = %s'%sumsize(L1)
- L = unmap(list(L),L1,map1)
- print 'L after map1 = %s'%sumsize(L)
- L = weave(list(L),[],lst1) #put back 1 in L
- print 'L after lst1 = %s'%sumsize(L)
- L = weave(list(L),lst0,[]) #put back 0 in L
- print 'L after lst0= %s'%sumsize(L)
- report_results(list(L),final_map)
- return L
-
-def output2(L2,map1,map2,lst0,lst1,NP,final_map=[]):
- global t_iter_start
-## print_all(L,L1,L2,map1,map2,lst0,lst1,NP,final_map=[])
- #print 'L = %s, L1 = %s, L2 = %s'%(sumsize(L),sumsize(L1),sumsize(L2))
- L1 = unmap2(L2,map2)
- print 'L1 after map2 = %s'%sumsize(L1)
-## if NP > 1: #an unrolling was done
-## L1 = check_and_trim_L(NP,list(L1))#map into reduced size before unrolling was done by phase.
-## print 'L1 = %s'%sumsize(L1)
- L = unmap2(L1,map1)
- print 'L after map1 = %s'%sumsize(L)
- L = weave(list(L),[],lst1) #put back 1 in L
- print 'L after lst1 = %s'%sumsize(L)
- L = weave(list(L),lst0,[]) #put back 0 in L
- print 'L after lst0= %s'%sumsize(L)
- report_results(list(L),final_map)
- return L
-
-def output3(L2,map1,map2,lst0,lst1,NP,final_map=[]):
- """ find out where results came from"""
- global t_iter_start
- L1 = unmap2(L2,map2)
- L = unmap2(L1,map1)
- L = weave(list(L),[],lst1) #put back 1 in L
- L = weave(list(L),lst0,[]) #put back 0 in L
- return L
-
-def print_all(L,L1,L2,map1,map2,lst0,lst1,NP,final_map=[]):
-## return
- print 'L = ',
- print L
- print 'L1 = ',
- print L1
- print 'L2 = ',
- print L2
- print 'map1 = ',
- print map1
- print 'map2 = ',
- print map2
- print 'lst0 = ',
- print lst0
- print 'lst1 = ',
- print lst1
-
-
-def rnge(n,m):
- """ return interval n+range(m)"""
- N = []
- for j in range(m):
- N = N + [n + j]
- return N
-
-def create_cluster(n=0,p=1,L=100):
- """n is the start node and p is the multiplier on the # of POs to extract
- ll is the limit on the number of latches to include"""
- clstr=rem = [] #make a list of nodes to remove because not compatible
- N = 0 #number of end skips
- init = False
- skip=0 #number of initial skips
- abc('w temp.aig')
- np = n_pos()
- for i in range(np):
- if n + p*(i+1-skip) > np:
- if n_latches() > L:
- bp = n_pos()-p
- remove(rnge(bp,p),1) #remove last p
- abc('scl')
- return clstr
- abc('r temp.aig')
- abc('cone -s -O %d -R %d;scl'%(n,p*(i+1-skip)))
- xx = n_pos()
- if n_latches() > L:
- if not init: #have not found start point yet
- n=n+p #increase start point
- print 'n,FF = %d,%d'%(n,n_latches())
- skip = skip + 1
- continue
- else:
- if not init:
-## nn=p*(i-skip)
-## clstr = clstr + rnge(nn,p*(i+1-skip))
-## print clstr #initial cluster
- init = True
-## abc('w old.aig')
- remove(rem,1)
- abc('scl')
- ps()
- if n_latches() > L:
- x = xx - p #remove last p POs
- rem = rem + rnge(x,p)
-## print len(rem)
- print 'x,len(rem) = %d,%d,%d'%(x,len(rem))
- N = N+1
- else:
- bn=p*(i-skip)
- nr=rnge(bn,p)
- clstr = clstr + nr
- if N > 100: #don't do more than 10 end-skips
- bp = n_pos()-p
- remove(rnge(bp,p),1) #put last p on remove list
- abc('scl')
- return clstr
-
-def generate_clusters(b=0,inc=10,end=100):
- abc('w temp_gen_clstr.aig')
- abc('w t_gen_cl.aig')
- clusters = []
- while True:
- abc('r t_gen_cl.aig')
- clstr = create_cluster(b,inc,end)
- clusters = clusters + [clstr]
- abc('r t_gen_cl.aig')
- if clstr == []:
- return clusters
- remove(clstr,1)
- abc('w t_gen_cl.aig')
-
-def map_clusters_to_original(cl):
- L = range(n_pos())
- Clstrs = []
- k = 0
- for j in range(len(cl)):
- c = cl[j]
- cc = pick(L,c)
- Clstrs = Clstrs + [cc]
- L = pick_not(L,cc)
- return Clstrs
-
-def pick(L,c):
- """ computes L(c) """
- x=[]
- for i in range(len(c)):
- x = x + [L[c[i]]]
- return x
-
-def pick_not(L,c):
- """ computes L(~c)"""
- x = []
- for i in range(len(L)):
- if not i in c:
- x = x + [L[i]]
- return x
-
-def report_L(lst=[],v=0):
- """lst must refer to original PO numbering"""
- global _L_last
- if lst == []:
- return
- for j in lst:
- if _L_last[j] == -1: #means not reported yet
- _L_last[j] = v
- report_result(j,v)
-
-def report_s(s):
- """s must refer to original PO numbering
- Differs from above """
- global _L_last
- assert len(s) == len(_L_last), 'two lengths are not equal'
- if s == []:
- return
- for j in range(len(s)):
- if not _L_last[j] == s[j]: #means not reported yet
- assert _L_last[j] == -1, 'j = %d, _L_last[j] = %d, s[j] = %d'%(j,_L_last[j],s[j])
- if _L_last[j] == -1:
- _L_last[j] = s[j]
- report_result(j,s[j])
-
-
-def report_results(L,final_map=[],if_final=False):
- global _L_last,t_iter_start,file_out
- out = '\n@@@@ Time = %.2f: results = %s'%((time.time()- t_iter_start),sumsize(L))
- print out
- file_out.write(out + '\n')
- file_out.flush()
- for j in range(len(L)):
- if not L[j] == _L_last [j]:
- assert _L_last[j] == -1, '_L_last[j] = %d, L[j] = %d'%(_L_last[j],L[j])
- report_result(j,L[j])
- _L_last = list(L) #update _L_last
-## print 'report: _L_last = %s'%sumsize(_L_last)
- print '\n'
-
-def report_result(POn, REn, final_map=[]):
- if final_map == []:
- print 'PO = %d, Result = %d: '%(POn, REn),
- else:
- print 'PO = %d, Result = %d: '%(final_map[POn], REn),
-
-
-def scorr_T(t=10000):
- global smp_trace, scorr_T_done
- if scorr_T_done:
- return
- scorr_T_done = 1
- print 'Trying scorr_T (scorr -C 2, &scorr, &scorr -C 0)'
- funcs = [eval('(pyabc_split.defer(abc)("scorr -C 2"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("&get;&scorr;&put"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("&get;&scorr -C 0;&put"))')]
- funcs = create_funcs(slps,t)+funcs
- mtds = sublist(methods,slps) + ['scorr2','&scorr','&scorr0']
- best = n_ands()
- abc('w %s_best_T.aig'%f_name)
- name1 = '%s_sc1.aig'%f_name
- if os.access(name1,os.R_OK):
- os.remove(name1)
- name2 = '%s_sc2.aig'%f_name
- if os.access(name2,os.R_OK):
- os.remove(name2)
- name3 = '%s_sc3.aig'%f_name
- if os.access(name3,os.R_OK):
- os.remove(name3)
- N=m_best = 0
- for i,res in pyabc_split.abc_split_all(funcs):
- if i == 0:
- break
- if i == 1:
- abc('w %s_sc1.aig'%f_name)
- print 'scorr: ',
- ps()
- N=N+1
- if N == 3 or n_latches() == 0:
- break
- if i == 2 or n_latches() == 0:
- abc('w %s_sc2.aig'%f_name)
- print '&scorr: ',
- ps()
- N=N+1
- if N == 3:
- break
- if i == 3 or n_latches() == 0:
- abc('w %s_sc3.aig'%f_name)
- print '&scorr0: ',
- ps()
- N=N+1
- if N == 3:
- break
- if os.access(name1,os.R_OK):
- abc('r %s'%name1)
- if n_ands() < best:
- best = n_ands()
- m_best = 1
- abc('w %s_best_T.aig'%f_name)
- if os.access(name2,os.R_OK):
- abc('r %s'%name2)
- if n_ands() < best:
- m_best = 2
- best = n_ands()
- abc('w %s_best_T.aig'%f_name)
- if os.access(name3,os.R_OK):
- abc('r %s'%name3)
- if n_ands() < best:
- m_best = 3
- best = n_ands()
- abc('w %s_best_T.aig'%f_name)
- smp_trace = smp_trace + ['%s'%mtds[m_best]]
- abc('r %s_best_T.aig'%f_name)
-
-def pscorr(t=900):
- result = par_scorr(t)
- if n_ands() == 0:
- return result
- else:
- return 'UNDECIDED'
-
-def par_scorr(t=30,ratio = 1):
- t_init = time.time()
-## abc('dr -m;drw')
- abc('dretime;dc2')
- funcs = [eval('(pyabc_split.defer(abc)("scorr -vq -F 1"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("scorr -vq -F 2"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("scorr -vq -F 4"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("scorr -vq -F 8"))')]
- funcs = funcs + [eval('(pyabc_split.defer(abc)("scorr -vq -F 16"))')]
- funcs = create_funcs(slps,t)+funcs
- mtds = sublist(methods,slps) + ['scorr1','scorr2', 'scorr4', 'scorr8', 'scorr16']
- best = n_ands()
- print 'par_scorr: best = %d'%best
- abc('w %s_best.aig'%f_name)
- idone = []
- for i,res in pyabc_split.abc_split_all(funcs):
-## print i,res
- if i == 0: #timeout
- break
- else:
- idone = idone + [i]
- if n_ands() <= ratio * best:
- best = n_ands()
-## print 'par_scorr: best = %d, method = %s'%(best, mtds[i])
- abc('w %s_best.aig'%f_name)
- if best == 0 or len(idone) >= 5:
- mtd = mtds[i]
- break
- else:
- break
-## print 'Time: %.2f'%(time.time() - t_init)
- abc('r %s_best.aig'%f_name)
-## if best == 0:
-## print mtd
- return mtd
-
-def par_scorr_q(t=10000,ratio = 1):
- abc('dretime;dc2')
- abc('bmc2 -T 5')
- depth = n_bmc_frames()
- mtds = funcs = []
- n=1
- while True:
- funcs = funcs + [eval('(pyabc_split.defer(abc)("scorr -vq -F %d"))'%n)]
- mtds = mtds + ['scorr%d'%n]
- n = 2* n
- if n > max(1,min(depth,16)):
- break
- funcs = create_funcs(slps,t)+funcs
- mtds = sublist(methods,slps) + mtds
- best = n_ands()
- print 'best = %d'%best
- abc('w %s_best.aig'%f_name)
- idone = []
- for i,res in pyabc_split.abc_split_all(funcs):
-## print i,res
- if i == 0:
- break
- else:
- idone = idone + [i]
- if n_ands() <= ratio * best:
- best = n_ands()
- print 'best = %d, method = %s'%(best, mtds[i])
- abc('w %s_best.aig'%f_name)
- if best == 0 or len(idone) >= len(mtds)-1:
- break
- else:
- break
- abc('r %s_best.aig'%f_name)
-
-
-def indicate_0_pos(L2):
- """
- puts 0's in L2 where the corresponding output is driven by a const-0
- """
-## assert n_pos() == len(L2), 'list L2=%d and n_pos=%d in current AIG dont match'%(len(L2),n_pos())
- for j in range(n_pos()):
- i=is_const_po(j)
- if i == 0:
- L2[j]=0
- return L2
-
-def list_0_pos():
- """
- returns indices of outputs driven by const-0
- """
- L = []
- for j in range(n_pos()):
- i=is_const_po(j) #returns const value of PO if const. Else -1
- if i == 0:
- L = L + [j]
- return L
-
-def mprove2(L=0,op='simple',t=100,nn=0):
- global _L_last, f_name, skip_spec
- print 'mprove2 entered' ,
- if L == 0:
- L = [-1]*n_pos()
- ps()
- print 'mprove2 entered with L = ',
- print sumsize(L)
- abc('w %s_mp2.aig'%f_name) #save aig before pos removed
- old_f_name = f_name #we may call sp() which can change f_name
- n = count_less(L,0)
- ind = []
- for j in range(len(L)):
- if L[j] > -1:
- ind = ind +[j]
- if len(ind) == n_pos(): #all POs already solved
- return 'ALL_SOLVED',L
- remove(ind,-1) #remove solved POs
- if len(ind)>0:
- print 'Removed %d proved POs'%len(ind)
- if n_pos() == 0:
- f_name = old_f_name
- abc('r %s_mp2.aig'%f_name)
- return 'ALL_SOLVED',L
- ps()
- N = n_pos()
- if N == 1: #only one PO left
- v = -1
- skip_spec_old = skip_spec
- skip_spec = True
- result = simple(2000,1)
- ff_name == f_name
- result = sp(0,2000) #warning sp() can change f_name. 0 means simplify
- f_name = ff_name
- skip_spec = skip_spec_old
- res = result[0]
- print 'result of sp = ',
- print res
-#### print result
- if res == 'SAT':
- v = 1
- if res == 'UNSAT':
- v = 0
- i = L.index(-1)
-## print 'i=%d,v=%d,L=%s'%(i,v,str(L))
- L[i] = v
- f_name = old_f_name #if sp() changed f_name need to revert to old f_name
- abc('r %s_mp2.aig'%f_name)
- print 'reverting %s_mp2.aig'%f_name,
- ps()
- print sumsize(L)
- if v > -1:
- res = 'ALL_SOLVED'
- return res,L
- r = pre_simp()
- NP = n_pos()/N
- L1 = [-1]*n_pos()
- Llst0 = []
- if r[0] == Unsat:
- L1 = [0]*N
- else:
- Llst0 = list_0_pos()
- Llst0.sort()
- print 'Llst0 = %s'%str(Llst0)
- n_0 = len(Llst0)
- if n_0 > 0:
-## print 'Found %d const-0 POs'%n_0
- remove(Llst0,0)
- print 'Removed %d const-0 POs'%len(Llst0)
- if NP > 1: # we want to do iso here because more than one phase was found.
- iso() # additional iso - changes number of POs
- map3 = create_map(eq_classes(),N) #creates map into previous
-## tb = min(n_pos(),20)
- N = n_pos()
- tb = min(N,50)
-## print 'Trying par_multi_sat for %d sec.'%tb
- S,lst1,s = par_multi_sat(tb,1,1,0) #this gives a list of SAT POs
- L2 = s10 = s
- n_solved = n_pos() - count_less(s10,0)
- if 1 in s10 or 0 in s10: #something solved
- if n_solved < N: #not all solved
- rem = indices(s,0)+indices(s,1)
- rem.sort()
- remove(rem,1)
- """ if lst1 > 1 element, simplify and run par_multi_sat again to get lst2
- then merge lst1 and lst2 appropriately to create new lst1 for below.
- """
- tb = tb+25
- gap = max(15,.2*tb)
- if len(rem) > 0:
- s210 = s10
- #iterate here as long as more than 1 PO is found SAT
- n_solved = n_pos() - count_less(s210,0)
- while n_solved > 0:
- gap = int(1+1.2*gap)
- print 'gap = %.2f'%gap
- pre_simp(1) #warning this may create const-0 pos
- S,lst2,s = par_multi_sat(tb,gap,1,0) #this can find UNSAT POs
- s210 = s
- n_solved = n_pos() - count_less(s210,0)
- s10 = put(s210,list(s10)) #put the new values found into s10
- if count_less(s10,0) == 0 or n_solved == 0: #all solved or nothing solved
- break #s10 has the results
- else:
- out = '\n@@@@ Time = %.2f: additional POs found SAT = %d'%((time.time()- t_iter_start),len(lst2))
- print out
- file_out.write(out + '\n')
- file_out.flush()
- rem = indices(s210,0)+indices(s210,1)
- rem.sort()
- remove(rem,1) #this zeros the l210 and then removes ALL const-1 POs.
- #If there are more than lst2 removed, it fires an assertion.
- continue
- L2 = s10 #put results in s10
- else: #lst1 is empty or S == SAT'
- print 'no cex found or S = UNSAT'
- else: #all solved
- print 'all POs solved'
- print 'Removed %d solved POs'%(len(s10) - count_less(s10,0))
- else:
- print 'nothing solved'
- write_file('bmc2')
- if -1 in s10:
- print 'Entering solve_all ',
- ps()
- S,s210 = solve_all([-1]*n_pos(),900) #solve_all calls sp() or simple but preserves the aig and f_name
-## else: zzz
- if -1 in s210: #then no POs were solved by solve_all
-## abc('r %s_smp2_2.aig'%f_name)
- if n_pos() < 50:
- print 'Entering mprove with %d sec. for each cone'%t,
- ps()
- print 'L2 before mprove: %s'%sumsize(L2)
- s210 = mprove([-1]*n_pos(),op,t) #proving each output separately
- else:
- s210 = [-1]*n_pos()
- print 's210 after mprove and before inject 1 %s:'%sumsize(s210)
- L2 = put(s210,s10)
- print 'L2 after inject 1 %s:'%sumsize(L2)
- else: #all POs solved
- L2 = s10
- assert NP == 1, 'NP > 1: ERROR'
- if NP>1:
- print 'NP = %d'%NP
- print 'L1 before unmap3: %s'%sumsize(L1) #L1 should be all -1's of length before iso
- L1 = unmap(list(L1),L2,map3)
- print 'L1 after unmap of map3: ',
- print sumsize(L1)
- else:
- print 'L2 = %s'%str(L2)
- L1 = L2
- L1 = inject(list(L1),Llst0,0)
- print 'L1 after inject of Llst0 0s: %s:'%sumsize(L1)
- if NP >1:
- L1 = check_and_trim_L(NP,L1)
- assert len(L1)<=len(L),"L1 = %d larger than L = %d"%(len(L1),len(L))
-## print 'L = %s'%str(L)
- L = insert(L1,list(L)) # replace -1s in L with values in L1. Size of L1<=L L is really L2
- print sumsize(L)
- f_name = old_f_name
- abc('r %s_mp2.aig'%f_name) #restore aig
- if 1 in L:
- S = 'SAT'
- if not -1 in L:
- S = 'ALL_PROVED'
- return S,L
-
-def merge(L1,L2,n=0):
- """L2 refers to POs that were solved after POs in L1 were removed
- modifies L2 to refer to the original POs.
- if n=0 adds in L1 and sorts
- """
- if L1 == []:
- return L2
- if L2 == []:
- if n == 0:
- return L1
- else:
- return []
- m = max(L1)
- LL1 = L1 + [3+m+max(L2)] #this makes sure that there are enough gaps
- g = gaps(LL1)
-## print g
- L = []
- for i in range(len(L2)):
- l2i=L2[i]
- assert l2i < len(g),'ERROR, L2 = %s,g = %s'%(str(L2),str(g))
- L = L + [g[l2i]]
-## print L
- if n == 0:
- L = L + L1
- L.sort()
- return L #L is already sorted
-
-def put(s2,s11):
- """ put in the values of s2 into where there are -1's in s1 into s1
- return s2 """
- s1 = list(s11)
- k = 0
- assert len(s2) == count_less(s1,0),'mismatch in put'
- for j in range(len(s1)):
- if s1[j] == -1:
- s1[j] = s2[k]
- k=k+1
- return s1
-
-def gaps(L1):
- """L2 refers to POs that were solved after POs in L1 were removed
- modifies L2 to refer to the original POs.
- if n=0 adds in L1 and sorts
- """
- if L1 == [] or max(L1)+1 == len(L1):
- return []
- L1_gaps = []
- i=0
- for j in range(len(L1)):
- lj=L1[j]
-## print lj,i
- if lj == i:
- i = i+1
- continue
- assert lj > i,'Error'
- while lj > i:
- L1_gaps = L1_gaps + [i]
- i = i+1
-## print L1_gaps
- i=i+1
- return L1_gaps
-
-## j=i=0
-## L = []
-## L1.sort()
-## L2.sort()
-## LL1 = L1 + [10000000] #make sure list L2 is processed to the end
-#### print 'L1 and L2 is sorted %d, %d: '%(len(L1),len(L2))
-## if not L2 == []:
-## while True:
-## ## print i,j
-## if LL1[i] <= L2[j]:
-## i = i+1
-## else:
-## L= L + [L2[j] + i]
-## ## print L
-## j = j+1
-## if j == len(L2):
-## break
-## if n == 0:
-## L = L + L1
-## L.sort()
-## return L #L is already sorted
-
-
-def solve_all(L2,t):
- global f_name, skip_spec
- abc('w %s_solve_all.aig'%f_name)
- old_f_name = f_name
-## abc('orpos')
-## print 'solve_all for %.2f sec.: '%t,
-## ps()
- skip_spec_old = skip_spec
- skip_spec = True
- tt = max(t,900)
- print 'Entering simple for %d sec.'%tt
- result = simple(tt,1) #### temporary 1 means do not simplify
-## result = sp(0,t) #warning sp() may change f_name
- skip_spec = skip_spec_old
-## print 'solve_all: result = %s'%result
- if result[0] == 'UNSAT':
- L2 = [0]*len(L2)
- f_name = old_f_name
- abc('r %s_solve_all.aig'%f_name)
- return result[0],L2
-
-def inject(L,lst,v):
- """
- expends the len(L) by len(lst). puts value v in expanded position
- Preserves values in L
- """
- k = i = j = 0 #i indexes L, j indexes lst, and k is total length of LL
- if lst == []:
- return L
- LL = []
- N = len(L) + len(lst)
- while True:
- if lst[j] == k:
- LL= LL + [v]
- if j < len(lst)-1:
- j = j+1
- else:
- LL = LL + [L[i]]
- if i < len(L)-1:
- i = i+1
- k = k+1
- if k >= N:
- break
- return LL
-
-def insert(L1,L):
- """ insert L1 in L and return L"""
- k=0
- for j in range(len(L)):
- if L[j] > -1:
- continue
- else:
- L[j] = L1[k]
- k = k+1
- if k >= len(L1):
- break
- return L
-
-
-
-def duplicate_values(L1,NP):
- """ append values """
-## L=L1*NP
- L = L1
- for j in range(NP-1):
- L = L+[-1]*len(L1)
- return L
-
-##def duplicate_values2(L1,NP):
-## """ interleave values """
-## L = []
-## for j in range(len(L1)):
-## v = L1[j]
-## L = L + [v]*NP
-## return L
-
-def check_and_trim_L(NP,L):
- """This happens when an unrolling creates additional POs
- We want to check that L[j] = L[j+kN] etc to make sure the PO results agree
- in all phases, i.e. sat, unsat, or undecided. if one is sat then make all L[j+kN] sat,
- If one is unsat, then all L[j+kN] must be unsat. If not then make L[j]=-1.
- Return first N of L.
- """
- N = len(L)/NP #original number of POs
- for j in range(N):
- if L[j] == 1:
- continue
- for k in range(NP)[1:]: #k = 1,2,...,NP-1
- if L[j+k*N] == 1:
- L[j] = 1
- break
- elif L[j] == -1:
- continue #we have to continue to look for a 1
- elif L[j] == 0:
- if L[j+k*N] == -1:
- print 'some copies of PO unsat and some undecided'
- L[j] = -1
- break
- continue #have to make sure that all phases are 0
- return L[:N]
-
-def pass_down(L,L1,map):
- """map maps L into L1.Populate L1 with values in L"""
-## print len(L),len(L1),len(map),max(map)
-## print sumsize(L)
-## print sumsize(L1)
- for j in range(len(map)):
- if L[j] == -1:
- continue
- assert L1[map[j]] == -1 or L1[map[j]] == L[j], 'L1=%d, L = %d'%(L1[map[j]],L[j])
- L1[map[j]] = max(L[j],L1[map[j]])
- return L1
-
-def mpr():
- tt = time.time()
- N=n_pos()
- r = pre_simp()
- if r == Unsat:
- L = [0]*N
- else:
- L = mprove([-1]*n_pos(),'simple',100)
- L = L[:N]
- print sumsize(L)
- print 'Time = %.2f'%(time.time() - tt)
- return L
-
-
-def mprove(L,op='simple',tt=1000):
- """ 0 = unsat, 1 = sat, -1 = undecided"""
- global max_bmc, init_initial_f_name, initial_f_name,win_list, last_verify_time
- global f_name_save, nam_save, temp_dec, f_name
- f_name_save = f_name
- nam_save = '%s_mp_save.aig'%f_name
- abc('w %s'%nam_save)
- N = len(L)
- print 'Length L = %d, n_pos() = %d'%(len(L),n_pos())
- t = tt #controls the amount of time spent on each cone
- funcs = [eval('(pyabc_split.defer(%s)())'%op)]
- funcs = create_funcs(slps,t)+funcs
- mtds = sublist(methods,slps) + [op]
- res = L
- NN = count_less(L,0)
- rr = range(N)
- rr.reverse()
- init_name = init_initial_f_name
- for j in rr:
- if L[j] > -1:
- continue #already solved
- print '\n************** No. Outputs = %d ******************************'%NN
- abc('r %s'%nam_save) #restore original function
-## ps()
- x = time.time()
- name = '%s_cone_%d.aig'%(f_name,j)
- print '________%s(%s)__________'%(op,name)
- abc('cone -s -O %d;scl'%j)
- abc('w %s_cone.aig'%f_name)
-## ps()
- read_file_quiet_i('%s_cone.aig'%f_name) #needed to reset initial settings
-## ps()
- temp_dec = False
- i,result = fork_last(funcs,mtds)
-## print '\ni = %d, result = %s'%(i,str(result))
- f_name = f_name_save #restore original f_name
- T = '%.2f'%(time.time() - x)
- out = get_status()
-## print '\nout= %d, result = %s'%(out,str(result))
- rslt = Undecided
- if not out == result:
- print 'out = %d, result = %d'%(out,result)
-## assert out == result,'out = %d, result = %d'%(out,result)
- if out == Unsat or result == 'UNSAT' or result == Unsat:
- res[j] = 0
- rslt = Unsat
- if out < Unsat:
- res[j] = 1
- rslt = Sat
- print '\n%s: %s in time = %s'%(name,RESULT[rslt],T)
- abc('r %s'%nam_save) #final restore of original function for second mprove if necessary.
- init_initial_f_name = init_name
-## print res
- return res
-
-##def sp1(options = ''):
-## global sec_options
-## sec_options = options
-## return super_prove(1)
-
-def super_prove(n=0,t=900):
- """Main proof technique now. Does original prove and if after speculation there are multiple output left
- if will try to prove each output separately, in reverse order. It will quit at the first output that fails
- to be proved, or any output that is proved SAT
- n controls call to prove(n)
- is n == 0 do smp and abs first, then spec
- if n == 1 do smp and spec first then abs
- if n == 2 just do quick simplification instead of full simplification, then abs first, spec second
- """
- global max_bmc, init_initial_f_name, initial_f_name,win_list, last_verify_time, f_name
-## print 'sec_options = %s'%sec_options
-## init_initial_f_name = initial_f_name
- size = str([n_pis(),n_pos(),n_latches(),n_ands()])
- add_trace('[%s: size = %s ]'%(f_name,size))
- if x_factor > 1:
- print 'x_factor = %f'%x_factor
- input_x_factor()
- max_bmc = -1
- x = time.time()
- add_trace('prove')
- result = prove(n)
- print 'prove result = ',
- print result
- tt = time.time() - x
- if ((result == 'SAT') or (result == 'UNSAT')):
- print '%s: total clock time taken by super_prove = %0.2f sec.'%(result,tt)
- add_trace('%s'%result)
- add_trace('Total time = %.2f'%tt)
- print m_trace
- return [result]+[m_trace]
- elif ((result == 'UNDECIDED') and (n_latches() == 0)):
- add_trace('%s'%result)
- add_trace('Total time = %.2f'%tt)
- print m_trace
- return [result]+[m_trace]
- print '%s: total clock time taken by super_prove so far = %0.2f sec.'%(result,(time.time() - x))
- y = time.time()
- print 'Entering BMC_VER_result'
- add_trace('BMC_VER_result')
- result = BMC_VER_result() #this does backing up if cex is found
- print 'Total clock time taken by last gasp verification = %0.2f sec.'%(time.time() - y)
- tt = time.time() - x
- print 'Total clock time for %s = %0.2f sec.'%(init_initial_f_name,tt)
- add_trace('%s'%result)
- add_trace('Total time for %s = %.2f'%(init_initial_f_name,tt))
-## print m_trace
- return [result]+[m_trace]
-
-def reachm(t):
- x = time.clock()
- abc('&get;&reachm -vcs -T %d'%t)
- print 'reachm done in time = %f'%(time.clock() - x)
- return get_status()
-
-def reachp(t):
- x = time.clock()
- abc('&get;&reachp -rv -T %d'%t)
- print 'reachm2 done in time = %f'%(time.clock() - x)
- return get_status()
-
-def scorr():
- run_command('scorr')
- ps()
-
-def select_undecided(L):
- res = []
- for j in range(len(L)):
- l = L[j]
- if l[1] == 'UNDECIDED':
- res = res + [l[0]]
- return res
-
-####def execute(L,t):
-#### """
-#### run the files in the list L using ss, sp, ssm each for max time = t
-#### """
-#### funcs1 = [eval('(pyabc_split.defer(ss)())')]
-#### funcs1 = create_funcs(slps,t)+funcs1
-#### mtds1 =sublist(methods,slps) + ['ss']
-#### funcs2 = [eval('(pyabc_split.defer(sp)())')]
-#### funcs2 = create_funcs(slps,t)+funcs2
-#### mtds2 =sublist(methods,slps) + ['sp']
-#### funcs3 = [eval('(pyabc_split.defer(ssm)())')]
-#### funcs3 = create_funcs(slps,t)+funcs3
-#### mtds3 =sublist(methods,slps) + ['ssm']
-#### for j in range(len(L)):
-#### name = L[j]
-#### print '\n\n\n\n________ss__________'
-#### read_file_quiet(name)
-#### print '****ss****'
-#### fork_last(funcs1,mtds1)
-#### print '***Done with ss on %s\n'%name
-#### print '\n\n******ssm************'
-#### read_file_quiet(name)
-#### print '****ssm****'
-#### fork_last(funcs3,mtds3)
-#### print '***Done with ssm on %s \n'%name
-
-def execute_op(op,L,t):
- """
- run the files in the list L using operation "op", each for max time = t
- """
- global res
- funcs = [eval('(pyabc_split.defer(%s)())'%op)]
- funcs = create_funcs(slps,t)+funcs
- mtds =sublist(methods,slps) + [op]
- res = []
- for j in range(len(L)):
- x = time.time()
- name = L[j]
- print '\n\n\n\n________%s__________'%op
- read_file_quiet_i(name)
- m,result = fork_last(funcs,mtds)
- if result == Undecided:
- result = RESULT[result]
- T = '%.2f'%(time.time() - x)
- new_res = [name,result,T]
- res = res + [new_res]
- print '\n%s'%new_res
- return res
-
-def x_ops(ops,L,t):
- """ execute each op in the set of ops on each file in the set of files of L, each for time t"""
- result = []
- for j in range(len(ops)):
- op = ops[j]
- result.append('Result of %s'%op)
- result.append(execute_op(op,L,t))
- return result
-
-def iso(n=0):
- if n_ands() > 500000:
- return False
- if n_pos() < 2:
- print 'no more than 1 output'
- return False
- npos=n_pos()
- if n == 0:
- abc('&get;&iso -q;&put')
- if n_pos() == npos:
- print 'no reduction'
- return False
- else:
- run_command('&get;&iso;iso;&put')
- if n_pos() == npos:
- print 'no reduction'
- return False
- print 'Reduced n_pos from %d to %d'%(npos,n_pos())
- return True
-
-def check_iso(N):
- ans = get_large_po()
- if ans == -1:
- return 'no output found'
- n_iso = count_iso(N)
- return n_iso
-
-def count_iso(N):
- abc('&get;write_aiger -u file1.aig') #put this cone in & space and write file1
-## print 'PO %d is used'%i
- n_iso = 0 #start count
- for i in range(N):
- abc('permute;write_aiger -u file2.aig')
- n = filecmp.cmp('file1.aig','file2.aig')
- print n,
- n_iso = n_iso+n
- print 'the number of isomorphisms was %d out of %d'%(n_iso,N)
- return n_iso
-
-def get_large_po():
-## remove_const_pos() #get rid of constant POs
- NL = n_latches()
- NO = n_pos()
- abc('&get') #put the in & space
- n_latches_max = 0
- nl = imax = -1
- for i in range(NO): #look for a big enough PO
- abc('&put;cone -s -O %d;scl'%i)
- nl = n_latches()
- if nl >.15*NL:
- imax = i
-## print 'cone %d has %d FF'%(i,nl)
- break
- if nl> n_latches_max:
- n_latches_max = nl
- imax = i
- print i,nl
- if i == NO-1:
- print 'no PO is big enough'
- return -1
- print 'PO_cone = %d, n_latches = %d'%(imax,nl)
-
-def scorro():
- run_command('scorr -o')
- l = remove_const_pos(0)
- ps()
-
-def drw():
- run_command('drw')
- ps()
-
-def dc2rs():
- abc('dc2rs')
- ps()
-
-def reachn(t):
- x = time.clock()
- abc('&get;&reachn -rv -T %d'%t)
- print 'reachm3 done in time = %f'%(time.clock() - x)
- return get_status()
-
-def reachx(t=900):
- x = time.time()
- abc('reachx -t %d'%t)
- print 'reachx done in time = %f'%(time.time() - x)
- return get_status()
-
-def reachy(t=900):
- x = time.clock()
- abc('&get;&reachy -v -T %d'%t)
-## print 'reachy done in time = %f'%(time.clock() - x)
- return get_status()
-
-def create_funcs(J,t):
- """evaluates strings indexed by J in methods given by FUNCS
- Returns a list of lambda functions for the strings in FUNCs
- If J = [], then create provers for all POs"""
- funcs = []
- for j in range(len(J)):
- k=J[j]
- funcs = funcs + [eval(FUNCS[k])]
- return funcs
-
-def check_abs():
- global init_initial_f_name
- abc('w %s_save.aig'%init_initial_f_name)
- ni = n_pis()
- nl = n_latches()
- na = n_ands()
- abc('r %s_smp_abs.aig'%init_initial_f_name)
- if ((ni == n_pis()) and (nl == n_latches()) and (na == n_ands())):
- return True
- else:
- abc('r %s_save.aig'%init_initial_f_name)
- return False
-
-def modify_methods(J,dec=0):
- """ adjusts the engines to reflect number of processors"""
- N = bmc_depth()
- L = n_latches()
- I = n_real_inputs()
- npr = n_proc - dec
- reachi = reachs
- if 18 in J: #if sleep in J add 1 more processor
- npr = npr+1
- if ( ((I+L<550)&(N>100)) or (I+L<400) or (L<80) ):
- if not 24 in J: #24 is reachy
- if L < 70 and not 4 in reachs:
- reachi = [4]+reachs #[4] = reachx
- J = reachi+J # add all reach methods
- if len(J)>npr:
- J = remove_intrps(J) #removes only if len(J)<n_processes
- if len(J)< npr: #if not using all processors, add in pdrs
- for j in range(len(allpdrs)):
- if allpdrs[j] in J: #leave it in
- continue
- else: #add it in
- J = J + [allpdrs[j]]
- if len(J) == npr:
- break
- if len(J)>npr:
- J = remove_intrps(J)
- return J
-
-def BMC_VER():
- """ a special version of BMC_VER_result that just works on the current network
- Just runs engines in parallel - no backing up
- """
- global init_initial_f_name, methods, last_verify_time, n_proc,last_gasp_time
- xt = time.time()
- result = 5
- t = max(2*last_verify_time,last_gasp_time) ####
- print 'Verify time set to %d'%t
- J = slps + pdrs + bmcs + intrps
- J = modify_methods(J)
- F = create_funcs(J,t)
- mtds = sublist(methods,J)
- print mtds
- (m,result) = fork_break(F,mtds,'US')
- result = RESULT[result]
- print 'BMC_VER result = %s'%result
- return result
-
-def BMC_VER_result(t=0):
-## return 'UNDECIDED' #TEMP
- global init_initial_f_name, methods, last_verify_time,f_name,last_gasp_time
- xt = time.time()
- result = 5
- abc('r %s.aig'%f_name)
- abc('scl')
- print '\n***Running proof on %s after scl:'%f_name,
- ps()
- if t == 0:
- t = max(2*last_verify_time,last_gasp_time) #each time a new time-out is set t at least 1000 sec.
- print 'Verify time set to %d'%t
- J = slps + allpdrs2 + bmcs + intrps + sims
- last_name = seq_name(f_name).pop()
- if not last_name in ['abs','spec']:
- J = slps +allpdrs2 +bmcs + intrps + sims
-## if 'smp' == last_name or last_name == f_name: # then we try harder to prove it.
- J = modify_methods(J) #if # processors is enough and problem is small enough then add in reachs
- F = create_funcs(J,t)
- mtds = sublist(methods,J)
- print '%s'%mtds
- (m,result) = fork(F,mtds)
- result = get_status()
- if result == Unsat:
- return 'UNSAT'
-## if last_name == 'smp' or last_name == f_name: # can't backup so just return result
- if not last_name in ['abs','spec']:
- if result < Unsat:
- return 'SAT'
- if result > Unsat: #still undecided
- return 'UNDECIDED'
- else: # (last_name == 'spec' or last_name == 'abs') - the last thing we did was an "abstraction"
- if result < Unsat:
- if last_name == 'abs':
- add_trace('de_abstract')
- if last_name == 'spec':
- add_trace('de_speculate')
- f_name = revert(f_name,1) # revert the f_name back to previous
- abc('r %s.aig'%f_name)
- abc('scl')
- return BMC_VER_result() #recursion here.
- else:
- return 'UNDECIDED'
-
-def try_split():
- abc('w %s_savetemp.aig'%f_name)
- na = n_ands()
- split(3)
- if n_ands()> 2*na:
- abc('r %s_savetemp.aig'%f_name)
-
-def time_diff():
- global last_time
- new_time = time.clock()
- diff = new_time - last_time
- last_time = new_time
- result = 'Lapsed time = %.2f sec.'%diff
- return result
-
-def prove_all_ind():
- """Tries to prove output k by induction, using other outputs as constraints.
- If ever an output is proved
- it is set to 0 so it can't be used in proving another output to break circularity.
- Finally all zero'ed outputs are removed.
- Prints out unproved outputs Finally removes 0 outputs
- """
- global n_pos_proved, n_pos_before
- print 'n_pos_proved = %d'%n_pos_proved
- n_proved = 0
- N = n_pos()
-## l=remove_const_pos()
-## print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- if n_pos() == 1:
- return
- abc('w %s_osavetemp.aig'%f_name)
- lst = range(n_pos())
-## lst.reverse()
-## list.reverse()
-## for j in list[1:]:
- for j in lst:
-## abc('zeropo -N 0')
- abc('swappos -N %d'%j)
-## l=remove_const_pos() #may not have to do this if constr works well with 0'ed outputs
- abc('constr -N %d'%(n_pos()-1))
- abc('fold')
- n = max(1,n_ands())
- f = max(1,min(40000/n,16))
- f = int(f)
-## abc('ind -C 10000 -F %d'%f)
- abc('ind -C 1000 -F %d'%f)
-## run_command('print_status')
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name) #have to restore original here
- if status == Unsat:
-## print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- if j < n_pos_before - n_pos_proved:
- n_proved = n_proved + 1 # keeps track of real POs proved.
- elif status < Unsat:
- print '-%d'%j,
- else:
- print '*%d'%j,
- l=remove_const_pos(0)
- n_pos_proved = n_pos_proved + n_proved
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- print 'n_pos_proved = %d'%n_pos_proved
- #return status
-
-def remove_iso(L):
- global n_pos_proved, n_pos_before
- lst = []
- for j in range(len(L)):
- ll = L[j][1:]
- if len(ll) == 0:
- continue
- else:
- lst = lst + ll
- zero(lst)
- n_pos_proved = n_pos_proved + count_less(lst,n_pos_before - n_pos_proved)
- print 'The number of POs removed by iso was %d'%len(lst)
- l=remove_const_pos(0) #can an original PO be zero?
-
-def prove_all_iso():
- """Tries to prove output k by isomorphism. Gets number of iso-eq_classes as an array of lists.
- Updates n_pos_proved
- """
- global n_pos_proved, n_pos_before
- n_proved = 0
- N = n_pos()
- if n_pos() == 1:
- return
- print 'n_pos_proved = %d'%n_pos_proved
-## run_command('&get;&iso;&put')
- abc('&get;&iso')
- L = eq_classes()
-## print L
- remove_iso(L)
- print '\nThe number of POs reduced by iso was from %d to %d'%(N,n_pos())
-
-def count_less(L,n):
- count = 0
- for j in range(len(L)):
- if L[j] < n:
- count = count + 1
- return count
-
-def prove_all_mtds(t):
- """
- Tries to prove output k with multiple methods in parallel,
- using other outputs as constraints. If ever an output is proved
- it is set to 0 so it can't be used in proving another output to break circularity.
- Finally all zero'ed ooutputs are removed.
- """
- N = n_pos()
-## l=remove_const_pos()
-## print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- run_command('swappos -N %d'%j)
-## l=remove_const_pos() #may not have to do this if constr works well with 0'ed outputs
- abc('constr -N %d'%(n_pos()-1))
- abc('fold')
-## cmd = '&get;,pdr -vt=%d'%t #put in parallel.
-## abc(cmd)
- verify(pdrs+bmcs+intrps+sims,t)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- assert not is_sat(), 'one of the POs is SAT' #we can do better than this
- l=remove_const_pos(0)
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def prove_all_pdr(t):
- """Tries to prove output k by pdr, using other outputs as constraints. If ever an output is proved
- it is set to 0 so it can't be used in proving another output to break circularity.
- Finally all zero'ed outputs are removed. """
- N = n_pos()
-## l=remove_const_pos()
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- abc('swappos -N %d'%j)
-## l=remove_const_pos() #may not have to do this if constr works well with 0'ed outputs
- abc('constr -N %d'%(n_pos()-1))
- abc('fold')
- cmd = '&get;,pdr -vt=%d'%t #put in parallel.
- abc(cmd)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- l=remove_const_pos(0)
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def prove_each_ind():
- """Tries to prove output k by induction, """
- N = n_pos()
- l=remove_const_pos(0)
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- abc('cone -s -O %d'%j)
- n = max(1,n_ands())
- f = max(1,min(40000/n,16))
- f = int(f)
- abc('ind -u -C 10000 -F %d'%f)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- l=remove_const_pos(0)
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def prove_each_pdr(t):
- """Tries to prove output k by PDR. If ever an output is proved
- it is set to 0. Finally all zero'ed ooutputs are removed. """
- N = n_pos()
- l=remove_const_pos(0)
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- abc('cone -O %d -s'%j)
- abc('scl -m')
- abc('&get;,pdr -vt=%d'%t)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Unsat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- l=remove_const_pos(0)
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def disprove_each_bmc(t):
- """Tries to prove output k by PDR. If ever an output is proved
- it is set to 0. Finally all zero'ed ooutputs are removed. """
- N = n_pos()
- l=remove_const_pos(0)
- print '0 valued output removal changed POs from %d to %d'%(N,n_pos())
- abc('w %s_osavetemp.aig'%f_name)
- list = range(n_pos())
- for j in list:
- abc('cone -O %d -s'%j)
- abc('scl -m')
- abc('bmc3 -T %d'%t)
- status = get_status()
- abc('r %s_osavetemp.aig'%f_name)
- if status == Sat:
- print '+',
- abc('zeropo -N %d'%j)
- abc('w %s_osavetemp.aig'%f_name) #if changed, store it permanently
- print '%d'%j,
- l=remove_const_pos(0)
- print '\nThe number of POs reduced from %d to %d'%(N,n_pos())
- #return status
-
-def add_pord(s):
- global pord_trace
- pord_trace = pord_trace + [s]
-
-def pord_1_2(t):
- """ two phase pord. First one tries with 10% of the time. If not solved then try with full time"""
- global n_pos_proved, ifpord1, pord_on, pord_trace
- #first eliminate easy POs
- ttt = n_ands()/1000
- if ttt < 100:
- ttt=100
- elif ttt<200:
- ttt = 200
- elif ttt< 300:
- ttt = 300
- else:
- ttt = 500
- S,lst,L = par_multi_sat(ttt,1,1,1)
- lst = indices(L,1)
- if 1 in L:
- return [Sat]+[['par_multi_sat: SAT']]
- if -1 in L:
- restrict_v(L,-1)
- else: return [Unsat] + [['par_multi_sat: UNSAT']]
- pord_trace = []
- pord_on = True # make sure that we do not reparameterize after abstract in prove_2
- n_pos_proved = 0
- if n_pos()<4:
- return [Undecided] +[pord_trace]
- if ifpord1:
- add_pord('pord1')
- t_time = .1*t
- print 'Trying each output for %0.2f sec'%(.1*t)
- result = pord_all(.1*t) #we want to make sure that there is no easy cex.
- if (result <= Unsat):
- return [result] + [pord_trace]
- return [Undecided] + [pord_trace]
-
-def pord_all(t,n=4):
- """Tries to prove or disprove each output j by PDRM BMC3 or SIM. in time t"""
- global cex_list, n_pos_proved, last_cx, pord_on, ifpord1,pord_trace
- print 'last_cx = %d, time = %0.2f'%(last_cx,t)
- btime = time.time()
- N = n_pos()
- prove_all_ind() ############ change this to keep track of n_pos_proved
- nn = n_pos()
- abc('w %s_osavetemp.aig'%f_name)
- if nn < n or nn*t > 300: #Just cut to the chase immediately.
- return Undecided
- lst = range(n_pos())
- proved = disproved = []
- abc('&get') #using this space to save original file.
- ### Be careful that & space is not changed.
- cx_list = []
- n_proved = 0
- lcx = last_cx + 1
- lst = lst[lcx:]+lst[:lcx]
- lst.reverse()
- n_und = 0
- for j in lst:
- print '\ncone %s. '%j,
- abc('&r -s %s_osavetemp.aig'%f_name) #for safety
- abc('&put; cone -s -O %d'%j) #puts the &space into reg-space and extracts cone j
- #requires that &space is not changed. &put resets status. Use &put -s to keep status
- abc('scl -m')
- ps()
-## print 'running sp2'
- ###
- result = run_sp2_par(t)
- if result == 'UNDECIDED':
- n_und = n_und + 1
- status = Undecided
- if ((n_und > 1) and not ifpord1):
- break
- elif result == 'SAT':
- status = Sat
- disproved = disproved + [j]
- last_cx = j
- cx = cex_get()
- cx_list = cx_list + [cx]
- assert len(cx_list) == len(disproved), cx_list
- if len(cx_list) > 0:
- break
- else: #is unsat here
- status = Unsat
- proved = proved + [j]
- if j < n_pos_before - n_pos_proved:
- n_proved = n_proved +1
-## n_pos_proved = n_pos_proved + n_proved. #this should not be here because we should start fresh
- print '\nProved %d outputs'%len(proved)
- print 'Disproved %d outputs'%len(disproved)
- print 'Time for pord_all was %0.2f'%(time.time() - btime)
- NN = len(proved+disproved)
- cex_list = cx_list
- if len(disproved)>0:
- assert status == Sat, 'status = %d'%status
- n_pos_proved = 0 #we want to reset this because of a bad speculation
- return Sat
- else:
- n_pos_proved = n_pos_proved + n_proved
- if nn == n_pos_proved:
- return Unsat
- abc('r %s_osavetemp.aig'%f_name)
-## abc('&put') # returning original to work spece
- remove(proved,0)
- print '\nThe number of unproved POs reduced from %d to %d'%(N,n_pos()),
- ps()
- if n_pos() > 0:
- return Undecided
- else:
- return Unsat
-
-def bmc_ss(t):
- """
- finds a set cexs in t seconds starting at 2*N where N is depth of bmc -T 1
- The cexs are put in the global cex_list
- """
- global cex_list
- x = time.time()
- abc('bmc3 -a -C 1000000 -T %f'%(t))
- if is_sat():
- cex_list = cex_get_vector() #does this get returned from a concurrent process?
- n = count_non_None(cex_list)
- L = list_non_None(cex_list)
- print '%d cexs found in %0.2f sec'%(n,(time.time()-x))
-## remove_disproved_pos(cex_list)
- else:
- L = []
- return L
-
-def iso_slp(t=30):
- F = [eval('pyabc_split.defer(sleep)(t))')]
- F = F = F+[eval('(pyabc_split.defer(iso)())')]
- for i,res in pyabc_split.abc_split_all(F):
- if i == 0:
- return
-
-##def iter_par_multi_sat(t=10,m=1):
-## while True:
-## abc('w %s_save.aig'%f_name)
-## S,lst1 = par_multi_sat(t,m) #run 3 engines in parallel looking for SAT outputs
-## lst1.sort()
-## print 'Found %d SAT POs'%len(lst1)
-## abc('r %s_save.aig'%f_name)
-## if len(lst1)==0:
-## break
-## remove(lst1,1)
-## pre_simp(1,1)
-## iso()
-
-def show_partitions(L):
- for i in range(len(L)):
- abc('&r -s %s.aig'%L[i])
- print '\nSize = ',
- run_command('&ps')
- abc('&popart')
- eqs = eq_classes()
- N = len(eqs)
- print 'No. of partitions = %d'%N
- if N == 1:
- continue
- l = []
- for j in range(N):
- l=l + [len(eqs[j])]
- print l
-
-
-def r_part(name):
- read_file_quiet_i(name)
- abc('&get;&scl;&scorr -C 2;&put')
- res1 = reparam()
- res2 = False
- npos = n_pos()
-## if n_pos() < 100:
-## res2 = iso()
-## ps()
- if n_pos() < 1000:
- iso()
- if n_pos() < 500:
- abc('r %s.aig'%name)
- abc('w %s_leaf.aig'%name)
- return
-## abc('w %s_leaf.aig'%name)
-## return
- res = two_eq_part()
- if res == False:
- abc('r %s.aig'%name)
- abc('w %s_leaf.aig'%name)
- return
- elif min(res) < .2*max(res) and min(res) < 500:
- abc('r %s.aig'%name)
- abc('w %s_leaf.aig'%name)
- return
- else: #recur
- r_part('%s_p0'%name)
- r_part('%s_p1'%name)
- return
-
-def two_eq_part():
- abc('&get;&popart')
- part = eq_classes()
- if len(part) == 1:
- print 'Partition has only one part'
- return False
- abc('w %s_save.aig'%f_name)
- nn = n_pos()
- p1=p0 = []
- init = True
- for i in range(len(part)): #union first half together together
- if init == True:
- p0=p0 + part[i]
- if len(p0)>nn/2:
- init = False
- else:
- p1 = p1 + part[i]
- p0.sort()
- p1.sort()
- abc('&get')
- remove(p1,1)
- n0=n_pos()
-## print 'writing %s_p0.aig'%f_name
- abc('w %s_p0.aig'%f_name)
- abc('r %s_save.aig'%f_name)
- remove(p0,1)
-## print 'writing %s_p1.aig'%f_name
- n1=n_pos()
- abc('w %s_p1.aig'%f_name)
- return [n0,n1]
-
-def merge_parts(p,n):
- parts = []
- end = []
- for i in range(len(p)):
- if len(p[i]) > n:
- parts = parts + [p[i]]
- else:
- end =end + p[i]
- parts = parts + [end]
- return parts
-
-
-def extract_parts(S=11):
- abc('&get;&popart -S %d'%S)
- part = eq_classes()
- if len(part) == 1:
- print 'Partition has only one part'
- return 1
- parts = merge_parts(part,2)
- lp=len(parts)
- print 'Found %d parts'%lp
- abc('w %s_save.aig'%f_name)
- for i in range(lp):
- abc('r %s_save.aig'%f_name)
- p=[]
- for j in range(lp):
- if i == j:
- continue
- else:
- p = p + parts[j]
- remove(p,1)
- abc('&get;&scl;&lcorr;&put')
- abc('w %s_part%d.aig'%(f_name,i))
- return len(parts)
-
-def two_part():
- abc('&get;&popart')
- part = eq_classes()
- if len(part) == 1:
- print 'Partition has only one part'
- return False
- part1 = part[1:] #all but the 0th
- p1=[]
- for i in range(len(part1)): #union together
- p1=p1 + part1[i]
- p1.sort()
- abc('w %s_p.aig'%f_name)
- remove(p1,1)
-## print 'writing %s_p0.aig'%f_name
- abc('w %s_p0.aig'%f_name)
- n0=n_pos()
- abc('r %s_p.aig'%f_name)
- p0 = part[0]
- p0.sort()
- remove(p0,1)
-## print 'writing %s_p1.aig'%f_name
- n1=n_pos()
- abc('w %s_p1.aig'%f_name)
- return [n0,n1]
-
-def set_t_gap(t1,t2):
- nam = max(30000,n_ands())
- ratio = 1+float(nam-30000)/float(70000)
- gp = .5*ratio*t2
- gp = min(100,gp)
- t = min(100,ratio*t1)
- return (t,gp)
-
-def par_multi_sat(t=10,gap=0,m=1,H=0):
- """ m = 1 means multiple of 1000 to increment offset"""
- global last_gap
- abc('w %s_save.aig'%f_name)
- if not t == 0:
- if gap == 0:
- gap = max(.2,.2*t)
- gap = max(15,gap)
- if gap > t:
- t=gap
- t,gt = set_t_gap(t,gap)
- gt = max(15,gt)
- if gt <= last_gap:
- gt = 1.2*last_gap
- else:
- t = gt = 5
- if gt > t:
- t = gt
- last_gap = gt
-## H = max(100, t/n_pos()+1)
- if not H == 0:
- H = (gt*1000)/n_pos()
- H = max(min(H,1000*gt),100)
- tme = time.time()
- list0 = listr_0_pos() #reduces POs
- list0.sort()
-## print 'list0 = %s'%str(list0)
- if len(list0)>0:
- print 'temporarily removed %d cost-0 POs'%len(list0)
- ps()
- if len(list0)> 0:
- print 'Found %d const-0 POs, but not removed'%len(list0)
-## print ll
- print 'par_multi_sat entered for %.2f sec. and gap = %.2f sec., H = %.2f'%(t,gt,H)
- base = m*1000
- if not m == 1:
- offset = (m-1)*32000
- abc('&get;&cycle -F %d;&put'%offset)
- mx = 1000000000/max(1,n_latches())
- N = n_pos()
- na = n_ands()
- F = [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,H))'%(0*base))]
-## if na < 50000:
- F = F + [eval('(pyabc_split.defer(pdraz)(t,gt,H))')] #need pdr in??
- F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,4,0))'%(0*base))]
- F = F + [eval('(pyabc_split.defer(sleep)(t))')]
- F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,4,0))'%(100))]
- F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(100))]
- if mx > 1*base:
- F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,1,97))'%(1*base))]
- F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(1*base))]
-## if mx > 2*base:
-## F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d))'%(2*base))]
-## F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(2*base))]
- if mx > 4*base and na < 400000:
- F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,4,23))'%(4*base))]
- F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(4*base))]
-## if mx > 8*base and na < 300000:
-## F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,3,53))'%(8*base))]
-## F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(8*base))]
-## if mx > 16*base and na < 200000 :
-## F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,2,79))'%(16*base))]
-## F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(16*base))]
-## if mx > 32*base and na < 100000:
-## F = F + [eval('(pyabc_split.defer(sim3az)(t,gt,%d,1,97))'%(32*base))]
-## F = F + [eval('(pyabc_split.defer(bmc3az)(t,gt,%d,0))'%(32*base))]
- ss=LL=L = []
- S = 'UNDECIDED'
- zero_done = two_done = False
- s=ss = [-1]*n_pos()
- ii = []
- nn = len(F)
- for i,res in pyabc_split.abc_split_all(F):
- ii = ii + [i]
- if len(ii) == len(F)-1: #all done but sleep
- break
- if i == 3: #sleep timeout
- print 'sleep timeout'
- break
-## if i == 1:
-## print 'PDR produced: %s'%str(res)
-#### print i
- if i == 0:
- zero_done = True # bmc with start at 0 is done
- if i == 2:
- two_done = True
- if res == None: #this can happen if one of the methods bombs out
- print 'Method %d returned None'%i
- continue
-## print res
- s1 = switch(res[1]) #res[1]= s
- s = merge_s(list(s),s1)
- print sumsize(s)
- ss = ss + [s1]
-## LL = LL + [res[0]]
-## L = L + res[0]
-## L = [x for x in set(L)] #uniquefy
- if count_less(s,0) == 0:
- S = 'UNSAT'
- break
- # if i == 1 and is_unsat() and na < 50000: #pdr can return unsat.
-## if i == 1 and is_unsat(): #pdr can return unsat.
-## print 'Method pdr proved remaining POs UNSAT'
-## S = 'UNSAT'
-## L = res[0]
-## break
-## if not -1 in s:
-## S = 'UNSAT'
-## break
- if len(ss)>1 and zero_done and two_done:
- ss2 = ss[-2:] #checking if last 2 results agree
- r = ss2[0]
- if r == ss2[1] and count_less(r,1) < len(r): #at least 1 SAT PO found
- break
-## if len(LL) > 1 and zero_done and two_done:
-## ll2 = LL[-2:] #checking if last 2 results agree
-## if ll2[0] == ll2[1] and ll2[0] > 0:
-## break
- print 'Found %d SAT POs in '%(len(L)),
- print 'time = %.2f'%(time.time()-tme)
- print sumsize(s)
-## L.sort()
-## print 'L_before = %s'%(str(L))
-#### check_None_status(L,s,1) #now 1 in s means sat. s can have 0 in it, meaning it found some POs unsat.
-## L = merge(list(list0),list(L),1) #shift L according to list0 but do not include list0.
-## print 'L_shifted = %s'%(str(L))
-## # Need to return only SAT POs have to do the same for s
- print 'len(s) = %d, len(list0) = %d'%(len(s),len(list0))
- ss = expand(s,list0,0)
-## assert list0 == indices(ss,0)
- print sumsize(ss)
-## assert check_consistancy(L,ss), 'inconsistant'
- abc('r %s_save.aig'%f_name)
- return S,[],ss
-
-
-def check_consistancy(L,s):
- """ L is list of SAT's found. s is index of all"""
- consistant = True
- print 'checking s[L]'
- for j in L: #make sure that s[L] = 1
-## print j,
-## print s[j]
- if not s[j] == 1:
- print j,
- consistant = False
- print 'checking s=1 => L'
- for j in range(len(s)): #make sure that there are no other 1's
- if s[j] == 1:
- if not j in L:
- print j,
- consistant = False
- return consistant
-
-
-def check_s(s1,s2):
- assert len(s1) == len(s2),'lengths do not match'
- miss = []
- for i in range(len(s1)):
- if (s1[i] == 0 and s2[i] == 1) or (s1[i] == 1 and s2[i] == 0):
- miss = miss + [i]
- print miss
-
-
-def merge_s(s1,s2):
- assert len(s1) == len(s2), 'error in lengths, s1 = %s, s2 = %s'%(str(s1),str(s2))
- s = [-1]*len(s1)
- for i in range(len(s1)):
- if not s1[i] == s2[i]:
- if s1[i] == -1 or s2[i] == -1:
- s[i] = max(s1[i],s2[i])
- else:
- print 'error: conflict in values at i = %d'%i
- print 's1[i]=%d,s2[i]=%d'%(s1[i],s2[i])
- else: #put in common value
- s[i] = s1[i]
- return s
-
-def switch(ss):
- """ This changes the convention of SAT and UNSAT to SAT = 1, UNSAT = 0"""
- s1 = ss
- for i in range(len(ss)):
- si = ss[i]
- if si == 0:
- s1[i] = 1
- elif si == 1:
- s1[i] = 0
- return s1
-
-
-def pdr_ss_r(t):
- """
- assumes that 0 POs have been removed
- finds a set cexs in t seconds. Returns list of SAT POs found
- """
- global cex_list
- x = time.time()
- abc('pdr -az -T %f'%(t))
- if is_sat():
- print 'entering cex get vector'
- cex_list = cex_get_vector() #does this get returned from a concurrent process?
-## n = count_non_None(cex_list)
- print len(cex_list)
- L = list_non_None(cex_list)
- n = len(L)
- print '%d cexs found in %0.2f sec.'%(n,(time.time()-x))
- if n == len(cex_list):
- print 'all remaining POs are SAT'
-## return L
- else:
- remove_disproved_pos(cex_list) #note that this will not remove all POs
- else:
- L = []
- print 'T = %0.2f'%(time.time()-x)
- return L
-
-def bmc_ss_r(t):
- """
- assumes that 0 POs have been removed
- finds a set cexs in t seconds. Returns list of SAT POs found
- """
- global cex_list
- x = time.time()
- abc('bmc3 -az -C 1000000 -T %f'%(t))
- if is_sat():
- print 'entering cex get vector'
- cex_list = cex_get_vector() #does this get returned from a concurrent process?
-## n = count_non_None(cex_list)
- L = list_non_None(cex_list)
- n= len(L)
- print '%d cexs found in %0.2f sec.'%(n,(time.time()-x))
- if n == len(cex_list):
- print 'all remaining POs are SAT'
-## return L
- else:
- remove_disproved_pos(cex_list) #note that this will not remove all POs
- else:
- L = []
- print 'T = %0.2f'%(time.time()-x)
- return L
-
-def sim_ss_r(t):
- """
- assumes that 0 POs have been removed
- finds a set cexs in t seconds. Returns list of SAT POs found
- """
- global cex_list
- x = time.time()
- run_command('sim3 -az -T %f'%(t))
- if is_sat():
- print 'entering cex get vector'
- cex_list = cex_get_vector() #does this get returned from a concurrent process?
-## n = count_non_None(cex_list)
- L = list_non_None(cex_list)
- n = len(L)
- print '%d cexs found in %0.2f sec.'%(n,(time.time()-x))
- if n == len(cex_list):
- print 'all remaining POs are SAT'
-## return L
- else:
- remove_disproved_pos(cex_list) #note that this will not remove all POs
- else:
- L = []
- print 'T = %0.2f'%(time.time()-x)
- return L
-
-def check_None_status(L,s=[],v=0):
- """ L is the PO numbers that had non_None in
- 0 means sat and 1 means unsat is
- v tells which value means sat"""
- if s == []:
- s = status_get_vector()
- error = False
- for j in L:
- if s[j] == v:
- continue
- else:
- error = True
- for i in range(len(s)):
- if s[i] == v:
- if i in L:
- continue
- else:
- error = True
- if error:
- print 'status and non_None do not agree'
- print 'L = %d'%L
- print 'SAT and UNSAT counts switched'
- print sumsize(s)
-
-
-def list_non_None(lst):
- """ return [i for i,s in enumerate(cex_list) if not s == None]"""
- L = []
- for i in range(len(lst)):
- if not lst[i] == None:
- L = L + [i]
- return L
-
-def count_non_None(lst):
- #return len([i for i,s in enumerate(cex_list) if not s == None]
- count = 0
- for i in range(len(lst)):
- if not lst[i] == None:
- count = count + 1
- return count
-
-def remove_disproved_pos(lst):
- for i in range(len(lst)):
- if not lst[i] == None:
- abc('zeropo -N %d'%i)
- l=remove_const_pos(0)
-
-def remove_proved_pos(lst):
- for i in range(len(lst)):
- if lst[i] > -1:
- abc('zeropo -N %d'%i)
- remove_const_pos(0)
-
-
-
-def bmc_j(t=900):
- """ finds a cex in t seconds starting at 2*N where N is depth of bmc -T 1"""
- x = time.time()
- tt = min(5,max(1,.05*t))
- abc('bmc3 -T %0.2f'%tt)
- if is_sat():
-## print 'cex found in %0.2f sec at frame %d'%((time.time()-x),cex_frame())
- return get_status()
-## abc('bmc3 -T 1')
- N = n_bmc_frames()
- N = max(1,N)
-## print bmc_depth()
-## abc('bmc3 -C 1000000 -T %f -S %d'%(t,int(1.5*max(3,max_bmc))))
- cmd = 'bmc3 -J 2 -D 4000 -C 1000000 -T %f -S %d'%(t,2*N)
-## print cmd
- abc(cmd)
-## if is_sat():
-## print 'cex found in %0.2f sec at frame %d'%((time.time()-x),cex_frame())
- return RESULT[get_status()]
-
-def pdrseed(t=900):
- """uses the abstracted version now"""
-## abc('&get;,treb -rlim=60 -coi=3 -te=1 -vt=%f -seed=521'%t)
- abc('&get;,treb -rlim=100 -vt=%f -seed=521'%t)
- return RESULT[get_status()]
-
-def pdrold(t):
- abc('&get; ,pdr -vt=%f'%t)
- return RESULT[get_status()]
-
-def pdr(t=900):
- abc('&get; ,treb -vt=%f'%t)
- return RESULT[get_status()]
-
-def pdr0(t=900):
- abc('&get; ,pdr -rlim=100 -vt=%f'%t)
- return RESULT[get_status()]
-
-def pdra(t=900):
-## abc('&get; ,treb -rlim=100 -ssize -pre-cubes=3 -vt=%f'%t)
- abc('&get; ,treb -abs -rlim=100 -sat=abc -vt=%f'%t)
- return RESULT[get_status()]
-
-def pdrm(t=900):
- abc('pdr -C 0 -T %f'%t)
- return RESULT[get_status()]
-
-def pdrmm(t):
- abc('pdr -C 0 -M 298 -T %f'%t)
- return RESULT[get_status()]
-
-def bmc2(t):
- abc('bmc2 -C 1000000 -T %f'%t)
- return RESULT[get_status()]
-
-def bmc(t=900):
- abc('&get; ,bmc -vt=%d'%t)
- return RESULT[get_status()]
-
-def intrp(t=900):
- abc('&get; ,imc -vt=%d'%t)
- return RESULT[get_status()]
-
-def bmc3az(t=900,gt=10,C=999,H=0):
- t_init = time.time()
- if C > 999:
- abc('&get; &cycle -F %d; &put'%C)
- abc('bmc3 -az -C 1000000 -T %d -G %d -H %.2f'%(t,gt,H))
- cex_list = cex_get_vector()
- L = list_non_None(cex_list)
-## check_None_status(L)
- print 'bmc3az(%.2f,%.2f,%d,%d): CEXs = %d, time = %.2f'%(t,gt,C,H,len(L),(time.time()-t_init))
-## s = status_get_vector()
- s = [-1]*n_pos()
- for j in L:
- s[j]=0 #0 here means SAT. It will be switched in par_multi_sat
- return L,s
-
-def pdraz(t=900,gt=10,H=0):
- print 'pdraz entered with t = %.2f, gt = %.2f, H = %.2f'%(t,gt,H)
- t_init = time.time()
- run_command('pdr -az -T %d -G %d -H %.2f'%(t,gt,H))
- cex_list = cex_get_vector()
- L = list_non_None(cex_list)
-## check_None_status(L)
- s = status_get_vector()
- if s == None:
- print "status_get_vector returned None"
- else:
- print 'Number of UNSAT POs = %d'%(len(s) - count_less(s,1))
- print 'pdraz(%.2f,%.2f,%d): CEXs = %d, time = %.2f'%(t,gt,H,len(L),(time.time()-t_init))
- return L,s
-
-def sim3az(t=900,gt=10,C=1000,W=5,N=0):
- """ N = random seed, gt is gap time, W = # words, F = #frames"""
- t_init = time.time()
- if C > 1000:
- abc('&get; &cycle -F %d; &put'%C)
- abc('sim3 -az -T %.2f -G %.2f -F 40 -W %d -N %d'%(t,gt,W,N))
- cex_list = cex_get_vector()
- L = list_non_None(cex_list)
-## check_None_status(L)
- s = [-1]*n_pos()
- for i in L:
- s[i] = 0 #0 indicates SAT here
- print 'sim3az(%.2f,%.2f,%d,%d,%d): CEXs=%d, time = %.2f'%(t,gt,C,W,N,len(L),(time.time()-t_init))
- return L,s
-
-def bmc3(t=900):
- abc('bmc3 -C 1000000 -T %d'%t)
- return RESULT[get_status()]
-
-def intrpm(t=900):
- abc('int -C 1000000 -F 10000 -K 1 -T %d'%t)
- print 'intrpm: status = %d'%get_status()
- return RESULT[get_status()]
-
-def split(n):
- global aigs
- abc('orpos;&get')
- abc('&posplit -v -N %d;&put;dc2'%n)
- res =a_trim()
-
-def keep_splitting():
- for j in range(5):
- split(5+j)
- no = n_pos()
- status = prove_g_pos_split()
- if status <= Unsat:
- return status
- if no == n_pos():
- return Undecided
-
-def drill(n):
- run_command('&get; &reachm -vcs -H 5 -S %d -T 50 -C 40'%n)
-
-
-def pre_reduce():
- x = time.clock()
- pre_simp()
- write_file('smp')
- abstract(ifbip)
-#### write_file('abs')
- print 'Time = %0.2f'%(time.clock() - x)
-
-def sublist(L,I):
- # return [s for i,s in enumerate(L) if i in I]
- z = []
- for i in range(len(I)):
- s = L[I[i]],
- s = list(s)
- z = z + s
- return z
-
-#PARALLEL FUNCTIONS
-""" funcs should look like
-funcs = [pyabc_split.defer(abc)('&get;,bmc -vt=50;&put'),pyabc_split.defer(super_prove)()]
-After this is executed funcs becomes a special list of lambda functions
-which are given to abc_split_all to be executed as in below.
-It has been set up so that each of the functions works on the current aig and
-possibly transforms it. The new aig and status is always read into the master when done
-"""
-
-def tf():
- result = top_fork()
- return result
-
-def top_fork(J,t):
- global x_factor, final_verify_time, last_verify_time, methods
- set_globals()
- mtds = sublist(methods,J)
- F = create_funcs(J,t)
- print 'Running %s in parallel for max %d sec.'%(mtds,t)
- (m,result) = fork_last(F,mtds) #FORK here
- return get_status()
-
-def run_sp2_par(t):
- """ Runs the single method simple, timed for t seconds."""
- global cex_list,methods, pord_trace
- J = slps+[6] #6 is the 'simple' method
-## mtds = sublist(methods,J)
-## print mtds,
- print 'time = %0.2f'%t
- funcs = create_funcs(J,t)
- y = time.time()
- for i,res in pyabc_split.abc_split_all(funcs):
-## print 'i,res = %d,%s'%(i,res)
- T = time.time()-y
- if i == 0:
- print 'Timer expired in %0.2f'%T
- return 'UNDECIDED'
- else:
-## print i,res
- #note simple returns a vector
- mtd = res[1]
- ress = res[0]
- if ress == 'UNSAT':
- print 'simple proved UNSAT in %0.2f sec.'%T
- add_pord('UNSAT by %s'%mtd)
- return 'UNSAT'
- elif ress == 'UNDECIDED':
- print 'simple returned UNDECIDED in %0.2f sec.'%T
- return 'UNDECIDED'
- if ress == 'SAT':
- print 'simple found cex in %0.2f sec.'%T
- add_pord('SAT by %s'%mtd)
- return 'SAT'
- else:
- assert False, 'ress = %s'%ress
-
-def run_parallel(J,t,BREAK='US'):
- """ Runs the listed methods J, each for time = t, in parallel and
- breaks according to BREAK = subset of '?USLB'"""
- global cex_list, methods
- mtds = sublist(methods,J)
- F = create_funcs(J,t) #if J = [] we are going to create functions that process each output separately.
- #if 18, then these are run in parallel with sleep
- if ((J == []) ):
- result = fork_break(F,mtds,BREAK)
-## #redirect here to suppress printouts.
-## with redirect.redirect( redirect.null_file, sys.stdout ):
-## with redirect.redirect( redirect.null_file, sys.stderr ):
-## result = fork_break(F,mtds,BREAK)
- elif 'L' in BREAK:
- result = fork_last(F,mtds)
- elif 'B' in BREAK:
- result = fork_best(F,mtds)
- else:
- result = fork_break(F,mtds,BREAK)
- return result
-
-def fork_all(funcs,mtds):
- """Runs funcs in parallel and continue running until all are done"""
- global methods
- y = time.time()
- for i,res in pyabc_split.abc_split_all(funcs):
- status = prob_status()
- t = time.time()-y
- if not status == -1: #solved here
- if status == 1: #unsat
- print '%s proved UNSAT in %f sec.'%(mtds[i],t)
- else:
- print '%s found cex in %f sec. - '%(mtds[i],t),
- if not mtds[i] == 'REACHM':
- print 'cex depth at %d'%cex_frame()
- else:
- print ' '
- continue
- else:
- print '%s was undecided in %f sec. '%(mtds[i],t)
- return i,res
-
-def fork_break(funcs,mtds,BREAK):
- """
- Runs funcs in parallel and breaks according to BREAK <= '?US'
- If mtds = 'sleep' or [], we are proving outputs in parallel
- Saves cex's found in cex_list in case we are proving POs.
- """
- global methods,last_verify_time,seed,cex_list,last_winner,last_cex
- seed = seed + 3 # since parallel processes do not chenge the seed in the prime process, we need to change it here
- cex_list = lst = []
- y = time.time() #use wall clock time because parent fork process does not use up compute time.
- for i,res in pyabc_split.abc_split_all(funcs):
- status = get_status()
- t = time.time()-y
- lm = len(mtds)
- if ((lm < 2) and not i == 0): # the only single mtds case is where it is 'sleep'
- M = 'Output %d'%(i-lm)
- else:
- M = mtds[i]
- last_winner = M
- if M == 'sleep':
- print 'sleep: time expired in %0.2f sec.'%(t)
-## return 0,[Undecided]+[M]
-## assert status >= Unsat,'status = %d'%status
- break
- if ((status > Unsat) and '?' in BREAK): #undecided
- break
- elif status == Unsat or res == 'UNSAT': #unsat
- print '%s: UNSAT in %0.2f sec.'%(M,(t))
- status = Unsat
- if 'U' in BREAK:
- break
- elif status < Unsat or res == 'SAT': #status == 0 - cex found
- status = Sat
- if M in methods:
- if methods.index(M) in exbmcs+allreachs+allpdrs+[1]: #set the known best depth so far. [1] is interp
- set_max_bmc(n_bmc_frames())
- last_cex = M
- print '%s: -- cex in %0.2f sec. at depth %d => '%(M,t,cex_frame()),
- cex_list = cex_list+[cex_get()] #accumulates multiple cex's and puts them on list.
- if len(cex_list)>1:
- print 'len(cex_list): %d'%len(cex_list)
- if 'S' in BREAK:
- break
- else:
- continue
- add_trace('%s by %s'%(RESULT[status],M))
- return i,[status]+[M]
-
-def fork_best(funcs,mts):
- """ fork the functions, If not solved, take the best result in terms of AIG size"""
- global f_name
- n = len(mts)-1
- r = range(len(mts))
- y = time.time()
- m_best = -1
- best_size = [n_pis(),n_latches(),n_ands()]
-## print best_size
- abc('w %s_best_aig.aig'%f_name)
- for i,res in pyabc_split.abc_split_all(funcs):
- if mts[i] == 'sleep':
- m_best = i
- break
- r = delete(r,i)
- if len(r) == 1:
- if mts[r[0]] == 'sleep':
- break
- status = prob_status()
- if not status == -1: #solved here
- m = i
- t = time.time()-y
- if status == 1: #unsat
- print '%s proved UNSAT in %f sec.'%(mts[i],t)
- else:
- print '%s found cex in %f sec. - '%(mts[i],t),
- break
- else:
- cost = rel_cost(best_size)
- if cost < 0:
- best_size = [n_pis(),n_latches(),n_ands()]
- m_best = i
- abc('w %s_best_aig.aig'%f_name)
- abc('r %s_best_aig.aig'%f_name)
- add_trace('%s'%mts[m_best])
- return m_best,res
-
-def delete(r,i):
- """ remove element in the list r that corresponds to i """
- ii = r.index(i)
- z = []
- for i in range(len(r)):
- if i == ii:
- continue
- else:
- z = z + [r[i]]
- return z
-
-
-def take_best(funcs,mts):
- """ fork the functions, If not solved, take the best result in terms of AIG size"""
- global f_name
- n = len(mts)-1
- y = time.time()
- m_best = -1
- best_size = 1000000
- abc('w %s_best_aig.aig'%f_name)
- for i,res in pyabc_split.abc_split_all(funcs):
- if n_ands() < best_size:
- best_size = n_ands()
- m_best = i
- abc('w %s_best_aig.aig'%f_name)
- abc('r %s_best_aig.aig'%f_name)
- return m_best,res
-
-def fork_last(funcs,mtds):
- """ fork the functions, and take first definitive answer, but
- if last method ends first, then kill others"""
- global m_trace,hist,sec_options
- n = len(mtds)-1
- m = -1
- y = time.time()
- sres =lst = ''
-## print mtds
- #print 'starting fork_last'
- for i,res in pyabc_split.abc_split_all(funcs):
-## print i,res
- status = prob_status()
- if mtds[i] == 'par_scorr' and n_ands() == 0:
- add_trace('UNSAT by %s'%res)
- return i,Unsat
- if not status == -1 or res in ['SAT','UNSAT']: #solved here
- m = i
- t = int(time.time()-y)
- if status == 1 or res == 'UNSAT': #unsat
- sres = str(res)
- res = Unsat
- print '%s proved UNSAT in %d sec.'%(mtds[i],t)
- else:
- res = Sat
- print '%s found cex in %0.2f sec. - '%(mtds[i],(t)),
- break
- elif i == n:
-## print res
- if mtds[i] == 'pre_simp':
- m_trace = m_trace + [res[1]]
- hist = res[2]
- t = int(time.time()-y)
- m = i
- if mtds[i] == 'initial_speculate':
- return m,res
- else:
- print '%s: UNDECIDED in %d sec.'%(mtds[i],t)
- res = Undecided
- ps()
- break
- elif mtds[i] == 'sleep':
- res = Undecided
- t = time.time()-y
- print 'Timer expired in %0.2f'%t
- break
- lst = lst + ', '+mtds[i]
-## sres = str(res)
- if sres[:5] == 'scorr':
- add_trace('UNSAT by %s'%sres)
- return m,Unsat
- add_trace('%s by %s'%(RESULT[res],mtds[i]))
- return m,res
-
-def fork(funcs,mtds):
- """ runs funcs in parallel This keeps track of the verify time
- when a cex was found, and if the time to find
- the cex was > 1/2 allowed time, then last_verify_time is increased by 2"""
- global win_list, methods, last_verify_time,seed
- beg_time = time.time()
- i,res = fork_break(funcs,mtds,'US') #break on Unsat of Sat.
- t = time.time()-beg_time #wall clock time because fork does not take any compute time.
- if t > .4*last_verify_time:
-## if t > .15*last_verify_time: ##### temp
- t = last_verify_time = last_verify_time + .1*t
- #print 'verify time increased to %s'%convert(t)
- assert res[0] == get_status(),'res: %d, status: %d'%(res,get_status())
-## add_trace('%s by %s'%(RESULT[res[0]],mtds[i]))
- return i,res
-
-def save_time(M,t):
- global win_list,methods
- j = methods.index(M)
- win_list = win_list + [(j,t)]
- #print win_list
-
-def summarize(lst):
- result = [0]*10
- for j in range(len(lst)):
- k = lst[j]
- result[k[0]]=result[k[0]]+k[1]
- return result
-
-def top_n(lst,n):
- result = []
- ll = list(lst) #makes a copy
- m = min(n,len(ll))
- for i in range(m):
- mx_index = ll.index(max(ll))
- result = result + [mx_index]
- ll[mx_index] = -1
- return result
-
-def super_pre_simp():
- while True:
- nff = n_latches()
- print 'Calling pre_simp'
- pre_simp()
- if n_latches() == nff:
- break
-
-#______________________________
-#new synthesis command
-
-####def synculate(t):
-#### """
-#### Finds candidate sequential equivalences and refines them by simulation, BMC, or reachability
-#### using any cex found. If any are proved, then they are used to reduce the circuit. The final aig
-#### is a new synthesized circuit where all the proved equivalences are merged.
-#### If we put this in a loop with increasing verify times, then each time we work with a simpler model
-#### and new equivalences. Should approach srm. If in a loop, we can remember the cex_list so that we don't
-#### have to deal with disproved equivalences. Then use refine_with_cexs to trim the initial equivalences.
-#### If used in synthesis, need to distinguish between
-#### original outputs and new ones. Things to take care of: 1. a PO should not go away until it has been processes by merged_proved_equivalences
-#### 2. Note that &resim does not use the -m option where as in speculation - m is used. It means that if
-#### an original PO isfound to be SAT, the computation quits becasue one of the output
-#### miters has been disproved.
-#### """
-#### global G_C,G_T,n_pos_before, x_factor, n_latches_before, last_verify_time, f_name,cex_list, max_verify_time
-####
-####
-#### def refine_with_cexs():
-#### """Refines the gores file to reflect equivalences that go away because of cexs in cex_list"""
-#### global f_name
-#### abc('&r %s_gores.aig'%f_name)
-#### for j in range(len(cex_list)):
-#### cex_put(cex_list[j])
-#### run_command('&resim') #put the jth cex into the cex space and use it to refine the equivs
-#### abc('&w %s_gores.aig'%f_name)
-#### return
-####
-#### def generate_srms():
-#### """generates a synthesized reduced model (srms) from the gores file"""
-#### global f_name, po_map
-#### abc('&r %s_gores.aig; &srm -sf; r gsrms.aig; w %s_gsrms.aig'%(f_name,f_name))
-#### print 'New srms = ',ps()
-#### po_map = range(n_pos())
-#### return 'OK'
-####
-#### def merge_proved_equivalences():
-#### #this only changes the gores file.
-#### run_command('&r %s_gores.aig; &equiv_mark -vf %s_gsrms.aig; &reduce -v; &w %s_gores.aig'%(f_name,f_name,f_name))
-#### return
-####
-#### def generate_equivalences():
-#### set_globals()
-#### t = max(1,.5*G_T)
-#### r = max(1,int(t))
-#### cmd = "&get; &equiv2 -C %d -F 200 -T %f -S 1 -R %d"%((G_C),t,r)
-#### abc(cmd)
-#### #run_command('&ps')
-#### eq_simulate(.5*t)
-#### #run_command('&ps')
-#### cmd = '&semi -W 63 -S 5 -C 500 -F 20 -T %d'%(.5*t)
-#### abc(cmd)
-#### #run_command('&ps')
-#### run_command('&w %s_gores.aig'%f_name)
-####
-#### l=remove_const_pos() #makes sure no 0 pos to start
-#### cex_list = []
-#### n_pos_before = n_pos()
-#### n_latches_before = n_latches()
-###### print 'Generating equivalences'
-#### generate_equivalences()
-###### print 'Generating srms file'
-#### generate_srms() #this should not create new 0 pos
-###### if n_pos()>100:
-###### removed
-#### l=remove_const_pos()
-#### n_pos_last = n_pos()
-#### if n_pos_before == n_pos():
-#### print 'No equivalences found. Quitting synculate'
-#### return Undecided_no_reduction
-#### print 'Initial synculation: ',ps()
-###### ps()
-#### set_globals()
-#### simp_sw = init = True
-#### simp_sw = False #temporary
-#### print '\nIterating synculation refinement'
-#### abc('w initial_sync.aig')
-#### max_verify_time = t
-#### print 'max_verify_time = %d'%max_verify_time
-#### """
-#### in the following loop we increase max_verify_time by twice time spent to find last cexs or Unsat's
-#### We iterate only when we have proved cex + unsat > 1/2 n_pos. Then we update srms and repeat.
-#### """
-#### while True: # refinement loop
-#### t = max_verify_time #this may have been increased since the last loop
-###### print 'max_verify_time = %d'%max_verify_time
-#### set_globals()
-#### if not init:
-#### generate_srms() #generates a new gsrms file and leaves it in workspace
-###### print 'generate_srms done'
-#### if n_pos() == n_pos_before:
-#### break
-#### if n_pos() == n_pos_last: #if nothing new, then quit if max_verification time is reached.
-#### if t > max_verify_time:
-#### break
-#### if simp_sw: #Warning: If this holds then simplify could create some 0 pos
-#### na = n_ands()
-#### simplify()
-#### while True:
-#### npo = n_pos()
-###### print 'npos = %d'%npo
-#### merge_proved_equivalences() #So we need to merge them here. Can merging create more???
-#### generate_srms()
-#### if npo == n_pos():
-#### break
-#### if n_ands() > .7*na: #if not significant reduction, stop simplification
-#### simp_sw = False #simplify only once.
-#### if n_latches() == 0:
-#### return check_sat()
-#### n_pos_last = n_pos()
-#### init = False # make it so that next time it is not the first time through
-#### syn_par(t)
-#### if (len(cex_list)+len(result)) == 0: #nothing happened aand ran out of time.
-#### break
-#### abc('w %s_gsrms.aig'%f_name)
-#### #print 'No. of cexs after syn_parallel = %d'%len(cex_list)
-#### merge_proved_equivalences() #changes the underlying gores file by merging fanouts of proved eqs
-#### #print 'merge done'
-#### refine_with_cexs() #changes the gores file by refining the equivalences in it using cex_list.
-#### #print 'refine_with_cexs done'
-#### continue
-#### extract(0,n_pos_before) #get rid of unproved outputs
-#### return
-####
-####def syn_par(t):
-#### """prove n outputs at once and quit at first cex. Otherwise if no cex found return aig
-#### with the unproved outputs"""
-#### global trim_allowed,max_verify_time, n_pos_before
-#### global cex_list, result
-#### b_time = time.time()
-#### n = n_pos()
-#### if n == n_pos_before:
-#### return
-#### mx = n_pos()
-#### if n_pos() - n_pos_before > 50:
-#### mx = n_pos_before + 50
-#### r = range(n_pos_before, mx)
-#### N = max(1,(mx-n_pos_before)/2)
-#### abc('w %s__ysavetemp.aig'%f_name)
-#### F = [eval(FUNCS[18])] #create a timer function
-#### #print r
-#### for i in r:
-#### F = F + [eval('(pyabc_split.defer(verify_only)(%d,%d))'%(i,t))]
-#### cex_list = result = []
-#### outcome = ''
-#### #redirect printout here
-###### with redirect.redirect( redirect.null_file, sys.stdout ):
-###### with redirect.redirect( redirect.null_file, sys.stderr ):
-#### for i,res in pyabc_split.abc_split_all(F):
-#### status = get_status()
-###### print i
-#### if i == 0: #timed out
-#### outcome = 'time expired after = %d'%(time.time() - b_time)
-#### break
-#### if status < Unsat:
-#### cex_list = cex_list + [cex_get()]
-#### if status == Unsat:
-#### result = result + [r[i-1]]
-#### if (len(result)+len(cex_list))>= N:
-#### T = time.time() - b_time
-#### if T > max_verify_time/2:
-#### max_verify_time = 2*T
-#### break
-#### continue
-#### if not outcome == '':
-#### print outcome
-###### print 'cex_list,prove_list = ',cex_list,result
-#### abc('r %s__ysavetemp.aig'%f_name) #restore initial aig so that pos can be 0'ed out
-#### if not result == []: # found some unsat's
-###### min_r = min(result)
-###### max_r = max(result)
-###### no = n_pos()
-###### assert (0 <= min_r and max_r < no), 'min_r, max_r, length = %d, %d, %d'%(min_r,max_r,len(result))
-#### zero(result)
-#### return
-#### #print "Number PO's proved = %d"%len(result)
-####
-####def absec(n):
-#### #abc('w t.aig')
-#### for j in range(n):
-#### print '\nFrame %d'%(j+1)
-#### run_command('absec -F %d'%(j+1))
-#### if is_unsat():
-#### print 'UNSAT'
-#### break
-####
-####
-####"""
-#### we might be proving some original pos as we go, and on the other hand we might have some equivalences that we
-#### can't prove. There are two uses, in verification
-#### verification - we want to remove the proved pos whether they are original or not. But if a cex for an original, then need to
-#### remember this.
-#### synthesis - the original outputs need to be kept and ignored in terms of cex's - supposedly they can't be proved.
-####"""
-####
-####""" Experimental"""
-####
-####def csec():
-#### global f_name
-#### if os.path.exists('%s_part0.aig'%f_name):
-#### os.remove('%s_part0.aig'%f_name)
-#### run_command('demiter')
-#### if not os.path.exists('%s_part0.aig'%f_name):
-#### return
-#### run_command('r %s_part0.aig'%f_name)
-#### ps()
-#### run_command('comb')
-#### ps()
-#### abc('w %s_part0comb.aig'%f_name)
-#### run_command('r %s_part1.aig'%f_name)
-#### ps()
-#### run_command('comb')
-#### ps()
-#### abc('w %s_part1comb.aig'%f_name)
-#### run_command('&get; &cec %s_part0comb.aig'%(f_name))
-#### if is_sat():
-#### return 'SAT'
-#### if is_unsat():
-#### return 'UNSAT'
-#### else:
-#### return 'UNDECIDED'
-
- ###########################
-#### we will verify outputs ORed in groups of g[i]
-#### here we take div = N so no ORing
-## div = max(1,N/1)
-## g = distribute(N,div)
-## if len(g) <= 1:
-## t = tt
-## g.reverse()
-#### print g
-## x = 0
-## G = []
-## for i in range(div):
-## y = x+g[i]
-## F = F + [eval('(pyabc_split.defer(verify_range)(%d,%d,%s))'%(x,y,convert(t)))]
-## G = G + [range(x,y)]
-## x = y
-#### print G
-###########################
-
-
-""" These commands map into luts and leave the result in mapped format. To return to aig format, you
-have to do 'st'
-"""
-def sop_balance(k=4):
- '''minimizes LUT logic levels '''
-## kmax = k
- kmax=min(k+2,15)
- abc('st; if -K %d;ps'%kmax)
- print nl(),
-## for i in range(1):
-## abc('st; if -K %d;ps'%kmax)
-## run_command('ps')
- kmax=min(k+2,15)
- abc('st; if -g -C %d -K %d -F 2;ps'%(10,kmax)) #balance
- print nl(),
- for i in range(1):
- abc('st;dch; if -C %d -K %d;ps'%(10,kmax))
- print nl(),
-
-def speedup(k=4):
- run_command('speedup;if -K %d'%k)
- print nl()
-
-def speed_tradeoff(k=4):
- print nl(),
- best = n_nodes()
- abc('write_blif %s_bestsp.blif'%f_name)
- L_init = n_levels()
- while True:
- L_old = n_levels()
- L = L_old -1
- abc('speedup;if -D %d -F 2 -K %d -C 11'%(L,k))
- if n_nodes() < best:
- best = n_nodes()
- abc('write_blif %s_bestsp.blif'%f_name)
- if n_levels() == L_old:
- break
- print nl(),
- continue
- abc('r %s_bestsp.blif'%f_name)
- return
-
-def area_tradeoff(k=4):
- print nl(),
- best = n_nodes()
- abc('write_blif %s_bestsp.blif'%f_name)
- L_init = n_levels()
- while True:
- L_old = n_levels()
- L = L_old +1
- n_nodes_old = n_nodes()
- abc('speedup;if -a -D %d -F 2 -K %d -C 11'%(L,k))
- if n_nodes() < best:
- best = n_nodes()
- abc('write_blif %s_bestsp.blif'%f_name)
-## if n_levels() == L_old:
- if n_nodes == n_nodes_old:
- break
- print nl(),
- continue
- abc('r %s_bestar.blif'%f_name)
- return
-
-
-def map_lut_dch(k=4):
- '''minimizes area '''
- abc('st; dch; if -a -F 2 -K %d -C 11; mfs2 -a -L 50 ; lutpack -L 50'%k)
-
-def map_lut_dch_iter(k=8):
-## print 'entering map_lut_dch_iter with k = %d'%k
- best = n_nodes()
- abc('write_blif %s_best.blif'%f_name)
-## abc('st;dch;if -a -K %d -F 2 -C 11; mfs -a -L 1000; lutpack -L 1000'%k)
-## if n_nodes() < best:
-## abc('write_blif %s_best.blif'%f_name)
-## best = n_nodes()
-## print nl(),
-## else:
-## abc('r %s_best.blif'%f_name)
-## best = n_nodes()
-## abc('write_blif %s_best.blif'%f_name)
-## print 'best = %d'%best
- n=0
- while True:
- map_lut_dch(k)
- if n_nodes()< best:
- best = n_nodes()
-## print 'best=%d'%best
- n = 0
- abc('write_blif %s_best.blif'%f_name)
- print nl(),
- continue
- else:
- n = n+1
- if n>2:
- break
- abc('r %s_best.blif'%f_name)
-
-def dmitri_iter(k=8):
- best = 100000
- n=0
- while True:
- dmitri(k)
- if n_nodes()< best:
- best = n_nodes()
-## print '\nbest=%d'%best
- n = 0
- abc('write_blif %s_best.blif'%f_name)
- continue
- else:
- n = n+1
- if n>2:
- break
- abc('r %s_best.blif'%f_name)
-## run_command('cec -n %s.aig'%f_name)
- print nl()
-
-def shrink():
- tm = time.time()
- best = n_ands()
- while True:
- abc('&get;&if -K 4 -F 1 -A 0 -a;&shrink;&put')
- print n_ands(),
- if n_ands()< .99*best:
- best = n_ands()
- continue
- break
- print 't = %.2f, '%(time.time()-tm),
- ps()
-
-def shrink_lut():
- tm = time.time()
- abc('&get;&if -K 4 -F 1 -A 0 -a;&put')
- best = n_nodes()
- print best,
- abc('&shrink')
- while True:
- abc('&if -K 4 -F 1 -A 0 -a;&put')
- print n_nodes(),
- if n_nodes() < .99*best:
- best = n_nodes()
- abc('&shrink')
- continue
- break
- abc('&put')
- print 'time = %.2f, '%(time.time()-tm),
- ps()
-
-
-def map_lut(k=4):
- '''minimizes edge count'''
- for i in range(5):
- abc('st; if -e -K %d; ps; mfs ;ps; lutpack -L 50; ps'%(k))
- print nl(),
-
-def extractax(o=''):
- abc('extract -%s'%o)
-
-def nl():
- return [n_nodes(),n_levels()]
-
-def dc2_iter(th=.999):
- abc('st')
- tm = time.time()
- while True:
- na=n_ands()
- abc('dc2')
- print n_ands(),
-## print nl(),
- if n_ands() > th*na:
- break
- print 't = %.2f, '%(time.time()-tm),
- ps()
-## print n_ands()
-
-def drw_iter(th=.999):
- abc('st')
- tm = time.time()
- while True:
- na=n_ands()
- abc('drw')
- print n_ands(),
-## print nl(),
- if n_ands() > th*na:
- break
- print 't = %.2f, '%(time.time()-tm),
- ps()
-## print n_ands()
-
-def adc2_iter(th=.999):
- abc('st;&get')
- while True:
- na=n_ands()
- abc('&dc2;&put')
-## print n_ands(),
- if n_ands() > th*na:
- break
- print n_ands()
-
-def try_extract():
-## abc('dc2;dc2')
- print 'Initial: ',
- ps()
- na = n_ands()
-## abc('w %s_savetemp.aig'%f_name)
- #no need to save initial aig since fork_best will return initial if best.
- J = [32,33]
- mtds = sublist(methods,J)
- F = create_funcs(J,0)
- (m,result) = take_best(F,mtds) #FORK here
- if not m == -1:
- print 'Best extract is %s: '%mtds[m],
- ps()
-## if (n_ands() < na):
-## return
-## else:
-## abc('r %s_savetemp.aig'%f_name)
-
-def speedup_iter(k=8):
- abc('st;if -K %d'%k)
- run_command('ps')
- abc('write_blif %s_bests.blif'%f_name)
- run_command('ps')
- best = n_levels()
- print 'n_levels before speedup = %d'%n_levels()
- n=0
- while True:
- nl()
- abc('speedup;if -K %d'%k)
- if n_levels() < best:
- best = n_levels()
- abc('write_blif %s_bests.blif'%f_name)
- n=0
- else:
- n = n+1
- if n>2:
- break
- abc('r %s_bests.blif'%f_name)
- print 'n_levels = %d'%n_levels()
-
-def jog(n=16):
- """ applies to a mapped blif file"""
- run_command('eliminate -N %d;fx'%n)
- run_command('if -K %d'%(n/2))
- run_command('fx')
-
-def perturb_f(k=4):
- abc('st;dch;if -g -K %d'%(k))
-## snap()
- abc('speedup;if -K %d -C 10'%(k))
- jog(5*k)
-## snap()
-## abc('if -a -K %d -C 11 -F 2;mfs -a -L 50;lutpack -L 50'%k
-
-def perturb(k=4):
- abc('st;dch;if -g -K %d'%k)
-## snap()
- abc('speedup;if -K %d -C 10'%(k))
-
-def preprocess(k=4):
- n_initial = n_nodes()
- abc('write_blif %s_temp_initial.blif'%f_name)
-## abc('st;dc2')
- abc('w %s_temp_initial.aig'%f_name)
- ni = n_pis() + n_latches()
- res = 1
- if ni >= 101:
- abc('st;if -a -F 2 -K %d'%k)
- return res
-## dc2_iter()
- abc('st;if -a -K %d'%k) # to get plain direct map
- if n_nodes() > n_initial:
- abc('r %s_temp_initial.blif'%f_name)
- res = 1
- #plain
- n_plain = n_nodes()
-## print nl()
- abc('write_blif %s_temp_plain.blif'%f_name)
- #clp
- abc('st;clp; if -a -K %d'%k)
-## print nl()
- abc('write_blif %s_temp_clp.blif'%f_name)
- n_clp = n_nodes()
- #clp_lutmin
- abc('r %s_temp_initial.blif'%f_name)
- abc('st;clp;lutmin -K %d;'%k)
- abc('write_blif %s_temp_clp_lut.blif'%f_name)
- n_clp_lut = n_nodes()
-## print nl()
- if n_plain <= min(n_clp,n_clp_lut):
- abc('r %s_temp_plain.blif'%f_name)
- res = 1
- elif n_clp < n_clp_lut:
- abc('r %s_temp_clp.blif'%f_name)
- res = 1
- else:
- abc('r %s_temp_clp_lut.blif'%f_name)
- res = 1
-## print nl()
- return res
-
-def snap():
-## abc('fraig;fraig_store')
- abc('fraig_store')
-
-def snap_bestk(k):
- abc('write_blif %s_temp.blif'%f_name)
- unsave_bestk(k)
- snap()
- abc('r %s_temp.blif'%f_name)
-
-def cec_it():
- """ done because &r changes the names. Can't use -n because rfraig_store reorders pis and pos."""
- abc('write_blif %s_temp.blif'%f_name)
- abc('&r -s %s.aig;&put'%f_name)
- run_command('cec %s_temp.blif'%f_name)
- abc('r %s_temp.blif'%f_name)
-
-def save_bestk(b,k):
-## if os.access('%s_best%d.blif'%(f_name,k),os.R_OK):
-## res = get_bestk(k)
-## else:
- """ saves the best, returns bestk and if not best, leaves blif unchanged"""
- res = b
- if n_nodes() < res:
- res = n_nodes()
- abc('write_blif %s_best%d.blif'%(f_name,k))
- print 'best%d = %d'%(k,res)
- return res
-## unsave_bestk(k)
-
-def unsave_bestk(k):
- abc('r %s_best%d.blif'%(f_name,k))
-
-def unsnap(k=4):
-## snap()
- abc('fraig_restore')
- map_lut_dch(k)
-## abc('fraig_restore;if -a -F 2 -C 11 -K %d'%k)
-
-def map_until_conv(k=4):
- kk = 2*k
- # make sure that no residual results are left over.
- if os.access('%s_best%d.blif'%(f_name,k),os.R_OK):
- os.remove('%s_best%d.blif'%(f_name,k))
- if os.access('%s_best%d.blif'%(f_name,kk),os.R_OK):
- os.remove('%s_best%d.blif'%(f_name,kk))
- tt = time.time()
- #get initial map and save
- map_lut_dch(k)
- bestk = save_bestk(100000,k)
- print nl()
-## snap()
- res = preprocess() #get best of initial, clp, and lutmin versions
- print nl()
-## map_lut_dch(k)
-## ###
-## bestk = save_bestk(bestk,k)
-## map_iter(k)
-## bestk = save_bestk(bestk,k)
-## ###
- map_lut_dch_iter(kk) #initialize with mapping with 2k input LUTs
- bestkk = save_bestk(100000,kk)
- snap()
- unsnap(k) #have to do snap first if want current result snapped in.
- # unsnap fraigs snapshots and does map_lut_dch at end
- print nl()
- bestk = save_bestk(bestk,k)
- abc('r %s_bestk%d.blif'%(f_name,k))
- map_iter(k) #1
- bestk = save_bestk(bestk,k)
- while True:
- print 'Perturbing with %d-Lut'%kk
-## snap()
- map_lut_dch_iter(kk)
-## snap()
- bestkk_old = bestkk
- bestkk = save_bestk(bestkk,kk)
- if bestkk >= bestkk_old:
- break
-## snap()
-## jog(kk)
-## perturb_f(k)
-## snap()
-## perturb_f(k)
-## snap()
-## unsave_bestk(k)
-## map_lut_dch(k+1)
-## snap()
-## snap_bestk(k)
- snap()
- unsnap(k) #fraig restore and map
-## bestk = save_bestk(bestk,k)
-## snap()
- bestk_old = bestk
- map_iter(k)
- bestk = save_bestk(bestk,k)
- if bestk >= bestk_old:
- break
- continue
- abc('fraig_restore') #dump what is left in fraig_store
- unsave_bestk(k)
- print '\nFinal size = ',
- print nl()
- print 'time for %s = %.02f'%(f_name,(time.time()-tt))
-## cec_it()
-
-def get_bestk(k=4):
- abc('write_blif %s_temp.blif'%f_name)
- unsave_bestk(k)
- res = n_nodes()
- abc('r %s_temp.blif'%f_name)
- return res
-
-def map_iter(k=4):
- tt = time.time()
- bestk = get_bestk(k)
-## bestk = n_nodes()
-## bestk = save_bestk(bestk,k)
-## abc('st;dch;if -a -F 2 -K %d -C 11; mfs -a -L 1000; lutpack -L 1000'%k)#should be same as Initial
-## map_lut_dch_iter(k) ####
- map_lut_dch(k)
- bestk = save_bestk(bestk,k)
- n=0
- unsave_bestk(k)
- while True:
-## snap()
- perturb(k) #
-## snap()
- perturb(k)
-## snap_bestk(k)
-## unsnap(k)
-## bestk = save_bestk(bestk,k)
-## snap()
-## map_lut_dch(k+1)
-## abc('if -K %d'%(k+1))
-## snap()
-## unsnap(k)
- old_bestk = bestk
-## print old_bestk
- map_lut_dch_iter(k)
- bestk = save_bestk(bestk,k)
- print bestk
- if bestk < old_bestk:
- n=0 # keep it up
- continue
- elif n == 2: #perturb
- break
- else:
- n = n+1
- print '%d-perturb'%n
-## snap()
-## unsave_bestk(k)
- unsave_bestk(k)
-
-def map_star(k=4):
- tt = time.time()
- map_until_conv(k)
- abc('write_blif %s_best_star.blif'%f_name)
- best = n_nodes()
- while True:
- jog(2*k)
- map_until_conv(k)
- if n_nodes() >= best:
- break
- else:
- best = n_nodes()
- abc('write_blif %s_best_star.blif'%f_name)
- abc('r %s_best_star.blif'%f_name)
- print 'SIZE = %d, TIME = %.2f for %s'%(n_nodes(),(time.time() - tt),f_name)
-
-def decomp_444():
- abc('st; dch; if -K 10 -S 444')
- abc('write_blif -S 444 %s_temp.blif; r %s_temp.blif'%(f_name,f_name))
-
-def dmitri(k=8):
-## abc('w t.aig')
-## dc2_iter()
-## print 'first iter done: %d'%n_ands()
-## abc('dc2rs')
-#### dc2_iter()
-## print 'second iter done: %d'%n_ands()
-## sop_balance(k)
-## abc('w t_before.aig')
-## run_command('cec -n t.aig')
-## speedup_iter(k)
-## print 'n_levels after speedup = %d'%n_levels()
-## abc('write_blif %s_save.blif'%f_name)
-## nn=n_levels()
- abc('st;dch; if -g -K %d'%(k))
-## print 'n_levels after sop balance = %d'%n_levels()
-## if n_levels() > nn:
-## run_command('r %s_save.blif'%f_name)
-## print 'n_levels = %d'%n_levels()
-## print 'final n_levels = %d'%n_levels()
-## print 'sop_balance done: ',
-## print nl()
-## run_command('st;w t_after.aig')
-## run_command('cec -n t.aig')
- abc('if -G %d '%k)
-## print 'after if -G %d: '%k,
-## print nl()
-## run_command('cec -n t.aig')
- abc('cubes')
-## print 'after cubes: ',
-## print nl()
-## run_command('cec -n t.aig')
- abc('addbuffs -v')
-## print 'after addbuffs: ',
- print nl(),
-## run_command('cec -n t.aig')
-
-def lut():
- dc2_iter()
- abc('extract -a')
- print nl()
- dc2_iter()
-## ps()
- sop_balance(6)
- map_lut_dch()
- map_lut()
- print nl()
-## run_command('ps')
-
-################################## gate level abstraction
- """
- Code for using
- for abstraction
- """
-
-def bip_abs(t=100):
- """ t is ignored here"""
- set_globals()
- time = max(1,.1*G_T)
- abc('&get;,bmc -vt=%f'%time)
- set_max_bmc(bmc_depth())
- c = 2*G_C
- f = max(2*max_bmc,20)
- b = min(max(10,max_bmc),200)
- t1 = x_factor*max(1,2*G_T)
- t = max(t1,t)
- s = min(max(3,c/30000),10) # stability between 3 and 10
-## cmd = '&get;,abs -bob=%d -stable=%d -timeout=%d -vt=%d -depth=%d -dwr=vabs'%(b,s,t,t,f)
- cmd = '&get;,abs -timeout=%d -vt=%d -dwr=%s_vabs'%(t,t,f_name)
- print 'Running %s'%cmd
-## abc(cmd)
- run_command(cmd)
- bmc_depth()
- abc('&w %s_greg.aig'%f_name)
- return max_bmc
-
-def check_frames():
- abc('read_status vta.status')
- return n_bmc_frames()
-
-def vta_abs(t):
- """ Do gate-level abstraction for F frames """
- r = 100 *(1 - abs_ratio)
-## abc('orpos; &get;&vta -dv -A %s_vabs.aig -P 2 -T %d -R %d; &vta_gla;&w %s_gla.aig;&gla_derive; &put; w %s_gabs.aig'%(f_name,t,r,f_name,f_name))
- abc('orpos; &get;&vta -dv -A %s_vabs.aig -P 2 -T %d -R %d; &vta_gla;&w %s_gla.aig'%(f_name,t,r,f_name))
-
-## write_file('abs')
-
-
-def sizeof():
- return [n_pis(),n_pos(),n_latches(),n_ands()]
-
-def abstract(ifb=2):
- global abs_ratio
-## print 'ifb = %d'%ifb
- if ifb == 0: #new way using vta_abs and no bip
- add_trace('abstracta')
- return abstracta(False)
- elif ifb == 1: #old way using ,abs
- assert ifb == ifbip, 'call to abstract has ifb not = global ifbip'
- add_trace('abstractb')
- return abstractb()
- else:
- #new way using ,abs -dwr -- (bip_abs)
- add_trace('abstracta')
- return abstracta(True)
-
-def abstracta(if_bip=True):
- """
- if_bip = 0 it uses a new abstraction based on &vta (gate level abstraction) and no bip operations
- Right now, if we do not prove it with abstraction in the time allowed,
- we abandon abstraction and go on with speculation
- if_bip = 1, we use ,abs -dwr
- """
- global G_C, G_T, latches_before_abs, x_factor, last_verify_time, x, win_list, j_last, sims
- global latches_before_abs, ands_before_abs, pis_before_abs, abs_ratio
-## n_vabs = 0
- latches_before_abs = n_latches()
- ands_before_abs = n_ands()
- pis_before_abs = n_real_inputs()
- tt = time.time()
- print 'using abstracta, ',
-## print 'if_bip = %d'%if_bip
-## latch_ratio = abs_ratio
-## t = 100
- t = 1000 #temporary
- t = abs_time
- if if_bip == 0:
- t = 1000 #timeout on vta
- t = abs_time
- tt = time.time()
- if n_pos() > 1 and if_bip == 0:
- abc('orpos')
- print 'POs ORed together, ',
- initial_size = sizeof()
- abc('w %s_before_abs.aig'%f_name)
- # 25 below means that it will quit if #FF+#ANDS > 75% of original
-## funcs = [eval("(pyabc_split.defer(abc)('orpos;&get;&vta -d -R 25'))")] #right now we need orpos
- if if_bip:
- print 'using bip_abs'
- mtds = ['bip_abs']
- funcs = [eval('(pyabc_split.defer(bip_abs)(t))')]
- else:
- if gla:
- print 'using gla_abs_iter for %0.2f sec.'%(t-2)
- mtds = ['gla_abs_iter']
- add_trace('gla_abs')
- funcs = [eval('(pyabc_split.defer(gla_abs_iter)(t-2))')]
- else:
- print 'using vta_abs for %0.2f sec.'%(t-2)
- mtds = ['vta_abs']
- funcs = [eval('(pyabc_split.defer(vta_abs)(t-2))')]
- funcs = funcs + [eval('(pyabc_split.defer(monitor_and_prove)())')]
-## J = [34,30]
- J = pdrs[:1]+bmcs[:1] #just use one pdr and one bmc here.
-## J = pdrs+bmcs
-## J = modify_methods(J,2)
- funcs = funcs + create_funcs(J,1000)
- mtds = mtds + ['monitor_and_prove'] + sublist(methods,J)
- print 'methods = ',
- print mtds
- vta_term_by_time=0
- for i,res in pyabc_split.abc_split_all(funcs):
-## print i,res
- if i == 0: #vta or gla ended first
- print 'time taken = %0.2f'%(time.time() - tt)
- if is_sat():
- print 'vta/gla abstraction found cex in frame %d'%cex_frame()
- add_trace('SAT by gla')
- return Sat
- if is_unsat():
- print 'vta/gla abstraction proved UNSAT'
- add_trace('UNSAT by gla')
- return Unsat
- else: #undecided
- if if_bip:
- abc('&r -s %s_greg.aig; &abs_derive; &put; w %s_gabs.aig'%(f_name,f_name))
- else:
- abc('&r -s %s_gla.aig;&gla_derive; &put; w %s_gabs.aig'%(f_name,f_name))
- if time.time() - tt < .95*t:
- print 'abstraction terminated but not by timeout'
- vta_term_by_time = 0
- break
- else:
- print 'abstraction terminated by a timeout of %0.2f'%t
-## print 'final abstraction: ',
-## ps()
- vta_term_by_time=1
- break
- if i == 1: #monitor and prove ended first (sleep timed out)
- print 'monitor_and_prove: '
-## print i,res
- if res == None:
- print 'monitor and prove had an error'
- continue
- result = res[0]
- if res[0] > Undecided: #we abandon abstraction
- add_trace('de_abstract')
- print 'monitor and prove timed out or too little reduction'
- abc('r %s_before_abs.aig'%f_name)
- return Undecided_no_reduction
- if res[0] == Undecided:
- break
- else:
- if not initial_size == sizeof(): #monitor and prove should not return SAT in this case'
- assert not is_sat(), 'monitor_and_prove returned SAT on abstraction!'
- print 'time taken = %0.2f'%(time.time() - tt)
- if is_unsat() or res[0] == 'UNSAT' or res[0] == Unsat:
- add_trace('UNSAT by %s'%res[1])
- return Unsat
- elif is_sat() or res[0] < Unsat:
- add_trace('SAT by %s'%res[1])
- return Sat
- else:
- abc('r %s_before_abs.aig'%f_name)
- return Undecided_no_reduction
- else: #one of the engines got an answer
- print 'time taken = %0.2f'%(time.time() - tt)
-## add_trace('initial %s'%mtds[i])
- if is_unsat():
- print 'Initial %s proved UNSAT'%mtds[i]
- add_trace('UNSAT by initial %s'%mtds[i])
- return Unsat
- if is_sat():
- print 'Initial %s proved SAT'%mtds[i]
- add_trace('SAT by initial %s'%mtds[i])
- return Sat
- else: # an engine failed here
- print 'Initial %s terminated without result'%mtds[i]
- add_trace('method %s failed'%mtds[i])
-## return Undecided
- continue
- if vta_term_by_time == 0 and if_bip == 0 and gabs: #vta timed out itself
- print 'Trying to verify final abstraction',
- ps()
- result = verify([7,9,19,23,24,30],100)
- if result[0] == Unsat:
- add_trace('UNSAT by %s'%result[1])
- print 'Abstraction proved valid'
- return result[0]
- # should do abstraction refinement here if if_bip==1
- if if_bip == 0 and gabs: # thus using vta or gla abstraction and no refinement
- print 'abstraction no good - restoring initial simplified AIG',
- abc('r %s_before_abs.aig'%f_name)
- add_trace('de_abstract')
- ps()
- return Undecided_no_reduction
- else: # thus using bip_abs (ifbip=1) or gate abstraction (ifbip=0&gabs=False) and refinement
- if is_sat():
- print 'Found true counterexample in frame %d'%cex_frame()
- add_trace('SAT')
- return Sat_true
- if is_unsat():
- add_trace('UNSAT')
- return Unsat
- ## set_max_bmc(NBF)
- NBF = bmc_depth()
- print 'Abstraction good to %d frames'%max_bmc
- #note when things are done in parallel, the &aig is not restored!!!
- if if_bip:
- abc('&r -s %s_greg.aig; &w initial_greg.aig; &abs_derive; &put; w initial_gabs.aig; w %s_gabs.aig'%(f_name,f_name))
- else:
- run_command('&r -s %s_gla.aig; &w initial_gla.aig; &gla_derive; &put; w initial_gabs.aig; w %s_gabs.aig'%(f_name,f_name))
- set_max_bmc(NBF)
- print 'Initial abstraction: ',
- ps()
- abc('w %s_init_abs.aig'%f_name)
- latches_after = n_latches()
- ## if latches_after >= .90*latches_before_abs: #the following should match similar statement
- ## if ((rel_cost_t([pis_before_abs, latches_before_abs, ands_before_abs])> -.1) or
- ## (latches_after >= .75*latches_before_abs)):
- if small_abs(abs_ratio):
- abc('r %s_before_abs.aig'%f_name)
- print "Too little reduction!"
- print 'Abstract time wasted = %0.2f'%(time.time()-tt)
- add_trace('de_abstract')
- return Undecided_no_reduction
- sims_old = sims
- sims=sims[:1] #make it so that rarity sim is not used since it can't find a cex
-## result = Undecided_no_reduction
- print 'small_abs = %.2f, vta_term_by_time = %d'%(small_abs(abs_ratio),vta_term_by_time)
- if not vta_term_by_time:
- print 'Entering abstraction_refinement'
- result = abstraction_refinement(latches_before_abs, NBF,abs_ratio)
- sims = sims_old
- if result <= Unsat:
- return result
- if small_abs(abs_ratio): #r is ratio of final to initial latches in absstraction. If greater then True
-## if small_abs(abs_ratio) or result == Undecided_no_reduction or vta_term_by_time: #r is ratio of final to initial latches in absstraction. If greater then True
- abc('r %s_before_abs.aig'%f_name) #restore original file before abstract.
- print "Too little reduction! ",
- print 'Abstract time wasted = %0.2f'%(time.time()-tt)
- add_trace('de_abstract')
- return Undecided_no_reduction
- elif vta_term_by_time:
- abc('r %s_gabs.aig'%f_name)
- print 'Simplifying and testing abstraction'
- reparam()
- result = simplify()
- assert result >= Unsat, 'simplify returned SAT'
- if result > Unsat: #test if abstraction is unsat
- result = simple()
- res = result[0]
- if res == 'UNSAT':
- return Unsat
- else:
- abc('r %s_before_abs.aig'%f_name) #restore original file before abstract.
- print "Timed out with bad abstraction",
- print 'Abstract time wasted = %0.2f'%(time.time()-tt)
- add_trace('de_abstract')
- return Undecided_no_reduction
-## if res == 'SAT':
-#### result = Sat #this was an error
-## result = Undecided_no_reduction
-## elif res == 'UNSAT':
-## result = Unsat
-## else:
-## result = Undecided_no_reduction
-## return result
- else:
- write_file('abs') #this is only written if it was not solved and some change happened.
- print 'Abstract time = %0.2f'%(time.time()-tt)
- return result
-
-def gla_abs_iter(t):
- """ this iterates &gla every x sec and checks if it should be stopped or continued.
- Uses the fact that when &gla ends
- it leaves the result in the &-space showing which elements are abstracted.
- cex_abs_depth, time_abs_prev and time_abs come from monitor_and_prove
- gla_abs_iter and monitor_and_prove are run in parallel
- """
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- it_interval = 10000
- total = t
- tt = time.time()
- run_command('orpos;&get')
-## run_command('&w %s_gla.aig'%f_name)
- abs_depth = abs_depth_prev = 0
-## while True:
- r = 100 *(1 - abs_ratio)
- q = 99 #############TEMP
-## run_command('&r %s_gla.aig'%f_name)
- time_remain = total - (time.time() - tt) #time remaining
- it = min(it_interval,time_remain)
-## if it < 2:
-## break
- #gla and vabs are the file with the abstraction info and gabs is the derived file.
- cmd = '&gla -mvs -B 1 -A %s_vabs.aig -T %d -R %d -Q %d -S %d'%(f_name,it,r,q,abs_depth)
- print 'Executing %s'%cmd
- name = '%s_vabs.aig'%f_name
- run_command(cmd)
- if os.access(name,os.R_OK):
- run_command('&r -s %s_vabs.aig'%f_name) #get the last abstraction result
- run_command('&w %s_gla.aig'%f_name) #saves the result of abstraction.
- else:
- run_command('&r -s %s_abs_old.aig'%f_name) #get the last abstraction result
- run_command('&w %s_gla.aig'%f_name) #saves the result of abstraction.
- print 'wrote %s_gla file'%f_name
- run_command('&gla_derive;&put')
- run_command('w %s_gabs.aig'%f_name)
-## break
-## abs_depth_prev = abs_depth
-## abs_depth = n_bmc_frames()
-## print 'abs_depth = %d'%abs_depth
-## #test here if done
-## if (time.time()-tt) > total:
-## break
-## print 'reading abs_values'
-## read_abs_values()
-## print 'values read'
-## if abs_done(time_remain):
-## print 'abs_done'
-## break
-## else:
-## continue
-
-def read_abs_values():
- """here we read in the abs values written by monitor and prove"""
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- if not os.access('%s_ab.txt'%f_name,os.R_OK):
- print '%s_ab.txt does not exist'%f_name
- return #file does not exist so do nochange values
-## print '%s_ab.txt file exists and is readable'%f_name
- ab = open('%s_ab.txt'%f_name,'r')
- print '%s_ab.txt is opened'%f_name
- s = ab.readline()
-## print s
- cex_abs_depth = int(s)
- s = ab.readline()
-## print s
- time_abs_prev = float(s)
- s = ab.readline()
-## print s
- time_abs = float(s)
- s = ab.readline()
-## print s
- abs_depth_prev = float(s)
- s = ab.readline()
-## print s
- abs_depth = float(s)
- ab.close()
-## print 'read: ',
-## print cex_abs_depth,time_abs_prev,time_abs,abs_depth_prev,abs_depth
-## print 'it is closed'
-
-def write_abs_values():
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- """here we write in the abs values written by monitor and prove"""
-## print 'write: ',
-## print cex_abs_depth,time_abs_prev,time_abs,abs_depth_prev,abs_depth
- ab = open('%s_ab.txt'%f_name,'w')
- ab.write(str(cex_abs_depth)+'\n')
- ab.write(str(time_abs_prev)+'\n')
- ab.write(str(time_abs)+'\n')
- ab.write(str(abs_depth_prev)+'\n')
- ab.write(str(abs_depth))
- ab.close()
-
-def abs_done(time_remain):
- """ heuristic to see if we are not making any progress and should quit
- look at frame of last cex found (cex_abs_depth) for current abstraction using a parallel engine
- look at depth of current abstraction (abs_depth) and last abstraction (abs_deptth_prev)
- look at time between new abstractions time_abs - time_abs_prev.
- compute approximate frames_per_sec
- if frames_to_next_cex > frames_per_sec * time_remain
- then won't get there is the time allowed.
- We have to pass all the information along when we are doing things in parallel by writing a file
- with this info in it and reading it in later. This is because monitor_and prove
- runs in parallel and global variables are not passed around.
- """
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
-## print 'checking if abs has enough time to next cex'
- frames_to_next_cex = cex_abs_depth - abs_depth
- div = time_abs - time_abs_prev
- div = max(.1,div)
- frames_per_sec = (abs_depth - abs_depth_prev)/div
- if frames_per_sec <= 0:
- return False #something wrong
- print 'frames_per_sec = %0.2f, frames_to_next_cex = %d, time remaining = %0.2f'%(frames_per_sec, frames_to_next_cex, time_remain)
- if frames_to_next_cex > 0.2*(frames_per_sec * time_remain): #later frames will take longer so factor of 5 here
- print 'not enough abs time to next cex'
- return True
- return False
-
-##def gla_abs(t):
-## """ Do gate-level abstraction for F frames """
-## r = 100 *(1 - abs_ratio)
-## run_command('orpos; &get;&gla -dv -A %s_vabs.aig -T %d -R %d; &w %s_gla.aig'%(f_name,t,r,f_name))
-
-
-def monitor_and_prove():
- """
- monitor and prove. Runs in parallel with abstraction method.
- It looks for a new vabs and if found, will try to verify it in parallel
- We want to write a file that has variables
- cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- which will be used by abs_done called by gla_abs_iter which is to replace gla_abs
- """
- global ifbip
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- #write the current aig as vabs.aig so it will be regularly verified at the beginning.
- name = '%s_vabs.aig'%f_name
- if os.access('%s'%name,os.R_OK): #make it so that there is no initial abstraction
- os.remove('%s'%name)
- initial_size = sizeof()
- print 'initial size = ',
- print initial_size
- time_abs = time_abs_prev = time.time()
- cex_abs_depth = 0
- abs_depth = abs_depth_prev = 0
- write_abs_values()
-## if read_and_sleep(5): # wait until first abstraction when res is False
-## #time has run out as controlled by abs_time
-## return [Undecided_no_reduction] + ['read_and_sleep']
- t = abs_time +10
- tt = time.time()
-## print 'first read and sleep done'
- #a return of Undecided means that abstraction might be good and calling routine will check this
- while True: #here we iterate looking for a new abstraction and trying to prove it
- time_done = abs_bad = 0
- funcs = [eval('(pyabc_split.defer(read_and_sleep)())')]
- J = sims+intrps+pdrs+bmcs
- J = modify_methods(J,1)
- funcs = funcs + create_funcs(J,t)
- mtds = ['read_and_sleep'] + sublist(methods,J)
- print 'methods = %s'%mtds
- for i,res in pyabc_split.abc_split_all(funcs):
-## print 'Mon. & Pr.: ,
-## print i,res
- if i == 0: # read_and_sleep terminated
- if res == False: #found new abstraction
- read_abs_values()
- time_abs_prev = time_abs
- time_abs = time.time()
- print 'time between new abstractions = %0.2f'%(time_abs - time_abs_prev)
- write_abs_values()
- abs_bad = 0 #new abs starts out good.
- if not initial_size == sizeof() and n_latches() > abs_ratio * initial_size[2]:
- return [Undecided_no_reduction]+['read_and_sleep']
- else:
- break
- elif res == True: # read and sleep timed out
- time_done = 1
- print 'read_and_sleep timed out'
- if abs_bad:
- return [Undecided_no_reduction]+['read_and_sleep']
- else: #abs is still good. Let other engines continue
- return [Undecided]+['read_and_sleep'] #calling routine handles >Unsat all the same right now.
- else:
- assert False, 'something wrong. read and sleep did not return right thing'
- if i > 0: #got result from one of the verify engines
- print 'monitor_and_prove: Method %s terminated'%mtds[i],
-## print i,res
- if res == None:
- print 'Method %s failed'%mtds[i]
- continue
-## print 'method %s found SAT in frame %d'%(mtds[i],cex_frame())
- if is_unsat() or res == Unsat or res == 'UNSAT':
- print '\nParallel %s proved UNSAT on current abstr\n'%mtds[i]
- return [Unsat] + [mtds[i]]
- elif is_sat() or res < Unsat or res == 'SAT': #abstraction is not good yet.
- print 'method = %s'%mtds[i]
- if not mtds[i] == 'RareSim': #the other engines give a better estimate of true cex depth
- read_abs_values()
- cex_abs_depth = cex_frame()
- write_abs_values()
- print '\nParallel %s found SAT on current abstr in frame %d\n'%(mtds[i],cex_frame())
-## print 'n_vabs = %d'%n_vabs
- if initial_size == sizeof():# the first time we were working on an aig before abstraction
- print initial_size == abstraction_size
- return [Sat]+[mtds[i]]
-## print 'current abstraction invalid'
- abs_bad = 1
- break #this kills off other verification engines working on bad abstraction
- else: #one of the engines undecided for some reason - failed?
- print '\nParallel %s terminated without result on current abstr\n'%mtds[i]
- continue
- if abs_bad and not time_done: #here we wait until have a new vabs.
- time_remain = t -(time.time() - tt)
- abc('r %s_abs.aig'%f_name) #read in the abstraction to destroy is_sat().
- if abs_done(time_remain):
- return [Undecided]+['timeout']
- res = read_and_sleep(5) #this will check every 5 sec, until abs_time sec has passed without new abs
- if res == False: #found new vabs. Now continue if vabs small enough
-## print 'n_vabs = %d'%n_vabs
- if (not initial_size == sizeof()) and n_latches() > abs_ratio * initial_size[2]:
- return [Undecided_no_reduction]+['no reduction']
- else:
- continue
- elif res ==True: #read_and_sleep timed out
-## print 'read_and_sleep timed out'
- return [Undecided_no_reduction]+['no reduction']
- else:
- break #this should not happen
- elif abs_bad and time_done:
-## print 'current abstraction bad, time has run out'
- return [Undecided_no_reduction]+['no reduction']
- elif time_done: #abs is good here
-## print 'current abstraction still good, time has run out'
- return [Undecided]+['reduction'] #this will cause calling routine to try to verify the final abstraction
- #right now handles the same as Undecided_no_reduction-if time runs out we quit abstraction
- else: #abs good and time not done
- continue
-## print 'current abstraction still good, time has not run out'
- return [len(funcs)]+['error']
-
-def read_and_sleep(t=5):
- """
- keep looking for a new vabs every 5 seconds. This is usually run in parallel with
- &vta -d or &gla
- Returns False when new abstraction is found, and True when time runs out.
- """
- global cex_abs_depth, abs_depth, abs_depth_prev, time_abs_prev, time_abs
- #t is not used at present
- tt = time.time()
- T = 1000 #if after the last abstraction, no answer, then terminate
- T = abs_time + 10
- set_size()
- name = '%s_vabs.aig'%f_name
-## if ifbip > 0:
-## name = '%s_vabs.aig'%f_name
-## print 'name = %s'%name
- sleep(5)
- while True:
- if time.time() - tt > T: #too much time between abstractions
-## print 'read_and_sleep timed out in %d sec.'%T
- return True
- if os.access(name,os.R_OK):
- #possible race condition
- run_command('&r -s %s; &w %s_vabs_old.aig'%(name,f_name))
-## print '%s exists'%name
- if not os.access(name,os.R_OK): #if not readable now then what was read in might not be OK.
- print '%s does not exist'%name
- continue
-## print '%s is read'%name
-## run_command('&r %s;read_status %s_vabs.status'%(name,f_name)) #need to use & space to keep the abstraction information
- os.remove(name)
- run_command('read_status %s_vabs.status'%f_name)
-## print '%s and %s_vabs.status have been read'%(name,f_name)
-## print 'reading %s_vabs.status'%f_name
- #name is the derived model (not the model with abstraction info
- run_command('&r -s %s_vabs_old.aig'%f_name)
- run_command('&w %s_gla.aig'%f_name)
- run_command('&gla_derive;&put')
- run_command('w %s_gabs.aig'%f_name)
-## print '%s is removed'%name
- read_abs_values()
- time_abs_prev = time_abs
- time_abs = time.time()
-## print 'abs values has been read'
- run_command('read_status %s_vabs.status'%f_name)
- abs_depth_prev = abs_depth
- abs_depth = n_bmc_frames()
- write_abs_values()
-## print 'abs values has been written'
- time_remain = T - (time.time() - tt)
- if abs_done(time_remain):
- return True
-## if not check_size():
- if True:
- print '\nNew abstraction: ',
- ps()
-## print 'Time = %0.2f'%(time.time() - tt)
- set_size()
- abc('w %s_abs.aig'%f_name)
- return False
- #if same size, keep going.
- print '.',
- sleep(5)
-####################################################
diff --git a/scripts/simple.sh b/scripts/simple.sh
deleted file mode 100644
index 357dd165..00000000
--- a/scripts/simple.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/simple_aiger $*"
diff --git a/scripts/simple_bip.sh b/scripts/simple_bip.sh
deleted file mode 100644
index f6220099..00000000
--- a/scripts/simple_bip.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/simple_bip_aiger $*"
diff --git a/scripts/simple_liveness.sh b/scripts/simple_liveness.sh
deleted file mode 100644
index f5232d15..00000000
--- a/scripts/simple_liveness.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/simple_liveness_aiger $*"
diff --git a/scripts/simple_sat.sh b/scripts/simple_sat.sh
deleted file mode 100644
index dc19023a..00000000
--- a/scripts/simple_sat.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/simple_sat_aiger $*"
diff --git a/scripts/super_prove.sh b/scripts/super_prove.sh
deleted file mode 100644
index da0a6ec6..00000000
--- a/scripts/super_prove.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-abc_root()
-{
- cwd="$(pwd)"
- cd $(dirname "$1")
- echo $(dirname "$(pwd)")
- cd "${cwd}"
-}
-
-abc_dir=$(abc_root "$0")
-bin_dir="${abc_dir}"/bin
-
-exec ${bin_dir}/abc -q "/super_prove_aiger $*"
diff --git a/src/base/main/mainReal.c b/src/base/main/mainReal.c
index a22a871a..a26cfa84 100644
--- a/src/base/main/mainReal.c
+++ b/src/base/main/mainReal.c
@@ -45,10 +45,6 @@ SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
***********************************************************************/
-#ifdef ABC_PYTHON_EMBED
-#include <Python.h>
-#endif /* ABC_PYTHON_EMBED */
-
#include "base/abc/abc.h"
#include "mainInt.h"
#include "base/wlc/wlc.h"
@@ -108,29 +104,6 @@ int Abc_RealMain( int argc, char * argv[] )
pAbc = Abc_FrameGetGlobalFrame();
pAbc->sBinary = argv[0];
-#ifdef ABC_PYTHON_EMBED
- {
- PyObject* pModule;
- void init_pyabc(void);
-
- Py_SetProgramName(argv[0]);
- Py_NoSiteFlag = 1;
- Py_Initialize();
-
- init_pyabc();
-
- pModule = PyImport_ImportModule("pyabc");
- if (pModule)
- {
- Py_DECREF(pModule);
- }
- else
- {
- fprintf( pAbc->Err, "error: pyabc.py not found. PYTHONPATH may not be set properly.\n");
- }
- }
-#endif /* ABC_PYTHON_EMBED */
-
// default options
fBatch = INTERACTIVE;
fInitSource = 1;
@@ -354,12 +327,6 @@ int Abc_RealMain( int argc, char * argv[] )
}
}
-#ifdef ABC_PYTHON_EMBED
- {
- Py_Finalize();
- }
-#endif /* ABC_PYTHON_EMBED */
-
// if the memory should be freed, quit packages
// if ( fStatus < 0 )
{
diff --git a/src/base/main/mainUtils.c b/src/base/main/mainUtils.c
index 30d1693c..c0145641 100644
--- a/src/base/main/mainUtils.c
+++ b/src/base/main/mainUtils.c
@@ -190,23 +190,6 @@ void Abc_UtilsSource( Abc_Frame_t * pAbc )
}
#endif
-#ifdef ABC_PYTHON_EMBED
- if ( getenv("ABC_PYTHON_ABC_RC") )
- {
- /* read script file from $ABC_PYTHON_ABC_RC */
-
- char * sPath = getenv("ABC_PYTHON_ABC_RC");
-
- if (sPath){
- char * sCmd = ABC_ALLOC(char, strlen(sPath) + 50);
- (void) sprintf(sCmd, "source -s %s", sPath);
- (void) Cmd_CommandExecute(pAbc, sCmd);
- ABC_FREE(sCmd);
- }
- }
- else
-#endif /* #ifdef ABC_PYTHON_EMBED */
-
{
char * sPath1, * sPath2;
char * home;
diff --git a/src/misc/util/utilSignal.c b/src/misc/util/utilSignal.c
index af0948bd..03af81d1 100644
--- a/src/misc/util/utilSignal.c
+++ b/src/misc/util/utilSignal.c
@@ -41,8 +41,6 @@ ABC_NAMESPACE_IMPL_START
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
-#ifndef ABC_PYTHON_EMBED
-
int Util_SignalSystem(const char* cmd)
{
return system(cmd);
@@ -63,8 +61,6 @@ void Util_SignalTmpFileRemove(const char* fname, int fLeave)
}
}
-#endif /* ABC_PYTHON_EMBED */
-
ABC_NAMESPACE_IMPL_END
////////////////////////////////////////////////////////////////////////
diff --git a/src/python/abc.sh b/src/python/abc.sh
deleted file mode 100644
index 688cf567..00000000
--- a/src/python/abc.sh
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/bin/sh
-#
-# Setup the ABC/Py environment and run the ABC/Py executable
-# (ABC/Py stands for ABC with embedded Python)
-#
-# ABC/Py expects the following directory structure
-#
-# abc_root/
-# bin/
-# abc - this script
-# abc_exe - the ABC executable
-# ... - Other scripts
-# lib/
-# pyabc.py - support file for pyabc extension
-# python_library.zip - The Python standard library. Only if not using the system Python interpreter.
-# *.so - Python extensions, Only if not using the system Python interpreter.
-# scripts/
-# *.py - default directory for python scripts
-#
-
-# usage: abspath <dir>
-# get the absolute path of <dir>
-abspath()
-{
- cwd="$(pwd)"
- cd "$1"
- echo "$(pwd)"
- cd "${cwd}"
-}
-
-self=$0
-
-self_dir=$(dirname "${self}")
-self_dir=$(abspath "${self_dir}")
-
-abc_root=$(dirname "${self_dir}")
-
-abc_exe="${abc_root}/bin/abc_exe"
-
-PYTHONPATH="${abc_root}/lib":"${PYTHONPATH}"
-export PYTHONPATH
-
-if [ -d "${abc_root}/scripts" ] ; then
- ABC_PYTHON_SCRIPTS="${abc_root}/scripts"
- export ABC_PYTHON_SCRIPTS
-
- PYTHONPATH="${ABC_PYTHON_SCRIPTS}":"${PYTHONPATH}"
- export PYTHONPATH
-fi
-
-if [ -f "${abc_root}/scripts/abc.rc" ] ; then
- ABC_PYTHON_ABC_RC="${abc_root}/scripts/abc.rc"
- export ABC_PYTHON_ABC_RC
-fi
-
-if [ -f "${abc_root}/lib/python_library.zip" ] ; then
- PYTHONHOME="${abc_root}"
- export PYTHONHOME
-
- PYTHONPATH="${abc_root}/lib/python_library.zip":"${PYTHONPATH}"
- export PYTHONPATH
-fi
-
-PATH="${abc_root}/bin:$PATH"
-export PATH
-
-if [ "$1" = "--debug" ]; then
- shift
- abc_debugger="$1"
- shift
-
- echo export PYTHONHOME=$PYTHONHOME
- echo export PYTHONPATH=$PYTHONPATH
- echo export ABC_PYTHON_SCRIPTS=$ABC_PYTHON_SCRIPTS
- echo export ABC_PYTHON_ABC_RC=$ABC_PYTHON_ABC_RC
-fi
-
-exec ${abc_debugger} "${abc_exe}" "$@"
diff --git a/src/python/abcpy_test.py b/src/python/abcpy_test.py
deleted file mode 100644
index 28c3505b..00000000
--- a/src/python/abcpy_test.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# You can use 'from pyabc import *' and then not need the pyabc. prefix everywhere
-import pyabc
-
-# A new command is just a function that accepts a list of string arguments
-# The first argument is always the name of the command
-# It MUST return an integer. -1: user quits, -2: error. Return 0 for success.
-
-# a simple command that just prints its arguments and returns success
-def pytest1_cmd(args):
- print args
- return 0
-
-# registers the command:
-# The first argument is the function
-# The second argument is the category (mainly for the ABC help command)
-# The third argument is the new command name
-# Keet the fourth argument 0, or consult with Alan
-pyabc.add_abc_command(pytest1_cmd, "Python-Test", "pytest1", 0)
-
-# a simple command that just prints its arguments and runs the command 'scorr -h'
-def pytest2_cmd(args):
- print args
- pyabc.run_command('scorr -h')
- return 0
-
-pyabc.add_abc_command(pytest2_cmd, "Python-Test", "pytest2", 0)
-
-# Now a more complicated command with argument parsing
-# This command gets two command line arguments -c and -v. -c cmd runs the command 'cmd -h' and -v prints the python version
-# for more details see the optparse module: http://docs.python.org/library/optparse.html
-
-import optparse
-
-def pytest3_cmd(args):
- usage = "usage: %prog [options]"
-
- parser = optparse.OptionParser(usage, prog="pytest3")
-
- parser.add_option("-c", "--cmd", dest="cmd", help="command to ask help for")
- parser.add_option("-v", "--version", action="store_true", dest="version", help="display Python Version")
-
- options, args = parser.parse_args(args)
-
- if options.version:
- print sys.version
- return 0
-
- if options.cmd:
- pyabc.run_command("%s -h"%options.cmd)
- return 0
-
- return 0
-
-pyabc.add_abc_command(pytest3_cmd, "Python-Test", "pytest3", 0)
diff --git a/src/python/build.txt b/src/python/build.txt
deleted file mode 100644
index 60a3a9ba..00000000
--- a/src/python/build.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-On Windows:
-
-python setup.py build
-python setup.py bdist_wininst
-
-On Linux (from the main abc directory)
-
-To build the extensions (make sure -fPIC is added to OPTFLAG in the main ABC Makefile first)
-
-make ABC_PYTHON=/usr/bin/python pyabc_extension_install
-
-To build the ABC with embedded python
-
-make pyabc.tgz
-
-
-
-
-Updating the latest version on mima:
-
-alanmi@mima:~/abc_60$ cp ./src/python/build/lib.linux-x86_64-2.6/_pyabc.so /hd/common/pyabc/builds/101030/_pyabc.so
-alanmi@mima:~/abc_60$ cp ./src/python/build/lib.linux-x86_64-2.6/pyabc.py /hd/common/pyabc/builds/101030/pyabc.py
-
-alanmi@mima:/hd/common/pyabc$ rm current
-alanmi@mima:/hd/common/pyabc$ ln -s builds/101030 current
-alanmi@mima:/hd/common/pyabc$ ls -l
-total 4
-lrwxrwxrwx 1 alanmi common 13 2010-10-30 14:55 current -> builds/101030
-
-
-Latest documentation:
-http://goo.gl/jNV2 \ No newline at end of file
diff --git a/src/python/getch.py b/src/python/getch.py
deleted file mode 100644
index 89e13078..00000000
--- a/src/python/getch.py
+++ /dev/null
@@ -1,37 +0,0 @@
-
-class _Getch:
- """Gets a single character from standard input. Does not echo to the screen."""
- def __init__(self):
- try:
- self.impl = _GetchWindows()
- except ImportError:
- self.impl = _GetchUnix()
-
- def __call__(self): return self.impl()
-
-
-class _GetchUnix:
- def __init__(self):
- import tty, sys
-
- def __call__(self):
- import sys, tty, termios
- fd = sys.stdin.fileno()
- old_settings = termios.tcgetattr(fd)
- try:
- tty.setraw(sys.stdin.fileno())
- ch = sys.stdin.read(1)
- finally:
- termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
- return ch
-
-
-class _GetchWindows:
- def __init__(self):
- import msvcrt
-
- def __call__(self):
- import msvcrt
- return msvcrt.getch()
-
-getch = _Getch()
diff --git a/src/python/module.make b/src/python/module.make
deleted file mode 100644
index 51be60af..00000000
--- a/src/python/module.make
+++ /dev/null
@@ -1,92 +0,0 @@
-# To compile with the embedded python interpreter set
-# the variable ABC_PYTHON to point to the python executable
-#
-# Examples:
-# make ABC_PYTHON=/usr/bin/python
-# make ABC_PYTHON=/usr/bin/python2.5
-#
-# To build the Python extension build the target pyabc
-# To create a package of ABC with embedded Python use the target pyabc.tgz
-
-ifdef ABC_PYTHON
-
- # get the directory containing this file
- ABC_PYTHON_FILES_PREFIX := $(CURDIR)/src/python
-
- ABC_SWIG := swig
- ABC_PYTHON_CONFIG := $(ABC_PYTHON)-config
- ABC_PYTHON_CFLAGS := $(shell $(ABC_PYTHON_CONFIG) --includes) -DABC_PYTHON_EMBED=1
- ABC_PYTHON_LDFLAGS := $(shell $(ABC_PYTHON_CONFIG) --ldflags)
-
- CFLAGS += $(ABC_PYTHON_CFLAGS)
- CXXFLAGS += $(ABC_PYTHON_CFLAGS)
- LIBS += $(ABC_PYTHON_LDFLAGS)
-
- ABC_PYTHON_SRC := $(ABC_PYTHON_FILES_PREFIX)/pyabc_wrap.c
-
- SRC += $(ABC_PYTHON_SRC)
-
- GARBAGE += \
- $(ABC_PYTHON_SRC) \
- $(ABC_PYTHON_SRC:_wrap.c=.py) \
- $(ABC_PYTHON_SRC:_wrap.c=.pyc) \
- $(ABC_PYTHON_FILES_PREFIX)/build \
- $(ABC_PYTHON_FILES_PREFIX)/dist \
- pyabc.tgz
-
- ABC_PYABC_DIR ?= pyabc
- ABC_PYABC_TGZ ?= pyabc.tgz
- ABC_PYABC_EXTRA_BIN ?=
- ABC_PYABC_EXTRA_LIB ?=
-
-
-%_wrap.c %.py : %.i
- $(ABC_SWIG) -python -outdir $(<D) $<
-
-.PHONY: pyabc_extension_build
-
-pyabc_extension_build : lib$(PROG).a $(ABC_PYTHON_SRC) $(ABC_PYTHON_SRC:_wrap.c=.py)
- ( cd $(ABC_PYTHON_FILES_PREFIX) && rm -rf build/ )
- ( cd $(ABC_PYTHON_FILES_PREFIX) && $(ABC_PYTHON) setup.py build )
-
-.PHONY: pyabc_extension_install
-
-pyabc_extension_install : pyabc_extension_build
- ( cd $(ABC_PYTHON_FILES_PREFIX) && $(ABC_PYTHON) setup.py install --user )
-
-.PHONY: pyabc_extension_bdist
-
-pyabc_extension_bdist : pyabc_extension_build
- ( cd $(ABC_PYTHON_FILES_PREFIX) && python setup.py bdist )
-
-.PHONY: pyabc_tgz
-
-pyabc_tgz : $(ABC_PYABC_TGZ)
-
-$(ABC_PYABC_TGZ) : $(PROG) $(ABC_PYTHON_SRC:_wrap.c=.py) $(ABC_PYTHON_FILES_PREFIX)/abc.sh $(ABC_PYTHON_FILES_PREFIX)/package.py
- $(ABC_PYTHON) $(ABC_PYTHON_FILES_PREFIX)/package.py \
- --pyabc_dir=$(ABC_PYABC_DIR) \
- --abc=$(PROG) \
- --abc_sh=$(ABC_PYTHON_FILES_PREFIX)/abc.sh \
- --pyabc=$(ABC_PYTHON_FILES_PREFIX) \
- --extra_bin="$(ABC_PYABC_EXTRA_BIN)" \
- --extra_lib="$(ABC_PYABC_EXTRA_LIB)" \
- --out=$@ \
- $(ABC_PYTHON_OPTIONS)
-
-PYABC_INSTALL_TARGET ?= $(shell date +%Y-%m-%d_%H-%M.%N_${USER})
-PYABC_INSTALL_TARGET := $(PYABC_INSTALL_TARGET)
-
-PYABC_INSTALL_DIR ?= /hd/common/pyabc/builds/pyabc_builds/
-
-pyabc_install_target: pyabc_extension_bdist
- mkdir -p "$(PYABC_INSTALL_DIR)/$(PYABC_INSTALL_TARGET)"
- tar \
- --directory="$(PYABC_INSTALL_DIR)/$(PYABC_INSTALL_TARGET)" \
- --show-transformed-names \
- --transform='s#^.*/##g' \
- -xvzf "$(ABC_PYTHON_FILES_PREFIX)/dist/pyabc-1.0.linux-x86_64.tar.gz"
- find "$(PYABC_INSTALL_DIR)/$(PYABC_INSTALL_TARGET)/"* -type d | xargs rmdir
- echo "Installed at $(PYABC_INSTALL_DIR)/$(PYABC_INSTALL_TARGET)"
-
-endif
diff --git a/src/python/package.py b/src/python/package.py
deleted file mode 100644
index 2e6ad559..00000000
--- a/src/python/package.py
+++ /dev/null
@@ -1,176 +0,0 @@
-import os
-import sys
-import optparse
-import zipfile
-import tarfile
-import tempfile
-import time
-import py_compile
-
-def zip_library(f, extra_files = []):
- lib = "%s/lib/python%s/"%(sys.prefix,sys.version[:3])
-
- zf = zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED)
-
- for root, _, files in os.walk(lib):
- arcroot = os.path.relpath(root, lib)
- for f in files:
- _, ext = os.path.splitext(f)
- if ext in ['.py']:
- zf.write(os.path.join(root,f), os.path.join(arcroot, f))
-
- for s, r in extra_files:
- zf.write( s, r )
-
- zf.close()
-
-def add_python_lib(tf, lib_dir, lib, mtime):
-
- _, prefix = os.path.split(lib)
-
- for root, _, files in os.walk(lib):
-
- relpath = os.path.relpath(root, lib)
-
- if '.hg' in relpath.split('/'):
- continue
-
- if relpath=='.':
- arcroot = lib_dir
- else:
- arcroot = os.path.join( lib_dir, os.path.relpath(root, lib) )
-
- arcroot = os.path.join(arcroot, prefix)
-
- add_dir(tf, arcroot, mtime)
-
- for f in files:
- _, ext = os.path.splitext(f)
- if ext in ['.py', '.so']:
- add_file( tf, os.path.join(root,f), os.path.join(arcroot, f), 0666, mtime)
-
-def add_dir(tf, dir, mtime):
- ti = tarfile.TarInfo(dir)
- ti.mode = 0777
- ti.mtime = mtime
- ti.type = tarfile.DIRTYPE
-
- tf.addfile(ti)
-
-def add_fileobj(tf, f, arcname, mode, mtime):
- ti = tarfile.TarInfo(arcname)
- ti.mode = mode
- ti.mtime = mtime
-
- f.seek(0, os.SEEK_END)
- ti.size = f.tell()
-
- f.seek(0, os.SEEK_SET)
- tf.addfile(ti, f)
-
-def add_file(tf, fname, arcname, mode, mtime):
- print "\t adding %s as %s"%(fname, arcname)
-
- with open(fname, "rb") as f:
- add_fileobj(tf, f, arcname, mode, mtime)
-
-def package(pyabc_dir, extra_bin, extra_lib, extra_files, abc_exe, abc_sh, pyabc, ofname, scripts_dir, use_sys):
-
- mtime = time.time()
-
- tf = tarfile.open(ofname, "w:gz")
-
- add_dir(tf, "%s"%pyabc_dir, mtime)
-
- add_dir(tf, "%s/bin"%pyabc_dir, mtime)
-
- add_file(tf, abc_exe, "%s/bin/abc_exe"%pyabc_dir, 0777, mtime)
- add_file(tf, abc_sh, "%s/bin/abc"%pyabc_dir, 0777, mtime)
-
- if scripts_dir:
- for fn in os.listdir(scripts_dir):
- if fn.startswith('.'):
- continue
- fullname = os.path.join(scripts_dir, fn)
- if os.path.isfile(fullname):
- fnroot, fnext = os.path.splitext(fn)
- if fnext==".sh":
- add_file( tf, fullname, os.path.join("%s/bin"%pyabc_dir, fnroot), 0777, mtime)
- elif fnext not in ( '.pyc', '.pyo'):
- add_file( tf, fullname, os.path.join("%s/scripts"%pyabc_dir, fn), 0666, mtime)
-
- for bin in extra_bin:
- add_file( tf, bin, os.path.join("%s/bin"%pyabc_dir, os.path.basename(bin)), 0777, mtime)
-
- lib_dir = "%s/lib"%pyabc_dir
-
- add_dir(tf, lib_dir, mtime)
-
- for lib in extra_lib:
- add_python_lib( tf, lib_dir, lib, mtime)
-
- for file, dest in extra_files:
- add_file(tf, file, '%s/%s'%(pyabc_dir, dest), 0666, mtime)
-
- for entry in os.listdir(pyabc):
- if entry.endswith('.py'):
- add_file( tf, os.path.join(pyabc, entry), os.path.join("%s/lib"%pyabc_dir, entry), 0666, mtime)
-
- if not use_sys:
- # ZIP standard library
- zf = tempfile.NamedTemporaryFile("w+b")
- #zip_library(zf, [(pyabc, "pyabc.py")])
- zip_library(zf, [])
- zf.flush()
-
- add_fileobj(tf, zf, "%s/lib/python_library.zip"%pyabc_dir, 0666, mtime)
-
- zf.close()
-
- # add all extensions
-
- lib_dynload = os.path.join(sys.exec_prefix,"lib", "python%s"%sys.version[:3], "lib-dynload")
-
- for fn in os.listdir(lib_dynload):
- fullname = os.path.join(lib_dynload, fn)
- if os.path.isfile(fullname):
- add_file( tf, fullname, os.path.join("%s/lib"%pyabc_dir, fn), 0666, mtime)
-
- tf.close()
-
-
-def main(args):
-
- usage = "usage: %prog [options]"
-
- parser = optparse.OptionParser(usage)
-
- parser.add_option("-d", "--pyabc_dir", dest="pyabc_dir", help="name of generated directory" )
- parser.add_option("-b", "--extra_bin", dest="extra_bin", help="extra binaries to pack" )
- parser.add_option("-l", "--extra_lib", dest="extra_lib", help="extra directories in lib to pack" )
- parser.add_option("-f", "--extra_files", dest="extra_files", help="additional files (comma separated pairs of file:dest" )
- parser.add_option("-a", "--abc", dest="abc", help="location of the ABC exeutable")
- parser.add_option("-s", "--abc_sh", dest="abc_sh", help="location of the ABC setup script")
- parser.add_option("-p", "--pyabc", dest="pyabc", help="location of pyabc.py")
- parser.add_option("-o", "--out", dest="out", help="location of output tar gzipped file")
- parser.add_option("-x", "--scripts", dest="scripts", default="scripts", help="location of scripts")
- parser.add_option("-S", "--system", action="store_false", dest="sys", default=True, help="use default python installation")
-
- options, args = parser.parse_args(args)
-
- if len(args) > 1:
- parser.print_help()
- return 1
-
- if not options.pyabc_dir or not options.abc or not options.abc_sh or not options.pyabc or not options.out:
- parser.print_help()
- return 1
-
- extra_bin = options.extra_bin.split(',') if options.extra_bin else []
- extra_lib = options.extra_lib.split(',') if options.extra_lib else []
- extra_files = [ s.split(':') for s in options.extra_files.split(',')] if options.extra_files else []
-
- return package(options.pyabc_dir, extra_bin, extra_lib, extra_files, options.abc, options.abc_sh, options.pyabc, options.out, options.scripts, options.sys)
-
-if __name__=="__main__":
- main(sys.argv)
diff --git a/src/python/pyabc.i b/src/python/pyabc.i
deleted file mode 100644
index 0e7b9312..00000000
--- a/src/python/pyabc.i
+++ /dev/null
@@ -1,1319 +0,0 @@
-%module pyabc
-
-// -------------------------------------------------------------------
-// SWIG typemap allowing us to grab a Python callable object
-// -------------------------------------------------------------------
-
-#ifdef SWIG<Python>
-
-%typemap(in) PyObject *PyFunc
-{
-
- if ( !PyCallable_Check($source) )
- {
- PyErr_SetString(PyExc_TypeError, "Need a callable object!");
- return NULL;
- }
-
- $target = $source;
-}
-
-#endif /* #ifdef SWIG<Python> */
-
-%{
-
-#include <base/main/main.h>
-#include <misc/util/utilCex.h>
-
-#include <stdlib.h>
-#include <signal.h>
-
-#include <sys/prctl.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-int n_ands()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk && Abc_NtkIsStrash(pNtk) )
- {
- return Abc_NtkNodeNum(pNtk);
- }
-
- return -1;
-}
-
-int n_nodes()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk )
- {
- return Abc_NtkNodeNum(pNtk);
- }
-
- return -1;
-}
-
-int n_pis()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk )
- {
- return Abc_NtkPiNum(pNtk);
- }
-
- return -1;
-}
-
-
-int n_pos()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk )
- {
- return Abc_NtkPoNum(pNtk);
- }
-
- return -1;
-}
-
-int n_latches()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk )
- {
- return Abc_NtkLatchNum(pNtk);
- }
-
- return -1;
-}
-
-int n_levels()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk )
- {
- return Abc_NtkLevel(pNtk);
- }
-
- return -1;
-}
-
-double n_area()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( pNtk && Abc_NtkHasMapping(pNtk) )
- {
- return Abc_NtkGetMappedArea(pNtk);
- }
-
- return -1;
-}
-
-int has_comb_model()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- return pNtk && pNtk->pModel;
-}
-
-int has_seq_model()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- return pNtk && pNtk->pSeqModel;
-}
-
-int n_bmc_frames()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- return Abc_FrameReadBmcFrames(pAbc);
-}
-
-int prob_status()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- return Abc_FrameReadProbStatus(pAbc);
-}
-
-int is_valid_cex()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- return pNtk && Abc_FrameReadCex(pAbc) && Abc_NtkIsValidCex( pNtk, Abc_FrameReadCex(pAbc) );
-}
-
-int is_true_cex()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- return pNtk && Abc_FrameReadCex(pAbc) && Abc_NtkIsTrueCex( pNtk, Abc_FrameReadCex(pAbc) );
-}
-
-int n_cex_pis()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
-
- return Abc_FrameReadCex(pAbc) ? Abc_FrameReadCexPiNum( pAbc ) : -1;
-}
-
-int n_cex_regs()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
-
- return Abc_FrameReadCex(pAbc) ? Abc_FrameReadCexRegNum( pAbc ) : -1;
-}
-
-int cex_po()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
-
- return Abc_FrameReadCex(pAbc) ? Abc_FrameReadCexPo( pAbc ) : -1;
-}
-
-int cex_frame()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
-
- return Abc_FrameReadCex(pAbc) ? Abc_FrameReadCexFrame( pAbc ) : -1;
-}
-
-int n_phases()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- return pNtk ? Abc_NtkPhaseFrameNum(pNtk) : 1;
-}
-
-int is_const_po( int iPoNum )
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- return Abc_FrameCheckPoConst( pAbc, iPoNum );
-}
-
-Abc_Cex_t* _cex_get()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Cex_t* pCex = Abc_FrameReadCex(pAbc);
-
- if ( ! pCex )
- {
- return NULL;
- }
-
- return Abc_CexDup( pCex, -1 );
-}
-
-int _cex_get_vec_len()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Ptr_t* vCexVec = Abc_FrameReadCexVec(pAbc);
-
- if( ! vCexVec )
- {
- return 0;
- }
-
- return Vec_PtrSize(vCexVec);
-}
-
-Abc_Cex_t* _cex_get_vec(int i)
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Ptr_t* vCexVec = Abc_FrameReadCexVec(pAbc);
-
- if( ! vCexVec )
- {
- return NULL;
- }
-
- Abc_Cex_t* pCex = (Abc_Cex_t*)Vec_PtrEntry( vCexVec, i );
-
- if ( ! pCex )
- {
- return NULL;
- }
-
- return Abc_CexDup( pCex, -1 );
-}
-
-int _status_get_vec_len()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Int_t* vStatusVec = Abc_FrameReadStatusVec(pAbc);
-
- if( ! vStatusVec )
- {
- return 0;
- }
-
- return Vec_IntSize(vStatusVec);
-}
-
-int _status_get_vec(int i)
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Int_t* vStatusVec = Abc_FrameReadStatusVec(pAbc);
-
- if( ! vStatusVec )
- {
- return -1;
- }
-
- return Vec_IntEntry( vStatusVec, i );
-}
-
-void _cex_put(Abc_Cex_t* pCex)
-{
- if ( pCex )
- {
- pCex = Abc_CexDup(pCex, -1);
- }
-
- Abc_FrameSetCex( pCex );
-}
-
-void _cex_free(Abc_Cex_t* pCex)
-{
- Abc_CexFree(pCex);
-}
-
-int _cex_n_regs(Abc_Cex_t* pCex)
-{
- return pCex->nRegs;
-}
-
-int _cex_n_pis(Abc_Cex_t* pCex)
-{
- return pCex->nPis;
-}
-
-int _cex_get_po(Abc_Cex_t* pCex)
-{
- return pCex->iPo;
-}
-
-int _cex_get_frame(Abc_Cex_t* pCex)
-{
- return pCex->iFrame;
-}
-
-static PyObject* VecInt_To_PyList(Vec_Int_t* v)
-{
- PyObject* pylist = PyList_New( Vec_IntSize(v) );
-
- int elem, i;
-
- Vec_IntForEachEntry( v, elem, i)
- {
- PyList_SetItem( pylist, i, PyInt_FromLong(elem) );
- }
-
- return pylist;
-}
-
-PyObject* eq_classes()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Ptr_t *vPoEquivs = Abc_FrameReadPoEquivs(pAbc);
-
- PyObject* eq_classes;
- Vec_Int_t* pEntry;
- int i;
-
- if( ! vPoEquivs )
- {
- Py_RETURN_NONE;
- }
-
- eq_classes = PyList_New( Vec_PtrSize(vPoEquivs) );
-
- Vec_PtrForEachEntry( Vec_Int_t*, vPoEquivs, pEntry, i )
- {
- PyList_SetItem( eq_classes, i, VecInt_To_PyList(pEntry) );
- }
-
- return eq_classes;
-}
-
-PyObject* co_supp( int iCo )
-{
- PyObject* co_supp;
- Vec_Int_t * vSupp;
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( !pNtk )
- {
- Py_RETURN_NONE;
- }
-
- vSupp = Abc_NtkNodeSupportInt( pNtk, iCo );
-
- if( !vSupp )
- {
- Py_RETURN_NONE;
- }
-
- co_supp = VecInt_To_PyList( vSupp );
- Vec_IntFree( vSupp );
-
- return co_supp;
-}
-
-int is_func_iso( int iCo1, int iCo2 )
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( !pNtk )
- {
- return 0;
- }
-
- return Abc_NtkFunctionalIso( pNtk, iCo1, iCo2, 0 );
-}
-
-int is_func_iso2( int iCo1, int iCo2 )
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
-
- if ( !pNtk )
- {
- return 0;
- }
-
- return Abc_NtkFunctionalIso( pNtk, iCo1, iCo2, 1 );
-}
-
-void _pyabc_array_clear()
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Int_t *vObjIds = Abc_FrameReadObjIds(pAbc);
- Vec_IntClear( vObjIds );
-}
-
-void _pyabc_array_push(int i)
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Int_t *vObjIds = Abc_FrameReadObjIds(pAbc);
- Vec_IntPush( vObjIds, i );
-}
-
-int pyabc_array_read_entry(int i)
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Vec_Int_t *vObjIds = Abc_FrameReadObjIds(pAbc);
- if( !vObjIds )
- return -1;
- return Vec_IntEntry( vObjIds, i );
-}
-
-static PyObject* pyabc_internal_python_command_callback = 0;
-
-void pyabc_internal_set_command_callback( PyObject* callback )
-{
- Py_XINCREF(callback);
- Py_XDECREF(pyabc_internal_python_command_callback);
-
- pyabc_internal_python_command_callback = callback;
-}
-
-static int pyabc_internal_abc_command_callback(Abc_Frame_t * pAbc, int argc, char ** argv)
-{
- int i;
-
- PyObject* args;
- PyObject* arglist;
- PyObject* res;
-
- PyGILState_STATE gstate;
-
- long lres;
-
- if ( !pyabc_internal_python_command_callback )
- return 0;
-
- gstate = PyGILState_Ensure();
-
- args = PyList_New(argc);
-
- for( i=0 ; i<argc ; i++ )
- PyList_SetItem(args, i, PyString_FromString(argv[i]) );
-
- arglist = Py_BuildValue("(O)", args);
- Py_INCREF(arglist);
-
- res = PyEval_CallObject( pyabc_internal_python_command_callback, arglist );
- Py_DECREF(arglist);
-
- if ( !res )
- {
- PyGILState_Release(gstate);
- return -1;
- }
-
- lres = PyInt_AsLong(res);
- Py_DECREF(res);
-
- PyGILState_Release(gstate);
-
- return lres;
-}
-
-int run_command(char* cmd)
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- int rc;
-
- Py_BEGIN_ALLOW_THREADS
-
- rc = Cmd_CommandExecute(pAbc, cmd);
-
- Py_END_ALLOW_THREADS
-
- return rc;
-}
-
-void pyabc_internal_register_command( char * sGroup, char * sName, int fChanges )
-{
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
-
- Cmd_CommandAdd( pAbc, sGroup, sName, (Cmd_CommandFuncType)pyabc_internal_abc_command_callback, fChanges);
-}
-
-static int sigchld_pipe_fd = -1;
-
-static void sigchld_handler(int signum)
-{
- while( write(sigchld_pipe_fd, "", 1) == -1 && errno==EINTR )
- ;
-}
-
-static void install_sigchld_handler(int sigchld_fd)
-{
- sigchld_pipe_fd = sigchld_fd;
- signal(SIGCHLD, sigchld_handler);
-}
-
-static int sigint_pipe_fd = -1;
-
-static void sigint_handler(int signum)
-{
- unsigned char tmp = (unsigned char)signum;
- while( write(sigint_pipe_fd, &tmp, 1) == -1 && errno==EINTR )
- ;
-}
-
-static void install_sigint_handler(int sigint_fd)
-{
- sigint_pipe_fd = sigint_fd;
-
- signal(SIGINT, sigint_handler);
-
- // try to catch other signals that ask the process to terminate
- signal(SIGABRT, sigint_handler);
- signal(SIGQUIT, sigint_handler);
- signal(SIGTERM, sigint_handler);
-
- // try to ensure cleanup on exceptional conditions
- signal(SIGBUS, sigint_handler);
- signal(SIGILL, sigint_handler);
- signal(SIGSEGV, sigint_handler);
-
- // try to ensure cleanup before being killed due to resource limit
- signal(SIGXCPU, sigint_handler);
- signal(SIGXFSZ, sigint_handler);
-}
-
-sigset_t old_procmask;
-static int nblocks = 0;
-
-void block_sigint()
-{
- sigset_t procmask;
-
- assert(nblocks==0);
- nblocks ++ ;
-
- sigemptyset(&procmask);
- sigaddset(&procmask, SIGINT);
-
- sigprocmask(SIG_BLOCK, &procmask, &old_procmask);
-}
-
-void unblock_sigint()
-{
- assert( nblocks==1);
- nblocks--;
-
- sigprocmask(SIG_SETMASK, &old_procmask, NULL);
-}
-
-static PyObject* pyabc_internal_system_callback = 0;
-static PyObject* pyabc_internal_tmpfile_callback = 0;
-static PyObject* pyabc_internal_tmpfile_remove_callback = 0;
-
-int Util_SignalSystem(const char* cmd)
-{
- PyObject* arglist;
- PyObject* res;
-
- PyGILState_STATE gstate;
-
- long lres;
-
- if ( !pyabc_internal_system_callback )
- return -1;
-
- gstate = PyGILState_Ensure();
-
- arglist = Py_BuildValue("(O)", PyString_FromString(cmd));
- Py_INCREF(arglist);
-
- res = PyEval_CallObject( pyabc_internal_system_callback, arglist );
- Py_DECREF(arglist);
-
- if ( !res )
- {
- PyGILState_Release(gstate);
- return -1;
- }
-
- lres = PyInt_AsLong(res);
- Py_DECREF(res);
-
- PyGILState_Release(gstate);
-
- return lres;
-}
-
-int Util_SignalTmpFile(const char* prefix, const char* suffix, char** out_name)
-{
- char* str;
- Py_ssize_t size;
-
- PyObject* arglist;
- PyObject* res;
-
- PyGILState_STATE gstate;
-
- *out_name = NULL;
-
- if ( !pyabc_internal_tmpfile_callback )
- return 0;
-
- gstate = PyGILState_Ensure();
-
- arglist = Py_BuildValue("(ss)", prefix, suffix);
- Py_INCREF(arglist);
-
- res = PyEval_CallObject( pyabc_internal_tmpfile_callback, arglist );
- Py_DECREF(arglist);
-
- if ( !res )
- {
- PyGILState_Release(gstate);
- return -1;
- }
-
- PyString_AsStringAndSize(res, &str, &size);
-
- *out_name = ABC_ALLOC(char, size+1);
- strcpy(*out_name, str);
-
- Py_DECREF(res);
-
- PyGILState_Release(gstate);
-
- return open(*out_name, O_WRONLY);
-}
-
-void Util_SignalTmpFileRemove(const char* fname, int fLeave)
-{
- PyObject* arglist;
- PyObject* res;
-
- PyGILState_STATE gstate;
-
- if ( !pyabc_internal_tmpfile_remove_callback )
- return;
-
- gstate = PyGILState_Ensure();
-
- arglist = Py_BuildValue("(si)", fname, fLeave);
- Py_INCREF(arglist);
-
- res = PyEval_CallObject( pyabc_internal_tmpfile_remove_callback, arglist );
- Py_DECREF(arglist);
- Py_XDECREF(res);
-
- PyGILState_Release(gstate);
-}
-
-void pyabc_internal_set_util_callbacks( PyObject* system_callback, PyObject* tmpfile_callback, PyObject* tmpfile_remove_callback )
-{
- Py_XINCREF(system_callback);
- Py_XDECREF(pyabc_internal_system_callback);
-
- pyabc_internal_system_callback = system_callback;
-
- Py_XINCREF(tmpfile_callback);
- Py_XDECREF(pyabc_internal_tmpfile_callback);
-
- pyabc_internal_tmpfile_callback = tmpfile_callback;
-
- Py_XINCREF(tmpfile_remove_callback);
- Py_XDECREF(pyabc_internal_tmpfile_remove_callback);
-
- pyabc_internal_tmpfile_remove_callback = tmpfile_remove_callback;
-}
-
-PyObject* _wait_no_hang()
-{
- int status;
- int pid;
-
- pid = wait3(&status, WNOHANG, NULL);
-
- return Py_BuildValue("(iii)", pid, status, errno);
-}
-
-int _posix_kill(int pid, int signum)
-{
- return kill(pid, signum);
-}
-
-void _set_death_signal()
-{
- // send SIGINT if parent process is dead
- prctl(PR_SET_PDEATHSIG, SIGINT);
-
- // if parent process is already dead (and adopted by init)
- if ( getppid() == 1)
- {
- raise(SIGINT);
- }
-}
-
-%}
-
-%init
-%{
- Abc_Start();
-%}
-
-int n_ands();
-int n_nodes();
-int n_pis();
-int n_pos();
-int n_latches();
-int n_levels();
-double n_area();
-
-int run_command(char* cmd);
-
-int has_comb_model();
-int has_seq_model();
-
-int n_bmc_frames();
-int prob_status();
-
-int is_valid_cex();
-int is_true_cex();
-int n_cex_pis();
-int n_cex_regs();
-int cex_po();
-int cex_frame();
-
-int n_phases();
-int is_const_po( int iPoNum );
-
-Abc_Cex_t* _cex_get();
-int _cex_get_vec_len();
-Abc_Cex_t* _cex_get_vec(int i);
-int _status_get_vec_len();
-int _status_get_vec(int i);
-void _cex_put(Abc_Cex_t* pCex);
-void _cex_free(Abc_Cex_t* pCex);
-int _cex_n_regs(Abc_Cex_t* pCex);
-int _cex_n_pis(Abc_Cex_t* pCex);
-int _cex_get_po(Abc_Cex_t* pCex);
-int _cex_get_frame(Abc_Cex_t* pCex);
-
-PyObject* eq_classes();
-PyObject* co_supp(int iCo);
-int is_func_iso(int iCo1, int iCo2);
-int is_func_iso2(int iCo1, int iCo2);
-
-void _pyabc_array_clear();
-void _pyabc_array_push(int i);
-int pyabc_array_read_entry(int i);
-
-void pyabc_internal_set_command_callback( PyObject* callback );
-void pyabc_internal_register_command( char * sGroup, char * sName, int fChanges );
-
-void install_sigchld_handler(int sigint_fd);
-void install_sigint_handler(int sigint_fd);
-
-void block_sigint();
-void unblock_sigint();
-
-void pyabc_internal_set_util_callbacks( PyObject* system_callback, PyObject* tmpfile_callback, PyObject* tmpfile_remove_callback );
-
-PyObject* _wait_no_hang();
-
-void _set_death_signal();
-
-int _posix_kill(int pid, int signum);
-void _set_death_signal();
-
-%pythoncode
-%{
-
-class _Cex(object):
-
- def __new__(cls, pCex):
-
- if not pCex:
- return None
-
- if int(pCex)==1:
- return True
-
- return object.__new__(cls)
-
- def __init__(self, pCex):
- self.pCex = pCex
-
- def __del__(self):
- if _cex_free:
- _cex_free(self.pCex)
-
- def n_regs(self):
- return _cex_n_regs(self.pCex)
-
- def n_pis(self):
- return _cex_n_pis(self.pCex)
-
- def get_po(self):
- return _cex_get_po(self.pCex)
-
- def get_frame(self):
- return _cex_get_frame(self.pCex)
-
-def cex_get_vector():
-
- return [ _Cex(_cex_get_vec(i)) for i in xrange(_cex_get_vec_len()) ]
-
-def status_get_vector():
-
- return [ _status_get_vec(i) for i in xrange(_status_get_vec_len()) ]
-
-def cex_get():
-
- return _Cex( _cex_get() )
-
-def cex_put(cex):
-
- assert cex is not None
- assert cex.pCex is not None
-
- return _cex_put(cex.pCex)
-
-
-def create_abc_array(List):
- _pyabc_array_clear()
- for ObjId in List:
- _pyabc_array_push(ObjId)
-
-
-import threading
-import select
-import signal
-import tempfile
-import os
-import errno
-import sys, traceback
-import subprocess
-
-_active_lock = threading.Lock()
-_die_flag = False
-
-_active_pids = set()
-_active_temp_files = set()
-
-_terminated_pids_cond = threading.Condition(_active_lock)
-_terminated_pids = {}
-
-def add_temp_file(fname):
- with _active_lock:
- _active_temp_files.add(fname)
-
-def remove_temp_file(fname):
- with _active_lock:
- _active_temp_files.remove(fname)
-
-_old_os_wait3 = os.wait3
-_select_select = select.select
-
-def _retry_select(fd):
- while True:
- try:
- rrdy,_,_ = _select_select([fd],[],[])
- if fd in rrdy:
- return
- except select.error as e:
- if e[0] == errno.EINTR:
- continue
- raise
-
-def _retry_read(fd):
-
- while True:
- try:
- return fd.read(1)
- except OSError as e:
- if e.errno == errno.EINTR:
- continue
- raise
-
-def _retry_os_read(fd):
-
- while True:
- try:
- return os.read(fd, 1)
- except OSError as e:
- if e.errno == errno.EINTR:
- continue
- raise
-
-def _retry_wait():
-
- while True:
-
- pid, status, e = _wait_no_hang()
-
- if pid>0:
- return pid, status
-
- elif pid==0:
- return 0,0
-
- elif pid == -1 and e == errno.ECHILD:
- return 0,0
-
- elif pid==-1 and e != errno.EINTR:
- raise OSError(e, 'unknown error in wait3()')
-
-def _sigint_wait_thread_func(fd):
-
- global _die_flag
-
- while True:
-
- _retry_select(fd)
- _retry_read(fd)
-
- with _active_lock:
-
- if _die_flag:
- os._exit(-1)
-
- _die_flag = True
-
- for pid in _active_pids:
- rc = _posix_kill(pid, signal.SIGINT)
-
- for fname in _active_temp_files:
- os.remove(fname)
-
- os._exit(-1)
-
-def _child_wait_thread_func(fd):
-
- while True:
-
- _retry_select(fd)
- rc = _retry_read(fd)
-
- with _active_lock:
-
- while True:
-
- pid, status = _retry_wait()
-
- if pid==0:
- break
-
- if pid in _active_pids:
- _active_pids.remove(pid)
-
- _terminated_pids[pid] = status
- os.write(_wait_fd_write, "1")
- _terminated_pids_cond.notifyAll()
-
-_sigint_pipe_read_fd = -1
-_sigint_pipe_write_fd = -1
-
-_sigchld_pipe_read_fd = -1
-_sigchld_pipe_write_fd = -1
-
-wait_fd = -1
-_wait_fd_write = -1
-
-def _start_threads():
-
- global wait_fd, _wait_fd_write
- wait_fd, _wait_fd_write = os.pipe()
-
- global _sigint_pipe_read_fd, _sigint_pipe_write_fd
-
- _sigint_pipe_read_fd, _sigint_pipe_write_fd = os.pipe()
- sigint_read = os.fdopen(_sigint_pipe_read_fd, "r", 0 )
-
- sigint_wait_thread = threading.Thread(target=_sigint_wait_thread_func, name="SIGINT wait thread", args=(sigint_read,))
- sigint_wait_thread.setDaemon(True)
- sigint_wait_thread.start()
-
- install_sigint_handler(_sigint_pipe_write_fd)
-
- global _sigchld_pipe_read_fd, _sigchld_pipe_write_fd
-
- _sigchld_pipe_read_fd, _sigchld_pipe_write_fd = os.pipe()
- sigchld_read = os.fdopen(_sigchld_pipe_read_fd, "r", 0 )
-
- child_wait_thread = threading.Thread(target=_child_wait_thread_func, name="child process wait thread", args=(sigchld_read,))
- child_wait_thread.setDaemon(True)
- child_wait_thread.start()
-
- install_sigchld_handler(_sigchld_pipe_write_fd)
-
-_close_on_fork = []
-
-def close_on_fork(fd):
- _close_on_fork.append(fd)
-
-def after_fork():
-
- _set_death_signal()
-
- global _close_on_fork
-
- for fd in _close_on_fork:
- os.close(fd)
-
- _close_on_fork = []
-
- os.close(wait_fd)
- os.close(_wait_fd_write)
-
- os.close(_sigint_pipe_read_fd)
- os.close(_sigint_pipe_write_fd)
-
- os.close(_sigchld_pipe_read_fd)
- os.close(_sigchld_pipe_write_fd)
-
- global _active_lock
- _active_lock = threading.Lock()
-
- global _terminated_pids_cond
- _terminated_pids_cond = threading.Condition(_active_lock)
-
- global _terminated_pids
- _terminated_pids = {}
-
- global _active_pids
- _active_pids = set()
-
- global _active_temp_files
- _active_temp_files = set()
-
- _start_threads()
-
-class _sigint_block_section(object):
- def __init__(self):
- self.blocked = False
-
- def __enter__(self):
- block_sigint()
- self.blocked = True
-
- def __exit__(self, type, value, traceback):
- self.release()
-
- def release(self):
- if self.blocked:
- self.blocked = False
- unblock_sigint()
-
-_old_os_fork = os.fork
-
-def _fork():
-
- ppid = os.getpid()
-
- with _sigint_block_section() as cs:
-
- with _active_lock:
-
- if _die_flag:
- os._exit(-1)
-
- pid = _old_os_fork()
-
- if pid == 0:
- after_fork()
-
- if pid > 0:
- _active_pids.add(pid)
-
- return pid
-
-def _waitpid(pid, options=0):
-
- while True:
-
- with _active_lock:
-
- if pid in _terminated_pids:
- _retry_os_read(wait_fd)
- status = _terminated_pids[pid]
- del _terminated_pids[pid]
- return pid, status
-
- if options==os.WNOHANG:
- return 0, 0
-
- _terminated_pids_cond.wait()
-
-def _wait(options=0):
-
- while True:
-
- with _active_lock:
-
- for pid, status in _terminated_pids.iteritems():
- _retry_os_read(wait_fd)
- del _terminated_pids[pid]
- return pid, status
-
- if options==os.WNOHANG:
- return 0, 0
-
- _terminated_pids_cond.wait()
-
-_old_os_kill = os.kill
-
-def _kill(pid, sig):
-
- with _active_lock:
-
- if pid in _terminated_pids:
- return None
-
- return _old_os_kill(pid,sig)
-
-os.kill = _kill
-os.fork = _fork
-os.wait = _wait
-os.waitpid = _waitpid
-
-def _split_command_line(cmd):
-
- args = []
-
- i=0
-
- while i<len(cmd):
-
- while i<len(cmd) and cmd[i] in [' ','\t','\f']:
- i += 1
-
- if i >= len(cmd):
- break
-
- arg = []
-
- in_quotes = None
-
- while i<len(cmd):
-
- if not in_quotes and cmd[i] in ['\'','\"','\'']:
- in_quotes = cmd[i]
-
- elif in_quotes and cmd[i]==in_quotes:
- in_quotes = None
-
- elif cmd[i] == '\\' and i<(len(cmd)+1):
-
- i += 1
-
- if cmd[i]=='\\':
- arg.append('\\')
- elif cmd[i]=='\'':
- arg.append('\'')
- elif cmd[i]=='\"':
- arg.append('\'')
- elif cmd[i]=='\"':
- arg.append('\"')
- elif cmd[i]=='a':
- arg.append('\a')
- elif cmd[i]=='b':
- arg.append('\b')
- elif cmd[i]=='n':
- arg.append('\n')
- elif cmd[i]=='f':
- arg.append('\f')
- elif cmd[i]=='r':
- arg.append('\r')
- elif cmd[i]=='t':
- arg.append('\t')
- elif cmd[i]=='v':
- arg.append('\v')
- else:
- arg.append(cmd[i])
-
- elif not in_quotes and cmd[i] in [' ','\t','\f']:
- break
-
- else:
- arg.append(cmd[i])
-
- i += 1
-
- args.append( "".join(arg) )
-
- return args
-
-
-def system(cmd):
-
- args = _split_command_line(cmd)
-
- if args[-2] == '>':
-
- with open(args[-1],'w') as fout:
- p = subprocess.Popen(args[:-2], stdout=fout)
- rc = p.wait()
- return rc
-
- else:
- p = subprocess.Popen(args)
- return p.wait()
-
-def tmpfile(prefix, suffix):
-
- with _active_lock:
- with tempfile.NamedTemporaryFile(delete=False, prefix=prefix, suffix=suffix) as file:
- _active_temp_files.add(file.name)
- return file.name
-
-def tmpfile_remove(fname, leave):
-
- with _active_lock:
- os.remove(fname)
- _active_temp_files.remove(fname)
-
-pyabc_internal_set_util_callbacks( system, tmpfile,tmpfile_remove )
-
-
-_start_threads()
-
-
-_registered_commands = {}
-
-def _cmd_callback(args):
- try:
- assert len(args) > 0
-
- cmd = args[0]
- assert cmd in _registered_commands
-
- res = _registered_commands[cmd](args)
-
- assert type(res) == int, "User-defined Python command must return an integer."
-
- return res
-
- except Exception, e:
- import traceback
- traceback.print_exc()
-
- except SystemExit, se:
- pass
-
- return 0
-
-pyabc_internal_set_command_callback( _cmd_callback )
-
-def add_abc_command(fcmd, group, cmd, change):
- _registered_commands[ cmd ] = fcmd
- pyabc_internal_register_command( group, cmd, change)
-
-import optparse
-
-xxx = {}
-
-def cmd_python(cmd_args):
-
- usage = "usage: %prog [options] <Python files>"
-
- parser = optparse.OptionParser(usage, prog="python")
-
- parser.add_option("-c", "--cmd", dest="cmd", help="Execute Python command directly")
- parser.add_option("-v", "--version", action="store_true", dest="version", help="Display Python Version")
-
- options, args = parser.parse_args(cmd_args)
-
- if options.version:
- print sys.version
- return 0
-
- if options.cmd:
- exec options.cmd in xxx
- return 0
-
- scripts_dir = os.getenv('ABC_PYTHON_SCRIPTS', ".")
- scripts_dirs = scripts_dir.split(':')
-
- for fname in args[1:]:
- if os.path.isabs(fname):
- execfile(fname, xxx)
- else:
- for d in scripts_dirs:
- fname = os.path.join(scripts_dir, fname)
- if os.path.exists(fname):
- execfile(fname, xxx)
- break
-
- return 0
-
-add_abc_command(cmd_python, "Python", "python", 0)
-
-
-%}
diff --git a/src/python/pyabc_split.py b/src/python/pyabc_split.py
deleted file mode 100644
index 89038a2c..00000000
--- a/src/python/pyabc_split.py
+++ /dev/null
@@ -1,412 +0,0 @@
-"""
-module pyabc_split
-
-Executes python functions and their arguements as separate processes and returns their return values through pickling. This modules offers a single function:
-
-Function: split_all(funcs)
-
-The function returns a generator objects that allowes iteration over the results,
-
-Arguments:
-
-funcs: a list of tuples (f, args) where f is a python function and args is a collection of arguments for f.
-
-Caveats:
-
-1. Global variables in the parent process are not affected by the child processes.
-2. The functions can only return simple types, see the pickle module for details
-
-Usage:
-
-Assume you would like to run the function f_1(1), f_2(1,2), f_3(1,2,3) in different processes.
-
-def f_1(i):
- return i+1
-
-def f_2(i,j):
- return i*10+j+1
-
-def f_3(i,j,k):
- return i*100+j*10+k+1
-
-Construct a tuple of the function and arguments for each function
-
-t_1 = (f_1, [1])
-t_2 = (f_2, [1,2])
-t_3 = (f_3, [1,2,3])
-
-Create a list containing these tuples:
-
-funcs = [t_1, t_2, t_3]
-
-Use the function split_all() to run these functions in separate processes:
-
-for res in split_all(funcs):
- print res
-
-The output will be:
-
-2
-13
-124
-
-(The order may be different, except that in this case the processes are so fast that they terminate before the next one is created)
-
-Alternatively, you may quite in the middle, say after the first process returns:
-
-for res in split_all(funcs):
- print res
- break
-
-This will kill all processes not yet finished.
-
-To run ABC operations, that required saving the child process state and restoring it at the parent, use abc_split_all().
-
- import pyabc
-
- def abc_f(truth):
- import os
- print "pid=%d, abc_f(%s)"%(os.getpid(), truth)
- pyabc.run_command('read_truth %s'%truth)
- pyabc.run_command('strash')
-
- funcs = [
- defer(abc_f)("1000"),
- defer(abc_f)("0001")
- ]
-
- for _ in abc_split_all(funcs):
- pyabc.run_command('write_verilog /dev/stdout')
-
-Author: Baruch Sterin <sterin@berkeley.edu>
-"""
-
-import os
-import select
-import fcntl
-import errno
-import sys
-import cPickle as pickle
-import signal
-import cStringIO
-
-import traceback
-
-from contextlib import contextmanager
-
-import pyabc
-
-def _retry_select(rlist):
- while True:
- try:
- rrdy,_,_ = select.select(rlist,[],[])
- if rrdy:
- return rrdy
- except select.error as e:
- if e[0] == errno.EINTR:
- continue
- raise
-
-class _splitter(object):
-
- def __init__(self):
- self.pids = []
- self.fds = {}
- self.buffers = {}
- self.results = {}
-
- def is_done(self):
- return len(self.fds) == 0
-
- def _kill(self, pids):
-
- # close pipes and kill child processes
- for pid in pids:
-
- if pid == -1:
- continue
-
- i, fd = self.fds[pid]
-
- del self.buffers[fd]
- del self.fds[pid]
-
- self.pids[i] = -1
- self.results[pid] = None
-
- os.close(fd)
-
- try:
- os.kill( pid, signal.SIGINT)
- except Exception as e:
- print >>sys.stderr, 'exception while trying to kill pid=%d: '%pid, e
- raise
-
- # wait for termination and update result
- for pid in pids:
- os.waitpid( pid, 0 )
-
- def kill(self, ids):
-
- self._kill( [ self.pids[i] for i in ids ] )
-
- def cleanup(self):
- self._kill( self.fds.keys() )
-
- def child( self, fdw, f):
-
- # call function
- try:
- res = f()
- except:
- traceback.print_exc()
- raise
-
- # write return value into pipe
- with os.fdopen( fdw, "w" ) as fout:
- pickle.dump(res, fout)
-
- return 0
-
- def _fork_one(self, f):
-
- # create a pipe to communicate with the child process
- pr,pw = os.pipe()
-
- # set pr to be non-blocking
- fcntl.fcntl(pr, fcntl.F_SETFL, os.O_NONBLOCK)
-
- parentpid = os.getpid()
- rc = 1
-
- try:
-
- # create child process
- pid = os.fork()
-
- if pid == 0:
- # child process:
- os.close(pr)
- pyabc.close_on_fork(pw)
-
- rc = self.child( pw, f)
- os._exit(rc)
- else:
- # parent process:
- os.close(pw)
- return (pid, pr)
-
- finally:
- if os.getpid() != parentpid:
- os._exit(rc)
-
- def fork_one(self, func):
- pid, fd = self._fork_one(func)
- i = len(self.pids)
- self.pids.append(pid)
- self.fds[pid] = (i, fd)
- self.buffers[fd] = cStringIO.StringIO()
- return i
-
- def fork_all(self, funcs):
- return [ self.fork_one(f) for f in funcs ]
-
- def communicate(self):
-
- rlist = [ fd for _, (_,fd) in self.fds.iteritems() ]
- rlist.append(pyabc.wait_fd)
-
- stop = False
-
- while not stop:
-
- rrdy = _retry_select( rlist )
-
- for fd in rrdy:
-
- if fd == pyabc.wait_fd:
- stop = True
- continue
-
- self.buffers[fd].write( os.read(fd, 16384) )
-
- def get_next_result(self):
-
- # read from the pipes as needed, while waiting for the next child process to terminate
- self.communicate()
-
- # wait for the next child process to terminate
- pid, rc = os.wait()
- assert pid in self.fds
-
- # retrieve the pipe file descriptor
- i, fd = self.fds[pid]
- del self.fds[pid]
-
- # remove the pid
- self.pids[i] = -1
-
- # retrieve the buffer
- buffer = self.buffers[fd]
- del self.buffers[fd]
-
- # fill the buffer
- while True:
- s = os.read(fd, 16384)
- if not s:
- break
- buffer.write(s)
-
- os.close(fd)
-
- try:
- return (i, pickle.loads(buffer.getvalue()))
- except EOFError, pickle.UnpicklingError:
- return (i, None)
-
- def __iter__(self):
- def iterator():
- while not self.is_done():
- yield self.get_next_result()
- return iterator()
-
-@contextmanager
-def make_splitter():
- # ensure cleanup of child processes
- s = _splitter()
- try:
- yield s
- finally:
- s.cleanup()
-
-def split_all_full(funcs):
- # provide an iterator for child process result
- with make_splitter() as s:
-
- s.fork_all(funcs)
-
- for res in s:
- yield res
-
-def defer(f):
- return lambda *args, **kwargs: lambda : f(*args,**kwargs)
-
-def split_all(funcs):
- for _, res in split_all_full( ( defer(f)(*args) for f,args in funcs ) ):
- yield res
-
-import tempfile
-
-@contextmanager
-def temp_file_names(suffixes):
- names = []
- try:
- for suffix in suffixes:
- with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as file:
- names.append( file.name )
- yield names
- finally:
- for name in names:
- os.unlink(name)
-
-class abc_state(object):
- def __init__(self):
- with tempfile.NamedTemporaryFile(delete=False, suffix='.aig') as file:
- self.aig = file.name
- with tempfile.NamedTemporaryFile(delete=False, suffix='.log') as file:
- self.log = file.name
- pyabc.run_command(r'write_status %s'%self.log)
- pyabc.run_command(r'write_aiger %s'%self.aig)
-
- def __del__(self):
- os.unlink( self.aig )
- os.unlink( self.log )
-
- def restore(self):
- pyabc.run_command(r'read_aiger %s'%self.aig)
- pyabc.run_command(r'read_status %s'%self.log)
-
-def abc_split_all(funcs):
- import pyabc
-
- def child(f, aig, log):
- res = f()
- pyabc.run_command(r'write_status %s'%log)
- pyabc.run_command(r'write_aiger %s'%aig)
- return res
-
- def parent(res, aig, log):
- pyabc.run_command(r'read_aiger %s'%aig)
- pyabc.run_command(r'read_status %s'%log)
- return res
-
- with temp_file_names( ['.aig','.log']*len(funcs) ) as tmp:
-
- funcs = [ defer(child)(f, tmp[2*i],tmp[2*i+1]) for i,f in enumerate(funcs) ]
-
- for i, res in split_all_full(funcs):
- yield i, parent(res, tmp[2*i],tmp[2*i+1])
-
-if __name__ == "__main__":
-
- # define some functions to run
-
- def f_1(i):
- return i+1
-
- def f_2(i,j):
- return i*10+j+1
-
- def f_3(i,j,k):
- return i*100+j*10+k+1
-
- # Construct a tuple of the function and arguments for each function
-
- t_1 = (f_1, [1])
- t_2 = (f_2, [1,2])
- t_3 = (f_3, [1,2,3])
-
- # Create a list containing these tuples:
-
- funcs = [t_1, t_2, t_3]
-
- # Use the function split_all() to run these functions in separate processes:
-
- for res in split_all(funcs):
- print res
-
- # Alternatively, quit after the first process returns:
-
- for res in split_all(funcs):
- print res
- break
-
- # For operations with ABC that save and restore status
-
- import pyabc
-
- def abc_f(truth):
- import os
- print "pid=%d, abc_f(%s)"%(os.getpid(), truth)
- pyabc.run_command('read_truth %s'%truth)
- pyabc.run_command('strash')
- return 100
-
- funcs = [
- defer(abc_f)("1000"),
- defer(abc_f)("0001")
- ]
-
- best = None
-
- for i, res in abc_split_all(funcs):
- print i, res
- if best is None:\
- # save state
- best = abc_state()
- pyabc.run_command('write_verilog /dev/stdout')
-
- # if there is a saved state, restore it
- if best is not None:
- best.restore()
- pyabc.run_command('write_verilog /dev/stdout')
diff --git a/src/python/reachx_cmd.py b/src/python/reachx_cmd.py
deleted file mode 100644
index 8461cb1d..00000000
--- a/src/python/reachx_cmd.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# You can use 'from pyabc import *' and then not need the pyabc. prefix everywhere
-
-import sys
-import optparse
-import subprocess
-import tempfile
-import threading
-import os
-import os.path
-from contextlib import contextmanager, nested
-
-import pyabc
-
-
-def popen_and_wait_with_timeout(timeout,cmd, *args, **kwargs):
- """ Wait for a subprocess.Popen object to terminate, or until timeout (in seconds) expires. """
-
- p = None
- t = None
-
- try:
- p = subprocess.Popen(cmd, *args, **kwargs)
-
- if timeout <= 0:
- timeout = None
-
- t = threading.Thread(target=lambda: p.communicate())
- t.start()
-
- t.join(timeout)
-
- finally:
-
- if p is not None and p.poll() is None:
- p.kill()
-
- if t is not None and t.is_alive():
- t.join()
-
- if p is not None:
- return p.returncode
-
- return -1
-
-@contextmanager
-def temp_file_name(suffix=""):
- file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
- name = file.name
- file.close()
-
- try:
- yield name
- finally:
- os.unlink(name)
-
-def cygpath(path):
- if sys.platform == "win32":
- if os.path.isabs(path):
- drive, tail = os.path.splitdrive(path)
- drive = drive.lower()
- tail = tail.split(os.path.sep)
- return '/cygdrive/%s'%drive[0] + '/'.join(tail)
- else:
- path = path.split(os.path.sep)
- return "/".join(path)
- return path
-
-def run_reachx_cmd(effort, timeout):
- with nested(temp_file_name(suffix=".aig"), temp_file_name()) as (tmpaig_name, tmplog_name):
- pyabc.run_command("write %s"%tmpaig_name)
-
- cmdline = [
- 'read %s'%cygpath(tmpaig_name),
- 'qua_ffix -effort %d -L %s'%(effort, cygpath(tmplog_name)),
- 'quit'
- ]
-
- cmd = ["jabc", "-c", " ; ".join(cmdline)]
-
- rc = popen_and_wait_with_timeout(timeout, cmd, shell=False, stdout=sys.stdout, stderr=sys.stderr)
-
- if rc != 0:
- # jabc failed or stopped. Write a status file to update the status to unknown
- with open(tmplog_name, "w") as f:
- f.write('snl_UNK -1 unknown\n')
- f.write('NULL\n')
- f.write('NULL\n')
-
- pyabc.run_command("read_status %s"%tmplog_name)
-
- return rc
-
-def reachx_cmd(argv):
- usage = "usage: %prog [options]"
-
- parser = optparse.OptionParser(usage, prog="reachx")
-
- parser.add_option("-e", "--effort", dest="effort", type=int, default=0, help="effort level. [default=0, means unlimited]")
- parser.add_option("-t", "--timeout", dest="timeout", type=int, default=0, help="timeout in seconds [default=0, unlimited]")
-
- options, args = parser.parse_args(argv)
-
- rc = run_reachx_cmd(options.effort, options.timeout)
- print "%s command: jabc returned: %d"%(argv[0], rc)
-
- return 0
-
-pyabc.add_abc_command(reachx_cmd, "Verification", "reachx", 0)
diff --git a/src/python/redirect.py b/src/python/redirect.py
deleted file mode 100644
index 0afccb77..00000000
--- a/src/python/redirect.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""
-
-A simple context manager for redirecting streams in Python.
-The streams are redirected at the the C runtime level so that the output of C extensions
-that use stdio will also be redirected.
-
-null_file : a stream representing the null device (e.g. /dev/null on Unix)
-redirect: a context manager for redirecting streams
-
-Author: Baruch Sterin (sterin@berkeley.edu)
-
-"""
-
-import os
-import sys
-
-from contextlib import contextmanager
-
-null_file = open( os.devnull, "w" )
-
-@contextmanager
-def _dup( f ):
- fd = os.dup( f.fileno() )
- yield fd
- os.close(fd)
-
-@contextmanager
-def save_stdout( src = sys.stdout ):
- """
- Redirect
- """
- fd = os.dup( src.fileno() )
- own = True
-
- try:
- with os.fdopen( fd, "w", 0) as f:
- own = False
- yield f
- except:
- if own:
- os.close(fd)
- raise
-
-@contextmanager
-def redirect(dst = null_file, src = sys.stdout):
-
- """
- Redirect the src stream into dst.
-
- Example:
- with redirect( open("somefile.txt", sys.stdout ) ):
- do some stuff ...
- """
-
- if src.fileno() == dst.fileno():
- yield
- return
-
- with _dup( src ) as fd_dup_src:
-
- dst.flush()
-
- src.flush()
- os.close( src.fileno() )
- os.dup2( dst.fileno(), src.fileno() )
-
- yield
-
- src.flush()
- os.close( src.fileno() )
- os.dup2( fd_dup_src, src.fileno() )
-
-def start_redirect(dst = null_file, src = sys.stdout):
-
- """
- Start redirection of src stream into dst. Return the duplicated file handle of the source.
-
- Example:
- fd = start_redirect( open("somefile.txt"), sys.stdout )
- ... do some stuff ...
- end_redirect(sys.stdout, fd)
- """
-
- if src.fileno() == dst.fileno():
- return None
-
- fd_dup_src = os.dup( src.fileno() )
-
- dst.flush()
- src.flush()
-
- os.close( src.fileno() )
- os.dup2( dst.fileno(), src.fileno() )
-
- return fd_dup_src
-
-def end_redirect(src, fd_dup_src):
-
- """
- End redirection of stream src.Redirect the src stream into dst. src is the source stream and fd_dup_src is the value returned by
- start_redirect()
- """
-
- if fd_dup_src is None:
- return
-
- src.flush()
- os.close( src.fileno() )
- os.dup2( fd_dup_src, src.fileno() )
-
- os.close(fd_dup_src)
diff --git a/src/python/setup.py b/src/python/setup.py
deleted file mode 100644
index 560262d4..00000000
--- a/src/python/setup.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import sys
-
-from distutils.core import setup, Extension
-from distutils.sysconfig import get_config_vars
-from distutils import util
-from distutils.command.build_ext import build_ext
-from distutils import sysconfig
-
-define_macros = []
-libraries = []
-library_dirs = []
-
-if sys.platform == "win32":
-
- src_file = [ 'pyabc.i' ]
-
- define_macros.append( ('WIN32', 1) )
- define_macros.append( ('ABC_DLL', 'ABC_DLLEXPORT') )
-
- libraries.append('abcr')
- library_dirs.append('./../../lib')
-
-else:
-
- src_file = [ 'pyabc_wrap.c' ]
-
- if get_config_vars()['SIZEOF_VOID_P'] > 4:
- define_macros.append( ('LIN64', 1) )
- else:
- define_macros.append( ('LIN', 1) )
-
- libraries.append( 'abc' )
- libraries.append( 'rt' )
- libraries.append( 'readline' )
- library_dirs.append('./../../')
-
-
-# ugly hack to silence strict-prototype warnings
-
-class build_ext_subclass( build_ext ):
-
- def build_extensions(self):
-
- CC = sysconfig.get_config_var("CC")
-
- if self.compiler.compiler_type == 'unix' and ( 'gcc' in CC or 'g++' in CC):
- for e in self.extensions:
- e.extra_compile_args.append( '-Wno-strict-prototypes' )
-
- build_ext.build_extensions(self)
-
-ext = Extension(
- '_pyabc',
- src_file,
- define_macros=define_macros,
- include_dirs = ["../../src"],
- library_dirs=library_dirs,
- libraries=libraries
- )
-
-setup(
- name='pyabc',
- version='1.0',
- ext_modules=[ext],
- py_modules=['pyabc','getch','pyabc_split','redirect', 'reachx_cmd'],
- cmdclass = {'build_ext': build_ext_subclass }
-)
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 22:29:24 +0000