mirror of https://github.com/m-labs/artiq.git
remove old compiler code
This commit is contained in:
parent
2503dcd837
commit
e5b58b50aa
|
|
@ -1,358 +0,0 @@
|
||||||
import inspect
|
|
||||||
from pythonparser import parse, ast
|
|
||||||
|
|
||||||
import llvmlite_artiq.ir as ll
|
|
||||||
|
|
||||||
from artiq.py2llvm.values import VGeneric, operators
|
|
||||||
from artiq.py2llvm.base_types import VBool, VInt, VFloat
|
|
||||||
|
|
||||||
|
|
||||||
def _gcd(a, b):
|
|
||||||
if a < 0:
|
|
||||||
a = -a
|
|
||||||
while a:
|
|
||||||
c = a
|
|
||||||
a = b % a
|
|
||||||
b = c
|
|
||||||
return b
|
|
||||||
|
|
||||||
|
|
||||||
def init_module(module):
|
|
||||||
func_def = parse(inspect.getsource(_gcd)).body[0]
|
|
||||||
function, _ = module.compile_function(func_def,
|
|
||||||
{"a": VInt(64), "b": VInt(64)})
|
|
||||||
function.linkage = "internal"
|
|
||||||
|
|
||||||
|
|
||||||
def _reduce(builder, a, b):
|
|
||||||
module = builder.basic_block.function.module
|
|
||||||
for f in module.functions:
|
|
||||||
if f.name == "_gcd":
|
|
||||||
gcd_f = f
|
|
||||||
break
|
|
||||||
gcd = builder.call(gcd_f, [a, b])
|
|
||||||
a = builder.sdiv(a, gcd)
|
|
||||||
b = builder.sdiv(b, gcd)
|
|
||||||
return a, b
|
|
||||||
|
|
||||||
|
|
||||||
def _signnum(builder, a, b):
|
|
||||||
function = builder.basic_block.function
|
|
||||||
orig_block = builder.basic_block
|
|
||||||
swap_block = function.append_basic_block("sn_swap")
|
|
||||||
merge_block = function.append_basic_block("sn_merge")
|
|
||||||
|
|
||||||
condition = builder.icmp_signed(
|
|
||||||
"<", b, ll.Constant(ll.IntType(64), 0))
|
|
||||||
builder.cbranch(condition, swap_block, merge_block)
|
|
||||||
|
|
||||||
builder.position_at_end(swap_block)
|
|
||||||
minusone = ll.Constant(ll.IntType(64), -1)
|
|
||||||
a_swp = builder.mul(minusone, a)
|
|
||||||
b_swp = builder.mul(minusone, b)
|
|
||||||
builder.branch(merge_block)
|
|
||||||
|
|
||||||
builder.position_at_end(merge_block)
|
|
||||||
a_phi = builder.phi(ll.IntType(64))
|
|
||||||
a_phi.add_incoming(a, orig_block)
|
|
||||||
a_phi.add_incoming(a_swp, swap_block)
|
|
||||||
b_phi = builder.phi(ll.IntType(64))
|
|
||||||
b_phi.add_incoming(b, orig_block)
|
|
||||||
b_phi.add_incoming(b_swp, swap_block)
|
|
||||||
|
|
||||||
return a_phi, b_phi
|
|
||||||
|
|
||||||
|
|
||||||
def _make_ssa(builder, n, d):
|
|
||||||
value = ll.Constant(ll.ArrayType(ll.IntType(64), 2), ll.Undefined)
|
|
||||||
value = builder.insert_value(value, n, 0)
|
|
||||||
value = builder.insert_value(value, d, 1)
|
|
||||||
return value
|
|
||||||
|
|
||||||
|
|
||||||
class VFraction(VGeneric):
|
|
||||||
def get_llvm_type(self):
|
|
||||||
return ll.ArrayType(ll.IntType(64), 2)
|
|
||||||
|
|
||||||
def _nd(self, builder):
|
|
||||||
ssa_value = self.auto_load(builder)
|
|
||||||
a = builder.extract_value(ssa_value, 0)
|
|
||||||
b = builder.extract_value(ssa_value, 1)
|
|
||||||
return a, b
|
|
||||||
|
|
||||||
def set_value_nd(self, builder, a, b):
|
|
||||||
a = a.o_int64(builder).auto_load(builder)
|
|
||||||
b = b.o_int64(builder).auto_load(builder)
|
|
||||||
a, b = _reduce(builder, a, b)
|
|
||||||
a, b = _signnum(builder, a, b)
|
|
||||||
self.auto_store(builder, _make_ssa(builder, a, b))
|
|
||||||
|
|
||||||
def set_value(self, builder, v):
|
|
||||||
if not isinstance(v, VFraction):
|
|
||||||
raise TypeError
|
|
||||||
self.auto_store(builder, v.auto_load(builder))
|
|
||||||
|
|
||||||
def o_getattr(self, attr, builder):
|
|
||||||
if attr == "numerator":
|
|
||||||
idx = 0
|
|
||||||
elif attr == "denominator":
|
|
||||||
idx = 1
|
|
||||||
else:
|
|
||||||
raise AttributeError
|
|
||||||
r = VInt(64)
|
|
||||||
if builder is not None:
|
|
||||||
elt = builder.extract_value(self.auto_load(builder), idx)
|
|
||||||
r.auto_store(builder, elt)
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_bool(self, builder):
|
|
||||||
r = VBool()
|
|
||||||
if builder is not None:
|
|
||||||
zero = ll.Constant(ll.IntType(64), 0)
|
|
||||||
a = builder.extract_element(self.auto_load(builder), 0)
|
|
||||||
r.auto_store(builder, builder.icmp_signed("!=", a, zero))
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_intx(self, target_bits, builder):
|
|
||||||
if builder is None:
|
|
||||||
return VInt(target_bits)
|
|
||||||
else:
|
|
||||||
r = VInt(64)
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
r.auto_store(builder, builder.sdiv(a, b))
|
|
||||||
return r.o_intx(target_bits, builder)
|
|
||||||
|
|
||||||
def o_roundx(self, target_bits, builder):
|
|
||||||
if builder is None:
|
|
||||||
return VInt(target_bits)
|
|
||||||
else:
|
|
||||||
r = VInt(64)
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
h_b = builder.ashr(b, ll.Constant(ll.IntType(64), 1))
|
|
||||||
|
|
||||||
function = builder.basic_block.function
|
|
||||||
add_block = function.append_basic_block("fr_add")
|
|
||||||
sub_block = function.append_basic_block("fr_sub")
|
|
||||||
merge_block = function.append_basic_block("fr_merge")
|
|
||||||
|
|
||||||
condition = builder.icmp_signed(
|
|
||||||
"<", a, ll.Constant(ll.IntType(64), 0))
|
|
||||||
builder.cbranch(condition, sub_block, add_block)
|
|
||||||
|
|
||||||
builder.position_at_end(add_block)
|
|
||||||
a_add = builder.add(a, h_b)
|
|
||||||
builder.branch(merge_block)
|
|
||||||
builder.position_at_end(sub_block)
|
|
||||||
a_sub = builder.sub(a, h_b)
|
|
||||||
builder.branch(merge_block)
|
|
||||||
|
|
||||||
builder.position_at_end(merge_block)
|
|
||||||
a = builder.phi(ll.IntType(64))
|
|
||||||
a.add_incoming(a_add, add_block)
|
|
||||||
a.add_incoming(a_sub, sub_block)
|
|
||||||
r.auto_store(builder, builder.sdiv(a, b))
|
|
||||||
return r.o_intx(target_bits, builder)
|
|
||||||
|
|
||||||
def o_float(self, builder):
|
|
||||||
r = VFloat()
|
|
||||||
if builder is not None:
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
af = builder.sitofp(a, r.get_llvm_type())
|
|
||||||
bf = builder.sitofp(b, r.get_llvm_type())
|
|
||||||
r.auto_store(builder, builder.fdiv(af, bf))
|
|
||||||
return r
|
|
||||||
|
|
||||||
def _o_eq_inv(self, other, builder, ne):
|
|
||||||
if not isinstance(other, (VInt, VFraction)):
|
|
||||||
return NotImplemented
|
|
||||||
r = VBool()
|
|
||||||
if builder is not None:
|
|
||||||
if isinstance(other, VInt):
|
|
||||||
other = other.o_int64(builder)
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
ssa_r = builder.and_(
|
|
||||||
builder.icmp_signed("==", a,
|
|
||||||
other.auto_load()),
|
|
||||||
builder.icmp_signed("==", b,
|
|
||||||
ll.Constant(ll.IntType(64), 1)))
|
|
||||||
else:
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
c, d = other._nd(builder)
|
|
||||||
ssa_r = builder.and_(
|
|
||||||
builder.icmp_signed("==", a, c),
|
|
||||||
builder.icmp_signed("==", b, d))
|
|
||||||
if ne:
|
|
||||||
ssa_r = builder.xor(ssa_r,
|
|
||||||
ll.Constant(ll.IntType(1), 1))
|
|
||||||
r.auto_store(builder, ssa_r)
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_eq(self, other, builder):
|
|
||||||
return self._o_eq_inv(other, builder, False)
|
|
||||||
|
|
||||||
def o_ne(self, other, builder):
|
|
||||||
return self._o_eq_inv(other, builder, True)
|
|
||||||
|
|
||||||
def _o_cmp(self, other, icmp, builder):
|
|
||||||
diff = self.o_sub(other, builder)
|
|
||||||
if diff is NotImplemented:
|
|
||||||
return NotImplemented
|
|
||||||
r = VBool()
|
|
||||||
if builder is not None:
|
|
||||||
diff = diff.auto_load(builder)
|
|
||||||
a = builder.extract_value(diff, 0)
|
|
||||||
zero = ll.Constant(ll.IntType(64), 0)
|
|
||||||
ssa_r = builder.icmp_signed(icmp, a, zero)
|
|
||||||
r.auto_store(builder, ssa_r)
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_lt(self, other, builder):
|
|
||||||
return self._o_cmp(other, "<", builder)
|
|
||||||
|
|
||||||
def o_le(self, other, builder):
|
|
||||||
return self._o_cmp(other, "<=", builder)
|
|
||||||
|
|
||||||
def o_gt(self, other, builder):
|
|
||||||
return self._o_cmp(other, ">", builder)
|
|
||||||
|
|
||||||
def o_ge(self, other, builder):
|
|
||||||
return self._o_cmp(other, ">=", builder)
|
|
||||||
|
|
||||||
def _o_addsub(self, other, builder, sub, invert=False):
|
|
||||||
if isinstance(other, VFloat):
|
|
||||||
a = self.o_getattr("numerator", builder)
|
|
||||||
b = self.o_getattr("denominator", builder)
|
|
||||||
if sub:
|
|
||||||
if invert:
|
|
||||||
return operators.truediv(
|
|
||||||
operators.sub(operators.mul(other,
|
|
||||||
b,
|
|
||||||
builder),
|
|
||||||
a,
|
|
||||||
builder),
|
|
||||||
b,
|
|
||||||
builder)
|
|
||||||
else:
|
|
||||||
return operators.truediv(
|
|
||||||
operators.sub(a,
|
|
||||||
operators.mul(other,
|
|
||||||
b,
|
|
||||||
builder),
|
|
||||||
builder),
|
|
||||||
b,
|
|
||||||
builder)
|
|
||||||
else:
|
|
||||||
return operators.truediv(
|
|
||||||
operators.add(operators.mul(other,
|
|
||||||
b,
|
|
||||||
builder),
|
|
||||||
a,
|
|
||||||
builder),
|
|
||||||
b,
|
|
||||||
builder)
|
|
||||||
else:
|
|
||||||
if not isinstance(other, (VFraction, VInt)):
|
|
||||||
return NotImplemented
|
|
||||||
r = VFraction()
|
|
||||||
if builder is not None:
|
|
||||||
if isinstance(other, VInt):
|
|
||||||
i = other.o_int64(builder).auto_load(builder)
|
|
||||||
x, rd = self._nd(builder)
|
|
||||||
y = builder.mul(rd, i)
|
|
||||||
else:
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
c, d = other._nd(builder)
|
|
||||||
rd = builder.mul(b, d)
|
|
||||||
x = builder.mul(a, d)
|
|
||||||
y = builder.mul(c, b)
|
|
||||||
if sub:
|
|
||||||
if invert:
|
|
||||||
rn = builder.sub(y, x)
|
|
||||||
else:
|
|
||||||
rn = builder.sub(x, y)
|
|
||||||
else:
|
|
||||||
rn = builder.add(x, y)
|
|
||||||
rn, rd = _reduce(builder, rn, rd) # rd is already > 0
|
|
||||||
r.auto_store(builder, _make_ssa(builder, rn, rd))
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_add(self, other, builder):
|
|
||||||
return self._o_addsub(other, builder, False)
|
|
||||||
|
|
||||||
def o_sub(self, other, builder):
|
|
||||||
return self._o_addsub(other, builder, True)
|
|
||||||
|
|
||||||
def or_add(self, other, builder):
|
|
||||||
return self._o_addsub(other, builder, False)
|
|
||||||
|
|
||||||
def or_sub(self, other, builder):
|
|
||||||
return self._o_addsub(other, builder, True, True)
|
|
||||||
|
|
||||||
def _o_muldiv(self, other, builder, div, invert=False):
|
|
||||||
if isinstance(other, VFloat):
|
|
||||||
a = self.o_getattr("numerator", builder)
|
|
||||||
b = self.o_getattr("denominator", builder)
|
|
||||||
if invert:
|
|
||||||
a, b = b, a
|
|
||||||
if div:
|
|
||||||
return operators.truediv(a,
|
|
||||||
operators.mul(b, other, builder),
|
|
||||||
builder)
|
|
||||||
else:
|
|
||||||
return operators.truediv(operators.mul(a, other, builder),
|
|
||||||
b,
|
|
||||||
builder)
|
|
||||||
else:
|
|
||||||
if not isinstance(other, (VFraction, VInt)):
|
|
||||||
return NotImplemented
|
|
||||||
r = VFraction()
|
|
||||||
if builder is not None:
|
|
||||||
a, b = self._nd(builder)
|
|
||||||
if invert:
|
|
||||||
a, b = b, a
|
|
||||||
if isinstance(other, VInt):
|
|
||||||
i = other.o_int64(builder).auto_load(builder)
|
|
||||||
if div:
|
|
||||||
b = builder.mul(b, i)
|
|
||||||
else:
|
|
||||||
a = builder.mul(a, i)
|
|
||||||
else:
|
|
||||||
c, d = other._nd(builder)
|
|
||||||
if div:
|
|
||||||
a = builder.mul(a, d)
|
|
||||||
b = builder.mul(b, c)
|
|
||||||
else:
|
|
||||||
a = builder.mul(a, c)
|
|
||||||
b = builder.mul(b, d)
|
|
||||||
if div or invert:
|
|
||||||
a, b = _signnum(builder, a, b)
|
|
||||||
a, b = _reduce(builder, a, b)
|
|
||||||
r.auto_store(builder, _make_ssa(builder, a, b))
|
|
||||||
return r
|
|
||||||
|
|
||||||
def o_mul(self, other, builder):
|
|
||||||
return self._o_muldiv(other, builder, False)
|
|
||||||
|
|
||||||
def o_truediv(self, other, builder):
|
|
||||||
return self._o_muldiv(other, builder, True)
|
|
||||||
|
|
||||||
def or_mul(self, other, builder):
|
|
||||||
return self._o_muldiv(other, builder, False)
|
|
||||||
|
|
||||||
def or_truediv(self, other, builder):
|
|
||||||
# multiply by the inverse
|
|
||||||
return self._o_muldiv(other, builder, False, True)
|
|
||||||
|
|
||||||
def o_floordiv(self, other, builder):
|
|
||||||
r = self.o_truediv(other, builder)
|
|
||||||
if r is NotImplemented:
|
|
||||||
return r
|
|
||||||
else:
|
|
||||||
return r.o_int(builder)
|
|
||||||
|
|
||||||
def or_floordiv(self, other, builder):
|
|
||||||
r = self.or_truediv(other, builder)
|
|
||||||
if r is NotImplemented:
|
|
||||||
return r
|
|
||||||
else:
|
|
||||||
return r.o_int(builder)
|
|
||||||
|
|
@ -1,169 +0,0 @@
|
||||||
import unittest
|
|
||||||
from pythonparser import parse, ast
|
|
||||||
import inspect
|
|
||||||
from fractions import Fraction
|
|
||||||
from ctypes import CFUNCTYPE, c_int, c_int32, c_int64, c_double
|
|
||||||
import struct
|
|
||||||
|
|
||||||
import llvmlite_or1k.binding as llvm
|
|
||||||
|
|
||||||
from artiq.language.core import int64
|
|
||||||
from artiq.py2llvm.infer_types import infer_function_types
|
|
||||||
from artiq.py2llvm import base_types, lists
|
|
||||||
from artiq.py2llvm.module import Module
|
|
||||||
|
|
||||||
def simplify_encode(a, b):
|
|
||||||
f = Fraction(a, b)
|
|
||||||
return f.numerator*1000 + f.denominator
|
|
||||||
|
|
||||||
|
|
||||||
def frac_arith_encode(op, a, b, c, d):
|
|
||||||
if op == 0:
|
|
||||||
f = Fraction(a, b) - Fraction(c, d)
|
|
||||||
elif op == 1:
|
|
||||||
f = Fraction(a, b) + Fraction(c, d)
|
|
||||||
elif op == 2:
|
|
||||||
f = Fraction(a, b) * Fraction(c, d)
|
|
||||||
else:
|
|
||||||
f = Fraction(a, b) / Fraction(c, d)
|
|
||||||
return f.numerator*1000 + f.denominator
|
|
||||||
|
|
||||||
|
|
||||||
def frac_arith_encode_int(op, a, b, x):
|
|
||||||
if op == 0:
|
|
||||||
f = Fraction(a, b) - x
|
|
||||||
elif op == 1:
|
|
||||||
f = Fraction(a, b) + x
|
|
||||||
elif op == 2:
|
|
||||||
f = Fraction(a, b) * x
|
|
||||||
else:
|
|
||||||
f = Fraction(a, b) / x
|
|
||||||
return f.numerator*1000 + f.denominator
|
|
||||||
|
|
||||||
|
|
||||||
def frac_arith_encode_int_rev(op, a, b, x):
|
|
||||||
if op == 0:
|
|
||||||
f = x - Fraction(a, b)
|
|
||||||
elif op == 1:
|
|
||||||
f = x + Fraction(a, b)
|
|
||||||
elif op == 2:
|
|
||||||
f = x * Fraction(a, b)
|
|
||||||
else:
|
|
||||||
f = x / Fraction(a, b)
|
|
||||||
return f.numerator*1000 + f.denominator
|
|
||||||
|
|
||||||
|
|
||||||
def frac_arith_float(op, a, b, x):
|
|
||||||
if op == 0:
|
|
||||||
return Fraction(a, b) - x
|
|
||||||
elif op == 1:
|
|
||||||
return Fraction(a, b) + x
|
|
||||||
elif op == 2:
|
|
||||||
return Fraction(a, b) * x
|
|
||||||
else:
|
|
||||||
return Fraction(a, b) / x
|
|
||||||
|
|
||||||
|
|
||||||
def frac_arith_float_rev(op, a, b, x):
|
|
||||||
if op == 0:
|
|
||||||
return x - Fraction(a, b)
|
|
||||||
elif op == 1:
|
|
||||||
return x + Fraction(a, b)
|
|
||||||
elif op == 2:
|
|
||||||
return x * Fraction(a, b)
|
|
||||||
else:
|
|
||||||
return x / Fraction(a, b)
|
|
||||||
|
|
||||||
|
|
||||||
class CodeGenCase(unittest.TestCase):
|
|
||||||
def test_frac_simplify(self):
|
|
||||||
simplify_encode_c = CompiledFunction(
|
|
||||||
simplify_encode, {"a": base_types.VInt(), "b": base_types.VInt()})
|
|
||||||
for a in _test_range():
|
|
||||||
for b in _test_range():
|
|
||||||
self.assertEqual(
|
|
||||||
simplify_encode_c(a, b), simplify_encode(a, b))
|
|
||||||
|
|
||||||
def _test_frac_arith(self, op):
|
|
||||||
frac_arith_encode_c = CompiledFunction(
|
|
||||||
frac_arith_encode, {
|
|
||||||
"op": base_types.VInt(),
|
|
||||||
"a": base_types.VInt(), "b": base_types.VInt(),
|
|
||||||
"c": base_types.VInt(), "d": base_types.VInt()})
|
|
||||||
for a in _test_range():
|
|
||||||
for b in _test_range():
|
|
||||||
for c in _test_range():
|
|
||||||
for d in _test_range():
|
|
||||||
self.assertEqual(
|
|
||||||
frac_arith_encode_c(op, a, b, c, d),
|
|
||||||
frac_arith_encode(op, a, b, c, d))
|
|
||||||
|
|
||||||
def test_frac_add(self):
|
|
||||||
self._test_frac_arith(0)
|
|
||||||
|
|
||||||
def test_frac_sub(self):
|
|
||||||
self._test_frac_arith(1)
|
|
||||||
|
|
||||||
def test_frac_mul(self):
|
|
||||||
self._test_frac_arith(2)
|
|
||||||
|
|
||||||
def test_frac_div(self):
|
|
||||||
self._test_frac_arith(3)
|
|
||||||
|
|
||||||
def _test_frac_arith_int(self, op, rev):
|
|
||||||
f = frac_arith_encode_int_rev if rev else frac_arith_encode_int
|
|
||||||
f_c = CompiledFunction(f, {
|
|
||||||
"op": base_types.VInt(),
|
|
||||||
"a": base_types.VInt(), "b": base_types.VInt(),
|
|
||||||
"x": base_types.VInt()})
|
|
||||||
for a in _test_range():
|
|
||||||
for b in _test_range():
|
|
||||||
for x in _test_range():
|
|
||||||
self.assertEqual(
|
|
||||||
f_c(op, a, b, x),
|
|
||||||
f(op, a, b, x))
|
|
||||||
|
|
||||||
def test_frac_add_int(self):
|
|
||||||
self._test_frac_arith_int(0, False)
|
|
||||||
self._test_frac_arith_int(0, True)
|
|
||||||
|
|
||||||
def test_frac_sub_int(self):
|
|
||||||
self._test_frac_arith_int(1, False)
|
|
||||||
self._test_frac_arith_int(1, True)
|
|
||||||
|
|
||||||
def test_frac_mul_int(self):
|
|
||||||
self._test_frac_arith_int(2, False)
|
|
||||||
self._test_frac_arith_int(2, True)
|
|
||||||
|
|
||||||
def test_frac_div_int(self):
|
|
||||||
self._test_frac_arith_int(3, False)
|
|
||||||
self._test_frac_arith_int(3, True)
|
|
||||||
|
|
||||||
def _test_frac_arith_float(self, op, rev):
|
|
||||||
f = frac_arith_float_rev if rev else frac_arith_float
|
|
||||||
f_c = CompiledFunction(f, {
|
|
||||||
"op": base_types.VInt(),
|
|
||||||
"a": base_types.VInt(), "b": base_types.VInt(),
|
|
||||||
"x": base_types.VFloat()})
|
|
||||||
for a in _test_range():
|
|
||||||
for b in _test_range():
|
|
||||||
for x in _test_range():
|
|
||||||
self.assertAlmostEqual(
|
|
||||||
f_c(op, a, b, x/2),
|
|
||||||
f(op, a, b, x/2))
|
|
||||||
|
|
||||||
def test_frac_add_float(self):
|
|
||||||
self._test_frac_arith_float(0, False)
|
|
||||||
self._test_frac_arith_float(0, True)
|
|
||||||
|
|
||||||
def test_frac_sub_float(self):
|
|
||||||
self._test_frac_arith_float(1, False)
|
|
||||||
self._test_frac_arith_float(1, True)
|
|
||||||
|
|
||||||
def test_frac_mul_float(self):
|
|
||||||
self._test_frac_arith_float(2, False)
|
|
||||||
self._test_frac_arith_float(2, True)
|
|
||||||
|
|
||||||
def test_frac_div_float(self):
|
|
||||||
self._test_frac_arith_float(3, False)
|
|
||||||
self._test_frac_arith_float(3, True)
|
|
||||||
|
|
@ -1,548 +0,0 @@
|
||||||
import inspect
|
|
||||||
import textwrap
|
|
||||||
import ast
|
|
||||||
import types
|
|
||||||
import builtins
|
|
||||||
from fractions import Fraction
|
|
||||||
from collections import OrderedDict
|
|
||||||
from functools import partial
|
|
||||||
from itertools import zip_longest, chain
|
|
||||||
|
|
||||||
from artiq.language import core as core_language
|
|
||||||
from artiq.language import units
|
|
||||||
from artiq.transforms.tools import *
|
|
||||||
|
|
||||||
|
|
||||||
def new_mangled_name(in_use_names, name):
|
|
||||||
mangled_name = name
|
|
||||||
i = 2
|
|
||||||
while mangled_name in in_use_names:
|
|
||||||
mangled_name = name + str(i)
|
|
||||||
i += 1
|
|
||||||
in_use_names.add(mangled_name)
|
|
||||||
return mangled_name
|
|
||||||
|
|
||||||
|
|
||||||
class MangledName:
|
|
||||||
def __init__(self, s):
|
|
||||||
self.s = s
|
|
||||||
|
|
||||||
|
|
||||||
class AttributeInfo:
|
|
||||||
def __init__(self, obj, mangled_name, read_write):
|
|
||||||
self.obj = obj
|
|
||||||
self.mangled_name = mangled_name
|
|
||||||
self.read_write = read_write
|
|
||||||
|
|
||||||
|
|
||||||
def is_inlinable(core, func):
|
|
||||||
if hasattr(func, "k_function_info"):
|
|
||||||
if func.k_function_info.core_name == "":
|
|
||||||
return True # portable function
|
|
||||||
if getattr(func.__self__, func.k_function_info.core_name) is core:
|
|
||||||
return True # kernel function for the same core device
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
class GlobalNamespace:
|
|
||||||
def __init__(self, func):
|
|
||||||
self.func_gd = inspect.getmodule(func).__dict__
|
|
||||||
|
|
||||||
def __getitem__(self, item):
|
|
||||||
try:
|
|
||||||
return self.func_gd[item]
|
|
||||||
except KeyError:
|
|
||||||
return getattr(builtins, item)
|
|
||||||
|
|
||||||
|
|
||||||
class UndefinedArg:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
def get_function_args(func_args, func_tr, args, kwargs):
|
|
||||||
# OrderedDict prevents non-determinism in argument init
|
|
||||||
r = OrderedDict()
|
|
||||||
|
|
||||||
# Process positional arguments. Any missing positional argument values
|
|
||||||
# are set to UndefinedArg.
|
|
||||||
for arg, arg_value in zip_longest(func_args.args, args,
|
|
||||||
fillvalue=UndefinedArg):
|
|
||||||
if arg is UndefinedArg:
|
|
||||||
raise TypeError("Got too many positional arguments")
|
|
||||||
if arg.arg in r:
|
|
||||||
raise SyntaxError("Duplicate argument '{}' in function definition"
|
|
||||||
.format(arg.arg))
|
|
||||||
r[arg.arg] = arg_value
|
|
||||||
|
|
||||||
# Process keyword arguments. Any missing keyword-only argument values
|
|
||||||
# are set to UndefinedArg.
|
|
||||||
valid_arg_names = {arg.arg for arg in
|
|
||||||
chain(func_args.args, func_args.kwonlyargs)}
|
|
||||||
for arg in func_args.kwonlyargs:
|
|
||||||
if arg.arg in r:
|
|
||||||
raise SyntaxError("Duplicate argument '{}' in function definition"
|
|
||||||
.format(arg.arg))
|
|
||||||
r[arg.arg] = UndefinedArg
|
|
||||||
for arg_name, arg_value in kwargs.items():
|
|
||||||
if arg_name not in valid_arg_names:
|
|
||||||
raise TypeError("Got unexpected keyword argument '{}'"
|
|
||||||
.format(arg_name))
|
|
||||||
if r[arg_name] is not UndefinedArg:
|
|
||||||
raise TypeError("Got multiple values for argument '{}'"
|
|
||||||
.format(arg_name))
|
|
||||||
r[arg_name] = arg_value
|
|
||||||
|
|
||||||
# Replace any UndefinedArg positional arguments with the default value,
|
|
||||||
# when provided.
|
|
||||||
for arg, default in zip(func_args.args[-len(func_args.defaults):],
|
|
||||||
func_args.defaults):
|
|
||||||
if r[arg.arg] is UndefinedArg:
|
|
||||||
r[arg.arg] = func_tr.code_visit(default)
|
|
||||||
# Same with keyword-only arguments.
|
|
||||||
for arg, default in zip(func_args.kwonlyargs, func_args.kw_defaults):
|
|
||||||
if default is not None and r[arg.arg] is UndefinedArg:
|
|
||||||
r[arg.arg] = func_tr.code_visit(default)
|
|
||||||
|
|
||||||
# Check that no argument was left undefined.
|
|
||||||
missing_arguments = ["'"+arg+"'" for arg, value in r.items()
|
|
||||||
if value is UndefinedArg]
|
|
||||||
if missing_arguments:
|
|
||||||
raise TypeError("Missing argument(s): " + " ".join(missing_arguments))
|
|
||||||
|
|
||||||
return r
|
|
||||||
|
|
||||||
|
|
||||||
# args/kwargs can contain values or AST nodes
|
|
||||||
def get_inline(core, attribute_namespace, in_use_names, retval_name, mappers,
|
|
||||||
func, args, kwargs):
|
|
||||||
global_namespace = GlobalNamespace(func)
|
|
||||||
func_tr = Function(core,
|
|
||||||
global_namespace, attribute_namespace, in_use_names,
|
|
||||||
retval_name, mappers)
|
|
||||||
func_def = ast.parse(textwrap.dedent(inspect.getsource(func))).body[0]
|
|
||||||
|
|
||||||
# Initialize arguments.
|
|
||||||
# The local namespace is empty so code_visit will always resolve
|
|
||||||
# using the global namespace.
|
|
||||||
arg_init = []
|
|
||||||
arg_name_map = []
|
|
||||||
arg_dict = get_function_args(func_def.args, func_tr, args, kwargs)
|
|
||||||
for arg_name, arg_value in arg_dict.items():
|
|
||||||
if isinstance(arg_value, ast.AST):
|
|
||||||
value = arg_value
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
value = ast.copy_location(value_to_ast(arg_value), func_def)
|
|
||||||
except NotASTRepresentable:
|
|
||||||
value = None
|
|
||||||
if value is None:
|
|
||||||
# static object
|
|
||||||
func_tr.local_namespace[arg_name] = arg_value
|
|
||||||
else:
|
|
||||||
# set parameter value with "name = value"
|
|
||||||
# assignment at beginning of function
|
|
||||||
new_name = new_mangled_name(in_use_names, arg_name)
|
|
||||||
arg_name_map.append((arg_name, new_name))
|
|
||||||
target = ast.copy_location(ast.Name(new_name, ast.Store()),
|
|
||||||
func_def)
|
|
||||||
assign = ast.copy_location(ast.Assign([target], value),
|
|
||||||
func_def)
|
|
||||||
arg_init.append(assign)
|
|
||||||
# Commit arguments to the local namespace at the end to handle cases
|
|
||||||
# such as f(x, y=x) (for the default value of y, x must be resolved
|
|
||||||
# using the global namespace).
|
|
||||||
for arg_name, mangled_name in arg_name_map:
|
|
||||||
func_tr.local_namespace[arg_name] = MangledName(mangled_name)
|
|
||||||
|
|
||||||
func_def = func_tr.code_visit(func_def)
|
|
||||||
func_def.body[0:0] = arg_init
|
|
||||||
return func_def
|
|
||||||
|
|
||||||
|
|
||||||
class Function:
|
|
||||||
def __init__(self, core,
|
|
||||||
global_namespace, attribute_namespace, in_use_names,
|
|
||||||
retval_name, mappers):
|
|
||||||
# The core device on which this function is executing.
|
|
||||||
self.core = core
|
|
||||||
|
|
||||||
# Local and global namespaces:
|
|
||||||
# original name -> MangledName or static object
|
|
||||||
self.local_namespace = dict()
|
|
||||||
self.global_namespace = global_namespace
|
|
||||||
|
|
||||||
# (id(static object), attribute) -> AttributeInfo
|
|
||||||
self.attribute_namespace = attribute_namespace
|
|
||||||
|
|
||||||
# All names currently in use, in the namespace of the combined
|
|
||||||
# function.
|
|
||||||
# When creating a name for a new object, check that it is not
|
|
||||||
# already in this set.
|
|
||||||
self.in_use_names = in_use_names
|
|
||||||
|
|
||||||
# Name of the variable to store the return value to, or None
|
|
||||||
# to keep the return statement.
|
|
||||||
self.retval_name = retval_name
|
|
||||||
|
|
||||||
# Host object mappers, for RPC and exception numbers
|
|
||||||
self.mappers = mappers
|
|
||||||
|
|
||||||
self._insertion_point = None
|
|
||||||
|
|
||||||
# This is ast.NodeVisitor/NodeTransformer from CPython, modified
|
|
||||||
# to add code_ prefix.
|
|
||||||
def code_visit(self, node):
|
|
||||||
method = "code_visit_" + node.__class__.__name__
|
|
||||||
visitor = getattr(self, method, self.code_generic_visit)
|
|
||||||
return visitor(node)
|
|
||||||
|
|
||||||
# This is ast.NodeTransformer.generic_visit from CPython, modified
|
|
||||||
# to update self._insertion_point.
|
|
||||||
def code_generic_visit(self, node, exclude_fields=set()):
|
|
||||||
for field, old_value in ast.iter_fields(node):
|
|
||||||
if field in exclude_fields:
|
|
||||||
continue
|
|
||||||
old_value = getattr(node, field, None)
|
|
||||||
if isinstance(old_value, list):
|
|
||||||
prev_insertion_point = self._insertion_point
|
|
||||||
new_values = []
|
|
||||||
if field in ("body", "orelse", "finalbody"):
|
|
||||||
self._insertion_point = new_values
|
|
||||||
for value in old_value:
|
|
||||||
if isinstance(value, ast.AST):
|
|
||||||
value = self.code_visit(value)
|
|
||||||
if value is None:
|
|
||||||
continue
|
|
||||||
elif not isinstance(value, ast.AST):
|
|
||||||
new_values.extend(value)
|
|
||||||
continue
|
|
||||||
new_values.append(value)
|
|
||||||
old_value[:] = new_values
|
|
||||||
self._insertion_point = prev_insertion_point
|
|
||||||
elif isinstance(old_value, ast.AST):
|
|
||||||
new_node = self.code_visit(old_value)
|
|
||||||
if new_node is None:
|
|
||||||
delattr(node, field)
|
|
||||||
else:
|
|
||||||
setattr(node, field, new_node)
|
|
||||||
return node
|
|
||||||
|
|
||||||
def code_visit_Name(self, node):
|
|
||||||
if isinstance(node.ctx, ast.Store):
|
|
||||||
if (node.id in self.local_namespace
|
|
||||||
and isinstance(self.local_namespace[node.id],
|
|
||||||
MangledName)):
|
|
||||||
new_name = self.local_namespace[node.id].s
|
|
||||||
else:
|
|
||||||
new_name = new_mangled_name(self.in_use_names, node.id)
|
|
||||||
self.local_namespace[node.id] = MangledName(new_name)
|
|
||||||
node.id = new_name
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
obj = self.local_namespace[node.id]
|
|
||||||
except KeyError:
|
|
||||||
try:
|
|
||||||
obj = self.global_namespace[node.id]
|
|
||||||
except KeyError:
|
|
||||||
raise NameError("name '{}' is not defined".format(node.id))
|
|
||||||
if isinstance(obj, MangledName):
|
|
||||||
node.id = obj.s
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
return value_to_ast(obj)
|
|
||||||
except NotASTRepresentable:
|
|
||||||
raise NotImplementedError(
|
|
||||||
"Static object cannot be used here")
|
|
||||||
|
|
||||||
def code_visit_Attribute(self, node):
|
|
||||||
# There are two cases of attributes:
|
|
||||||
# 1. static object attributes, e.g. self.foo
|
|
||||||
# 2. dynamic expression attributes, e.g.
|
|
||||||
# (Fraction(1, 2) + x).numerator
|
|
||||||
# Static object resolution has no side effects so we try it first.
|
|
||||||
try:
|
|
||||||
obj = self.static_visit(node.value)
|
|
||||||
except:
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
key = (id(obj), node.attr)
|
|
||||||
try:
|
|
||||||
attr_info = self.attribute_namespace[key]
|
|
||||||
except KeyError:
|
|
||||||
new_name = new_mangled_name(self.in_use_names, node.attr)
|
|
||||||
attr_info = AttributeInfo(obj, new_name, False)
|
|
||||||
self.attribute_namespace[key] = attr_info
|
|
||||||
if isinstance(node.ctx, ast.Store):
|
|
||||||
attr_info.read_write = True
|
|
||||||
return ast.copy_location(
|
|
||||||
ast.Name(attr_info.mangled_name, node.ctx),
|
|
||||||
node)
|
|
||||||
|
|
||||||
def code_visit_Call(self, node):
|
|
||||||
func = self.static_visit(node.func)
|
|
||||||
node.args = [self.code_visit(arg) for arg in node.args]
|
|
||||||
for kw in node.keywords:
|
|
||||||
kw.value = self.code_visit(kw.value)
|
|
||||||
|
|
||||||
if is_embeddable(func):
|
|
||||||
node.func = ast.copy_location(
|
|
||||||
ast.Name(func.__name__, ast.Load()),
|
|
||||||
node)
|
|
||||||
return node
|
|
||||||
elif is_inlinable(self.core, func):
|
|
||||||
retval_name = func.k_function_info.k_function.__name__ + "_return"
|
|
||||||
retval_name_m = new_mangled_name(self.in_use_names, retval_name)
|
|
||||||
args = [func.__self__] + node.args
|
|
||||||
kwargs = {kw.arg: kw.value for kw in node.keywords}
|
|
||||||
inlined = get_inline(self.core,
|
|
||||||
self.attribute_namespace, self.in_use_names,
|
|
||||||
retval_name_m, self.mappers,
|
|
||||||
func.k_function_info.k_function,
|
|
||||||
args, kwargs)
|
|
||||||
seq = ast.copy_location(
|
|
||||||
ast.With(
|
|
||||||
items=[ast.withitem(context_expr=ast.Name(id="sequential",
|
|
||||||
ctx=ast.Load()),
|
|
||||||
optional_vars=None)],
|
|
||||||
body=inlined.body),
|
|
||||||
node)
|
|
||||||
self._insertion_point.append(seq)
|
|
||||||
return ast.copy_location(ast.Name(retval_name_m, ast.Load()),
|
|
||||||
node)
|
|
||||||
else:
|
|
||||||
arg1 = ast.copy_location(ast.Str("rpc"), node)
|
|
||||||
arg2 = ast.copy_location(
|
|
||||||
value_to_ast(self.mappers.rpc.encode(func)), node)
|
|
||||||
node.args[0:0] = [arg1, arg2]
|
|
||||||
node.func = ast.copy_location(
|
|
||||||
ast.Name("syscall", ast.Load()), node)
|
|
||||||
return node
|
|
||||||
|
|
||||||
def code_visit_Return(self, node):
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
if self.retval_name is None:
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
return ast.copy_location(
|
|
||||||
ast.Assign(targets=[ast.Name(self.retval_name, ast.Store())],
|
|
||||||
value=node.value),
|
|
||||||
node)
|
|
||||||
|
|
||||||
def code_visit_Expr(self, node):
|
|
||||||
if isinstance(node.value, ast.Str):
|
|
||||||
# Strip docstrings. This also removes strings appearing in the
|
|
||||||
# middle of the code, but they are nops.
|
|
||||||
return None
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
if isinstance(node.value, ast.Name):
|
|
||||||
# Remove Expr nodes that contain only a name, likely due to
|
|
||||||
# function call inlining. Such nodes that were originally in the
|
|
||||||
# code are also removed, but this does not affect the semantics of
|
|
||||||
# the code as they are nops.
|
|
||||||
return None
|
|
||||||
else:
|
|
||||||
return node
|
|
||||||
|
|
||||||
def encode_exception(self, e):
|
|
||||||
exception_class = self.static_visit(e)
|
|
||||||
if not inspect.isclass(exception_class):
|
|
||||||
raise NotImplementedError("Exception type must be a class")
|
|
||||||
if issubclass(exception_class, core_language.RuntimeException):
|
|
||||||
exception_id = exception_class.eid
|
|
||||||
else:
|
|
||||||
exception_id = self.mappers.exception.encode(exception_class)
|
|
||||||
return ast.copy_location(
|
|
||||||
ast.Call(func=ast.Name("EncodedException", ast.Load()),
|
|
||||||
args=[value_to_ast(exception_id)], keywords=[]),
|
|
||||||
e)
|
|
||||||
|
|
||||||
def code_visit_Raise(self, node):
|
|
||||||
if node.cause is not None:
|
|
||||||
raise NotImplementedError("Exception causes are not supported")
|
|
||||||
if node.exc is not None:
|
|
||||||
node.exc = self.encode_exception(node.exc)
|
|
||||||
return node
|
|
||||||
|
|
||||||
def code_visit_ExceptHandler(self, node):
|
|
||||||
if node.name is not None:
|
|
||||||
raise NotImplementedError("'as target' is not supported")
|
|
||||||
if node.type is not None:
|
|
||||||
if isinstance(node.type, ast.Tuple):
|
|
||||||
node.type.elts = [self.encode_exception(e)
|
|
||||||
for e in node.type.elts]
|
|
||||||
else:
|
|
||||||
node.type = self.encode_exception(node.type)
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
return node
|
|
||||||
|
|
||||||
def get_user_ctxm(self, context_expr):
|
|
||||||
try:
|
|
||||||
ctxm = self.static_visit(context_expr)
|
|
||||||
except:
|
|
||||||
# this also catches watchdog()
|
|
||||||
return None
|
|
||||||
else:
|
|
||||||
if (ctxm is core_language.sequential
|
|
||||||
or ctxm is core_language.parallel):
|
|
||||||
return None
|
|
||||||
return ctxm
|
|
||||||
|
|
||||||
def code_visit_With(self, node):
|
|
||||||
if len(node.items) != 1:
|
|
||||||
raise NotImplementedError
|
|
||||||
item = node.items[0]
|
|
||||||
if item.optional_vars is not None:
|
|
||||||
raise NotImplementedError
|
|
||||||
ctxm = self.get_user_ctxm(item.context_expr)
|
|
||||||
if ctxm is None:
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
return node
|
|
||||||
|
|
||||||
# user context manager
|
|
||||||
self.code_generic_visit(node, {"items"})
|
|
||||||
if (not hasattr(ctxm, "__enter__")
|
|
||||||
or not hasattr(ctxm.__enter__, "k_function_info")):
|
|
||||||
raise NotImplementedError
|
|
||||||
enter = get_inline(self.core,
|
|
||||||
self.attribute_namespace, self.in_use_names,
|
|
||||||
None, self.mappers,
|
|
||||||
ctxm.__enter__.k_function_info.k_function,
|
|
||||||
[ctxm], dict())
|
|
||||||
if (not hasattr(ctxm, "__exit__")
|
|
||||||
or not hasattr(ctxm.__exit__, "k_function_info")):
|
|
||||||
raise NotImplementedError
|
|
||||||
exit = get_inline(self.core,
|
|
||||||
self.attribute_namespace, self.in_use_names,
|
|
||||||
None, self.mappers,
|
|
||||||
ctxm.__exit__.k_function_info.k_function,
|
|
||||||
[ctxm, None, None, None], dict())
|
|
||||||
try_stmt = ast.copy_location(
|
|
||||||
ast.Try(body=node.body,
|
|
||||||
handlers=[],
|
|
||||||
orelse=[],
|
|
||||||
finalbody=exit.body), node)
|
|
||||||
return ast.copy_location(
|
|
||||||
ast.With(
|
|
||||||
items=[ast.withitem(context_expr=ast.Name(id="sequential",
|
|
||||||
ctx=ast.Load()),
|
|
||||||
optional_vars=None)],
|
|
||||||
body=enter.body + [try_stmt]),
|
|
||||||
node)
|
|
||||||
|
|
||||||
def code_visit_FunctionDef(self, node):
|
|
||||||
node.args = ast.arguments(args=[], vararg=None, kwonlyargs=[],
|
|
||||||
kw_defaults=[], kwarg=None, defaults=[])
|
|
||||||
node.decorator_list = []
|
|
||||||
self.code_generic_visit(node)
|
|
||||||
return node
|
|
||||||
|
|
||||||
def static_visit(self, node):
|
|
||||||
method = "static_visit_" + node.__class__.__name__
|
|
||||||
visitor = getattr(self, method)
|
|
||||||
return visitor(node)
|
|
||||||
|
|
||||||
def static_visit_Name(self, node):
|
|
||||||
try:
|
|
||||||
obj = self.local_namespace[node.id]
|
|
||||||
except KeyError:
|
|
||||||
try:
|
|
||||||
obj = self.global_namespace[node.id]
|
|
||||||
except KeyError:
|
|
||||||
raise NameError("name '{}' is not defined".format(node.id))
|
|
||||||
if isinstance(obj, MangledName):
|
|
||||||
raise NotImplementedError(
|
|
||||||
"Only a static object can be used here")
|
|
||||||
return obj
|
|
||||||
|
|
||||||
def static_visit_Attribute(self, node):
|
|
||||||
value = self.static_visit(node.value)
|
|
||||||
return getattr(value, node.attr)
|
|
||||||
|
|
||||||
|
|
||||||
class HostObjectMapper:
|
|
||||||
def __init__(self, first_encoding=0):
|
|
||||||
self._next_encoding = first_encoding
|
|
||||||
# id(object) -> (encoding, object)
|
|
||||||
# this format is required to support non-hashable host objects.
|
|
||||||
self._d = dict()
|
|
||||||
|
|
||||||
def encode(self, obj):
|
|
||||||
try:
|
|
||||||
return self._d[id(obj)][0]
|
|
||||||
except KeyError:
|
|
||||||
encoding = self._next_encoding
|
|
||||||
self._d[id(obj)] = (encoding, obj)
|
|
||||||
self._next_encoding += 1
|
|
||||||
return encoding
|
|
||||||
|
|
||||||
def get_map(self):
|
|
||||||
return {encoding: obj for i, (encoding, obj) in self._d.items()}
|
|
||||||
|
|
||||||
|
|
||||||
def get_attr_init(attribute_namespace, loc_node):
|
|
||||||
attr_init = []
|
|
||||||
for (_, attr), attr_info in attribute_namespace.items():
|
|
||||||
if hasattr(attr_info.obj, attr):
|
|
||||||
value = getattr(attr_info.obj, attr)
|
|
||||||
if (hasattr(value, "kernel_attr_init")
|
|
||||||
and not value.kernel_attr_init):
|
|
||||||
continue
|
|
||||||
value = ast.copy_location(value_to_ast(value), loc_node)
|
|
||||||
target = ast.copy_location(ast.Name(attr_info.mangled_name,
|
|
||||||
ast.Store()),
|
|
||||||
loc_node)
|
|
||||||
assign = ast.copy_location(ast.Assign([target], value),
|
|
||||||
loc_node)
|
|
||||||
attr_init.append(assign)
|
|
||||||
return attr_init
|
|
||||||
|
|
||||||
|
|
||||||
def get_attr_writeback(attribute_namespace, rpc_mapper, loc_node):
|
|
||||||
attr_writeback = []
|
|
||||||
for (_, attr), attr_info in attribute_namespace.items():
|
|
||||||
if attr_info.read_write:
|
|
||||||
setter = partial(setattr, attr_info.obj, attr)
|
|
||||||
func = ast.copy_location(
|
|
||||||
ast.Name("syscall", ast.Load()), loc_node)
|
|
||||||
arg1 = ast.copy_location(ast.Str("rpc"), loc_node)
|
|
||||||
arg2 = ast.copy_location(
|
|
||||||
value_to_ast(rpc_mapper.encode(setter)), loc_node)
|
|
||||||
arg3 = ast.copy_location(
|
|
||||||
ast.Name(attr_info.mangled_name, ast.Load()), loc_node)
|
|
||||||
call = ast.copy_location(
|
|
||||||
ast.Call(func=func, args=[arg1, arg2, arg3], keywords=[]),
|
|
||||||
loc_node)
|
|
||||||
expr = ast.copy_location(ast.Expr(call), loc_node)
|
|
||||||
attr_writeback.append(expr)
|
|
||||||
return attr_writeback
|
|
||||||
|
|
||||||
|
|
||||||
def inline(core, k_function, k_args, k_kwargs, with_attr_writeback):
|
|
||||||
# OrderedDict prevents non-determinism in attribute init
|
|
||||||
attribute_namespace = OrderedDict()
|
|
||||||
# NOTE: in_use_names will be mutated. Do not mutate embeddable_func_names!
|
|
||||||
in_use_names = embeddable_func_names | {"sequential", "parallel",
|
|
||||||
"watchdog"}
|
|
||||||
mappers = types.SimpleNamespace(
|
|
||||||
rpc=HostObjectMapper(),
|
|
||||||
exception=HostObjectMapper(core_language.first_user_eid)
|
|
||||||
)
|
|
||||||
func_def = get_inline(
|
|
||||||
core=core,
|
|
||||||
attribute_namespace=attribute_namespace,
|
|
||||||
in_use_names=in_use_names,
|
|
||||||
retval_name=None,
|
|
||||||
mappers=mappers,
|
|
||||||
func=k_function,
|
|
||||||
args=k_args,
|
|
||||||
kwargs=k_kwargs)
|
|
||||||
|
|
||||||
func_def.body[0:0] = get_attr_init(attribute_namespace, func_def)
|
|
||||||
if with_attr_writeback:
|
|
||||||
func_def.body += get_attr_writeback(attribute_namespace, mappers.rpc,
|
|
||||||
func_def)
|
|
||||||
|
|
||||||
return func_def, mappers.rpc.get_map(), mappers.exception.get_map()
|
|
||||||
|
|
@ -1,130 +0,0 @@
|
||||||
import ast
|
|
||||||
import types
|
|
||||||
|
|
||||||
from artiq.transforms.tools import *
|
|
||||||
|
|
||||||
|
|
||||||
# -1 statement duration could not be pre-determined
|
|
||||||
# 0 statement has no effect on timeline
|
|
||||||
# >0 statement is a static delay that advances the timeline
|
|
||||||
# by the given amount
|
|
||||||
def _get_duration(stmt):
|
|
||||||
if isinstance(stmt, (ast.Expr, ast.Assign)):
|
|
||||||
return _get_duration(stmt.value)
|
|
||||||
elif isinstance(stmt, ast.If):
|
|
||||||
if (all(_get_duration(s) == 0 for s in stmt.body)
|
|
||||||
and all(_get_duration(s) == 0 for s in stmt.orelse)):
|
|
||||||
return 0
|
|
||||||
else:
|
|
||||||
return -1
|
|
||||||
elif isinstance(stmt, ast.Try):
|
|
||||||
if (all(_get_duration(s) == 0 for s in stmt.body)
|
|
||||||
and all(_get_duration(s) == 0 for s in stmt.orelse)
|
|
||||||
and all(_get_duration(s) == 0 for s in stmt.finalbody)
|
|
||||||
and all(_get_duration(s) == 0 for s in handler.body
|
|
||||||
for handler in stmt.handlers)):
|
|
||||||
return 0
|
|
||||||
else:
|
|
||||||
return -1
|
|
||||||
elif isinstance(stmt, ast.Call):
|
|
||||||
name = stmt.func.id
|
|
||||||
assert(name != "delay")
|
|
||||||
if name == "delay_mu":
|
|
||||||
try:
|
|
||||||
da = eval_constant(stmt.args[0])
|
|
||||||
except NotConstant:
|
|
||||||
da = -1
|
|
||||||
return da
|
|
||||||
elif name == "at_mu":
|
|
||||||
return -1
|
|
||||||
else:
|
|
||||||
return 0
|
|
||||||
else:
|
|
||||||
return 0
|
|
||||||
|
|
||||||
|
|
||||||
def _interleave_timelines(timelines):
|
|
||||||
r = []
|
|
||||||
|
|
||||||
current_stmts = []
|
|
||||||
for stmts in timelines:
|
|
||||||
it = iter(stmts)
|
|
||||||
try:
|
|
||||||
stmt = next(it)
|
|
||||||
except StopIteration:
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
current_stmts.append(types.SimpleNamespace(
|
|
||||||
delay=_get_duration(stmt), stmt=stmt, it=it))
|
|
||||||
|
|
||||||
while current_stmts:
|
|
||||||
dt = min(stmt.delay for stmt in current_stmts)
|
|
||||||
if dt < 0:
|
|
||||||
# contains statement(s) with indeterminate duration
|
|
||||||
return None
|
|
||||||
if dt > 0:
|
|
||||||
# advance timeline by dt
|
|
||||||
for stmt in current_stmts:
|
|
||||||
stmt.delay -= dt
|
|
||||||
if stmt.delay == 0:
|
|
||||||
ref_stmt = stmt.stmt
|
|
||||||
delay_stmt = ast.copy_location(
|
|
||||||
ast.Expr(ast.Call(
|
|
||||||
func=ast.Name("delay_mu", ast.Load()),
|
|
||||||
args=[value_to_ast(dt)], keywords=[])),
|
|
||||||
ref_stmt)
|
|
||||||
r.append(delay_stmt)
|
|
||||||
else:
|
|
||||||
for stmt in current_stmts:
|
|
||||||
if stmt.delay == 0:
|
|
||||||
r.append(stmt.stmt)
|
|
||||||
# discard executed statements
|
|
||||||
exhausted_list = []
|
|
||||||
for stmt_i, stmt in enumerate(current_stmts):
|
|
||||||
if stmt.delay == 0:
|
|
||||||
try:
|
|
||||||
stmt.stmt = next(stmt.it)
|
|
||||||
except StopIteration:
|
|
||||||
exhausted_list.append(stmt_i)
|
|
||||||
else:
|
|
||||||
stmt.delay = _get_duration(stmt.stmt)
|
|
||||||
for offset, i in enumerate(exhausted_list):
|
|
||||||
current_stmts.pop(i-offset)
|
|
||||||
|
|
||||||
return r
|
|
||||||
|
|
||||||
|
|
||||||
def _interleave_stmts(stmts):
|
|
||||||
replacements = []
|
|
||||||
for stmt_i, stmt in enumerate(stmts):
|
|
||||||
if isinstance(stmt, (ast.For, ast.While, ast.If)):
|
|
||||||
_interleave_stmts(stmt.body)
|
|
||||||
_interleave_stmts(stmt.orelse)
|
|
||||||
elif isinstance(stmt, ast.Try):
|
|
||||||
_interleave_stmts(stmt.body)
|
|
||||||
_interleave_stmts(stmt.orelse)
|
|
||||||
_interleave_stmts(stmt.finalbody)
|
|
||||||
for handler in stmt.handlers:
|
|
||||||
_interleave_stmts(handler.body)
|
|
||||||
elif isinstance(stmt, ast.With):
|
|
||||||
btype = stmt.items[0].context_expr.id
|
|
||||||
if btype == "sequential":
|
|
||||||
_interleave_stmts(stmt.body)
|
|
||||||
replacements.append((stmt_i, stmt.body))
|
|
||||||
elif btype == "parallel":
|
|
||||||
timelines = [[s] for s in stmt.body]
|
|
||||||
for timeline in timelines:
|
|
||||||
_interleave_stmts(timeline)
|
|
||||||
merged = _interleave_timelines(timelines)
|
|
||||||
if merged is not None:
|
|
||||||
replacements.append((stmt_i, merged))
|
|
||||||
else:
|
|
||||||
raise ValueError("Unknown block type: " + btype)
|
|
||||||
offset = 0
|
|
||||||
for location, new_stmts in replacements:
|
|
||||||
stmts[offset+location:offset+location+1] = new_stmts
|
|
||||||
offset += len(new_stmts) - 1
|
|
||||||
|
|
||||||
|
|
||||||
def interleave(func_def):
|
|
||||||
_interleave_stmts(func_def.body)
|
|
||||||
|
|
@ -1,43 +0,0 @@
|
||||||
def visit_With(self, node):
|
|
||||||
self.generic_visit(node)
|
|
||||||
if (isinstance(node.items[0].context_expr, ast.Call)
|
|
||||||
and node.items[0].context_expr.func.id == "watchdog"):
|
|
||||||
|
|
||||||
idname = "__watchdog_id_" + str(self.watchdog_id_counter)
|
|
||||||
self.watchdog_id_counter += 1
|
|
||||||
|
|
||||||
time = ast.BinOp(left=node.items[0].context_expr.args[0],
|
|
||||||
op=ast.Mult(),
|
|
||||||
right=ast.Num(1000))
|
|
||||||
time_int = ast.Call(
|
|
||||||
func=ast.Name("round", ast.Load()),
|
|
||||||
args=[time],
|
|
||||||
keywords=[], starargs=None, kwargs=None)
|
|
||||||
syscall_set = ast.Call(
|
|
||||||
func=ast.Name("syscall", ast.Load()),
|
|
||||||
args=[ast.Str("watchdog_set"), time_int],
|
|
||||||
keywords=[], starargs=None, kwargs=None)
|
|
||||||
stmt_set = ast.copy_location(
|
|
||||||
ast.Assign(targets=[ast.Name(idname, ast.Store())],
|
|
||||||
value=syscall_set),
|
|
||||||
node)
|
|
||||||
|
|
||||||
syscall_clear = ast.Call(
|
|
||||||
func=ast.Name("syscall", ast.Load()),
|
|
||||||
args=[ast.Str("watchdog_clear"),
|
|
||||||
ast.Name(idname, ast.Load())],
|
|
||||||
keywords=[], starargs=None, kwargs=None)
|
|
||||||
stmt_clear = ast.copy_location(ast.Expr(syscall_clear), node)
|
|
||||||
|
|
||||||
node.items[0] = ast.withitem(
|
|
||||||
context_expr=ast.Name(id="sequential",
|
|
||||||
ctx=ast.Load()),
|
|
||||||
optional_vars=None)
|
|
||||||
node.body = [
|
|
||||||
stmt_set,
|
|
||||||
ast.Try(body=node.body,
|
|
||||||
handlers=[],
|
|
||||||
orelse=[],
|
|
||||||
finalbody=[stmt_clear])
|
|
||||||
]
|
|
||||||
return node
|
|
||||||
|
|
@ -1,82 +0,0 @@
|
||||||
import ast
|
|
||||||
from copy import deepcopy
|
|
||||||
|
|
||||||
from artiq.transforms.tools import eval_ast, value_to_ast
|
|
||||||
|
|
||||||
|
|
||||||
def _count_stmts(node):
|
|
||||||
if isinstance(node, list):
|
|
||||||
return sum(map(_count_stmts, node))
|
|
||||||
elif isinstance(node, ast.With):
|
|
||||||
return 1 + _count_stmts(node.body)
|
|
||||||
elif isinstance(node, (ast.For, ast.While, ast.If)):
|
|
||||||
return 1 + _count_stmts(node.body) + _count_stmts(node.orelse)
|
|
||||||
elif isinstance(node, ast.Try):
|
|
||||||
r = 1 + _count_stmts(node.body) \
|
|
||||||
+ _count_stmts(node.orelse) \
|
|
||||||
+ _count_stmts(node.finalbody)
|
|
||||||
for handler in node.handlers:
|
|
||||||
r += 1 + _count_stmts(handler.body)
|
|
||||||
return r
|
|
||||||
else:
|
|
||||||
return 1
|
|
||||||
|
|
||||||
|
|
||||||
def _loop_breakable(node):
|
|
||||||
if isinstance(node, list):
|
|
||||||
return any(map(_loop_breakable, node))
|
|
||||||
elif isinstance(node, (ast.Break, ast.Continue)):
|
|
||||||
return True
|
|
||||||
elif isinstance(node, ast.With):
|
|
||||||
return _loop_breakable(node.body)
|
|
||||||
elif isinstance(node, ast.If):
|
|
||||||
return _loop_breakable(node.body) or _loop_breakable(node.orelse)
|
|
||||||
elif isinstance(node, ast.Try):
|
|
||||||
if (_loop_breakable(node.body)
|
|
||||||
or _loop_breakable(node.orelse)
|
|
||||||
or _loop_breakable(node.finalbody)):
|
|
||||||
return True
|
|
||||||
for handler in node.handlers:
|
|
||||||
if _loop_breakable(handler.body):
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
else:
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
class _LoopUnroller(ast.NodeTransformer):
|
|
||||||
def __init__(self, limit):
|
|
||||||
self.limit = limit
|
|
||||||
|
|
||||||
def visit_For(self, node):
|
|
||||||
self.generic_visit(node)
|
|
||||||
try:
|
|
||||||
it = eval_ast(node.iter)
|
|
||||||
except:
|
|
||||||
return node
|
|
||||||
l_it = len(it)
|
|
||||||
if l_it:
|
|
||||||
if (not _loop_breakable(node.body)
|
|
||||||
and l_it*_count_stmts(node.body) < self.limit):
|
|
||||||
replacement = []
|
|
||||||
for i in it:
|
|
||||||
if not isinstance(i, int):
|
|
||||||
replacement = None
|
|
||||||
break
|
|
||||||
replacement.append(ast.copy_location(
|
|
||||||
ast.Assign(targets=[node.target],
|
|
||||||
value=value_to_ast(i)),
|
|
||||||
node))
|
|
||||||
replacement += deepcopy(node.body)
|
|
||||||
if replacement is not None:
|
|
||||||
return replacement
|
|
||||||
else:
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
return node
|
|
||||||
else:
|
|
||||||
return node.orelse
|
|
||||||
|
|
||||||
|
|
||||||
def unroll_loops(node, limit):
|
|
||||||
_LoopUnroller(limit).visit(node)
|
|
||||||
Loading…
Reference in New Issue