def array_in_bounds(self, elem_type, a, i):
if elem_type == BOOL:
len = EBinOp(EEscape("{a}.length", ["a"], [a]), "<<", ENum(6).with_type(INT)).with_type(INT)
else:
len = EEscape("{a}.length", ["a"], [a]).with_type(INT)
return EAll([
EBinOp(i, ">=", ZERO).with_type(BOOL),
EBinOp(i, "<", len).with_type(BOOL)])
def visit_EUnaryOp(self, e):
op = e.op
if op == UOp.Distinct:
return self.visit_iterable(e)
elif op == UOp.The:
return self.find_one(e.e)
elif op == UOp.Sum:
sum_var = fresh_var(e.type, "sum")
loop_var = fresh_var(e.e.type.elem_type, "x")
self.stms.append(simplify_and_optimize(seq([
SDecl(sum_var, ENum(0).with_type(e.type)),
SForEach(loop_var, e.e,
SAssign(sum_var, EBinOp(sum_var, "+", loop_var).with_type(INT)))])))
return sum_var
elif op == UOp.Length:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Sum, EMap(e.e, ELambda(arg, ONE)).with_type(INT_BAG)).with_type(INT))
elif op == UOp.All:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Empty, EFilter(e.e, ELambda(arg, ENot(arg))).with_type(INT_BAG)).with_type(INT))
elif op == UOp.Any:
arg = EVar("x").with_type(e.e.type.elem_type)
return self.visit(EUnaryOp(UOp.Exists, EFilter(e.e, ELambda(arg, arg)).with_type(INT_BAG)).with_type(INT))
elif op == UOp.Empty:
iterable = e.e
v = fresh_var(BOOL, "v")
label = fresh_name("label")
x = fresh_var(iterable.type.elem_type, "x")
decl = SDecl(v, ETRUE)
find = SEscapableBlock(label,
SForEach(x, iterable, seq([
SAssign(v, EFALSE),
SEscapeBlock(label)])))
self.stms.append(simplify_and_optimize(seq([decl, find])))
return v
elif op == UOp.Exists:
return self.visit(ENot(EUnaryOp(UOp.Empty, e.e).with_type(BOOL)))
# elif op == UOp.AreUnique:
# s = fresh_var(TSet(e.e.type.elem_type), "unique_elems")
# u = fresh_var(BOOL, "is_unique")
# x = fresh_var(e.e.type.elem_type)
# label = fresh_name("label")
# self.visit(seq([
# SDecl(s, EEmptyList().with_type(s.type)),
# SDecl(u, ETRUE),
# SEscapableBlock(label,
# SForEach(x, e.e,
# SIf(EEscape("{s}.find({x}) != {s}.end()", ("s", "x"), (s, x)).with_type(BOOL),
# seq([SAssign(u, EFALSE), SEscapeBlock(label)]),
# SEscape("{indent}{s}.insert({x});\n", ("s", "x"), (s, x)))))]))
# return u.id
return self.visit_Exp(e)
def min_or_max(self, op, e, f):
if isinstance(e, EBinOp) and e.op == "+" and isinstance(e.e1, ESingleton) and isinstance(e.e2, ESingleton):
# argmin_f ([a] + [b]) ---> f(a) < f(b) ? a : b
return self.visit(ECond(
EBinOp(f.apply_to(e.e1.e), op, f.apply_to(e.e2.e)).with_type(BOOL),
e.e1.e,
e.e2.e).with_type(e.e1.e.type))
out = fresh_var(e.type.elem_type, "min" if op == "<" else "max")
first = fresh_var(BOOL, "first")
x = fresh_var(e.type.elem_type, "x")
decl1 = SDecl(out, evaluation.construct_value(out.type))
decl2 = SDecl(first, ETRUE)
find = SForEach(x, e,
SIf(EBinOp(
first,
BOp.Or,
EBinOp(f.apply_to(x), op, f.apply_to(out)).with_type(BOOL)).with_type(BOOL),
seq([SAssign(first, EFALSE), SAssign(out, x)]),
SNoOp()))
self.stms.append(simplify_and_optimize(seq([decl1, decl2, find])))
return out
def histogram(e : Exp) -> (Stm, EVar):
"""Compute a histogram of the elements in the iterable `e`.
Returns an unoptimized statement that declares and constructs a histogram
map and the fresh variable that got declared.
"""
elem_type = e.type.elem_type
h = fresh_var(TMap(elem_type, INT), "histogram")
x = fresh_var(elem_type, "x")
count = fresh_var(INT, "count")
stm = seq([
SDecl(h, EEmptyMap().with_type(h.type)),
SForEach(x, e,
SMapUpdate(h, x, count,
SAssign(count, EBinOp(count, "+", ONE).with_type(INT))))])
return (stm, h)
def array_resize_for_index(self, elem_type, a, i):
"""Resize the array until `i` is a legal index.
When i < 0, it will do nothing instead.
"""
new_a = fresh_name(hint="new_array")
if elem_type == BOOL:
t = "long"
else:
t = self.strip_generics(self.visit(elem_type, name=""))
len = EEscape("{a}.length", ["a"], [a]).with_type(INT)
double_and_incr_size = SEscape(
"{{indent}}{t}[] {new_a} = new {t}[({{len}} << 1) + 1];\n{{indent}}System.arraycopy({{a}}, 0, {new_a}, 0, {{len}});\n{{indent}}{{a}} = {new_a};\n".format(t=t, new_a=new_a),
["a", "len"], [a, len])
self.visit(SWhile(
EAll([EBinOp(i, ">=", ZERO).with_type(BOOL), ENot(self.array_in_bounds(elem_type, a, i))]),
double_and_incr_size))
def visit_EBinOp(self, e):
if e.op in ("+", "-") and is_collection(e.type):
return self.visit_iterable(e)
elif e.op == BOp.In and not isinstance(e.e2.type, TSet):
t = BOOL
res = fresh_var(t, "found")
x = fresh_var(e.e1.type, "x")
label = fresh_name("label")
self.stms.append(simplify_and_optimize(seq([
SDecl(res, EFALSE),
SEscapableBlock(label,
SForEach(x, e.e2, SIf(
EBinOp(x, "==", e.e1).with_type(BOOL),
seq([SAssign(res, ETRUE), SEscapeBlock(label)]),
SNoOp())))])))
return res
return self.visit_Exp(e)
def visit_SEnsureCapacity(self, s):
"""Ensure that array s.a satisfies capacity requirement s.capacity"""
return self.array_resize_for_index(s.a.type.elem_type, s.a, EBinOp(s.capacity, "-", ONE).with_type(INT))
def div_by_64_and_round_up(self, e):
return EBinOp(EBinOp(EBinOp(e, "-", ONE).with_type(INT), ">>", ENum(6).with_type(INT)).with_type(INT), "+", ONE).with_type(INT)
def stream(iterable : Exp, loop_var : EVar, body : Stm) -> Stm:
"""Convert an iterable expression to a streaming operation.
Input:
iterable - an expression with an iterable type (Bag, Set, or List), not
yet optimized
loop_var - a variable to use as the loop variable
body - a statement to run on that variable, not yet optimized
Output:
A statement equivalent to
for (loop_var in iterable) { body }
that eliminates as many intermediate collections and objects as possible.
NOTE: The output of function will not be correct if the body modifies any
free variable in the iterable expression or writes to any pointers that
are read by the iterable expression.
Generating code for the expression
Map {func} (Filter {predicate} big_collection)
might create two new collections as large as `big_collection`: one to hold
the result of the filter and one to hold the result of the map. If all the
code needs to do is to iterate over the result, then there is no reason to
make the two new collections.
This function is mutually recursive with `simplify_and_optimize`, so any
transformations performed by that method are also applied to the output of
this one.
"""
if isinstance(iterable, EEmptyList):
return SNoOp()
elif isinstance(iterable, ESingleton):
setup, value = simplify_and_optimize_expression(iterable.e)
# SScoped because if the iterable is e.g. [x] + [y], then the body
# might be appear in the same block twice. If the body declares any
# variables, that will cause problems in languages like Java or C++.
return seq([setup, SScoped(re_use(value, loop_var, simplify_and_optimize(body)))])
elif isinstance(iterable, ECond):
cond_setup, cond = simplify_and_optimize_expression(iterable.cond)
return seq([
cond_setup,
SIf(cond,
stream(iterable.then_branch, loop_var, body),
stream(iterable.else_branch, loop_var, body))])
elif isinstance(iterable, EUnaryOp) and iterable.op == UOp.Distinct:
tmp = fresh_var(TSet(iterable.type.elem_type), "distinct_elems")
return seq([
SDecl(tmp, EEmptyList().with_type(tmp.type)),
stream(iterable.e, loop_var, SIf(
ENot(EBinOp(loop_var, BOp.In, tmp).with_type(BOOL)),
seq([body, SCall(tmp, "add", [loop_var])]),
SNoOp()))])
elif isinstance(iterable, EBinOp) and iterable.op == "+":
return seq([
stream(iterable.e1, loop_var, body),
stream(iterable.e2, loop_var, body)])
elif isinstance(iterable, EBinOp) and iterable.op == "-":
if is_hashable(iterable.type.elem_type):
h_setup, h = histogram(iterable.e2)
val_ref = fresh_var(INT, "count")
return seq([
simplify_and_optimize(h_setup),
stream(
iterable.e1,
loop_var,
SIf(EGt(EMapGet(h, loop_var).with_type(INT), ZERO),
SMapUpdate(h, loop_var, val_ref, SAssign(val_ref, EBinOp(val_ref, "-", ONE).with_type(INT))),
body))])
else:
rhs = fresh_var(iterable.e2.type, "bag_subtraction_right")
return seq([
simplify_and_optimize(SDecl(rhs, iterable.e2)),
stream(
iterable.e1,
loop_var,
SIf(EIn(loop_var, rhs),
SCall(rhs, "remove", (loop_var,)),
body))])
elif isinstance(iterable, EFilter):
return stream(
EFlatMap(iterable.e, ELambda(iterable.predicate.arg,
ECond(iterable.predicate.body,
ESingleton(iterable.predicate.arg).with_type(iterable.type),
EEmptyList().with_type(iterable.type)).with_type(iterable.type))).with_type(iterable.type),
loop_var,
body)
elif isinstance(iterable, EMap):
return stream(
EFlatMap(iterable.e, ELambda(iterable.transform_function.arg,
ESingleton(iterable.transform_function.body).with_type(iterable.type))).with_type(iterable.type),
loop_var,
body)
elif isinstance(iterable, EFlatMap):
inner_loop_var = fresh_var(
iterable.transform_function.arg.type,
iterable.transform_function.arg.id)
return stream(
iterable.e,
inner_loop_var,
stream(iterable.transform_function.apply_to(inner_loop_var), loop_var, body))
elif isinstance(iterable, EListSlice):
elem_type = iterable.type.elem_type
l = fresh_var(iterable.e.type, "list")
s = fresh_var(INT, "start")
e = fresh_var(INT, "end")
return simplify_and_optimize(seq([
SDecl(l, iterable.e),
SDecl(s, max_of(iterable.start, ZERO)),
SDecl(e, min_of(iterable.end, ELen(l))),
SWhile(ELt(s, e), seq([
SDecl(loop_var, EListGet(l, s).with_type(elem_type)),
body,
SAssign(s, EBinOp(s, "+", ONE).with_type(INT))]))]))
elif isinstance(iterable, ELet):
v = fresh_var(
iterable.body_function.arg.type,
iterable.body_function.arg.id)
return seq([
simplify_and_optimize(SDecl(v, iterable.e)),
stream(iterable.body_function.apply_to(v), loop_var, body)])
elif isinstance(iterable, EMove):
return stream(iterable.e, loop_var, body)
else:
assert is_collection(iterable.type), repr(iterable)
setup, e = simplify_and_optimize_expression(iterable)
return seq([setup, SForEach(loop_var, e, simplify_and_optimize(body))])
def possibly_useful_nonrecursive(
solver,
e: Exp,
context: Context,
pool=RUNTIME_POOL,
assumptions: Exp = ETRUE,
ops: [Op] = ()) -> bool:
"""Heuristic filter to ignore expressions that are almost certainly useless."""
state_vars = OrderedSet(v for v, p in context.vars() if p == STATE_POOL)
args = OrderedSet(v for v, p in context.vars() if p == RUNTIME_POOL)
assumptions = EAll([assumptions, context.path_condition()])
at_runtime = pool == RUNTIME_POOL
h = extension_handler(type(e))
if h is not None:
res = h.possibly_useful(e, context, pool, assumptions, ops, solver)
if not res:
return res
if isinstance(e, EStateVar) and not free_vars(e.e):
return No("constant value in state position")
if (isinstance(e, EDropFront)
or isinstance(e, EDropBack)) and not at_runtime:
return No("EDrop* in state position")
if not allow_big_sets.value and isinstance(e, EFlatMap) and not at_runtime:
return No("EFlatMap in state position")
if not allow_int_arithmetic_state.value and not at_runtime and isinstance(
e, EBinOp) and e.type == INT:
return No("integer arithmetic in state position")
if is_collection(e.type) and not is_scalar(e.type.elem_type):
return No("collection of nonscalar: e {}\n elem_type: {}\n".format(
e, e.type.elem_type))
if isinstance(e.type, TMap) and not is_scalar(e.type.k):
return No("bad key type {}".format(pprint(e.type.k)))
if isinstance(e.type, TMap) and isinstance(e.type.v, TMap):
return No("map to map")
# This check is probably a bad idea: whether `the` is legal may depend on
# the contex that the expression is embedded within, so we can't skip it
# during synthesis just because it looks invalid now.
# if isinstance(e, EUnaryOp) and e.op == UOp.The:
# len = EUnaryOp(UOp.Length, e.e).with_type(INT)
# if not valid(EImplies(assumptions, EBinOp(len, "<=", ENum(1).with_type(INT)).with_type(BOOL))):
# return No("illegal application of 'the': could have >1 elems")
if not at_runtime and isinstance(
e, EBinOp) and e.op == "-" and is_collection(e.type):
return No("collection subtraction in state position")
# if not at_runtime and isinstance(e, ESingleton):
# return No("singleton in state position")
if not allow_nonzero_state_constants.value and not at_runtime and isinstance(
e, ENum) and e.val != 0:
return No("nonzero integer constant in state position")
if not allow_binop_state.value and at_runtime and isinstance(
e, EStateVar) and isinstance(e.e, EBinOp) and is_scalar(
e.e.e1.type) and is_scalar(e.e.e2.type):
return No(
"constant-time binary operator {!r} in state position".format(
e.e.op))
if not allow_conditional_state.value and not at_runtime and isinstance(
e, ECond):
return No("conditional in state position")
if isinstance(e, EMakeMap2) and isinstance(e.e, EEmptyList):
return No("trivially empty map")
if isinstance(e, EMakeMap2) and isinstance(e.e, ESingleton):
return No("really tiny map")
if not at_runtime and (isinstance(e, EArgMin) or isinstance(e, EArgMax)):
# Cozy has no way to efficiently implement mins/maxes when more than
# one element may leave the collection.
from cozy.state_maintenance import mutate
for op in ops:
elems = e.e
elems_prime = mutate(elems, op.body)
formula = EAll([assumptions] + list(op.assumptions) + [
EGt(
ELen(
EBinOp(elems, "-", elems_prime).with_type(elems.type)),
ONE)
])
if solver.satisfiable(formula):
return No(
"more than one element might be removed during {}".format(
op.name))
if not allow_peels.value and not at_runtime and isinstance(e, EFilter):
# catch "peels": removal of zero or one elements
if solver.valid(
EImplies(
assumptions,
ELe(
ELen(
EFilter(
e.e,
ELambda(e.predicate.arg, ENot(
e.predicate.body))).with_type(e.type)),
ONE))):
return No("filter is a peel")
if not allow_big_maps.value and not at_runtime and isinstance(
e, EMakeMap2) and is_collection(e.type.v):
all_collections = [sv for sv in state_vars if is_collection(sv.type)]
total_size = ENum(0).with_type(INT)
for c in all_collections:
total_size = EBinOp(total_size, "+",
EUnaryOp(UOp.Length,
c).with_type(INT)).with_type(INT)
my_size = EUnaryOp(
UOp.Length,
EFlatMap(
EUnaryOp(UOp.Distinct, e.e).with_type(e.e.type),
e.value_function).with_type(e.type.v)).with_type(INT)
s = EImplies(assumptions,
EBinOp(total_size, ">=", my_size).with_type(BOOL))
if not solver.valid(s):
return No("non-polynomial-sized map")
return True
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)