m-labs · Sep 13, 2014 · Sep 13, 2014 · Sep 13, 2014
diff --git a/artiq/devices/core.py b/artiq/devices/core.py
@@ -15,14 +15,14 @@ def __init__(self, core_com, runtime_env=None):
         self.core_com = core_com
 
     def run(self, k_function, k_args, k_kwargs):
-        funcdef, rpc_map = inline(self, k_function, k_args, k_kwargs)
-        lower_units(funcdef, self.runtime_env.ref_period)
-        fold_constants(funcdef)
-        unroll_loops(funcdef, 50)
-        interleave(funcdef)
-        lower_time(funcdef, getattr(self.runtime_env, "initial_time", 0))
-        fold_constants(funcdef)
+        func_def, rpc_map = inline(self, k_function, k_args, k_kwargs)
+        lower_units(func_def, self.runtime_env.ref_period)
+        fold_constants(func_def)
+        unroll_loops(func_def, 50)
+        interleave(func_def)
+        lower_time(func_def, getattr(self.runtime_env, "initial_time", 0))
+        fold_constants(func_def)
 
-        binary = get_runtime_binary(self.runtime_env, funcdef)
+        binary = get_runtime_binary(self.runtime_env, func_def)
         self.core_com.run(binary)
         self.core_com.serve(rpc_map)
diff --git a/artiq/devices/rtio_core.py b/artiq/devices/rtio_core.py
@@ -37,3 +37,15 @@ def pulse(self, duration):
         self.on()
         delay(duration)
         self.off()
+
+
+class RTIOCounter(AutoContext):
+    parameters = "channel"
+
+    @kernel
+    def count_rising(self, duration):
+        pass
+
+    @kernel
+    def sync(self):
+        return 42
diff --git a/artiq/py2llvm/__init__.py b/artiq/py2llvm/__init__.py
@@ -1,6 +1,6 @@
 from artiq.py2llvm.module import Module
 
-def get_runtime_binary(env, funcdef):
+def get_runtime_binary(env, func_def):
     module = Module(env)
-    module.compile_function(funcdef, dict())
+    module.compile_function(func_def, dict())
     return module.emit_object()
diff --git a/artiq/py2llvm/fractions.py b/artiq/py2llvm/fractions.py
@@ -18,8 +18,8 @@ def _gcd(a, b):
 
 
 def init_module(module):
-    funcdef = ast.parse(inspect.getsource(_gcd)).body[0]
-    module.compile_function(funcdef, {"a": VInt(64), "b": VInt(64)})
+    func_def = ast.parse(inspect.getsource(_gcd)).body[0]
+    module.compile_function(func_def, {"a": VInt(64), "b": VInt(64)})
 
 
 def _reduce(builder, a, b):

diff --git a/artiq/py2llvm/module.py b/artiq/py2llvm/module.py
@@ -31,25 +31,25 @@ def emit_object(self):
         self.finalize()
         return self.env.emit_object()
 
-    def compile_function(self, funcdef, param_types):
-        ns = infer_types.infer_function_types(self.env, funcdef, param_types)
+    def compile_function(self, func_def, param_types):
+        ns = infer_types.infer_function_types(self.env, func_def, param_types)
         retval = ns["return"]
 
         function_type = lc.Type.function(retval.get_llvm_type(),
-            [ns[arg.arg].get_llvm_type() for arg in funcdef.args.args])
-        function = self.llvm_module.add_function(function_type, funcdef.name)
+            [ns[arg.arg].get_llvm_type() for arg in func_def.args.args])
+        function = self.llvm_module.add_function(function_type, func_def.name)
         bb = function.append_basic_block("entry")
         builder = lc.Builder.new(bb)
 
-        for arg_ast, arg_llvm in zip(funcdef.args.args, function.args):
+        for arg_ast, arg_llvm in zip(func_def.args.args, function.args):
             arg_llvm.name = arg_ast.arg
         for k, v in ns.items():
             v.alloca(builder, k)
-        for arg_ast, arg_llvm in zip(funcdef.args.args, function.args):
+        for arg_ast, arg_llvm in zip(func_def.args.args, function.args):
             ns[arg_ast.arg].auto_store(builder, arg_llvm)
 
         visitor = ast_body.Visitor(self.env, ns, builder)
-        visitor.visit_statements(funcdef.body)
+        visitor.visit_statements(func_def.body)
 
         if not tools.is_terminated(builder.basic_block):
             if isinstance(retval, base_types.VNone):

diff --git a/artiq/transforms/interleave.py b/artiq/transforms/interleave.py
@@ -109,5 +109,5 @@ def _interleave_stmts(stmts):
         offset += len(new_stmts) - 1
 
 
-def interleave(funcdef):
-    _interleave_stmts(funcdef.body)
+def interleave(func_def):
+    _interleave_stmts(func_def.body)
diff --git a/artiq/transforms/lower_time.py b/artiq/transforms/lower_time.py
@@ -42,9 +42,9 @@ def visit_Expr(self, node):
             return node
 
 
-def lower_time(funcdef, initial_time):
-    _TimeLowerer().visit(funcdef)
-    funcdef.body.insert(0, ast.copy_location(
+def lower_time(func_def, initial_time):
+    _TimeLowerer().visit(func_def)
+    func_def.body.insert(0, ast.copy_location(
         ast.Assign(targets=[ast.Name("now", ast.Store())],
                    value=value_to_ast(int64(initial_time))),
-        funcdef))
+        func_def))
diff --git a/artiq/transforms/lower_units.py b/artiq/transforms/lower_units.py
@@ -40,8 +40,8 @@ def visit_Call(self, node):
         return node
 
 
-def lower_units(funcdef, ref_period):
+def lower_units(func_def, ref_period):
     if (not isinstance(ref_period, units.Quantity)
             or ref_period.unit is not units.s_unit):
         raise units.DimensionError("Reference period not expressed in seconds")
-    _UnitsLowerer(ref_period.amount).visit(funcdef)
+    _UnitsLowerer(ref_period.amount).visit(func_def)
diff --git a/examples/photon_histogram.py b/examples/photon_histogram.py
@@ -0,0 +1,52 @@
+from artiq.language.core import *
+from artiq.language.units import *
+from artiq.devices import corecom_serial, core, dds_core, rtio_core
+
+
+class PhotonHistogram(AutoContext):
+    parameters = "bd bdd pmt repeats nbins"
+
+    def report(self, i, n):
+        print(i, n)
+
+    @kernel
+    def cool_detect(self):
+        with parallel:
+            self.bd.pulse(200*MHz, 1*ms)
+            self.bdd.pulse(300*MHz, 1*ms)
+        self.bd.pulse(210*MHz, 100*us)
+        with parallel:
+            self.bd.pulse(220*MHz, 100*us)
+            self.pmt.count_rising(100*us)
+        self.bd.on(200*MHz)
+        self.bdd.on(300*MHz)
+        return self.pmt.sync()
+
+    @kernel
+    def run(self):
+        hist = array(0, self.nbins)
+
+        for i in range(self.repeats):
+            n = self.cool_detect()
+            if n >= self.nbins:
+                n = self.nbins-1
+            hist[n] += 1
+
+        for i in range(self.nbins):
+            self.report(i, hist[i])
+
+
+if __name__ == "__main__":
+    with corecom_serial.CoreCom() as com:
+        coredev = core.Core(com)
+        exp = PhotonHistogram(
+            core=coredev,
+            bd=dds_core.DDS(core=coredev, dds_sysclk=1*GHz,
+                            reg_channel=0, rtio_channel=1),
+            bdd=dds_core.DDS(core=coredev, dds_sysclk=1*GHz,
+                             reg_channel=1, rtio_channel=2),
+            pmt=rtio_core.RTIOCounter(core=coredev, channel=0),
+            repeats=100,
+            nbins=100
+        )
+        exp.run()
diff --git a/test/py2llvm.py b/test/py2llvm.py
@@ -78,10 +78,10 @@ def test_array_types(self):
 class CompiledFunction:
     def __init__(self, function, param_types):
         module = Module()
-        funcdef = ast.parse(inspect.getsource(function)).body[0]
+        func_def = ast.parse(inspect.getsource(function)).body[0]
         self.function, self.retval = module.compile_function(
-            funcdef, param_types)
-        self.argval = [param_types[arg.arg] for arg in funcdef.args.args]
+            func_def, param_types)
+        self.argval = [param_types[arg.arg] for arg in func_def.args.args]
         self.ee = module.get_ee()
 
     def __call__(self, *args):