def test_specify_by_func(self): with dl.DeltaGraph() as graph: p_1 = dl.placeholder_node_factory() p_2 = dl.placeholder_node_factory(p_1) p_1.specify_by_node(self.printer_1(p_2)) p_2.specify_by_func(self.printer_2, allow_const=True) for node in graph.nodes: self.assertIsInstance(node.body, dl.wiring.PyFuncBody)
def test_const_selfloop(self): with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() p.specify_by_node(self.printer_1(p)) for node in graph.nodes: self.assertIsInstance(node.body, dl.wiring.PyFuncBody)
def generate_graph_interactive_input(verbose=False): """This function returns instead a cyclical graph: -> Checker -> one_shot_run -> HwResetShaper- | | -------------------------------------------- In this way we can assert and deassert the reset and verify that the migen code extend the reset signal for N clock cycles """ if verbose: lvl = logging.DEBUG else: lvl = logging.INFO with dl.DeltaGraph() as graph: ph = dl.placeholder_node_factory() oneshot = one_shot_run.call(status=ph) shaper = HwResetShaper(tb_num_iter=50, name='reset_shaper_one_shot', lvl=lvl, vcd_name='reset_shaper_one_shot.vcd') shaper_runner = shaper.call(pulse_in=oneshot) checker = LengthChecker(5, interactive=True).check_shape( shaper_runner.reset_out) ph.specify_by_node(checker) return (graph, shaper)
def test_loose_input(self): """Loose input wire is bad.""" s = dl.lib.StateSaver(int) with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() s.transfer(p) with self.assertRaises(dl.data_types.DeltaIOError): graph.check()
def test_loose_optional_input(self): """Optional input without input does not raise an error.""" @dl.DeltaBlock(allow_const=False) def test_node(a: dl.DOptional(int)) -> dl.Void: pass with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() test_node(p) self.assertTrue(graph.check())
def test_union(self): union_mix = dl.Union([ dl.Int(dl.Size(16)), dl.Bool(), dl.Str(dl.Size(10)), dl.Tuple([ dl.Int(dl.Size(8)), dl.UInt(dl.Size(16)), dl.Float(dl.Size(64)), dl.Complex(dl.Size(128)), dl.Bool(), dl.Str(dl.Size(10)) ]), dl.Record(RecATI) ]) @dl.Interactive([("ack_union_mix", bool)], [("out_union_mix", union_mix)]) def testbench(node: dl.PythonNode): node.send(out_union_mix=5) assert node.receive("ack_union_mix") node.send(out_union_mix=False) assert node.receive("ack_union_mix") node.send(out_union_mix='abcd') assert node.receive("ack_union_mix") node.send(out_union_mix=(-5, 10, -1.5, (1.5 + 2.5j), False, 'hello')) assert node.receive("ack_union_mix") node.send(out_union_mix=RecATI([1, 2], (3.0, 4), 5)) assert node.receive("ack_union_mix") raise DeltaRuntimeExit s_union_mix = dl.lib.StateSaver(union_mix, verbose=True) with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() p.specify_by_node( testbench.call(s_union_mix.save_and_ack(p.out_union_mix))) self.check_executes_graph( graph, """\ saving 5 saving False saving abcd saving (-5, 10, -1.5, (1.5+2.5j), False, 'hello') saving RecATI(x=[1, 2], y=(3.0, 4), z=5) """)
def get_graph(): """Return the experiments graph `DeltaGraph` and data store instances. Note that the aggregator and commanger files can be provided with `vcd_name` which will lead to saving VCD of all signals for further debugging. """ result_storage = dl.lib.StateSaver(int) cmds_storage = dl.lib.StateSaver(dl.DUInt(dl.DSize(32))) hal_template = dl.lib.hal_template with dl.DeltaGraph() as graph: ph_hal_result = dl.placeholder_node_factory() ph_commander = dl.placeholder_node_factory() # aggregator node of HAL results result_aggregator = Aggregator( name="result_aggregator", vcd_name=None).call(hal_result=ph_hal_result, shot_completed=ph_commander.shot_completed) # commander node to send HAL instructions command_sender = Commander( name="command_sender", vcd_name=None).call(angle=result_aggregator.next_angle) hal_result = hal_template.call(hal_command=command_sender.hal_command) # local store for experiment results result_storage.save(result_aggregator.agg_result) cmds_storage.save(command_sender.hal_command) # tie up placeholders ph_hal_result.specify_by_node(hal_result) ph_commander.specify_by_node(command_sender) # listen for flag to stop runtime experiment_stopper(result_aggregator.completed) return graph, result_storage, cmds_storage
def test_compound(self): tuple_mix = dl.Tuple([ dl.Int(dl.Size(8)), dl.UInt(dl.Size(16)), dl.Float(dl.Size(64)), dl.Complex(dl.Size(128)), dl.Bool(), dl.Str(dl.Size(10)) ]) array_float = dl.Array(dl.Float(dl.Size(64)), dl.Size(3)) record_mix = dl.Record(RecATI) @dl.Interactive([("ack_tuple_mix", bool), ("ack_array_float", bool), ("ack_record_mix", bool)], [("out_tuple_mix", tuple_mix), ("out_array_float", array_float), ("out_record_mix", record_mix)]) def testbench(node: dl.PythonNode): node.send(out_tuple_mix=(-5, 1000, -100.5, (1.5 + 2.5j), False, '0123456789')) assert node.receive("ack_tuple_mix") node.send(out_array_float=[0.5, -0.25, 0.125]) assert node.receive("ack_array_float") node.send(out_record_mix=RecATI([1, 2], (3.0, 4), 5)) assert node.receive("ack_record_mix") raise DeltaRuntimeExit s_tuple_mix = dl.lib.StateSaver(tuple_mix, verbose=True) s_array_float = dl.lib.StateSaver(array_float, verbose=True) s_record_mix = dl.lib.StateSaver(record_mix, verbose=True) with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() p.specify_by_node( testbench.call(s_tuple_mix.save_and_ack(p.out_tuple_mix), s_array_float.save_and_ack(p.out_array_float), s_record_mix.save_and_ack(p.out_record_mix))) self.check_executes_graph( graph, """\ saving (-5, 1000, -100.5, (1.5+2.5j), False, '0123456789') saving [0.5, -0.25, 0.125] saving RecATI(x=[1, 2], y=(3.0, 4), z=5) """)
def test_non_const_node_via_placeholder(self): """Non-constant node created via a placeholder has one output reused multiple times.""" with dl.DeltaGraph() as graph: output = dl.placeholder_node_factory() terminate_non_const(output) terminate_non_const(output) terminate_non_const(output) output.specify_by_node(return_1_non_const()) self.assertTrue(graph.check()) self.assertEqual(len(graph.nodes), 5) self.assertEqual( type(graph.find_node_by_name("return_1_non_const").body), dl.wiring.PyFuncBody) self.assertEqual(type(graph.find_node_by_name("splitter").body), dl.wiring.PyFuncBody)
def setUp(self): r"""Build the following graph ``` add_1 / \ || || || || \ / increment ----------> saver ``` """ self.saver = dl.lib.StateSaver(int) with dl.DeltaGraph() as graph: add_1_placeholder = dl.placeholder_node_factory() incr_node = opt_increment.call(n=add_1_placeholder) self.saver.save_and_exit(incr_node.y) add_one = add1_or0(incr_node.x) add_1_placeholder.specify_by_node(add_one) self.graph = graph self.rt = dl.DeltaPySimulator(graph)
def test_PyMigenBody_python(self): @dl.DeltaBlock(allow_const=False) def exit_if_6_else_inc(n: int) -> int: print(n) if n == 6: raise DeltaRuntimeExit else: return n + 1 with dl.DeltaGraph() as graph: ph = dl.placeholder_node_factory() c1 = MigenIncrementer().call(i1=ph) ex = exit_if_6_else_inc(c1.o1) ph.specify_by_node(ex) self.check_executes_graph( graph, """\ 0 2 4 6 """)
def test_integration(self): """Constructs the following graph: +---------------------------+ | SAVE | | +-----+ ^ | +--->Add +----+ | |to 10| +----+ | | +--------> | | +-----+ |ADD +---+ 2 --->| | +----+ """ s = dl.lib.StateSaver(int, verbose=True) with dl.DeltaGraph() as graph: add_ph = dl.placeholder_node_factory() b = return_2_const() int_node = add_until_10.call(num=add_ph) add_node = add_non_const(b, int_node.x) add_ph.specify_by_node(add_node) s.save_and_exit(int_node.y) self.check_executes_graph(graph, "saving 11\n")
if time_rf >= time_pmt: exp_time = time_rf - time_pmt else: exp_time = math.pow(2, _TIME_RES) + time_rf - time_pmt logging.debug( f'time result {time_out}, expected time {exp_time}, reset {reset}') assert time_out == exp_time assert reset == 1 if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) with dl.DeltaGraph() as graph: # define placeholders p0_tb = dl.placeholder_node_factory() dut = TimestampChipInterface( name="timestamper_interface", vcd_name="tb_timestamper_itf.vcd").call(time_in=p0_tb) tb = testbench.call(time_out=dut.time_out, reset=dut.counter_reset) # resolve placeholders p0_tb.specify_by_node(tb) # run graph print(graph) rt = dl.DeltaPySimulator(graph) rt.run()
def test_primitives(self): tuple_int = dl.Tuple([ dl.Int(dl.Size(8)), dl.Int(dl.Size(16)), dl.Int(dl.Size(32)), dl.Int(dl.Size(64)) ]) tuple_uint = dl.Tuple([ dl.UInt(dl.Size(8)), dl.UInt(dl.Size(16)), dl.UInt(dl.Size(32)), dl.UInt(dl.Size(64)) ]) tuple_float = dl.Tuple([dl.Float(dl.Size(32)), dl.Float(dl.Size(64))]) tuple_complex = dl.Tuple( [dl.Complex(dl.Size(64)), dl.Complex(dl.Size(128))]) tuple_bool_char = dl.Tuple([dl.Bool(), dl.Str(dl.Size(1))]) @dl.Interactive([("ack_int", bool), ("ack_uint", bool), ("ack_float", bool), ("ack_complex", bool), ("ack_bool_char", bool)], [("out_int", tuple_int), ("out_uint", tuple_uint), ("out_float", tuple_float), ("out_complex", tuple_complex), ("out_bool_char", tuple_bool_char)]) def testbench(node: dl.PythonNode): node.send(out_int=(-128, -32768, -2147483648, -9223372036854775808)) assert node.receive("ack_int") node.send(out_int=(127, 32767, 2147483647, 9223372036854775807)) assert node.receive("ack_int") node.send(out_uint=(0, 0, 0, 0)) assert node.receive("ack_uint") node.send(out_uint=(255, 65535, 4294967295, 18446744073709551615)) assert node.receive("ack_uint") # this is just a rough estimate node.send(out_float=(1.0000001, 1.000000000000001)) assert node.receive("ack_float") node.send(out_complex=((1.0000001 + 1.0000001j), (1.000000000000001 + 1.000000000000001j))) assert node.receive("ack_complex") node.send(out_bool_char=(True, 'a')) assert node.receive("ack_bool_char") raise DeltaRuntimeExit s_int = dl.lib.StateSaver(tuple_int, verbose=True) s_uint = dl.lib.StateSaver(tuple_uint, verbose=True) s_float = dl.lib.StateSaver(tuple_float, verbose=True) s_complex = dl.lib.StateSaver(tuple_complex, verbose=True) s_bool_char = dl.lib.StateSaver(tuple_bool_char, verbose=True) with dl.DeltaGraph() as graph: p = dl.placeholder_node_factory() p.specify_by_node( testbench.call(s_int.save_and_ack(p.out_int), s_uint.save_and_ack(p.out_uint), s_float.save_and_ack(p.out_float), s_complex.save_and_ack(p.out_complex), s_bool_char.save_and_ack(p.out_bool_char))) self.check_executes_graph( graph, f"""\ saving (-128, -32768, -2147483648, -9223372036854775808) saving (127, 32767, 2147483647, 9223372036854775807) saving (0, 0, 0, 0) saving (255, 65535, 4294967295, 18446744073709551615) saving ({np.float32(1.0000001)}, 1.000000000000001) saving (({np.float32(1.0000001)}+{np.float32(1.0000001)}j), (1.000000000000001+1.000000000000001j)) saving (True, 'a') """)
plt.plot(list(data.keys()), data.values(), 'ro') plt.savefig('histogram.png') @dl.DeltaBlock() def user_interface() -> bool: if input('Start Experiment (y/n): ') == 'y': return True else: raise dl.DeltaRuntimeExit with dl.DeltaGraph() as graph: ui = user_interface() trig = triggers.call() cntr = counter.call(pmt=trig.pmt_trigger, rf=trig.rf_trigger) p1_dac_status = dl.placeholder_node_factory() p2_dac_voltage = dl.placeholder_node_factory() accume = accumulator.call(new_time=cntr, DAC_status=p1_dac_status, DAC_voltage=p2_dac_voltage, experiment_start=ui) dac = DAC_control.call(command=accume.DAC_command, params=accume.DAC_param) p1_dac_status.specify_by_node(dac.node_status) p2_dac_voltage.specify_by_node(dac.return_data) print(graph) rt = dl.DeltaPySimulator(graph) rt.run()