From 74cdafdde5fd199b343a6bb111f06f1071b3f7e8 Mon Sep 17 00:00:00 2001 From: Sebastien Bourdeauducq Date: Sun, 22 Jun 2014 18:52:37 +0200 Subject: [PATCH] compiler: interleave transform --- artiq/compiler/interleave.py | 115 ++++++++++++++++++++ artiq/compiler/transform.py | 203 ----------------------------------- artiq/devices/core.py | 2 + examples/compiler_test.py | 6 +- 4 files changed, 120 insertions(+), 206 deletions(-) create mode 100644 artiq/compiler/interleave.py delete mode 100644 artiq/compiler/transform.py diff --git a/artiq/compiler/interleave.py b/artiq/compiler/interleave.py new file mode 100644 index 000000000..eac041a14 --- /dev/null +++ b/artiq/compiler/interleave.py @@ -0,0 +1,115 @@ +import ast, types + +from artiq.language import units +from artiq.compiler.tools import eval_ast + +# -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 (in base_s_unit) +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.Call) and isinstance(stmt.func, ast.Name): + name = stmt.func.id + if name == "delay": + da = stmt.args[0] + if isinstance(da, ast.Call) \ + and isinstance(da.func, ast.Name) \ + and da.func.id == "Quantity" \ + and isinstance(da.args[0], ast.Num): + if not isinstance(da.args[1], ast.Name) or da.args[1].id != "base_s_unit": + raise units.DimensionError("Delay not expressed in seconds") + return da.args[0].n + else: + 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) + print("\n".join("{} -> {}".format(ast.dump(stmt.stmt), stmt.delay) for stmt in current_stmts)) + print("") + 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 + da_expr = ast.copy_location( + ast.Call(func=ast.Name("Quantity", ast.Load()), + args=[ast.Num(dt), ast.Name("base_s_unit", ast.Load())], + keywords=[], starargs=[], kwargs=[]), + ref_stmt) + delay_stmt = ast.copy_location( + ast.Expr(ast.Call(func=ast.Name("delay", ast.Load()), + args=[da_expr], + keywords=[], starargs=[], kwargs=[])), + 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): + replacements = [] + for stmt_i, stmt in enumerate(stmts): + if isinstance(stmt, (ast.For, ast.While, ast.If)): + interleave(stmt.body) + interleave(stmt.orelse) + elif isinstance(stmt, ast.With): + btype = stmt.items[0].context_expr.id + if btype == "sequential": + interleave(stmt.body) + replacements.append((stmt_i, stmt.body)) + elif btype == "parallel": + timelines = [[s] for s in stmt.body] + for timeline in timelines: + interleave(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 diff --git a/artiq/compiler/transform.py b/artiq/compiler/transform.py deleted file mode 100644 index 05010fbcd..000000000 --- a/artiq/compiler/transform.py +++ /dev/null @@ -1,203 +0,0 @@ -import inspect, textwrap, ast, types - -from artiq.language import units -from artiq.compiler import unparse -from artiq.compiler.tools import eval_ast - -def find_kernel_body(node): - while True: - if isinstance(node, ast.Module): - if len(node.body) != 1: - raise TypeError - node = node.body[0] - elif isinstance(node, ast.FunctionDef): - return node.body - else: - raise TypeError - -def _try_eval_with_units(node): - try: - r = eval_ast(node, units.__dict__) - except: - return node - if isinstance(r, units.Quantity): - return ast.copy_location(ast.Num(n=r.amount), node) - else: - return node - -def explicit_delays(stmts): - insertions = [] - for i, stmt in enumerate(stmts): - if isinstance(stmt, (ast.For, ast.While, ast.If)): - explicit_delays(stmt.body) - explicit_delays(stmt.orelse) - elif isinstance(stmt, ast.With): - explicit_delays(stmt.body) - elif isinstance(stmt, ast.Expr): - if not isinstance(stmt.value, ast.Call) or not isinstance(stmt.value.func, ast.Name): - continue - call = stmt.value - name = call.func.id - if name == "delay": - call.args[0] = _try_eval_with_units(call.args[0]) - elif name == "pulse": - call.func.id = "pulse_start" - insertions.append((i+1, ast.copy_location( - ast.Expr(ast.Call(func=ast.Name(id="delay", ctx=ast.Load()), - args=[_try_eval_with_units(call.args[2])], - keywords=[], starargs=[], kwargs=[])), - stmt))) - for i, (location, stmt) in enumerate(insertions): - stmts.insert(location+i, stmt) - -def _count_stmts(node): - if isinstance(node, (ast.For, ast.While, ast.If)): - print(ast.dump(node)) - return 1 + _count_stmts(node.body) + _count_stmts(node.orelse) - elif isinstance(node, ast.With): - return 1 + _count_stmts(node.body) - elif isinstance(node, list): - return sum(map(_count_stmts, node)) - else: - return 1 - -def unroll_loops(stmts, limit): - replacements = [] - for stmt_i, stmt in enumerate(stmts): - if isinstance(stmt, ast.For): - try: - it = eval_ast(stmt.iter) - except: - pass - else: - unroll_loops(stmt.body, limit) - unroll_loops(stmt.orelse, limit) - l_it = len(it) - if l_it: - n = l_it*_count_stmts(stmt.body) - if n < limit: - replacement = [] - for i in it: - if not isinstance(i, int): - replacement = None - break - replacement.append(ast.copy_location( - ast.Assign(targets=[stmt.target], value=ast.Num(n=i)), stmt)) - replacement += stmt.body - if replacement is not None: - replacements.append((stmt_i, replacement)) - else: - replacements.append((stmt_i, stmt.orelse)) - if isinstance(stmt, (ast.While, ast.If)): - unroll_loops(stmt.body, limit) - unroll_loops(stmt.orelse, limit) - elif isinstance(stmt, ast.With): - unroll_loops(stmt.body, limit) - offset = 0 - for location, new_stmts in replacements: - stmts[offset+location:offset+location+1] = new_stmts - offset += len(new_stmts) - 1 - -# -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.Call) and isinstance(stmt.func, ast.Name): - name = stmt.func.id - if name == "delay": - if isinstance(stmt.args[0], ast.Num): - return stmt.args[0].n - else: - return -1 - elif name == "wait_edge": - return -1 - else: - return 0 - else: - return -1 - -def _merge_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(id="delay", ctx=ast.Load()), - args=[ast.Num(n=dt)], - keywords=[], starargs=[], kwargs=[])), - 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 collapse(stmts): - replacements = [] - for stmt_i, stmt in enumerate(stmts): - if isinstance(stmt, (ast.For, ast.While, ast.If)): - collapse(stmt.body) - collapse(stmt.orelse) - elif isinstance(stmt, ast.With): - btype = stmt.items[0].context_expr.id - if btype == "sequential": - collapse(stmt.body) - replacements.append((stmt_i, stmt.body)) - elif btype == "parallel": - timelines = [[s] for s in stmt.body] - for timeline in timelines: - collapse(timeline) - merged = _merge_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 transform(k_function, k_args, k_kwargs): - node = ast.parse(textwrap.dedent(inspect.getsource(k_function))) - node = find_kernel_body(node) - - explicit_delays(node) - unroll_loops(node, 50) - collapse(node) - - unparse.Unparser(node) diff --git a/artiq/devices/core.py b/artiq/devices/core.py index 3e924adc0..c027127c6 100644 --- a/artiq/devices/core.py +++ b/artiq/devices/core.py @@ -3,6 +3,7 @@ from operator import itemgetter from artiq.compiler.inline import inline from artiq.compiler.fold_constants import fold_constants from artiq.compiler.unroll_loops import unroll_loops +from artiq.compiler.interleave import interleave from artiq.compiler.unparse import Unparser class Core: @@ -10,6 +11,7 @@ class Core: stmts, rpc_map = inline(self, k_function, k_args, k_kwargs) fold_constants(stmts) unroll_loops(stmts, 50) + interleave(stmts) print("=========================") print(" Inlined") diff --git a/examples/compiler_test.py b/examples/compiler_test.py index fcd4e55c1..35916a935 100644 --- a/examples/compiler_test.py +++ b/examples/compiler_test.py @@ -14,14 +14,14 @@ class CompilerTest(Experiment): @kernel def run(self, n, t2): - t2 += 1*us for i in my_range(n): self.set_some_slowdev(i) delay(100*ms) with parallel: with sequential: - self.a.pulse(100*MHz, 20*us) - self.b.pulse(100*MHz, t2) + for j in my_range(3): + self.a.pulse((j+1)*100*MHz, 20*us) + self.b.pulse(100*MHz, t2) with sequential: self.A.pulse(100*MHz, 10*us) self.B.pulse(100*MHz, t2)