def enumerate_with_info(self, context: Context, size: int,
pool: Pool) -> [EnumeratedExp]:
"""Enumerate expressions (and fingerprints) of the given size.
The output of this function is cached, so subsequent calls are very
cheap.
Arguments:
context : a Context object describing the vars in scope
size : size of expressions to enumerate
pool : expression pool to visit
"""
canonical_context = self.canonical_context(context)
if canonical_context is not context:
print("adapting request: {} ---> {}".format(
context, canonical_context))
for info in self.enumerate_with_info(canonical_context, size,
pool):
yield info._replace(e=context.adapt(info.e, canonical_context))
return
k = (pool, size, context)
cache = self.cache
if k in self.complete:
yield from cache.find_expressions_of_size(context, pool, size)
else:
assert k not in self.in_progress, "recursive enumeration?? {}".format(
k)
self.in_progress.add(k)
yield from self._enumerate_with_info(context, size, pool)
self.in_progress.remove(k)
self.complete.add(k)
def enumerate_with_info(self, context: Context, size: int,
pool: Pool) -> [EnumeratedExp]:
canonical_context = self.canonical_context(context)
if canonical_context is not context:
print("adapting request: {} ---> {}".format(
context, canonical_context))
for info in self.enumerate_with_info(canonical_context, size,
pool):
yield info._replace(e=context.adapt(info.e, canonical_context))
return
if context.parent() is not None:
yield from self.enumerate_with_info(context.parent(), size, pool)
k = (pool, size, context)
res = self.cache.get(k)
if res is not None:
# print("[[{} cached @ size={}]]".format(len(res), size))
for e in res:
yield e
else:
# print("ENTER {}".format(k))
examples = context.instantiate_examples(self.examples)
assert k not in self.in_progress, "recursive enumeration?? {}".format(
k)
self.in_progress.add(k)
res = []
self.cache[k] = res
queue = self.enumerate_core(context, size, pool)
cost_model = self.cost_model
while True:
if self.stop_callback():
raise StopException()
try:
e = next(queue)
except StopIteration:
break
fvs = free_vars(e)
if not belongs_in_context(fvs, context):
continue
e = freshen_binders(e, context)
_consider(e, context, pool)
wf = self.check_wf(e, context, pool)
if not wf:
_skip(e, context, pool, "wf={}".format(wf))
continue
fp = fingerprint(e, examples)
# collect all expressions from parent contexts
with task("collecting prev exps",
size=size,
context=context,
pool=pool_name(pool)):
prev = []
for sz in range(0, size + 1):
prev.extend(self.enumerate_with_info(
context, sz, pool))
prev = [p.e for p in prev if p.fingerprint == fp]
if any(alpha_equivalent(e, p) for p in prev):
_skip(e, context, pool, "duplicate")
should_keep = False
else:
# decide whether to keep this expression,
# decide which can be evicted
should_keep = True
# cost = self.cost_model.cost(e, pool)
# print("prev={}".format(prev))
# print("seen={}".format(self.seen))
with task("comparing to cached equivalents"):
for prev_exp in prev:
event("previous: {}".format(pprint(prev_exp)))
# prev_cost = self.cost_model.cost(prev_exp, pool)
# ordering = cost.compare_to(prev_cost)
to_keep = eviction_policy(e, context, prev_exp,
context, pool,
cost_model)
if e not in to_keep:
_skip(e, context, pool,
"preferring {}".format(pprint(prev_exp)))
should_keep = False
break
# if ordering == Order.LT:
# pass
# elif ordering == Order.GT:
# self.blacklist.add(e_key)
# _skip(e, context, pool, "worse than {}".format(pprint(prev_exp)))
# should_keep = False
# break
# else:
# self.blacklist.add(e_key)
# _skip(e, context, pool, "{} to cached {}".format(
# "equal" if ordering == Order.EQUAL else "similar",
# pprint(prev_exp)))
# assert ordering in (Order.EQUAL, Order.AMBIGUOUS)
# should_keep = False
# break
if should_keep:
with task("evicting"):
to_evict = []
for (key, exps) in self.cache.items():
(p, s, c) = key
if p == pool and c in itertools.chain(
[context], parent_contexts(context)):
for ee in exps:
if ee.fingerprint == fp: # and cost_model.compare(e, ee.e, context, pool) == Order.LT:
# to_evict.append((key, ee))
to_keep = eviction_policy(
e, context, ee.e, c, pool,
cost_model)
if ee.e not in to_keep:
to_evict.append((key, ee))
for key, ee in to_evict:
(p, s, c) = key
# self.blacklist.add((ee.e, c, pool))
_evict(ee.e, c, pool, e)
self.cache[key].remove(ee)
self.seen[(c, p, fp)].remove(ee.e)
_accept(e, context, pool)
seen_key = (context, pool, fp)
if seen_key not in self.seen:
self.seen[seen_key] = []
self.seen[seen_key].append(e)
info = EnumeratedExp(e=e, fingerprint=fp, cost=None)
res.append(info)
yield info
with task("accelerating"):
to_try = make_random_access(
self.heuristics(e, context, pool))
if to_try:
# print("trying {} accelerations".format(len(to_try)))
queue = itertools.chain(to_try, queue)
# print("EXIT {}".format(k))
self.in_progress.remove(k)
def enumerate_core(self, context: Context, size: int, pool: Pool) -> [Exp]:
"""
Arguments:
conext : a Context object describing the vars in scope
size : size to enumerate
pool : pool to enumerate
Yields all expressions of the given size legal in the given context and
pool.
"""
if size < 0:
return
if size == 0:
for (e, p) in LITERALS:
if p == pool:
yield e
for (v, p) in context.vars():
if p == pool:
yield v
for t in all_types(v):
yield construct_value(t)
for (e, ctx, p) in self.hints:
if p == pool and ctx.alpha_equivalent(context):
yield context.adapt(e, ctx)
for t in all_types(e):
yield construct_value(t)
return
yield from self.heuristic_enumeration(context, size, pool)
for e in collections(self.enumerate(context, size - 1, pool)):
yield EEmptyList().with_type(e.type)
if is_numeric(e.type.t):
yield EUnaryOp(UOp.Sum, e).with_type(e.type.t)
for e in self.enumerate(context, size - 1, pool):
yield ESingleton(e).with_type(TBag(e.type))
for e in self.enumerate(context, size - 1, pool):
if isinstance(e.type, TRecord):
for (f, t) in e.type.fields:
yield EGetField(e, f).with_type(t)
for e in self.enumerate(context, size - 1, pool):
if isinstance(e.type, THandle):
yield EGetField(e, "val").with_type(e.type.value_type)
for e in self.enumerate(context, size - 1, pool):
if isinstance(e.type, TTuple):
for n in range(len(e.type.ts)):
yield ETupleGet(e, n).with_type(e.type.ts[n])
for e in of_type(self.enumerate(context, size - 1, pool), BOOL):
yield EUnaryOp(UOp.Not, e).with_type(BOOL)
for e in self.enumerate(context, size - 1, pool):
if is_numeric(e.type):
yield EUnaryOp("-", e).with_type(e.type)
for m in self.enumerate(context, size - 1, pool):
if isinstance(m.type, TMap):
yield EMapKeys(m).with_type(TBag(m.type.k))
for (sz1, sz2) in pick_to_sum(2, size - 1):
for a1 in self.enumerate(context, sz1, pool):
t = a1.type
if not is_numeric(t):
continue
for a2 in of_type(self.enumerate(context, sz2, pool), t):
yield EBinOp(a1, "+", a2).with_type(t)
yield EBinOp(a1, "-", a2).with_type(t)
yield EBinOp(a1, ">", a2).with_type(BOOL)
yield EBinOp(a1, "<", a2).with_type(BOOL)
yield EBinOp(a1, ">=", a2).with_type(BOOL)
yield EBinOp(a1, "<=", a2).with_type(BOOL)
for a1 in collections(self.enumerate(context, sz1, pool)):
for a2 in of_type(self.enumerate(context, sz2, pool), a1.type):
yield EBinOp(a1, "+", a2).with_type(a1.type)
yield EBinOp(a1, "-", a2).with_type(a1.type)
for a2 in of_type(self.enumerate(context, sz2, pool),
a1.type.t):
yield EBinOp(a2, BOp.In, a1).with_type(BOOL)
for a1 in of_type(self.enumerate(context, sz1, pool), BOOL):
for a2 in of_type(self.enumerate(context, sz2, pool), BOOL):
yield EBinOp(a1, BOp.And, a2).with_type(BOOL)
yield EBinOp(a1, BOp.Or, a2).with_type(BOOL)
for a1 in self.enumerate(context, sz1, pool):
if not isinstance(a1.type, TMap):
for a2 in of_type(self.enumerate(context, sz2, pool),
a1.type):
yield EEq(a1, a2)
yield EBinOp(a1, "!=", a2).with_type(BOOL)
for m in self.enumerate(context, sz1, pool):
if isinstance(m.type, TMap):
for k in of_type(self.enumerate(context, sz2, pool),
m.type.k):
yield EMapGet(m, k).with_type(m.type.v)
yield EHasKey(m, k).with_type(BOOL)
for l in self.enumerate(context, sz1, pool):
if not isinstance(l.type, TList):
continue
for i in of_type(self.enumerate(context, sz2, pool), INT):
yield EListGet(l, i).with_type(l.type.t)
for (sz1, sz2, sz3) in pick_to_sum(3, size - 1):
for cond in of_type(self.enumerate(context, sz1, pool), BOOL):
for then_branch in self.enumerate(context, sz2, pool):
for else_branch in of_type(
self.enumerate(context, sz2, pool),
then_branch.type):
yield ECond(cond, then_branch,
else_branch).with_type(then_branch.type)
for l in self.enumerate(context, sz1, pool):
if not isinstance(l.type, TList):
continue
for st in of_type(self.enumerate(context, sz2, pool), INT):
for ed in of_type(self.enumerate(context, sz3, pool), INT):
yield EListSlice(l, st, ed).with_type(l.type)
for bag in collections(self.enumerate(context, size - 1, pool)):
# len of bag
count = EUnaryOp(UOp.Length, bag).with_type(INT)
yield count
# empty?
yield EUnaryOp(UOp.Empty, bag).with_type(BOOL)
# exists?
yield EUnaryOp(UOp.Exists, bag).with_type(BOOL)
# singleton?
yield EEq(count, ONE)
yield EUnaryOp(UOp.The, bag).with_type(bag.type.t)
yield EUnaryOp(UOp.Distinct, bag).with_type(bag.type)
yield EUnaryOp(UOp.AreUnique, bag).with_type(BOOL)
if bag.type.t == BOOL:
yield EUnaryOp(UOp.Any, bag).with_type(BOOL)
yield EUnaryOp(UOp.All, bag).with_type(BOOL)
def build_lambdas(bag, pool, body_size):
v = fresh_var(bag.type.t, omit=set(v for v, p in context.vars()))
inner_context = UnderBinder(context, v=v, bag=bag, bag_pool=pool)
for lam_body in self.enumerate(inner_context, body_size, pool):
yield ELambda(v, lam_body)
# Iteration
for (sz1, sz2) in pick_to_sum(2, size - 1):
for bag in collections(self.enumerate(context, sz1, pool)):
for lam in build_lambdas(bag, pool, sz2):
body_type = lam.body.type
yield EMap(bag, lam).with_type(TBag(body_type))
if body_type == BOOL:
yield EFilter(bag, lam).with_type(bag.type)
if is_numeric(body_type):
yield EArgMin(bag, lam).with_type(bag.type.t)
yield EArgMax(bag, lam).with_type(bag.type.t)
if is_collection(body_type):
yield EFlatMap(bag, lam).with_type(TBag(body_type.t))
# Enable use of a state-pool expression at runtime
if pool == RUNTIME_POOL:
for e in self.enumerate(context, size - 1, STATE_POOL):
yield EStateVar(e).with_type(e.type)
# Create maps
if pool == STATE_POOL:
for (sz1, sz2) in pick_to_sum(2, size - 1):
for bag in collections(self.enumerate(context, sz1,
STATE_POOL)):
if not is_scalar(bag.type.t):
continue
for lam in build_lambdas(bag, STATE_POOL, sz2):
t = TMap(bag.type.t, lam.body.type)
m = EMakeMap2(bag, lam).with_type(t)
yield m
def enumerate_with_info(self, context: Context, size: int,
pool: Pool) -> [EnumeratedExp]:
canonical_context = self.canonical_context(context)
if canonical_context is not context:
print("adapting request: {} ---> {}".format(
context, canonical_context))
for info in self.enumerate_with_info(canonical_context, size,
pool):
yield info._replace(e=context.adapt(info.e, canonical_context))
return
examples = context.instantiate_examples(self.examples)
if context.parent() is not None:
for info in self.enumerate_with_info(context.parent(), size, pool):
e = info.e
yield EnumeratedExp(e=e, fingerprint=fingerprint(e, examples))
k = (pool, size, context)
res = self.cache.get(k)
if res is not None:
for e in res:
yield e
else:
assert k not in self.in_progress, "recursive enumeration?? {}".format(
k)
self.in_progress.add(k)
res = []
self.cache[k] = res
queue = self.enumerate_core(context, size, pool)
cost_model = self.cost_model
while True:
if self.stop_callback():
raise StopException()
try:
e = next(queue)
except StopIteration:
break
fvs = free_vars(e)
if not belongs_in_context(fvs, context):
continue
e = freshen_binders(e, context)
_consider(e, size, context, pool)
wf = self.check_wf(e, context, pool)
if not wf:
_skip(e, size, context, pool, "wf={}".format(wf))
continue
fp = fingerprint(e, examples)
# collect all expressions from parent contexts
with task("collecting prev exps",
size=size,
context=context,
pool=pool_name(pool)):
prev = []
for sz in range(0, size + 1):
prev.extend(self.enumerate_with_info(
context, sz, pool))
prev = [p.e for p in prev if p.fingerprint == fp]
if any(alpha_equivalent(e, p) for p in prev):
_skip(e, size, context, pool, "duplicate")
should_keep = False
else:
# decide whether to keep this expression
should_keep = True
with task("comparing to cached equivalents"):
for prev_exp in prev:
event("previous: {}".format(pprint(prev_exp)))
to_keep = eviction_policy(e, context, prev_exp,
context, pool,
cost_model)
if e not in to_keep:
_skip(e, size, context, pool,
"preferring {}".format(pprint(prev_exp)))
should_keep = False
break
if should_keep:
if self.do_eviction:
with task("evicting"):
to_evict = []
for (key, exps) in self.cache.items():
(p, s, c) = key
if p == pool and c == context:
for ee in exps:
if ee.fingerprint == fp:
event("considering eviction of {}".
format(pprint(ee.e)))
to_keep = eviction_policy(
e, context, ee.e, c, pool,
cost_model)
if ee.e not in to_keep:
to_evict.append((key, ee))
for key, ee in to_evict:
(p, s, c) = key
_evict(ee.e, s, c, pool, e)
self.cache[key].remove(ee)
self.seen[(c, p, fp)].remove(ee.e)
_accept(e, size, context, pool)
seen_key = (context, pool, fp)
if seen_key not in self.seen:
self.seen[seen_key] = []
self.seen[seen_key].append(e)
info = EnumeratedExp(e=e, fingerprint=fp)
res.append(info)
yield info
with task("accelerating"):
to_try = make_random_access(
self.heuristics(e, context, pool))
if to_try:
event("trying {} accelerations of {}".format(
len(to_try), pprint(e)))
queue = itertools.chain(to_try, queue)
self.in_progress.remove(k)
def _enumerate_core(self, context: Context, size: int,
pool: Pool) -> [Exp]:
"""Build new expressions of the given size.
Arguments:
context : a Context object describing the vars in scope
size : size of expressions to enumerate; each expression in
the output will have this size
pool : pool to enumerate
This function is not cached. Clients should call `enumerate` instead.
This function tries to be a clean description of the Cozy grammar. It
does not concern itself with deduplication (which is handled
efficiently by equivalence class deduplication).
"""
if size < 0:
return
if size == 0:
for e in LITERALS:
yield e
all_interesting_types = OrderedSet(self.hint_types)
for v, _ in context.vars():
all_interesting_types |= all_types(v.type)
for t in all_interesting_types:
l = construct_value(t)
if l not in LITERALS:
yield l
for (v, p) in context.vars():
if p == pool:
yield v
for (e, ctx, p) in self.hints:
if p == pool:
fvs = free_vars(e)
if ctx.alpha_equivalent(context.generalize(fvs)):
yield context.adapt(e, ctx, e_fvs=fvs)
return
if not do_enumerate.value:
return
def build_lambdas(bag, pool, body_size):
v = fresh_var(bag.type.elem_type,
omit=set(v for v, p in context.vars()))
inner_context = UnderBinder(context, v=v, bag=bag, bag_pool=pool)
for lam_body in self.enumerate(inner_context, body_size, pool):
yield ELambda(v, lam_body)
# Load all smaller expressions in this context and pool.
# cache[S] contains expressions of size S in this context and pool.
cache = [list(self.enumerate(context, sz, pool)) for sz in range(size)]
# Enable use of a state-pool expression at runtime
if pool == RUNTIME_POOL:
for e in self.enumerate(context.root(), size - 1, STATE_POOL):
yield EStateVar(e).with_type(e.type)
# Arity-1 expressions
for e in cache[size - 1]:
if is_collection(e.type):
elem_type = e.type.elem_type
# This method of generating EEmptyList() ensures that we visit
# empty collections of all possible types.
yield EEmptyList().with_type(e.type)
if is_numeric(elem_type):
yield EUnaryOp(UOp.Sum, e).with_type(elem_type)
yield EUnaryOp(UOp.Length, e).with_type(INT)
yield EUnaryOp(UOp.Empty, e).with_type(BOOL)
yield EUnaryOp(UOp.Exists, e).with_type(BOOL)
yield EUnaryOp(UOp.The, e).with_type(elem_type)
yield EUnaryOp(UOp.Distinct, e).with_type(e.type)
yield EUnaryOp(UOp.AreUnique, e).with_type(BOOL)
if elem_type == BOOL:
yield EUnaryOp(UOp.Any, e).with_type(BOOL)
yield EUnaryOp(UOp.All, e).with_type(BOOL)
yield ESingleton(e).with_type(TBag(e.type))
if isinstance(e.type, TRecord):
for (f, t) in e.type.fields:
yield EGetField(e, f).with_type(t)
if isinstance(e.type, THandle):
yield EGetField(e, "val").with_type(e.type.value_type)
if isinstance(e.type, TTuple):
for n in range(len(e.type.ts)):
yield ETupleGet(e, n).with_type(e.type.ts[n])
if e.type == BOOL:
yield EUnaryOp(UOp.Not, e).with_type(BOOL)
if is_numeric(e.type):
yield EUnaryOp("-", e).with_type(e.type)
if isinstance(e.type, TMap):
yield EMapKeys(e).with_type(TBag(e.type.k))
# Arity-2 expressions
for (sz1, sz2) in pick_to_sum(2, size - 1):
# sz1 + sz2 = size - 1
for e1 in cache[sz1]:
t = e1.type
if is_numeric(t):
for a2 in of_type(cache[sz2], t):
yield EBinOp(e1, "+", a2).with_type(t)
yield EBinOp(e1, "-", a2).with_type(t)
if is_ordered(t):
for a2 in of_type(cache[sz2], t):
yield EBinOp(e1, ">", a2).with_type(BOOL)
yield EBinOp(e1, "<", a2).with_type(BOOL)
yield EBinOp(e1, ">=", a2).with_type(BOOL)
yield EBinOp(e1, "<=", a2).with_type(BOOL)
if t == BOOL:
for a2 in of_type(cache[sz2], BOOL):
yield EBinOp(e1, BOp.And, a2).with_type(BOOL)
yield EBinOp(e1, BOp.Or, a2).with_type(BOOL)
# Cozy supports the implication operator "=>", but this
# function does not enumerate it because
# - (a => b) is equivalent to ((not a) or b)
# - there isn't an implication operator in any of our
# current target languages, so we would need to
# desugar it to ((not a) or b) anyway.
if not isinstance(t, TMap):
for a2 in of_type(cache[sz2], t):
yield EEq(e1, a2)
yield EBinOp(e1, "!=", a2).with_type(BOOL)
if isinstance(t, TMap):
for k in of_type(cache[sz2], t.k):
yield EMapGet(e1, k).with_type(t.v)
yield EHasKey(e1, k).with_type(BOOL)
if isinstance(t, TList):
for i in of_type(cache[sz2], INT):
yield EListGet(e1, i).with_type(e1.type.elem_type)
if is_collection(t):
elem_type = t.elem_type
for e2 in of_type(cache[sz2], t):
yield EBinOp(e1, "+", e2).with_type(t)
yield EBinOp(e1, "-", e2).with_type(t)
for e2 in of_type(cache[sz2], elem_type):
yield EBinOp(e2, BOp.In, e1).with_type(BOOL)
for f in build_lambdas(e1, pool, sz2):
body_type = f.body.type
yield EMap(e1, f).with_type(TBag(body_type))
if body_type == BOOL:
yield EFilter(e1, f).with_type(t)
if is_numeric(body_type):
yield EArgMin(e1, f).with_type(elem_type)
yield EArgMax(e1, f).with_type(elem_type)
if is_collection(body_type):
yield EFlatMap(e1, f).with_type(
TBag(body_type.elem_type))
if pool == STATE_POOL and is_hashable(elem_type):
yield EMakeMap2(e1, f).with_type(
TMap(elem_type, body_type))
e1_singleton = ESingleton(e1).with_type(TBag(e1.type))
for f in build_lambdas(e1_singleton, pool, sz2):
yield ELet(e1, f).with_type(f.body.type)
# Arity-3 expressions
for (sz1, sz2, sz3) in pick_to_sum(3, size - 1):
# sz1 + sz2 + sz3 = size - 1
for e1 in cache[sz1]:
if e1.type == BOOL:
cond = e1
for then_branch in cache[sz2]:
for else_branch in of_type(cache[sz3],
then_branch.type):
yield ECond(cond, then_branch,
else_branch).with_type(
then_branch.type)
if isinstance(e1.type, TList):
for start in of_type(cache[sz2], INT):
for end in of_type(cache[sz3], INT):
yield EListSlice(e1, start, end).with_type(e1.type)
# It is not necessary to create slice expressions of
# the form a[:i] or a[i:]. Those are desugared
# after parsing to a[0:i] and a[i:len(a)]
# respectively, and Cozy is perfectly capable of
# discovering these expanded forms as well.
for h in all_extension_handlers():
yield from h.enumerate(context, size, pool, self.enumerate,
build_lambdas)