def mk_traces(self):
# will be modified in preprocess
tcs_all = Miscs.keys_to_str(self.tcs)
tcs,_ = get_traces(tcs_all,
ntcs=1,#using only 1 array
ntcs_extra = 0)
tcs_extra = tcs_all #refine on all tcs
return tcs, tcs_extra
def rfilter(self, tcs, do_parallel=True):
if is_empty(self.ps) or is_empty(tcs):
logger.debug('rfilter skips (|ps|={}, |tcs|={})'.format(
len(self.ps), len(tcs)))
return None
logger.debug('rfilter(|ps|={}, |tcs|={})'.format(
len(self.ps), len(tcs)))
if not isinstance(self.ps[0], InvExp):
from dig_miscs import Miscs
tcs = Miscs.keys_to_str(tcs)
def wprocess(tasks, Q):
rs = [p for p in tasks if all(p.seval(tc) for tc in tcs)]
if Q is None: #no multiprocessing
return rs
else:
Q.put(rs)
tasks = self.ps
if do_parallel:
from vu_common import get_workloads
from multiprocessing import (Process, Queue, current_process,
cpu_count)
Q = Queue()
workloads = get_workloads(tasks,
max_nprocesses=cpu_count(),
chunksiz=2)
logger.debug("workloads 'refine' {}: {}".format(
len(workloads), map(len, workloads)))
workers = [
Process(target=wprocess, args=(wl, Q)) for wl in workloads
]
for w in workers:
w.start()
wrs = []
for _ in workers:
wrs.extend(Q.get())
else:
wrs = wprocess(tasks, Q=None)
self.ps = wrs
Refine.print_diff('rfilter', len(tasks), len(self.ps))
def rfilter(self,tcs,do_parallel=True):
if is_empty(self.ps) or is_empty(tcs):
logger.debug('rfilter skips (|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
return None
logger.debug('rfilter(|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
if not isinstance(self.ps[0],InvExp):
from dig_miscs import Miscs
tcs = Miscs.keys_to_str(tcs)
def wprocess(tasks,Q):
rs = [p for p in tasks if all(p.seval(tc) for tc in tcs)]
if Q is None: #no multiprocessing
return rs
else:
Q.put(rs)
tasks = self.ps
if do_parallel:
from vu_common import get_workloads
from multiprocessing import (Process, Queue,
current_process, cpu_count)
Q=Queue()
workloads = get_workloads(tasks,
max_nprocesses=cpu_count(),
chunksiz=2)
logger.debug("workloads 'refine' {}: {}"
.format(len(workloads),map(len,workloads)))
workers = [Process(target=wprocess,args=(wl,Q))
for wl in workloads]
for w in workers: w.start()
wrs = []
for _ in workers: wrs.extend(Q.get())
else:
wrs = wprocess(tasks,Q=None)
self.ps = wrs
Refine.print_diff('rfilter', len(tasks), len(self.ps))
def solve(self): # mpp fixed
ts = [t for t in self.terms if t != 1]
tcs = Miscs.keys_to_str(self.tcs)
if self.subset_siz is None:
subset_siz = len(ts)
else:
subset_siz = self.subset_siz
blacklist = []
if self.xinfo['Input']:
blacklist = self.xinfo['Input']
if (self.xinfo['Output']
and len(self.xinfo['Output']) > len(self.xinfo['Input'])):
blacklist = self.xinfo['Output']
ts_common = gen_terms_fixed_coefs(ts,
subset_siz=subset_siz,
blacklist=blacklist,
is_mpp=True)
if self.mpp_opt == IeqMPP.opt_max_then_min:
def wprocess(is_max_plus, Q):
Q.put(IeqMPPFixed.build_poly(ts_common, tcs, is_max_plus))
Q = mp.Queue()
workers = [
mp.Process(target=wprocess, args=(is_max_plus, Q))
for is_max_plus in [True, False]
]
for w in workers:
w.start()
rs = []
for _ in workers:
rs.extend(Q.get())
else:
is_max_plus = self.mpp_opt == IeqMPP.opt_max_plus
rs = IeqMPPFixed.build_poly(ts_common, tcs, is_max_plus)
self.sols = map(InvMPP, rs)
def preprocess(self, xinfo):
"""
Preprocess input data
1) transforms external functions to special arrays
1) change arr repr to value->index repr to speed up arr idx lookup
2) generate nodes
"""
if __debug__:
assert is_dict(xinfo), xinfo
evs = ExtFun.gen_extvars(xinfo=xinfo)
#arrays only
evs = [OrderedDict([(k,v) for k,v in ev.iteritems() if is_list(v)])
for ev in evs]
evs = Miscs.keys_to_str(evs)
if not is_empty(evs): #add to traces
self.tcs = [merge_dict(evs + [tc]) for tc in self.tcs]
self.tcs_extra = [merge_dict(evs + [tc]) for tc in self.tcs_extra]
mytcs = []
for tc in self.tcs:
#arrs reprent ext funs (already in new format)
efs = ExtFun.gen_extfuns(tc=tc,xinfo=xinfo)
#convert normal arr format to new format
arrs = [(k, Miscs.getListIdxs(v)) for k,v in tc.items()]
arrs = OrderedDict(arrs)
d = merge_dict(efs + [arrs])
mytcs.append(d)
self.tcs = mytcs
self.trees = [Tree({'root':k,
'children': [None] * len(c.values()[0][0]),
'commute': ExtFun(k).is_commute()})
for k,c in self.tcs[0].items()]
self.xinfo = xinfo
def a_solve(pivot, solve_for, tcs):
"""
pivot = 'A'
solve_for_arr = 'B'
0: A_0 - 7*B_0 == 0
1: A_1 - 7*B_2 - 3 == 0
2: A_2 - 7*B_4 - 6 == 0
Hypothesizes
B_coef = c0A_i0 + c1A_i1 + ... + cnA_in + c(n+1)
B_i0 = c0A_i0 + c1A_i1 + ... + cnA_in + c(n+1)
B_i1 = c0A_i0 + c1A_i1 + ... + cnA_in + c(n+1)
"""
logger.debug("a_solve: Assume '%s' is pivot"%pivot)
logger.debug("solve '%s' with respect to pivot with |tcs|=%d"%(solve_for,len(tcs)))
_getIdxs = lambda a,d: [k for k in d[a] if not 'coef' in str(k)]
mytcs = [dict(tc[pivot].items() + tc[solve_for].items()) for tc in tcs]
idxs_ = _getIdxs(pivot,tcs[0])
pivot_idxs_n_const = [SR(1)] + idxs_
solve_for_keys= tcs[0][solve_for].keys()
rs = [Miscs.solve_eqts_(ts=pivot_idxs_n_const,rv=k,ds=mytcs)
for k in solve_for_keys]
rs = Miscs.keys_to_str(rs) #so that the keys are string
try:
sol = merge_dict(rs)
sol = (solve_for, sol)
return sol
except Exception:
return None
def solve(self): #mpp fixed
ts = [t for t in self.terms if t != 1]
tcs = Miscs.keys_to_str(self.tcs)
if self.subset_siz is None:
subset_siz = len(ts)
else:
subset_siz = self.subset_siz
blacklist = None
if self.xinfo['Input']:
blacklist = self.xinfo['Input']
if (self.xinfo['Output'] and
len(self.xinfo['Output']) > len(self.xinfo['Input'])):
blacklist = self.xinfo['Output']
ts_common = gen_terms_fixed_coefs(ts,subset_siz=subset_siz,
blacklist=blacklist,
is_mpp=True)
if self.mpp_opt == IeqMPP.opt_max_then_min:
def worker(Q,is_max_plus):
Q.put(IeqMPPFixed.build_poly(ts_common,tcs,is_max_plus))
Q = mp.Queue()
workers = [mp.Process(target=worker,args=(Q,is_max_plus))
for is_max_plus in [True,False]]
for w in workers: w.start()
rs = []
for _ in workers:
rs.extend(Q.get())
else:
is_max_plus = self.mpp_opt == IeqMPP.opt_max_plus
rs = IeqMPPFixed.build_poly(ts_common, tcs, is_max_plus)
self.sols = map(InvMPP, rs)
def extractIdxInfo(pivot,psInfo):
ps = [p[pivot] for p in psInfo]
ps = Miscs.keys_to_str([p for p in ps])
ps = [dict([(k,c) for k,c in p.iteritems() if k != 'coef'])
for p in ps]
return ps
def rfilter_old(self, tcs):
"""
Returns the subset of ps that satisfies all testcases tcs
Examples:
sage: logger.set_level(VLog.DEBUG)
sage: var('y z')
(y, z)
sage: rf = Refine(map(InvIeq,[x^2 >= 0 , x-y >= 7]));rf.rfilter([{x:1,y:0}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=2, |tcs|=1)
refine:Debug:rfilter (before 2, after 1, diff 1)
[x^2 >= 0]
sage: rf = Refine(map(InvIeq,[2*x -y >= 0])); rf.rfilter([{y: 14, x: 7}, {y: 13, x: 7}, {y: 6, x: 4}, {y: 1, x: 1}, {y: 2, x: 1}, {y: 5, x: 100}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=1, |tcs|=6)
[2*x - y >= 0]
sage: rf = Refine(map(InvIeq,[2*x -y >= 0])); rf.rfilter([{y: 14, x: 7}, {y: 13, x: 7}, {y: 6, x: 4}, {y: 1, x: 1}, {y: 2, x: 1}, {y: 25, x: 9}, {y:25 , x*y: 15, x: 9}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=1, |tcs|=7)
refine:Debug:rfilter (before 1, after 0, diff 1)
[]
** This is by design
sage: rf = Refine(map(InvIeq,[x^3 >= 0 , x-y >= 7])); rf.rfilter([{z:1}])
refine:Debug:rfilter(|ps|=2, |tcs|=1)
refine:Debug:rfilter (before 2, after 0, diff 2)
sage: assert(rf.ps == [])
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10',''), ('lambda x,y: max(x,y)>12',''), ('lambda x: x>=10','')])); rf.rfilter([{x:20,y:0},{x:9,y:13}]); sorted(rf.ps,key=str)
refine:Debug:vset (before 3, after 2, diff 1)
refine:Debug:rfilter(|ps|=2, |tcs|=2)
refine:Debug:rfilter (before 2, after 1, diff 1)
['lambda x,y: max(x,y)>12']
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10', ''), ('lambda x,y: max(x,y)>12','')])); rf.rfilter([{x:20,y:0}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=2, |tcs|=1)
['lambda x: x>=10', 'lambda x,y: max(x,y)>12']
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10',''), ('lambda x,y: max(x,y)>12','')])); rf.rfilter([]); sorted(rf.ps,key=str)
refine:Debug:rfilter skips (|ps|=2, |tcs|=0)
['lambda x: x>=10', 'lambda x,y: max(x,y)>12']
"""
if is_empty(self.ps) or is_empty(tcs):
logger.debug('rfilter skips (|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
return
logger.debug('rfilter(|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
if not isinstance(self.ps[0],InvExp):
from dig_miscs import Miscs
tcs = Miscs.keys_to_str(tcs)
old_len = len(self.ps)
self.ps = [p for p in self.ps if all(p.seval(tc) for tc in tcs)]
Refine.print_diff('rfilter', old_len, len(self.ps))
def rfilter_old(self, tcs):
"""
Returns the subset of ps that satisfies all testcases tcs
Examples:
sage: logger.set_level(VLog.DEBUG)
sage: var('y z')
(y, z)
sage: rf = Refine(map(InvIeq,[x^2 >= 0 , x-y >= 7]));rf.rfilter([{x:1,y:0}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=2, |tcs|=1)
refine:Debug:rfilter (before 2, after 1, diff 1)
[x^2 >= 0]
sage: rf = Refine(map(InvIeq,[2*x -y >= 0])); rf.rfilter([{y: 14, x: 7}, {y: 13, x: 7}, {y: 6, x: 4}, {y: 1, x: 1}, {y: 2, x: 1}, {y: 5, x: 100}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=1, |tcs|=6)
[2*x - y >= 0]
sage: rf = Refine(map(InvIeq,[2*x -y >= 0])); rf.rfilter([{y: 14, x: 7}, {y: 13, x: 7}, {y: 6, x: 4}, {y: 1, x: 1}, {y: 2, x: 1}, {y: 25, x: 9}, {y:25 , x*y: 15, x: 9}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=1, |tcs|=7)
refine:Debug:rfilter (before 1, after 0, diff 1)
[]
** This is by design
sage: rf = Refine(map(InvIeq,[x^3 >= 0 , x-y >= 7])); rf.rfilter([{z:1}])
refine:Debug:rfilter(|ps|=2, |tcs|=1)
refine:Debug:rfilter (before 2, after 0, diff 2)
sage: assert(rf.ps == [])
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10',''), ('lambda x,y: max(x,y)>12',''), ('lambda x: x>=10','')])); rf.rfilter([{x:20,y:0},{x:9,y:13}]); sorted(rf.ps,key=str)
refine:Debug:vset (before 3, after 2, diff 1)
refine:Debug:rfilter(|ps|=2, |tcs|=2)
refine:Debug:rfilter (before 2, after 1, diff 1)
['lambda x,y: max(x,y)>12']
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10', ''), ('lambda x,y: max(x,y)>12','')])); rf.rfilter([{x:20,y:0}]); sorted(rf.ps,key=str)
refine:Debug:rfilter(|ps|=2, |tcs|=1)
['lambda x: x>=10', 'lambda x,y: max(x,y)>12']
sage: rf = Refine(map(InvMPP,[('lambda x: x>=10',''), ('lambda x,y: max(x,y)>12','')])); rf.rfilter([]); sorted(rf.ps,key=str)
refine:Debug:rfilter skips (|ps|=2, |tcs|=0)
['lambda x: x>=10', 'lambda x,y: max(x,y)>12']
"""
if is_empty(self.ps) or is_empty(tcs):
logger.debug('rfilter skips (|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
return None
logger.debug('rfilter(|ps|={}, |tcs|={})'
.format(len(self.ps), len(tcs)))
if not isinstance(self.ps[0],InvExp):
from dig_miscs import Miscs
tcs = Miscs.keys_to_str(tcs)
old_len = len(self.ps)
self.ps = [p for p in self.ps if all(p.seval(tc) for tc in tcs)]
Refine.print_diff('rfilter', old_len, len(self.ps))
