def test_split_nodes(self): """Test that there is the correct number of nodes _before_ and _after_ the runtime adds any splitter nodes. """ self.assertEqual(len(self.graph.nodes), len(self.savers) + 1) DeltaPySimulator(self.graph) self.assertEqual(len(self.graph.nodes), len(self.savers) + 2)
def test_merge_use_in_graph(self): """Test to ensure in params must match when associating constructors with a NodeTemplate. """ test_template3 = NodeTemplate(name="test_3", inputs=[('a', int), ('b', int)], outputs=[('output', int)]) @DeltaBlock(template=test_template3, allow_const=False) def _simple_add_2(a: int, b: int) -> int: return a + b test_template2 = NodeTemplate(name="test_2", inputs=[('a', int), ('b', int)], outputs=[('output', int)]) @DeltaBlock(template=test_template2, allow_const=False) def simple_add_3(a: int, b: int) -> int: return a + b test_template3.merge(test_template2) saver = StateSaver() with DeltaGraph() as graph: n1 = simple_add_3(4, 73) saver.save_and_exit(n1) self.assertEqual(len(n1.bodies), 2) graph.select_bodies(preferred=['_simple_add_2']) self.assertIn("_simple_add_2", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([77], saver.saved)
def test_method(self): foo = Foo() with DeltaGraph() as test_graph: foo.add_set_x(a=4, b=5) rt = DeltaPySimulator(test_graph) rt.run() self.assertEqual(foo.x, 9)
def test_placeholder_method(self): foo = Foo() with DeltaGraph() as test_graph: n = placeholder_node_factory(a=4, b=5) n.specify_by_method(Foo.add_set_x, foo, node_key="node") rt = DeltaPySimulator(test_graph) rt.run() self.assertEqual(foo.x, 9)
def test_forked_return_non_const_to_non_const(self): """Non-constant node w/ forked return -> non-constant -> exit.""" s = StateSaver(int) with DeltaGraph() as graph: val = return_12_non_const() s.save_and_exit(increment_non_const(val.x)) DeltaPySimulator(graph).run() self.assertEqual(s.saved, [2])
def test_via_Interactive(self): saver = StateSaver() with DeltaGraph() as graph: n1 = broken_adder.call(a=1, b=3) saver.save_and_exit(n1) self.assertEqual(len(n1.bodies), 3) self.assertIn("broken_adder", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([5], saver.saved)
def test_via_DeltaBlock(self): saver = StateSaver() with DeltaGraph() as graph: n1 = simple_add(4, 3) saver.save_and_exit(n1) self.assertEqual(len(n1.bodies), 3) self.assertIn("simple_add", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([7], saver.saved)
def test_via_default_call(self): saver = StateSaver() with DeltaGraph() as graph: n1 = test_template1.call(9, 2) saver.save_and_exit(n1) self.assertEqual(len(n1.bodies), 3) self.assertIn("simple_add", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([11], saver.saved)
def test_func(self): @DeltaBlock(node_key="node") def add_assert(a: int, b: int, node: PythonNode = None) -> Void: self.assertEqual(node.receive('a') + node.receive('b'), 9) raise DeltaRuntimeExit with DeltaGraph() as test_graph: add_assert(a=4, b=5) rt = DeltaPySimulator(test_graph) rt.run()
def setUp(self): with DeltaGraph() as graph: ident_ph = placeholder_node_factory() inter = interactive_func.call(num=ident_ph) ident = int_to_str(inter) ident_ph.specify_by_node(ident) self.graph = graph self.runtime = DeltaPySimulator(self.graph) self.dummy_node = ident self.inter_node = inter
def test_tuple_first_sending_alone(self): """Demonstration of how a user can run into an error when sending tuples as the first part of an output, and not specifing the other outputs. """ with DeltaGraph() as graph: tuple_first_alone() with self.assertRaises(RuntimeError): DeltaPySimulator(graph).run()
def test_real_run(self): """Test that the graph runs and terminates.""" interactive_node = self.graph.find_node_by_name("blah") runtime = DeltaPySimulator(self.graph) # run for a short time - just enough for the processing to end runtime.run(0.1) # check that the interactive node has terminated self.assertFalse(runtime.threads[interactive_node.name].is_alive()) runtime.stop()
def test_splitting_to_one_node_non_const(self): """Splitted output of a non-constant node and sent to another node's different inputs.""" s = StateSaver(int) with DeltaGraph() as graph: val = return_1_non_const() s.save_and_exit(add_non_const(val, val)) DeltaPySimulator(graph).run() self.assertEqual(s.saved, [2])
def test_migen_node_reset_shaper_constant(self, mock_stdout): """One PyMigenBody that takes as input a reset signal and extends the length of the reset to N clock cycles reset. """ graph, _ = generate_graph_constant_input() rt = DeltaPySimulator(graph) rt.run() self.assertEqual( mock_stdout.getvalue(), 'CHECK_SHAPE: reset has lasted at least 5 clk cycles\n')
def test_via_DeltaMethodBlock(self): saver = StateSaver() cacher = OpCacher() with DeltaGraph() as graph: n1 = cacher.cached_add(1, 3) saver.save_and_exit(n1) self.assertEqual(len(n1.bodies), 4) self.assertIn("cached_add", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([4], saver.saved)
def test_splitting_of_multiple_forked_non_const(self): """Multiple forked outputs of a non-constant node are splitted.""" s = StateSaver(int) with DeltaGraph() as graph: val = return_12_non_const() s.save_and_exit( add_non_const( add_non_const(add_non_const(val.x, val.x), val.y), val.y)) DeltaPySimulator(graph).run() self.assertEqual(s.saved, [6])
def test_placeholder_func(self): @DeltaBlock(node_key="node") def add_assert(a: int, b: int, node: PythonNode = None) -> Void: self.assertEqual(node.receive('a') + node.receive('b'), 9) raise DeltaRuntimeExit with DeltaGraph() as test_graph: n = placeholder_node_factory(a=4, b=5) n.specify_by_func(add_assert, node_key="node") rt = DeltaPySimulator(test_graph) rt.run()
def test_positional_block_send(self): ts = TripleStateSaver(11) fs = ForkedSendTester() with DeltaGraph() as graph: b_send = fs.positional_send() ts.multi_count_print_exit(b_send.x, b_send.y, b_send.z) DeltaPySimulator(graph).run() self.assertEqual(ts.x_store, [1, 3, 5, 6, 7, 10]) self.assertEqual(ts.y_store, [2, 4]) self.assertEqual(ts.z_store, [False, True, False])
def test_clock_updates(self): """Messages should be displayed at end of run in logical clock order. """ self.rt = DeltaPySimulator(self.test_graph, msg_lvl=logging.DEBUG) self.rt.run() message_times = [ msg.clk for node, _, msg in self.rt.msg_log.messages if node.startswith("const_consumer") ] self.assertGreater(len(message_times), 0) for time_1, time_2 in zip(message_times, message_times[1:]): self.assertLess(time_1, time_2)
def test_migen_node_reset_shaper_pulse(self, mock_stdout): """One PyMigenBody that takes as input a reset signal and extends the length of the reset to N clock cycles reset. We generate a pulse of length 1 clock cycle (i.e. 0010) and check for (00000...111110) """ graph, _ = generate_graph_interactive_input(verbose=False) rt = DeltaPySimulator(graph) rt.run() self.assertEqual( mock_stdout.getvalue(), 'CHECK_SHAPE: reset has lasted exactly 5 clk cycles\n')
def test_no_message_logging(self): """Messages should not be logged at all. """ self.rt = DeltaPySimulator(self.test_graph) self.rt.run() message_times = [ msg.clk for node, _, msg in self.rt.msg_log.messages if node.startswith("const_consumer") ] self.assertEqual(message_times, []) for time_1, time_2 in zip(message_times, message_times[1:]): self.assertLess(time_1, time_2)
def test_queues(self): """Test that the queues out of the splitter node are DeltaQueues.""" splitter_node = self.graph.find_node_by_name("splitter") self.assertTrue(splitter_node is None) runtime = DeltaPySimulator(self.graph) splitter_node = self.graph.find_node_by_name("splitter") out_qs = runtime.out_queues[splitter_node.name] self.assertEqual(len(out_qs), 3) for q in out_qs.values(): self.assertIsInstance(q, DeltaQueue)
def test_splitting_of_one_forked_non_const(self): """One of forked outputs of a non-constant node is splitted.""" s1 = StateSaver(int) s2 = StateSaver(int) with DeltaGraph() as graph: val = return_12_non_const() val_x = val.x s1.save(val_x) s2.save_and_exit(val_x) rt = DeltaPySimulator(graph) rt.run() self.assertEqual(s2.saved, [1])
def test_one_migen_node_with_2_outs(self): """One PyMigenBody with 2 out ports produces what we expect.""" s = StateSaver(int, verbose=True) with DeltaGraph() as graph: counter = TestMigen(tb_num_iter=2000, name='counter', lvl=logging.INFO).call(in1=40, in2=2) s.save_and_exit(adder(counter.out1, multiplier(counter.out2))) rt = DeltaPySimulator(graph) rt.run() self.assertEqual(s.saved, [5042])
def test_template_different_selected(self): """Test that node key is still correctly used on a multi-body node that has its body selected different from the one that was specified via the constructor. """ foo = Foo_T() with DeltaGraph() as test_graph: n1 = add_print_t(a=4, b=5) n1.add_body(foo.add_set_x_t) test_graph.select_bodies(preferred=["add_set_x_t"]) DeltaPySimulator(test_graph).run() self.assertIn("add_set_x_t", n1.body.access_tags) self.assertEqual(foo.x, 9)
def test_select_different_from_constructor(self): """Test that it is possible to select a different body than the one associated with the used constructor. """ saver = StateSaver() with DeltaGraph() as graph: n1 = simple_add(1, 3) saver.save_and_exit(n1) graph.select_bodies(preferred=["broken_adder"]) self.assertEqual(len(n1.bodies), 3) self.assertIn("broken_adder", n1.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([5], saver.saved)
def test_multiple_nodes_same_template(self): """Test that the same NodeTemplate can be used to create multiple distinct nodes for the same graph. """ saver = StateSaver() with DeltaGraph() as graph: n1 = over_complex_add(1, 3) n2 = simple_add(4, n1) saver.save_and_exit(n2) self.assertEqual(len(n1.bodies), 3) self.assertEqual(len(n2.bodies), 3) self.assertIn("over_complex_add", n1.body.access_tags) self.assertIn("simple_add", n2.body.access_tags) DeltaPySimulator(graph).run() self.assertEqual([8], saver.saved)
def test_one_migen_node_with_separate_ctrl_on_output_valid(self): """One PyMigenBody with 2 optional output ports produces the correct valid values (for the different ports). The migen node should be generating a sequence of outputs (1, None), (None, 2), (3, None) etc... """ with DeltaGraph() as graph: alt = AlternatingOutputsMigen(tb_num_iter=100, name='alternatingOutput', lvl=logging.INFO).call(start=1) my_adder = add_non_const(alt.out_a, alt.out_b) # Checking that we have received a 1 and a 2 checker = InputCheckerWithExit(lambda x: (x == 3)) checker.check(my_adder) rt = DeltaPySimulator(graph) rt.run() self.assertEqual(checker.cond_met, True)
def test_migen_trigger_fails(self): """Assert that when the `test_bench_no_trigger` node sends data, the ouput of the migen node is 0 due to the data not loading into output signal properly. """ with DeltaGraph() as graph: test_bench_output = test_bench_no_trigger.call() c1 = TestMigenNode(tb_num_iter=10).call( inp=test_bench_output.inp, trigger=test_bench_output.trigger) self.saver.save_and_exit(c1.out) rt = DeltaPySimulator(graph) rt.run() self.assertEqual(self.saver.saved[0], 0)
def test_migen_trigger_succeeds(self): """Assert that when the `test_bench_ye_trigger` node sends data, the ouput of the migen node is 15 since the data signal is available on the particular clock cycle that loads in the data. """ with DeltaGraph() as graph: test_bench_output = test_bench_yes_trigger.call() c1 = TestMigenNode(tb_num_iter=10).call( inp=test_bench_output.inp, trigger=test_bench_output.trigger) self.saver.save_and_exit(c1.out) rt = DeltaPySimulator(graph) rt.run() self.assertEqual(self.saver.saved[0], 15)