From 3d257066e3d8a7b19db44696e32a100a03979486 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Mon, 1 Jun 2026 06:31:18 +0100 Subject: [PATCH 01/13] use parameterized to test ALL_BOARD_TYPES --- setup.cfg | 1 + spinn_machine/version/__init__.py | 6 +++--- spinn_machine/version/version_factory.py | 4 ++++ unittests/test_machine.py | 12 +++++++++--- 4 files changed, 17 insertions(+), 6 deletions(-) diff --git a/setup.cfg b/setup.cfg index 356ae5dc..f3e5baaf 100644 --- a/setup.cfg +++ b/setup.cfg @@ -64,4 +64,5 @@ test = testfixtures httpretty != 1.0.0 deepdiff + parameterized diff --git a/spinn_machine/version/__init__.py b/spinn_machine/version/__init__.py index 52d9d6d9..e981c7a5 100644 --- a/spinn_machine/version/__init__.py +++ b/spinn_machine/version/__init__.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from .version_factory import (FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, - version_factory) +from .version_factory import ( + ALL_BOARD_TYPES, FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) -__all__ = ["FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", "version_factory"] +__all__ = ["ALL_BOARD_TYPES", "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", "version_factory"] diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index e15500ae..57aa2eb2 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -36,6 +36,10 @@ SPIN2_1CHIP = 201 SPIN2_48CHIP = 248 +ALL_BOARD_TYPES = [["THREE", THREE], ["FIVE", FIVE], + ["SPIN2_1CHIP", SPIN2_1CHIP], + ["SPIN2_48CHIP", SPIN2_48CHIP]] + def version_factory() -> AbstractVersion: """ diff --git a/unittests/test_machine.py b/unittests/test_machine.py index 2e92a0f3..5d40a40f 100644 --- a/unittests/test_machine.py +++ b/unittests/test_machine.py @@ -15,12 +15,14 @@ """ test for testing the python representation of a spinnaker machine """ +from parameterized import parameterized + from testfixtures import LogCapture # type: ignore[import] import unittest from spinn_utilities.config_holder import set_config from spinn_utilities.testing import log_checker from spinn_machine import Chip, Link, Machine, Router -from spinn_machine.version import FIVE +from spinn_machine.version import ALL_BOARD_TYPES, FIVE from spinn_machine.version.version_strings import VersionStrings from spinn_machine.virtual_machine import ( virtual_machine_by_boards, virtual_machine_by_min_size) @@ -144,11 +146,15 @@ def test_summary(self) -> None: "Not all Chips had the same n_router_tables. " "The counts where Counter({456: 1, 321: 1}).") - def test_chip_already_exists(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_chip_already_exists(self, _: str, version: str) -> None: """ check that adding a chip that already exists causes an error + + :param _: name param only used to creat full test name + :param version: Version string for config """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) with self.assertRaises(SpinnMachineAlreadyExistsException): machine.add_chip(Chip( From a3ff35f6ac7d71e2f4f1d5a4d71d59bc41982f4b Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Mon, 1 Jun 2026 06:43:02 +0100 Subject: [PATCH 02/13] mypy ignore parameterized --- pyproject.toml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index b2bf2c79..f6ad0662 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,4 +14,8 @@ [build-system] requires = ["setuptools"] -build-backend = "setuptools.build_meta" \ No newline at end of file +build-backend = "setuptools.build_meta" + +[[tool.mypy.overrides]] +module = ["parameterized"] +ignore_missing_imports = true From 62e52fa8bb007afb23ed9e892d56cdee0d8d391b Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Mon, 1 Jun 2026 07:19:23 +0100 Subject: [PATCH 03/13] flake8 --- spinn_machine/version/__init__.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/spinn_machine/version/__init__.py b/spinn_machine/version/__init__.py index e981c7a5..55d34033 100644 --- a/spinn_machine/version/__init__.py +++ b/spinn_machine/version/__init__.py @@ -15,4 +15,5 @@ from .version_factory import ( ALL_BOARD_TYPES, FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) -__all__ = ["ALL_BOARD_TYPES", "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", "version_factory"] +__all__ = ["ALL_BOARD_TYPES", "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", + "version_factory"] From 53056c6f1f33e453f8d61f6972f7bed839491c77 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Tue, 2 Jun 2026 10:36:47 +0100 Subject: [PATCH 04/13] parameterized unittests --- spinn_machine/version/version_factory.py | 12 +- unittests/data/test_data.py | 53 ++------ unittests/test_chip.py | 3 - unittests/test_ignore_cores.py | 17 ++- unittests/test_json_machine.py | 30 +++-- unittests/test_machine.py | 93 +++++++------ unittests/test_using_virtual_machine.py | 93 +++++++------ unittests/test_virtual_machine_48chips.py | 153 +++++++++++++--------- unittests/version/test_version_string.py | 39 ------ 9 files changed, 250 insertions(+), 243 deletions(-) delete mode 100644 unittests/version/test_version_string.py diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index 57aa2eb2..678672ea 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -36,9 +36,15 @@ SPIN2_1CHIP = 201 SPIN2_48CHIP = 248 -ALL_BOARD_TYPES = [["THREE", THREE], ["FIVE", FIVE], - ["SPIN2_1CHIP", SPIN2_1CHIP], - ["SPIN2_48CHIP", SPIN2_48CHIP]] +ALL_BOARD_TYPES = [["THREE", str(THREE)], ["FIVE", str(FIVE)], + ["SPIN2_1CHIP", str(SPIN2_1CHIP)], + ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] +FOUR_PLUS_BOARD_TYPES = [["THREE", THREE], ["FIVE", str(FIVE)], + ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] +EIGHT_BY_EIGHT_BOARD_TYPES = [["FIVE", str(FIVE)], + ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] +BIG_BOARD_TYPES = [["FIVE", str(FIVE)], + ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] def version_factory() -> AbstractVersion: diff --git a/unittests/data/test_data.py b/unittests/data/test_data.py index 3644bcb7..ae0d701e 100644 --- a/unittests/data/test_data.py +++ b/unittests/data/test_data.py @@ -12,16 +12,18 @@ # See the License for the specific language governing permissions and # limitations under the License. +from parameterized import parameterized import unittest + from spinn_utilities.config_holder import set_config from spinn_utilities.exceptions import (ConfigException, DataNotYetAvialable) + from spinn_machine import virtual_machine from spinn_machine.config_setup import unittest_setup from spinn_machine.data import MachineDataView from spinn_machine.data.machine_data_writer import MachineDataWriter from spinn_machine.exceptions import SpinnMachineException -from spinn_machine.version import FIVE, THREE, SPIN2_48CHIP -from spinn_machine.version.version_strings import VersionStrings +from spinn_machine.version import BIG_BOARD_TYPES, FIVE, THREE, SPIN2_48CHIP class TestSimulatorData(unittest.TestCase): @@ -59,8 +61,9 @@ def test_machine(self) -> None: writer.set_machine("bacon") # type: ignore[arg-type] self.assertTrue(MachineDataView.has_machine()) - def test_where_is_mocked(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_where_is_mocked(self, _: str, version: str) -> None: + set_config("Machine", "version", version) writer = MachineDataWriter.mock() self.assertEqual( "No Machine created yet", @@ -77,8 +80,9 @@ def test_where_is_mocked(self) -> None: "global chip 2, 8 on 127.0.0.0 is chip 6, 4 on 127.0.8.4", MachineDataView.where_is_chip(machine[2, 8])) - def test_where_is_setup(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_where_is_setup(self, _: str, version: str) -> None: + set_config("Machine", "version", version) writer = MachineDataWriter.setup() self.assertEqual( "No Machine created yet", @@ -138,43 +142,6 @@ def test_v_to_p_spin2(self) -> None: self.assertEqual("", writer.get_physical_string((1, 2), 234)) - def test_mock_any(self) -> None: - # Should work with any version - set_config("Machine", "versions", VersionStrings.ANY.text) - # check there is a value not what it is - machine = MachineDataView.get_machine() - self.assertGreaterEqual(machine.n_chips, 1) - - def test_mock_4_or_more(self) -> None: - # Should work with any version that has 4 plus Chips - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) - # check there is a value not what it is - machine = MachineDataView.get_machine() - self.assertGreaterEqual(machine.n_chips, 4) - - def test_mock_big(self) -> None: - # Should work with any version - set_config("Machine", "versions", VersionStrings.BIG.text) - # check there is a value not what it is - machine = MachineDataView.get_machine() - self.assertGreaterEqual(machine.n_chips, 48) - - def test_mock3(self) -> None: - # Should work with any version - set_config("Machine", "version", "3") - # check there is a value not what it is - MachineDataView.get_machine() - - def test_mock5(self) -> None: - set_config("Machine", "version", "5") - # check there is a value not what it is - MachineDataView.get_machine() - - def test_mock201(self) -> None: - set_config("Machine", "version", "201") - # check there is a value not what it is - MachineDataView.get_machine() - def test_get_monitors(self) -> None: writer = MachineDataWriter.setup() self.assertEqual(0, MachineDataView.get_all_monitor_cores()) diff --git a/unittests/test_chip.py b/unittests/test_chip.py index 5cbc9d22..5eb0c0ab 100644 --- a/unittests/test_chip.py +++ b/unittests/test_chip.py @@ -15,18 +15,15 @@ from typing import Optional import unittest -from spinn_utilities.config_holder import set_config from spinn_utilities.ordered_set import OrderedSet from spinn_machine import Link, Router, Chip from spinn_machine.config_setup import unittest_setup -from spinn_machine.version.version_strings import VersionStrings class TestingChip(unittest.TestCase): def setUp(self) -> None: unittest_setup() - set_config("Machine", "versions", VersionStrings.ANY.text) self._x = 0 self._y = 1 diff --git a/unittests/test_ignore_cores.py b/unittests/test_ignore_cores.py index 4bbd903c..1f6c3f42 100644 --- a/unittests/test_ignore_cores.py +++ b/unittests/test_ignore_cores.py @@ -13,15 +13,18 @@ # limitations under the License. import unittest + +from parameterized import parameterized + from spinn_utilities.config_holder import set_config from spinn_utilities.exceptions import ConfigException + from spinn_machine.config_setup import unittest_setup from spinn_machine.exceptions import SpinnMachineException from spinn_machine.ignores import IgnoreChip, IgnoreCore, IgnoreLink -from spinn_machine.version import SPIN2_1CHIP +from spinn_machine.version import SPIN2_1CHIP, BIG_BOARD_TYPES from spinn_machine.version.version_201 import Version201 from spinn_machine.version.version_5 import Version5 -from spinn_machine.version.version_strings import VersionStrings class TestDownCores(unittest.TestCase): @@ -29,8 +32,9 @@ class TestDownCores(unittest.TestCase): def setUp(self) -> None: unittest_setup() - def test_bad_ignores(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_bad_ignores(self, _: str, version: str) -> None: + set_config("Machine", "version", version) try: IgnoreChip.parse_string("4,4,3,4:6,6,ignored_ip") @@ -50,8 +54,9 @@ def test_bad_ignores(self) -> None: except Exception as ex: self.assertTrue("downed_link" in str(ex)) - def test_down_cores_bad_string(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_down_cores_bad_string(self, _: str, version: str) -> None: + set_config("Machine", "version", version) with self.assertRaises(ConfigException): IgnoreCore.parse_string("4,4,bacon") diff --git a/unittests/test_json_machine.py b/unittests/test_json_machine.py index 0205c3ba..7b7022c7 100644 --- a/unittests/test_json_machine.py +++ b/unittests/test_json_machine.py @@ -12,17 +12,21 @@ # See the License for the specific language governing permissions and # limitations under the License. +from parameterized import parameterized from tempfile import mktemp import unittest + + from spinn_utilities.config_holder import set_config +from spinn_utilities.ordered_set import OrderedSet + from spinn_machine.virtual_machine import ( virtual_machine, virtual_machine_by_boards, virtual_machine_by_min_size) from spinn_machine.data.machine_data_writer import MachineDataWriter from spinn_machine.config_setup import unittest_setup from spinn_machine.json_machine import (machine_from_json, to_json_path) -from spinn_machine.version import (FIVE, SPIN2_1CHIP, THREE) -from spinn_machine.version.version_strings import VersionStrings -from spinn_utilities.ordered_set import OrderedSet +from spinn_machine.version import (BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES, + FIVE, SPIN2_1CHIP, THREE) class TestJsonMachine(unittest.TestCase): @@ -69,8 +73,9 @@ def test_json_version_201(self) -> None: for vchip, jchip in zip(vm, jm): self.assertEqual(str(vchip), str(jchip)) - def test_json_hole(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_json_hole(self, _: str, version: str) -> None: + set_config("Machine", "version", version) set_config("Machine", "down_chips", "3,3") writer = MachineDataWriter.mock() vm = virtual_machine_by_min_size(5, 5) @@ -84,8 +89,9 @@ def test_json_hole(self) -> None: for vchip, jchip in zip(vm, jm): self.assertEqual(str(vchip), str(jchip)) - def test_exceptions(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_exceptions(self, _: str, version: str) -> None: + set_config("Machine", "version", version) writer = MachineDataWriter.mock() vm = virtual_machine_by_boards(1) writer.set_machine(vm) @@ -104,8 +110,9 @@ def test_exceptions(self) -> None: vchip10 = jm[1, 0] self.assertEqual(vchip10.tag_ids, chip10.tag_ids) - def test_two_monitors(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_two_monitors(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine_by_boards(1) MachineDataWriter.mock().set_machine(vm) for chip in vm.chips: @@ -120,8 +127,9 @@ def test_two_monitors(self) -> None: for vchip, jchip in zip(vm, jm): self.assertEqual(str(vchip), str(jchip)) - def test_ethernet_exceptions(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_ethernet_exceptions(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine_by_boards(2) MachineDataWriter.mock().set_machine(vm) eth2 = vm.ethernet_connected_chips[1] diff --git a/unittests/test_machine.py b/unittests/test_machine.py index 5d40a40f..ccc87265 100644 --- a/unittests/test_machine.py +++ b/unittests/test_machine.py @@ -22,8 +22,8 @@ from spinn_utilities.config_holder import set_config from spinn_utilities.testing import log_checker from spinn_machine import Chip, Link, Machine, Router -from spinn_machine.version import ALL_BOARD_TYPES, FIVE -from spinn_machine.version.version_strings import VersionStrings +from spinn_machine.version import ( + ALL_BOARD_TYPES, BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES, FIVE) from spinn_machine.virtual_machine import ( virtual_machine_by_boards, virtual_machine_by_min_size) from spinn_machine.config_setup import unittest_setup @@ -150,9 +150,6 @@ def test_summary(self) -> None: def test_chip_already_exists(self, _: str, version: str) -> None: """ check that adding a chip that already exists causes an error - - :param _: name param only used to creat full test name - :param version: Version string for config """ set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) @@ -162,23 +159,25 @@ def test_chip_already_exists(self, _: str, version: str) -> None: self._nearest_ethernet_chip[0], self._nearest_ethernet_chip[1], self._ip)) - def test_machine_get_chip_at(self) -> None: + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_machine_get_chip_at(self, _: str, version: str) -> None: """ test the get_chip_at function from the machine with a valid request """ - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + set_config("Machine", "version", version) new_machine = virtual_machine_by_min_size(2, 2) self.assertEqual(1, new_machine[1, 0].x) self.assertEqual(0, new_machine[1, 0].y) self.assertEqual(0, new_machine[0, 1].x) self.assertEqual(1, new_machine[0, 1].y) - def test_machine_big_x(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_machine_big_x(self, _: str, version: str) -> None: """ test the add_chips method of the machine chips outside size should produce an error """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -192,12 +191,13 @@ def test_machine_big_x(self) -> None: except SpinnMachineException as ex: self.assertIn(f"has an x larger than width {width}", str(ex)) - def test_machine_big_y(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_machine_big_y(self, _: str, version: str) -> None: """ test the add_chips method of the machine chips outside size should produce an error """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -211,41 +211,46 @@ def test_machine_big_y(self) -> None: except SpinnMachineException as ex: self.assertIn(f"has a y larger than height {height}", str(ex)) - def test_machine_get_chip_at_invalid_location(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_machine_get_chip_at_invalid_location( + self, _: str, version: str) -> None: """ test the machines get_chip_at function with a location thats invalid, should return None and not produce an error """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertEqual(None, new_machine.get_chip_at(width + 2, height // 2)) - def test_machine_is_chip_at_true(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_machine_is_chip_at_true(self, _: str, version: str) -> None: """ test the is_chip_at function of the machine with a position to request which does indeed contain a chip """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertTrue(new_machine.is_chip_at(width // 2, height // 2)) - def test_machine_is_chip_at_false(self) -> None: + @parameterized.expand(ALL_BOARD_TYPES) + def test_machine_is_chip_at_false(self, _: str, version: str) -> None: """ test the is_chip_at function of the machine with a position to request which does not contain a chip """ - set_config("Machine", "versions", VersionStrings.ANY.text) + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertFalse(new_machine.is_chip_at(width + 2, height // 2)) - def test_machine_get_chips_on_board(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_machine_get_chips_on_board(self, _: str, version: str) -> None: + set_config("Machine", "version", version) new_machine = virtual_machine_by_boards(3) version = MachineDataView.get_machine_version() for eth_chip in new_machine._ethernet_connected_chips: @@ -258,13 +263,14 @@ def test_machine_get_chips_on_board(self) -> None: with self.assertRaises(KeyError): new_machine.get_fpga_link_with_id(3, 3) - def test_x_y_over_link(self) -> None: + @parameterized.expand(BIG_BOARD_TYPES) + def test_x_y_over_link(self, _: str, version: str) -> None: """ Test the x_y with each wrap around. Notice that the function only does the math not validate the values. """ - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + set_config("Machine", "version", version) # full wrap around machine = MachineDataView.get_machine_version().create_machine(24, 24) self.assertEqual(machine.xy_over_link(0, 0, 4), (23, 23)) @@ -286,13 +292,14 @@ def test_x_y_over_link(self) -> None: self.assertEqual(machine.xy_over_link(15, 23, 1), (16, 0)) self.assertEqual(machine.wrap, "VerWrap") - def test_get_global_xy(self) -> None: + @parameterized.expand(BIG_BOARD_TYPES) + def test_get_global_xy(self, _: str, version: str) -> None: """ Test get_global_xy with each wrap around. Notice that the function only does the math not validate the values. """ - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + set_config("Machine", "version", version) # full wrap around machine = MachineDataView.get_machine_version().create_machine(24, 24) self.assertEqual(machine.get_global_xy(1, 4, 4, 20), (5, 0)) @@ -310,8 +317,9 @@ def test_get_global_xy(self) -> None: self.assertEqual(machine.get_global_xy(1, 4, 4, 20), (5, 0)) self.assertEqual(machine.get_global_xy(5, 0, 20, 4), (25, 4)) - def test_no_boot(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_no_boot(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -319,8 +327,9 @@ def test_no_boot(self) -> None: with self.assertRaises(SpinnMachineException): machine.validate() - def test_negative_x(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_negative_x(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -330,8 +339,9 @@ def test_negative_x(self) -> None: with self.assertRaises(SpinnMachineException): machine.validate() - def test_negative_y(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_negative_y(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -347,31 +357,35 @@ def _non_ethernet_chip(self, machine: Machine) -> Chip: return chip raise SpinnMachineException("No none Ethernet Chip") - def test_weird_ethernet1(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_weird_ethernet1(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) self._non_ethernet_chip(machine)._ip_address = "1.2.3.4" with self.assertRaises(SpinnMachineException): machine.validate() - def test_bad_ethernet_chip_x(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_bad_ethernet_chip_x(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) width, _ = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = width + 1 with self.assertRaises(SpinnMachineException): machine.validate() - def test_bad_ethernet_chip_no_chip(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_bad_ethernet_chip_no_chip(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) _, height = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = height + 1 with self.assertRaises(SpinnMachineException): machine.validate() - def test_concentric_xys(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_concentric_xys(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_min_size(5, 5) found = list(machine.concentric_xys(2, (2, 2))) expected = [ @@ -381,8 +395,9 @@ def test_concentric_xys(self) -> None: (2, 4), (1, 3), (0, 2), (0, 1), (0, 0), (1, 0)] self.assertListEqual(expected, found) - def test_too_few_cores(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_too_few_cores(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) # Hack to get n_processors return a low number chip = next(machine.chips) diff --git a/unittests/test_using_virtual_machine.py b/unittests/test_using_virtual_machine.py index 5b01a6be..94408e40 100644 --- a/unittests/test_using_virtual_machine.py +++ b/unittests/test_using_virtual_machine.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from parameterized import parameterized from typing import Tuple import unittest @@ -25,21 +26,20 @@ from spinn_machine.data import MachineDataView from spinn_machine.exceptions import (SpinnMachineException) from spinn_machine.machine_factory import machine_repair -from spinn_machine.version.version_strings import VersionStrings -from spinn_machine.version.version_5 import CHIPS_PER_BOARD +from spinn_machine.version import ( + ALL_BOARD_TYPES, BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES) from .geometry import (to_xyz, shortest_mesh_path_length, shortest_torus_path_length, minimise_xyz) class TestUsingVirtualMachine(unittest.TestCase): - VERSION_5_N_CORES_PER_BOARD = sum(CHIPS_PER_BOARD.values()) - def setUp(self) -> None: unittest_setup() - def test_new_vm_with_max_cores(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_new_vm_with_max_cores(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cpus = version.max_cores_per_chip - 5 set_config("Machine", "max_machine_core", str(n_cpus)) @@ -59,8 +59,9 @@ def test_new_vm_with_max_cores(self) -> None: self.assertEqual(version.n_scamp_cores, len(list(chip.scamp_processors_ids))) - def test_iter_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_iter_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine_by_boards(1) n_chips = MachineDataView.get_machine_version().n_chips_per_board self.assertEqual(n_chips, vm.n_chips) @@ -69,8 +70,9 @@ def test_iter_chips(self) -> None: count += 1 self.assertEqual(n_chips, count) - def test_down_chip(self) -> None: - set_config("Machine", "versions", VersionStrings.FOUR_PLUS.text) + @parameterized.expand(FOUR_PLUS_BOARD_TYPES) + def test_down_chip(self, _: str, version: str) -> None: + set_config("Machine", "version", version) down_chips = set() down_chips.add((1, 1)) set_config("Machine", "down_chips", "1,1") @@ -89,8 +91,9 @@ def _check_path(self, source: XY, target: XY, path: Tuple[int, int, int], (source[1] + path[1] - path[2]) % height) self.assertEqual(target, new_target, "{}{}".format(source, path)) - def test_nowrap_shortest_path(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_nowrap_shortest_path(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(16, 28, validate=True) for source in machine.chip_coordinates: for target in machine.chip_coordinates: @@ -103,8 +106,9 @@ def test_nowrap_shortest_path(self) -> None: mac_len, abs(path[0]) + abs(path[1]) + abs(path[2])) self._check_path(source, target, path, 1000000, 1000000) - def test_fullwrap_shortest_path(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_fullwrap_shortest_path(self, _: str, version: str) -> None: + set_config("Machine", "version", version) width = 12 height = 24 machine = virtual_machine(width, height, validate=True) @@ -120,8 +124,9 @@ def test_fullwrap_shortest_path(self) -> None: "{}{}{}".format(source, target, path)) self._check_path(source, target, path, width, height) - def test_hoizontal_wrap_shortest_path(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_hoizontal_wrap_shortest_path(self, _: str, version: str) -> None: + set_config("Machine", "version", version) width = 12 height = 16 machine = virtual_machine(width, height, validate=False) @@ -145,8 +150,9 @@ def test_hoizontal_wrap_shortest_path(self) -> None: "{}{}{}".format(source, target, path)) self._check_path(source, target, path, width, height) - def test_vertical_wrap_shortest_path(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_vertical_wrap_shortest_path(self, _: str, version: str) -> None: + set_config("Machine", "version", version) width = 16 height = 12 machine = virtual_machine(width, height, validate=False) @@ -170,8 +176,9 @@ def test_vertical_wrap_shortest_path(self) -> None: "{}{}{}".format(source, target, path)) self._check_path(source, target, path, width, height) - def test_minimize(self) -> None: - set_config("Machine", "versions", VersionStrings.ANY.text) + @parameterized.expand(ALL_BOARD_TYPES) + def test_minimize(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) for x in range(-3, 3): for y in range(-3, 3): @@ -179,8 +186,9 @@ def test_minimize(self) -> None: min2 = machine._minimize_vector(x, y) self.assertEqual(min1, min2) - def test_unreachable_incoming_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_unreachable_incoming_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_min_size(6, 6) # Delete links incoming to 3, 3 @@ -192,8 +200,9 @@ def test_unreachable_incoming_chips(self) -> None: unreachable = machine.unreachable_incoming_chips() self.assertListEqual([(3, 3)], unreachable) - def test_unreachable_outgoing_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_unreachable_outgoing_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_min_size(6, 6) # Delete links outgoing from 3, 3 @@ -203,8 +212,9 @@ def test_unreachable_outgoing_chips(self) -> None: unreachable = machine.unreachable_outgoing_chips() self.assertListEqual([(3, 3)], unreachable) - def test_unreachable_incoming_local_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_unreachable_incoming_local_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -213,8 +223,9 @@ def test_unreachable_incoming_local_chips(self) -> None: unreachable = machine.unreachable_incoming_local_chips() self.assertListEqual([(8, 7)], unreachable) - def test_unreachable_outgoing_local_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_unreachable_outgoing_local_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -223,8 +234,9 @@ def test_unreachable_outgoing_local_chips(self) -> None: unreachable = machine.unreachable_outgoing_local_chips() self.assertListEqual([(8, 7)], unreachable) - def test_repair_with_local_orphan(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_repair_with_local_orphan(self, _: str, version: str) -> None: + set_config("Machine", "version", version) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -238,8 +250,10 @@ def test_repair_with_local_orphan(self) -> None: self.assertTrue(machine.is_chip_at(8, 7)) self.assertFalse(repaired.is_chip_at(8, 7)) - def test_repair_with_one_way_links_different_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_repair_with_one_way_links_different_boards( + self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(12, 12) # Assumes boards of exactly size 8,8 # Delete some links between boards @@ -254,8 +268,9 @@ def test_repair_with_one_way_links_different_boards(self) -> None: new_machine = machine_repair(machine) self.assertIsNotNone(new_machine) - def test_oneway_link_no_repair(self) -> None: - set_config("Machine", "versions", VersionStrings.EIGHT_BY_EIGHT.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_oneway_link_no_repair(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(8, 8) # Delete some random links @@ -271,8 +286,9 @@ def test_oneway_link_no_repair(self) -> None: new_machine = machine_repair(machine) self.assertIsNotNone(new_machine) - def test_removed_chip_repair(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_removed_chip_repair(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_boards(1) del machine._chips[(3, 3)] @@ -281,8 +297,9 @@ def test_removed_chip_repair(self) -> None: self.assertIsNotNone(new_machine) self.assertFalse(new_machine.is_link_at(2, 2, 1)) - def test_ignores(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_ignores(self, _: str, version: str) -> None: + set_config("Machine", "version", version) set_config("Machine", "down_chips", "2,2:4,4:6,6,ignored_ip") set_config("Machine", "down_cores", "1,1,4:3,3,3: 5,5,-5:7,7,7,ignored_ip:0,0,5-10") diff --git a/unittests/test_virtual_machine_48chips.py b/unittests/test_virtual_machine_48chips.py index 3bf53014..da1da4cf 100644 --- a/unittests/test_virtual_machine_48chips.py +++ b/unittests/test_virtual_machine_48chips.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from parameterized import parameterized import unittest from spinn_utilities.config_holder import set_config @@ -19,7 +20,7 @@ from spinn_machine.config_setup import unittest_setup from spinn_machine.data import MachineDataView from spinn_machine.exceptions import SpinnMachineException -from spinn_machine.version.version_strings import VersionStrings +from spinn_machine.version import BIG_BOARD_TYPES from spinn_machine.virtual_machine import ( virtual_machine_by_boards, virtual_machine_by_chips, virtual_machine_by_cores, virtual_machine_by_min_size) @@ -30,8 +31,9 @@ class TestVirtualMachine48Chips(unittest.TestCase): def setUp(self) -> None: unittest_setup() - def test_illegal_vms(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_illegal_vms(self, _: str, version: str) -> None: + set_config("Machine", "version", version) with self.assertRaises(SpinnMachineException): virtual_machine(width=-1, height=2) with self.assertRaises(SpinnMachineException): @@ -49,8 +51,9 @@ def test_illegal_vms(self) -> None: virtual_machine(size_x, None, # type: ignore[arg-type] validate=True) - def test_version_hole(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_version_hole(self, _: str, version: str) -> None: + set_config("Machine", "version", version) set_config("Machine", "down_chips", "3,3") vm = virtual_machine(height=8, width=8, validate=True) self.assertEqual(47, vm.n_chips) @@ -62,8 +65,9 @@ def test_version_hole(self) -> None: self.assertEqual(228, count) self.assertEqual(48, len(list(vm.local_xys))) - def test_version_hole2(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_version_hole2(self, _: str, version: str) -> None: + set_config("Machine", "version", version) set_config("Machine", "down_chips", "0,3") vm = virtual_machine(height=8, width=8, validate=True) self.assertEqual(47, vm.n_chips) @@ -76,30 +80,34 @@ def test_version_hole2(self) -> None: self.assertEqual(48, len(list(vm.local_xys))) self.assertEqual((0, 4), vm.get_unused_xy()) - def test_12_n_plus4_12_m_4(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_12_n_plus4_12_m_4(self, _: str, version: str) -> None: + set_config("Machine", "version", version) size_x = 12 * 5 size_y = 12 * 7 vm = virtual_machine(size_x + 4, size_y + 4, validate=True) self.assertEqual(size_x * size_y, vm.n_chips) - def test_12_n_12_m(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_12_n_12_m(self, _: str, version: str) -> None: + set_config("Machine", "version", version) size_x = 12 * 5 size_y = 12 * 7 vm = virtual_machine(size_x, size_y, validate=True) self.assertEqual(size_x * size_y, vm.n_chips) - def test_chips(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_chips(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine(8, 8) count = 0 for _chip in vm.chips: count += 1 self.assertEqual(count, 48) - def test_ethernet_chips_exist(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_ethernet_chips_exist(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine(width=48, height=24) for eth_chip in vm._ethernet_connected_chips: self.assertTrue(vm.get_chip_at(eth_chip.x, eth_chip.y), @@ -107,14 +115,16 @@ def test_ethernet_chips_exist(self) -> None: "_configured_chips" .format(eth_chip.x, eth_chip.y)) - def test_boot_chip(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_boot_chip(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine(12, 12) # based on Chip equaling its XY self.assertEqual(vm.boot_chip, (0, 0)) - def test_get_chips_on_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_get_chips_on_boards(self, _: str, version: str) -> None: + set_config("Machine", "version", version) vm = virtual_machine(width=24, height=36) # check each chip appears only once on the entire board count00 = 0 @@ -140,13 +150,15 @@ def test_get_chips_on_boards(self) -> None: # (24,36) is not on this virtual machine self.assertEqual(count2436, 0) - def test_big(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_big(self, _: str, version: str) -> None: + set_config("Machine", "version", version) virtual_machine( width=240, height=240, validate=True) - def test_48_28(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_48_28(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -160,8 +172,9 @@ def test_48_28(self) -> None: self.assertEqual(len(global_xys), 48 * 24) self.assertEqual(48, len(list(machine.local_xys))) - def test_48_24(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_48_24(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -175,8 +188,9 @@ def test_48_24(self) -> None: self.assertEqual(len(global_xys), 48 * 24) self.assertEqual(48, len(list(machine.local_xys))) - def test_52_28(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_52_28(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -190,8 +204,9 @@ def test_52_28(self) -> None: self.assertEqual(len(global_xys), 48 * 24) self.assertEqual(48, len(list(machine.local_xys))) - def test_52_24(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_52_24(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -205,8 +220,9 @@ def test_52_24(self) -> None: self.assertEqual(len(global_xys), 48 * 24) self.assertEqual(48, len(list(machine.local_xys))) - def test_fullwrap_holes(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_fullwrap_holes(self, _: str, version: str) -> None: + set_config("Machine", "version", version) hole = [(1, 1), (7, 7), (8, 1), (8, 10), (1, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -256,8 +272,9 @@ def test_fullwrap_holes(self) -> None: assert xy not in hole self.assertEqual(46, count) - def test_horizontal_wrap_holes(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_horizontal_wrap_holes(self, _: str, version: str) -> None: + set_config("Machine", "version", version) hole = [(1, 1), (7, 7), (8, 13), (8, 10), (1, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -307,8 +324,9 @@ def test_horizontal_wrap_holes(self) -> None: assert xy not in hole self.assertEqual(46, count) - def test_vertical_wrap_holes(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_vertical_wrap_holes(self, _: str, version: str) -> None: + set_config("Machine", "version", version) hole = [(1, 1), (7, 7), (8, 1), (8, 10), (13, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -358,8 +376,9 @@ def test_vertical_wrap_holes(self) -> None: assert xy not in hole self.assertEqual(46, count) - def test_no_wrap_holes(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_no_wrap_holes(self, _: str, version: str) -> None: + set_config("Machine", "version", version) hole = [(1, 1), (7, 7), (8, 13), (8, 10), (13, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -409,8 +428,9 @@ def test_no_wrap_holes(self) -> None: assert xy not in hole self.assertEqual(46, count) - def test_n_cores_full_wrap(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_n_cores_full_wrap(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 12) @@ -421,8 +441,9 @@ def test_n_cores_full_wrap(self) -> None: n_cores = sum(chip.n_processors for chip in machine.chips) self.assertEqual(n_cores, cores_per_board * 3) - def test_n_cores_no_wrap(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_n_cores_no_wrap(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(16, 16) @@ -447,8 +468,9 @@ def test_n_cores_no_wrap(self) -> None: where = machine.where_is_xy(15, 15) self.assertEqual(where, 'No chip 15, 15 found') - def test_n_cores_horizontal_wrap(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_n_cores_horizontal_wrap(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 16) @@ -459,8 +481,9 @@ def test_n_cores_horizontal_wrap(self) -> None: n_cores = sum(chip.n_processors for chip in machine.chips) self.assertEqual(n_cores, cores_per_board * 3) - def test_n_cores_vertical_wrap(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_n_cores_vertical_wrap(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 16) @@ -469,8 +492,9 @@ def test_n_cores_vertical_wrap(self) -> None: n_cores = sum(chip.n_processors for chip in machine.chips) self.assertEqual(n_cores, cores_per_board * 3) - def test_n_cores_8_8(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_n_cores_8_8(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(8, 8) @@ -480,8 +504,9 @@ def test_n_cores_8_8(self) -> None: n_cores = sum(chip.n_processors for chip in machine.chips) self.assertEqual(n_cores, cores_per_board) - def test_8_8_by_cores_1_board(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_8_8_by_cores_1_board(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -494,8 +519,9 @@ def test_8_8_by_cores_1_board(self) -> None: self.assertEqual(8, machine.height) self.assertEqual(n_cores, machine.total_available_user_cores) - def test_8_8_by_cores_3_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_8_8_by_cores_3_boards(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -515,8 +541,9 @@ def test_8_8_by_cores_3_boards(self) -> None: self.assertEqual(16, machine.height) self.assertEqual(n_cores*3, machine.total_available_user_cores) - def test_8_8_by_cores_6_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_8_8_by_cores_6_boards(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -529,8 +556,9 @@ def test_8_8_by_cores_6_boards(self) -> None: self.assertEqual(16, machine.height) self.assertEqual(n_cores * 6, machine.total_available_user_cores) - def test_8_8_by_cores_12_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_8_8_by_cores_12_boards(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -543,8 +571,9 @@ def test_8_8_by_cores_12_boards(self) -> None: self.assertEqual(28, machine.height) self.assertEqual(n_cores * 12, machine.total_available_user_cores) - def test_8_8_by_cores_18_boards(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_8_8_by_cores_18_boards(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -557,14 +586,16 @@ def test_8_8_by_cores_18_boards(self) -> None: self.assertEqual(28, machine.height) self.assertEqual(n_cores * 18, machine.total_available_user_cores) - def test_by_min_size(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_by_min_size(self, _: str, version: str) -> None: + set_config("Machine", "version", version) machine = virtual_machine_by_min_size(15, 21) self.assertGreaterEqual(machine.width, 15) self.assertGreaterEqual(machine.height, 21) - def test_by_min_size_edge_case(self) -> None: - set_config("Machine", "versions", VersionStrings.BIG.text) + @parameterized.expand(BIG_BOARD_TYPES) + def test_by_min_size_edge_case(self, _: str, version: str) -> None: + set_config("Machine", "version", version) version = MachineDataView.get_machine_version() width, height = version.board_shape machine = virtual_machine_by_min_size(width, height + 1) diff --git a/unittests/version/test_version_string.py b/unittests/version/test_version_string.py deleted file mode 100644 index 5b903bae..00000000 --- a/unittests/version/test_version_string.py +++ /dev/null @@ -1,39 +0,0 @@ -# Copyright (c) 2024 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -Testing Versions -""" -import unittest -from spinn_machine.config_setup import unittest_setup -from spinn_machine.exceptions import SpinnMachineException -from spinn_machine.version.version_strings import VersionStrings - - -class TestVersionString(unittest.TestCase): - - def setUp(self) -> None: - unittest_setup() - - def test_names(self) -> None: - vs = VersionStrings.from_string("any") - self.assertEqual(vs.text, "Any") - vs = VersionStrings.from_string("FourPlus") - self.assertEqual(vs.text, "Four plus") - with self.assertRaises(SpinnMachineException): - vs = VersionStrings.from_string("Foo") - - -if __name__ == '__main__': - unittest.main() From 61dc2996b65ce5ce2b9b3fa773a166635cb0a93a Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Tue, 2 Jun 2026 10:40:37 +0100 Subject: [PATCH 05/13] add to init.py --- spinn_machine/version/__init__.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/spinn_machine/version/__init__.py b/spinn_machine/version/__init__.py index 55d34033..5c0cb073 100644 --- a/spinn_machine/version/__init__.py +++ b/spinn_machine/version/__init__.py @@ -13,7 +13,8 @@ # limitations under the License. from .version_factory import ( - ALL_BOARD_TYPES, FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) + ALL_BOARD_TYPES, BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES, + FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) -__all__ = ["ALL_BOARD_TYPES", "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", - "version_factory"] +__all__ = ["ALL_BOARD_TYPES", "BIG_BOARD_TYPES", "FOUR_PLUS_BOARD_TYPES", + "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", "version_factory"] From 5a80954e3db4d14a94df638c75846020269ec235 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Thu, 4 Jun 2026 12:15:38 +0100 Subject: [PATCH 06/13] more parameterized.expand --- spinn_machine/version/version_factory.py | 12 +-- spinn_machine/version/version_strings.py | 99 ------------------ unittests/data/test_data.py | 8 +- unittests/test_ignore_cores.py | 8 +- unittests/test_json_machine.py | 16 +-- unittests/test_machine.py | 72 ++++++------- unittests/test_using_virtual_machine.py | 68 ++++++------ unittests/test_virtual_machine_48chips.py | 120 +++++++++++----------- 8 files changed, 148 insertions(+), 255 deletions(-) delete mode 100644 spinn_machine/version/version_strings.py diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index 678672ea..b4b92910 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -14,7 +14,6 @@ from __future__ import annotations import logging -import sys from typing import Optional, TYPE_CHECKING from typing_extensions import Never @@ -23,7 +22,6 @@ get_config_bool, get_config_int_or_none, get_config_str_or_none) from spinn_utilities.log import FormatAdapter from spinn_machine.exceptions import SpinnMachineException -from .version_strings import VersionStrings if TYPE_CHECKING: from .abstract_version import AbstractVersion @@ -98,14 +96,8 @@ def _get_cfg_version() -> Optional[int]: version = get_config_int_or_none("Machine", "version") versions = get_config_str_or_none("Machine", "versions") if versions is not None: - if version is not None: - raise SpinnMachineException( - f"Both {version=} and {versions=} found in cfg") - vs = VersionStrings.from_string(versions) - options = vs.options - # Use the fact that we run actions against different python versions - minor = sys.version_info.minor - version = options[minor % len(options)] + raise SpinnMachineException( + f"{versions=} in cfg is no longer supported.") if version is None: logger.warning( "The cfg has no version. This is deprecated! Please add a version") diff --git a/spinn_machine/version/version_strings.py b/spinn_machine/version/version_strings.py deleted file mode 100644 index 9517dc75..00000000 --- a/spinn_machine/version/version_strings.py +++ /dev/null @@ -1,99 +0,0 @@ -# Copyright (c) 2024 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from enum import Enum -from typing import List, Tuple -from typing_extensions import Self -from spinn_machine.exceptions import SpinnMachineException - - -class VersionStrings(Enum): - """ - A description of strings in cfg settings to say test versions - - As additional Versions are added this should allow easy testing of these - as far as possible. - """ - - ANY = (1, "Any", [3, 5, 201, 248]) - FOUR_PLUS = (2, "Four plus", [3, 5, 248]) - # To test stuff with more than four chips. - BIG = (3, "Big", [5, 248]) - # Tests that specifically require 8 by 8 board(s) - # Could be changed but not worth the effort until needed - EIGHT_BY_EIGHT = (5, "eight by eigth", [5, 248]) - # Tests for 8 by 8 boards with FPGAs defined - WITH_FPGAS = (6, "with fpgas", [5]) - - def __new__(cls, *args: Tuple[int, str, List[int]], **kwds: None) -> Self: - vs = object.__new__(cls) - vs._value_ = args[0] - return vs - - def __init__(self, value: int, text: str, versions: List[int]): - """ - :param value: enum ID for this version - :param text: label for this enum - :param versions: machine versions that this group includes - """ - # ignore the first param since it's already set by __new__ - _ = value - self.text = text - self._versions = versions - - def __str__(self) -> str: - return self.text - - @property - def short_str(self) -> str: - """ - The text but in a shortened version - - This makes the text lower case and removes some special characters - """ - return self.shorten(self.text) - - # this makes sure that the description is read-only - @property - def options(self) -> List[int]: - """ - The list of the versions covered by this string - - This list can grow as new versions are added - """ - return self._versions - - @classmethod - def shorten(cls, value: str) -> str: - """ - Makes the String lower case and removes some special characters - - :param value: original string - :returns: original in lower case and without special characters - """ - return value.lower().replace("_", "").replace("-", "").replace(" ", "") - - @classmethod - def from_string(cls, value: str) -> "VersionStrings": - """ - Gets a VersionString object from a String - - :param value: label - :returns: VersionStrings Enum with this label - """ - value_short = cls.shorten(value) - for vs in cls: - if value_short == vs.short_str: - return vs - raise SpinnMachineException(f"No version for {value=}") diff --git a/unittests/data/test_data.py b/unittests/data/test_data.py index ae0d701e..e59954fa 100644 --- a/unittests/data/test_data.py +++ b/unittests/data/test_data.py @@ -62,8 +62,8 @@ def test_machine(self) -> None: self.assertTrue(MachineDataView.has_machine()) @parameterized.expand(BIG_BOARD_TYPES) - def test_where_is_mocked(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_where_is_mocked(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) writer = MachineDataWriter.mock() self.assertEqual( "No Machine created yet", @@ -81,8 +81,8 @@ def test_where_is_mocked(self, _: str, version: str) -> None: MachineDataView.where_is_chip(machine[2, 8])) @parameterized.expand(BIG_BOARD_TYPES) - def test_where_is_setup(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_where_is_setup(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) writer = MachineDataWriter.setup() self.assertEqual( "No Machine created yet", diff --git a/unittests/test_ignore_cores.py b/unittests/test_ignore_cores.py index 1f6c3f42..9ef43ae0 100644 --- a/unittests/test_ignore_cores.py +++ b/unittests/test_ignore_cores.py @@ -33,8 +33,8 @@ def setUp(self) -> None: unittest_setup() @parameterized.expand(BIG_BOARD_TYPES) - def test_bad_ignores(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_bad_ignores(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) try: IgnoreChip.parse_string("4,4,3,4:6,6,ignored_ip") @@ -55,8 +55,8 @@ def test_bad_ignores(self, _: str, version: str) -> None: self.assertTrue("downed_link" in str(ex)) @parameterized.expand(BIG_BOARD_TYPES) - def test_down_cores_bad_string(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_down_cores_bad_string(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) with self.assertRaises(ConfigException): IgnoreCore.parse_string("4,4,bacon") diff --git a/unittests/test_json_machine.py b/unittests/test_json_machine.py index 7b7022c7..abe52131 100644 --- a/unittests/test_json_machine.py +++ b/unittests/test_json_machine.py @@ -74,8 +74,8 @@ def test_json_version_201(self) -> None: self.assertEqual(str(vchip), str(jchip)) @parameterized.expand(BIG_BOARD_TYPES) - def test_json_hole(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_json_hole(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "3,3") writer = MachineDataWriter.mock() vm = virtual_machine_by_min_size(5, 5) @@ -90,8 +90,8 @@ def test_json_hole(self, _: str, version: str) -> None: self.assertEqual(str(vchip), str(jchip)) @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_exceptions(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_exceptions(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) writer = MachineDataWriter.mock() vm = virtual_machine_by_boards(1) writer.set_machine(vm) @@ -111,8 +111,8 @@ def test_exceptions(self, _: str, version: str) -> None: self.assertEqual(vchip10.tag_ids, chip10.tag_ids) @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_two_monitors(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_two_monitors(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine_by_boards(1) MachineDataWriter.mock().set_machine(vm) for chip in vm.chips: @@ -128,8 +128,8 @@ def test_two_monitors(self, _: str, version: str) -> None: self.assertEqual(str(vchip), str(jchip)) @parameterized.expand(BIG_BOARD_TYPES) - def test_ethernet_exceptions(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_ethernet_exceptions(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine_by_boards(2) MachineDataWriter.mock().set_machine(vm) eth2 = vm.ethernet_connected_chips[1] diff --git a/unittests/test_machine.py b/unittests/test_machine.py index ccc87265..fd0d9dd4 100644 --- a/unittests/test_machine.py +++ b/unittests/test_machine.py @@ -147,11 +147,11 @@ def test_summary(self) -> None: "The counts where Counter({456: 1, 321: 1}).") @parameterized.expand(ALL_BOARD_TYPES) - def test_chip_already_exists(self, _: str, version: str) -> None: + def test_chip_already_exists(self, _: str, ver_num: str) -> None: """ check that adding a chip that already exists causes an error """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) with self.assertRaises(SpinnMachineAlreadyExistsException): machine.add_chip(Chip( @@ -160,11 +160,11 @@ def test_chip_already_exists(self, _: str, version: str) -> None: self._nearest_ethernet_chip[1], self._ip)) @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_machine_get_chip_at(self, _: str, version: str) -> None: + def test_machine_get_chip_at(self, _: str, ver_num: str) -> None: """ test the get_chip_at function from the machine with a valid request """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) new_machine = virtual_machine_by_min_size(2, 2) self.assertEqual(1, new_machine[1, 0].x) self.assertEqual(0, new_machine[1, 0].y) @@ -172,12 +172,12 @@ def test_machine_get_chip_at(self, _: str, version: str) -> None: self.assertEqual(1, new_machine[0, 1].y) @parameterized.expand(ALL_BOARD_TYPES) - def test_machine_big_x(self, _: str, version: str) -> None: + def test_machine_big_x(self, _: str, ver_num: str) -> None: """ test the add_chips method of the machine chips outside size should produce an error """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -192,12 +192,12 @@ def test_machine_big_x(self, _: str, version: str) -> None: self.assertIn(f"has an x larger than width {width}", str(ex)) @parameterized.expand(ALL_BOARD_TYPES) - def test_machine_big_y(self, _: str, version: str) -> None: + def test_machine_big_y(self, _: str, ver_num: str) -> None: """ test the add_chips method of the machine chips outside size should produce an error """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -213,44 +213,44 @@ def test_machine_big_y(self, _: str, version: str) -> None: @parameterized.expand(ALL_BOARD_TYPES) def test_machine_get_chip_at_invalid_location( - self, _: str, version: str) -> None: + self, _: str, ver_num: str) -> None: """ test the machines get_chip_at function with a location thats invalid, should return None and not produce an error """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertEqual(None, new_machine.get_chip_at(width + 2, height // 2)) @parameterized.expand(ALL_BOARD_TYPES) - def test_machine_is_chip_at_true(self, _: str, version: str) -> None: + def test_machine_is_chip_at_true(self, _: str, ver_num: str) -> None: """ test the is_chip_at function of the machine with a position to request which does indeed contain a chip """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertTrue(new_machine.is_chip_at(width // 2, height // 2)) @parameterized.expand(ALL_BOARD_TYPES) - def test_machine_is_chip_at_false(self, _: str, version: str) -> None: + def test_machine_is_chip_at_false(self, _: str, ver_num: str) -> None: """ test the is_chip_at function of the machine with a position to request which does not contain a chip """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() new_machine = virtual_machine_by_boards(1) width, height = version.board_shape self.assertFalse(new_machine.is_chip_at(width + 2, height // 2)) @parameterized.expand(BIG_BOARD_TYPES) - def test_machine_get_chips_on_board(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_machine_get_chips_on_board(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) new_machine = virtual_machine_by_boards(3) version = MachineDataView.get_machine_version() for eth_chip in new_machine._ethernet_connected_chips: @@ -264,13 +264,13 @@ def test_machine_get_chips_on_board(self, _: str, version: str) -> None: new_machine.get_fpga_link_with_id(3, 3) @parameterized.expand(BIG_BOARD_TYPES) - def test_x_y_over_link(self, _: str, version: str) -> None: + def test_x_y_over_link(self, _: str, ver_num: str) -> None: """ Test the x_y with each wrap around. Notice that the function only does the math not validate the values. """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) # full wrap around machine = MachineDataView.get_machine_version().create_machine(24, 24) self.assertEqual(machine.xy_over_link(0, 0, 4), (23, 23)) @@ -293,13 +293,13 @@ def test_x_y_over_link(self, _: str, version: str) -> None: self.assertEqual(machine.wrap, "VerWrap") @parameterized.expand(BIG_BOARD_TYPES) - def test_get_global_xy(self, _: str, version: str) -> None: + def test_get_global_xy(self, _: str, ver_num: str) -> None: """ Test get_global_xy with each wrap around. Notice that the function only does the math not validate the values. """ - set_config("Machine", "version", version) + set_config("Machine", "version", ver_num) # full wrap around machine = MachineDataView.get_machine_version().create_machine(24, 24) self.assertEqual(machine.get_global_xy(1, 4, 4, 20), (5, 0)) @@ -318,8 +318,8 @@ def test_get_global_xy(self, _: str, version: str) -> None: self.assertEqual(machine.get_global_xy(5, 0, 20, 4), (25, 4)) @parameterized.expand(ALL_BOARD_TYPES) - def test_no_boot(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_no_boot(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -328,8 +328,8 @@ def test_no_boot(self, _: str, version: str) -> None: machine.validate() @parameterized.expand(ALL_BOARD_TYPES) - def test_negative_x(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_negative_x(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -340,8 +340,8 @@ def test_negative_x(self, _: str, version: str) -> None: machine.validate() @parameterized.expand(ALL_BOARD_TYPES) - def test_negative_y(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_negative_y(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape # create an empty Machine @@ -358,16 +358,16 @@ def _non_ethernet_chip(self, machine: Machine) -> Chip: raise SpinnMachineException("No none Ethernet Chip") @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_weird_ethernet1(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_weird_ethernet1(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) self._non_ethernet_chip(machine)._ip_address = "1.2.3.4" with self.assertRaises(SpinnMachineException): machine.validate() @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_bad_ethernet_chip_x(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_bad_ethernet_chip_x(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) width, _ = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = width + 1 @@ -375,8 +375,8 @@ def test_bad_ethernet_chip_x(self, _: str, version: str) -> None: machine.validate() @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_bad_ethernet_chip_no_chip(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_bad_ethernet_chip_no_chip(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) _, height = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = height + 1 @@ -384,8 +384,8 @@ def test_bad_ethernet_chip_no_chip(self, _: str, version: str) -> None: machine.validate() @parameterized.expand(BIG_BOARD_TYPES) - def test_concentric_xys(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_concentric_xys(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(5, 5) found = list(machine.concentric_xys(2, (2, 2))) expected = [ @@ -396,8 +396,8 @@ def test_concentric_xys(self, _: str, version: str) -> None: self.assertListEqual(expected, found) @parameterized.expand(ALL_BOARD_TYPES) - def test_too_few_cores(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_too_few_cores(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) # Hack to get n_processors return a low number chip = next(machine.chips) diff --git a/unittests/test_using_virtual_machine.py b/unittests/test_using_virtual_machine.py index 94408e40..b3dcf7cc 100644 --- a/unittests/test_using_virtual_machine.py +++ b/unittests/test_using_virtual_machine.py @@ -38,8 +38,8 @@ def setUp(self) -> None: unittest_setup() @parameterized.expand(ALL_BOARD_TYPES) - def test_new_vm_with_max_cores(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_new_vm_with_max_cores(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cpus = version.max_cores_per_chip - 5 set_config("Machine", "max_machine_core", str(n_cpus)) @@ -60,8 +60,8 @@ def test_new_vm_with_max_cores(self, _: str, version: str) -> None: len(list(chip.scamp_processors_ids))) @parameterized.expand(ALL_BOARD_TYPES) - def test_iter_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_iter_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine_by_boards(1) n_chips = MachineDataView.get_machine_version().n_chips_per_board self.assertEqual(n_chips, vm.n_chips) @@ -71,8 +71,8 @@ def test_iter_chips(self, _: str, version: str) -> None: self.assertEqual(n_chips, count) @parameterized.expand(FOUR_PLUS_BOARD_TYPES) - def test_down_chip(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_down_chip(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) down_chips = set() down_chips.add((1, 1)) set_config("Machine", "down_chips", "1,1") @@ -92,8 +92,8 @@ def _check_path(self, source: XY, target: XY, path: Tuple[int, int, int], self.assertEqual(target, new_target, "{}{}".format(source, path)) @parameterized.expand(BIG_BOARD_TYPES) - def test_nowrap_shortest_path(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_nowrap_shortest_path(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(16, 28, validate=True) for source in machine.chip_coordinates: for target in machine.chip_coordinates: @@ -107,8 +107,8 @@ def test_nowrap_shortest_path(self, _: str, version: str) -> None: self._check_path(source, target, path, 1000000, 1000000) @parameterized.expand(BIG_BOARD_TYPES) - def test_fullwrap_shortest_path(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_fullwrap_shortest_path(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) width = 12 height = 24 machine = virtual_machine(width, height, validate=True) @@ -125,8 +125,8 @@ def test_fullwrap_shortest_path(self, _: str, version: str) -> None: self._check_path(source, target, path, width, height) @parameterized.expand(BIG_BOARD_TYPES) - def test_hoizontal_wrap_shortest_path(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_hoizontal_wrap_shortest_path(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) width = 12 height = 16 machine = virtual_machine(width, height, validate=False) @@ -151,8 +151,8 @@ def test_hoizontal_wrap_shortest_path(self, _: str, version: str) -> None: self._check_path(source, target, path, width, height) @parameterized.expand(BIG_BOARD_TYPES) - def test_vertical_wrap_shortest_path(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_vertical_wrap_shortest_path(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) width = 16 height = 12 machine = virtual_machine(width, height, validate=False) @@ -177,8 +177,8 @@ def test_vertical_wrap_shortest_path(self, _: str, version: str) -> None: self._check_path(source, target, path, width, height) @parameterized.expand(ALL_BOARD_TYPES) - def test_minimize(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_minimize(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) for x in range(-3, 3): for y in range(-3, 3): @@ -187,8 +187,8 @@ def test_minimize(self, _: str, version: str) -> None: self.assertEqual(min1, min2) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_incoming_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_unreachable_incoming_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(6, 6) # Delete links incoming to 3, 3 @@ -201,8 +201,8 @@ def test_unreachable_incoming_chips(self, _: str, version: str) -> None: self.assertListEqual([(3, 3)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_outgoing_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_unreachable_outgoing_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(6, 6) # Delete links outgoing from 3, 3 @@ -213,8 +213,8 @@ def test_unreachable_outgoing_chips(self, _: str, version: str) -> None: self.assertListEqual([(3, 3)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_incoming_local_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_unreachable_incoming_local_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -224,8 +224,8 @@ def test_unreachable_incoming_local_chips(self, _: str, version: str) -> None: self.assertListEqual([(8, 7)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_outgoing_local_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_unreachable_outgoing_local_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -235,8 +235,8 @@ def test_unreachable_outgoing_local_chips(self, _: str, version: str) -> None: self.assertListEqual([(8, 7)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_repair_with_local_orphan(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_repair_with_local_orphan(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] down_str = ":".join([f"{x},{y}" for x, y in down_chips]) @@ -252,8 +252,8 @@ def test_repair_with_local_orphan(self, _: str, version: str) -> None: @parameterized.expand(BIG_BOARD_TYPES) def test_repair_with_one_way_links_different_boards( - self, _: str, version: str) -> None: - set_config("Machine", "version", version) + self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(12, 12) # Assumes boards of exactly size 8,8 # Delete some links between boards @@ -269,8 +269,8 @@ def test_repair_with_one_way_links_different_boards( self.assertIsNotNone(new_machine) @parameterized.expand(BIG_BOARD_TYPES) - def test_oneway_link_no_repair(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_oneway_link_no_repair(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(8, 8) # Delete some random links @@ -287,8 +287,8 @@ def test_oneway_link_no_repair(self, _: str, version: str) -> None: self.assertIsNotNone(new_machine) @parameterized.expand(BIG_BOARD_TYPES) - def test_removed_chip_repair(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_removed_chip_repair(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) del machine._chips[(3, 3)] @@ -298,8 +298,8 @@ def test_removed_chip_repair(self, _: str, version: str) -> None: self.assertFalse(new_machine.is_link_at(2, 2, 1)) @parameterized.expand(BIG_BOARD_TYPES) - def test_ignores(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_ignores(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "2,2:4,4:6,6,ignored_ip") set_config("Machine", "down_cores", "1,1,4:3,3,3: 5,5,-5:7,7,7,ignored_ip:0,0,5-10") diff --git a/unittests/test_virtual_machine_48chips.py b/unittests/test_virtual_machine_48chips.py index da1da4cf..5d4f5179 100644 --- a/unittests/test_virtual_machine_48chips.py +++ b/unittests/test_virtual_machine_48chips.py @@ -32,8 +32,8 @@ def setUp(self) -> None: unittest_setup() @parameterized.expand(BIG_BOARD_TYPES) - def test_illegal_vms(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_illegal_vms(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) with self.assertRaises(SpinnMachineException): virtual_machine(width=-1, height=2) with self.assertRaises(SpinnMachineException): @@ -52,8 +52,8 @@ def test_illegal_vms(self, _: str, version: str) -> None: validate=True) @parameterized.expand(BIG_BOARD_TYPES) - def test_version_hole(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_version_hole(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "3,3") vm = virtual_machine(height=8, width=8, validate=True) self.assertEqual(47, vm.n_chips) @@ -66,8 +66,8 @@ def test_version_hole(self, _: str, version: str) -> None: self.assertEqual(48, len(list(vm.local_xys))) @parameterized.expand(BIG_BOARD_TYPES) - def test_version_hole2(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_version_hole2(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "0,3") vm = virtual_machine(height=8, width=8, validate=True) self.assertEqual(47, vm.n_chips) @@ -81,24 +81,24 @@ def test_version_hole2(self, _: str, version: str) -> None: self.assertEqual((0, 4), vm.get_unused_xy()) @parameterized.expand(BIG_BOARD_TYPES) - def test_12_n_plus4_12_m_4(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_12_n_plus4_12_m_4(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) size_x = 12 * 5 size_y = 12 * 7 vm = virtual_machine(size_x + 4, size_y + 4, validate=True) self.assertEqual(size_x * size_y, vm.n_chips) @parameterized.expand(BIG_BOARD_TYPES) - def test_12_n_12_m(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_12_n_12_m(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) size_x = 12 * 5 size_y = 12 * 7 vm = virtual_machine(size_x, size_y, validate=True) self.assertEqual(size_x * size_y, vm.n_chips) @parameterized.expand(BIG_BOARD_TYPES) - def test_chips(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_chips(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine(8, 8) count = 0 for _chip in vm.chips: @@ -106,8 +106,8 @@ def test_chips(self, _: str, version: str) -> None: self.assertEqual(count, 48) @parameterized.expand(BIG_BOARD_TYPES) - def test_ethernet_chips_exist(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_ethernet_chips_exist(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine(width=48, height=24) for eth_chip in vm._ethernet_connected_chips: self.assertTrue(vm.get_chip_at(eth_chip.x, eth_chip.y), @@ -116,15 +116,15 @@ def test_ethernet_chips_exist(self, _: str, version: str) -> None: .format(eth_chip.x, eth_chip.y)) @parameterized.expand(BIG_BOARD_TYPES) - def test_boot_chip(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_boot_chip(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine(12, 12) # based on Chip equaling its XY self.assertEqual(vm.boot_chip, (0, 0)) @parameterized.expand(BIG_BOARD_TYPES) - def test_get_chips_on_boards(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_get_chips_on_boards(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) vm = virtual_machine(width=24, height=36) # check each chip appears only once on the entire board count00 = 0 @@ -151,14 +151,14 @@ def test_get_chips_on_boards(self, _: str, version: str) -> None: self.assertEqual(count2436, 0) @parameterized.expand(BIG_BOARD_TYPES) - def test_big(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_big(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) virtual_machine( width=240, height=240, validate=True) @parameterized.expand(BIG_BOARD_TYPES) - def test_48_28(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_48_28(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -173,8 +173,8 @@ def test_48_28(self, _: str, version: str) -> None: self.assertEqual(48, len(list(machine.local_xys))) @parameterized.expand(BIG_BOARD_TYPES) - def test_48_24(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_48_24(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -189,8 +189,8 @@ def test_48_24(self, _: str, version: str) -> None: self.assertEqual(48, len(list(machine.local_xys))) @parameterized.expand(BIG_BOARD_TYPES) - def test_52_28(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_52_28(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -205,8 +205,8 @@ def test_52_28(self, _: str, version: str) -> None: self.assertEqual(48, len(list(machine.local_xys))) @parameterized.expand(BIG_BOARD_TYPES) - def test_52_24(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_52_24(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine(48, 24, validate=True) global_xys = set() for chip in machine.chips: @@ -221,8 +221,8 @@ def test_52_24(self, _: str, version: str) -> None: self.assertEqual(48, len(list(machine.local_xys))) @parameterized.expand(BIG_BOARD_TYPES) - def test_fullwrap_holes(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_fullwrap_holes(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) hole = [(1, 1), (7, 7), (8, 1), (8, 10), (1, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -273,8 +273,8 @@ def test_fullwrap_holes(self, _: str, version: str) -> None: self.assertEqual(46, count) @parameterized.expand(BIG_BOARD_TYPES) - def test_horizontal_wrap_holes(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_horizontal_wrap_holes(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) hole = [(1, 1), (7, 7), (8, 13), (8, 10), (1, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -325,8 +325,8 @@ def test_horizontal_wrap_holes(self, _: str, version: str) -> None: self.assertEqual(46, count) @parameterized.expand(BIG_BOARD_TYPES) - def test_vertical_wrap_holes(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_vertical_wrap_holes(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) hole = [(1, 1), (7, 7), (8, 1), (8, 10), (13, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -377,8 +377,8 @@ def test_vertical_wrap_holes(self, _: str, version: str) -> None: self.assertEqual(46, count) @parameterized.expand(BIG_BOARD_TYPES) - def test_no_wrap_holes(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_no_wrap_holes(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) hole = [(1, 1), (7, 7), (8, 13), (8, 10), (13, 8), (9, 6)] hole_str = ":".join([f"{x},{y}" for x, y in hole]) set_config("Machine", "down_chips", hole_str) @@ -429,8 +429,8 @@ def test_no_wrap_holes(self, _: str, version: str) -> None: self.assertEqual(46, count) @parameterized.expand(BIG_BOARD_TYPES) - def test_n_cores_full_wrap(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_n_cores_full_wrap(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 12) @@ -442,8 +442,8 @@ def test_n_cores_full_wrap(self, _: str, version: str) -> None: self.assertEqual(n_cores, cores_per_board * 3) @parameterized.expand(BIG_BOARD_TYPES) - def test_n_cores_no_wrap(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_n_cores_no_wrap(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(16, 16) @@ -469,8 +469,8 @@ def test_n_cores_no_wrap(self, _: str, version: str) -> None: self.assertEqual(where, 'No chip 15, 15 found') @parameterized.expand(BIG_BOARD_TYPES) - def test_n_cores_horizontal_wrap(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_n_cores_horizontal_wrap(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 16) @@ -482,8 +482,8 @@ def test_n_cores_horizontal_wrap(self, _: str, version: str) -> None: self.assertEqual(n_cores, cores_per_board * 3) @parameterized.expand(BIG_BOARD_TYPES) - def test_n_cores_vertical_wrap(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_n_cores_vertical_wrap(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(12, 16) @@ -493,8 +493,8 @@ def test_n_cores_vertical_wrap(self, _: str, version: str) -> None: self.assertEqual(n_cores, cores_per_board * 3) @parameterized.expand(BIG_BOARD_TYPES) - def test_n_cores_8_8(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_n_cores_8_8(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() cores_per_board = sum(version.chip_core_map.values()) machine = virtual_machine(8, 8) @@ -505,8 +505,8 @@ def test_n_cores_8_8(self, _: str, version: str) -> None: self.assertEqual(n_cores, cores_per_board) @parameterized.expand(BIG_BOARD_TYPES) - def test_8_8_by_cores_1_board(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_8_8_by_cores_1_board(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -520,8 +520,8 @@ def test_8_8_by_cores_1_board(self, _: str, version: str) -> None: self.assertEqual(n_cores, machine.total_available_user_cores) @parameterized.expand(BIG_BOARD_TYPES) - def test_8_8_by_cores_3_boards(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_8_8_by_cores_3_boards(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -542,8 +542,8 @@ def test_8_8_by_cores_3_boards(self, _: str, version: str) -> None: self.assertEqual(n_cores*3, machine.total_available_user_cores) @parameterized.expand(BIG_BOARD_TYPES) - def test_8_8_by_cores_6_boards(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_8_8_by_cores_6_boards(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -557,8 +557,8 @@ def test_8_8_by_cores_6_boards(self, _: str, version: str) -> None: self.assertEqual(n_cores * 6, machine.total_available_user_cores) @parameterized.expand(BIG_BOARD_TYPES) - def test_8_8_by_cores_12_boards(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_8_8_by_cores_12_boards(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -572,8 +572,8 @@ def test_8_8_by_cores_12_boards(self, _: str, version: str) -> None: self.assertEqual(n_cores * 12, machine.total_available_user_cores) @parameterized.expand(BIG_BOARD_TYPES) - def test_8_8_by_cores_18_boards(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_8_8_by_cores_18_boards(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() n_cores = sum(version.chip_core_map.values()) n_cores -= version.n_chips_per_board * version.n_scamp_cores @@ -587,15 +587,15 @@ def test_8_8_by_cores_18_boards(self, _: str, version: str) -> None: self.assertEqual(n_cores * 18, machine.total_available_user_cores) @parameterized.expand(BIG_BOARD_TYPES) - def test_by_min_size(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_by_min_size(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(15, 21) self.assertGreaterEqual(machine.width, 15) self.assertGreaterEqual(machine.height, 21) @parameterized.expand(BIG_BOARD_TYPES) - def test_by_min_size_edge_case(self, _: str, version: str) -> None: - set_config("Machine", "version", version) + def test_by_min_size_edge_case(self, _: str, ver_num: str) -> None: + set_config("Machine", "version", ver_num) version = MachineDataView.get_machine_version() width, height = version.board_shape machine = virtual_machine_by_min_size(width, height + 1) From 6c8298ca2e4fee8b2df34a72c2da5c02203fdb85 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Thu, 4 Jun 2026 14:42:15 +0100 Subject: [PATCH 07/13] cfg versions removed --- spinn_machine/spinn_machine.cfg | 2 -- spinn_machine/version/version_factory.py | 8 ++++---- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/spinn_machine/spinn_machine.cfg b/spinn_machine/spinn_machine.cfg index 313b0bab..12d9ce24 100644 --- a/spinn_machine/spinn_machine.cfg +++ b/spinn_machine/spinn_machine.cfg @@ -16,8 +16,6 @@ version = None * This replaces deprecated "width" and "height" options * "versions" option is for testing only and picks a version based on python version # Used Instead of version if multiple versions should be tested! -versions = None -@versions = Testing Option. Picks a valid version based on python version. Requires [virtual_board](virtual_board) width = None @width = Deprecated use [version](version). Width for a virtual machine. If used requires [height](height) and [virtual_board](virtual_board) diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index b4b92910..5145aedc 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -19,7 +19,8 @@ from typing_extensions import Never from spinn_utilities.config_holder import ( - get_config_bool, get_config_int_or_none, get_config_str_or_none) + get_config_bool, get_config_int_or_none, get_config_str_or_none, + has_config_option) from spinn_utilities.log import FormatAdapter from spinn_machine.exceptions import SpinnMachineException if TYPE_CHECKING: @@ -94,10 +95,9 @@ def version_factory() -> AbstractVersion: def _get_cfg_version() -> Optional[int]: version = get_config_int_or_none("Machine", "version") - versions = get_config_str_or_none("Machine", "versions") - if versions is not None: + if has_config_option("Machine", "versions"): raise SpinnMachineException( - f"{versions=} in cfg is no longer supported.") + f"versions in cfg is no longer supported.") if version is None: logger.warning( "The cfg has no version. This is deprecated! Please add a version") From 42138e9b7527a909666289916f48df1e3d44d2b3 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Thu, 4 Jun 2026 14:58:17 +0100 Subject: [PATCH 08/13] mypy types underscore --- unittests/test_machine.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/unittests/test_machine.py b/unittests/test_machine.py index fd0d9dd4..0945c178 100644 --- a/unittests/test_machine.py +++ b/unittests/test_machine.py @@ -369,7 +369,7 @@ def test_weird_ethernet1(self, _: str, ver_num: str) -> None: def test_bad_ethernet_chip_x(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) - width, _ = MachineDataView.get_machine_version().board_shape + width, __ = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = width + 1 with self.assertRaises(SpinnMachineException): machine.validate() @@ -378,7 +378,7 @@ def test_bad_ethernet_chip_x(self, _: str, ver_num: str) -> None: def test_bad_ethernet_chip_no_chip(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) - _, height = MachineDataView.get_machine_version().board_shape + __, height = MachineDataView.get_machine_version().board_shape self._non_ethernet_chip(machine)._nearest_ethernet_x = height + 1 with self.assertRaises(SpinnMachineException): machine.validate() From a2d2bc018275ab66f28d8147d4f9f326422d7aa5 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Thu, 4 Jun 2026 15:13:13 +0100 Subject: [PATCH 09/13] flake8 --- spinn_machine/version/version_factory.py | 6 +++--- unittests/test_using_virtual_machine.py | 6 ++++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index 5145aedc..fdf0c54a 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -42,8 +42,8 @@ ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] EIGHT_BY_EIGHT_BOARD_TYPES = [["FIVE", str(FIVE)], ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] -BIG_BOARD_TYPES = [["FIVE", str(FIVE)], - ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] +BIG_BOARD_TYPES = [["FIVE", str(FIVE)], + ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] def version_factory() -> AbstractVersion: @@ -97,7 +97,7 @@ def _get_cfg_version() -> Optional[int]: version = get_config_int_or_none("Machine", "version") if has_config_option("Machine", "versions"): raise SpinnMachineException( - f"versions in cfg is no longer supported.") + "versions in cfg is no longer supported.") if version is None: logger.warning( "The cfg has no version. This is deprecated! Please add a version") diff --git a/unittests/test_using_virtual_machine.py b/unittests/test_using_virtual_machine.py index b3dcf7cc..f3fb4541 100644 --- a/unittests/test_using_virtual_machine.py +++ b/unittests/test_using_virtual_machine.py @@ -213,7 +213,8 @@ def test_unreachable_outgoing_chips(self, _: str, ver_num: str) -> None: self.assertListEqual([(3, 3)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_incoming_local_chips(self, _: str, ver_num: str) -> None: + def test_unreachable_incoming_local_chips( + self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] @@ -224,7 +225,8 @@ def test_unreachable_incoming_local_chips(self, _: str, ver_num: str) -> None: self.assertListEqual([(8, 7)], unreachable) @parameterized.expand(BIG_BOARD_TYPES) - def test_unreachable_outgoing_local_chips(self, _: str, ver_num: str) -> None: + def test_unreachable_outgoing_local_chips( + self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 down_chips = [(8, 6), (9, 7), (9, 8)] From d1f986ad3ecbdb6c492129b5b0f566cc9beba811 Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Fri, 5 Jun 2026 06:48:38 +0100 Subject: [PATCH 10/13] FPGA_BOARD_TYPES --- spinn_machine/version/__init__.py | 5 +++-- spinn_machine/version/version_factory.py | 3 +-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/spinn_machine/version/__init__.py b/spinn_machine/version/__init__.py index 5c0cb073..515e4bc3 100644 --- a/spinn_machine/version/__init__.py +++ b/spinn_machine/version/__init__.py @@ -14,7 +14,8 @@ from .version_factory import ( ALL_BOARD_TYPES, BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES, - FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) + FPGA_BOARD_TYPES, FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) __all__ = ["ALL_BOARD_TYPES", "BIG_BOARD_TYPES", "FOUR_PLUS_BOARD_TYPES", - "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE", "version_factory"] + "FPGA_BOARD_TYPES", "version_factory", + "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE"] diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index fdf0c54a..d3cf37b0 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -40,10 +40,9 @@ ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] FOUR_PLUS_BOARD_TYPES = [["THREE", THREE], ["FIVE", str(FIVE)], ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] -EIGHT_BY_EIGHT_BOARD_TYPES = [["FIVE", str(FIVE)], - ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] BIG_BOARD_TYPES = [["FIVE", str(FIVE)], ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] +FPGA_BOARD_TYPES = [["FIVE", str(FIVE)]] def version_factory() -> AbstractVersion: From 5da6cd036f9e1dc4c9e93e488397c06f8c42fa4a Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Mon, 8 Jun 2026 17:27:43 +0100 Subject: [PATCH 11/13] MANY boards if possible. Comment if not --- spinn_machine/version/version_factory.py | 1 + unittests/data/test_data.py | 4 ++-- unittests/test_ignore_cores.py | 6 +++--- unittests/test_json_machine.py | 4 ++-- unittests/test_machine.py | 8 ++++---- unittests/test_using_virtual_machine.py | 26 ++++++++++++------------ 6 files changed, 25 insertions(+), 24 deletions(-) diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index d3cf37b0..d497819e 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -43,6 +43,7 @@ BIG_BOARD_TYPES = [["FIVE", str(FIVE)], ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] FPGA_BOARD_TYPES = [["FIVE", str(FIVE)]] +MANY_BOARD_TYPES = ALL_BOARD_TYPES def version_factory() -> AbstractVersion: diff --git a/unittests/data/test_data.py b/unittests/data/test_data.py index e59954fa..19cabc69 100644 --- a/unittests/data/test_data.py +++ b/unittests/data/test_data.py @@ -61,7 +61,7 @@ def test_machine(self) -> None: writer.set_machine("bacon") # type: ignore[arg-type] self.assertTrue(MachineDataView.has_machine()) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # needs multiple boards def test_where_is_mocked(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) writer = MachineDataWriter.mock() @@ -80,7 +80,7 @@ def test_where_is_mocked(self, _: str, ver_num: str) -> None: "global chip 2, 8 on 127.0.0.0 is chip 6, 4 on 127.0.8.4", MachineDataView.where_is_chip(machine[2, 8])) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_where_is_setup(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) writer = MachineDataWriter.setup() diff --git a/unittests/test_ignore_cores.py b/unittests/test_ignore_cores.py index 9ef43ae0..e3ecf9e6 100644 --- a/unittests/test_ignore_cores.py +++ b/unittests/test_ignore_cores.py @@ -22,7 +22,7 @@ from spinn_machine.config_setup import unittest_setup from spinn_machine.exceptions import SpinnMachineException from spinn_machine.ignores import IgnoreChip, IgnoreCore, IgnoreLink -from spinn_machine.version import SPIN2_1CHIP, BIG_BOARD_TYPES +from spinn_machine.version import SPIN2_1CHIP, MANY_BOARD_TYPES from spinn_machine.version.version_201 import Version201 from spinn_machine.version.version_5 import Version5 @@ -32,7 +32,7 @@ class TestDownCores(unittest.TestCase): def setUp(self) -> None: unittest_setup() - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(MANY_BOARD_TYPES) def test_bad_ignores(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) @@ -54,7 +54,7 @@ def test_bad_ignores(self, _: str, ver_num: str) -> None: except Exception as ex: self.assertTrue("downed_link" in str(ex)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(MANY_BOARD_TYPES) def test_down_cores_bad_string(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) with self.assertRaises(ConfigException): diff --git a/unittests/test_json_machine.py b/unittests/test_json_machine.py index abe52131..28f7cbaf 100644 --- a/unittests/test_json_machine.py +++ b/unittests/test_json_machine.py @@ -73,7 +73,7 @@ def test_json_version_201(self) -> None: for vchip, jchip in zip(vm, jm): self.assertEqual(str(vchip), str(jchip)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_json_hole(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "3,3") @@ -127,7 +127,7 @@ def test_two_monitors(self, _: str, ver_num: str) -> None: for vchip, jchip in zip(vm, jm): self.assertEqual(str(vchip), str(jchip)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs board with Ethernet def test_ethernet_exceptions(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) vm = virtual_machine_by_boards(2) diff --git a/unittests/test_machine.py b/unittests/test_machine.py index 0945c178..8deb69b4 100644 --- a/unittests/test_machine.py +++ b/unittests/test_machine.py @@ -248,7 +248,7 @@ def test_machine_is_chip_at_false(self, _: str, ver_num: str) -> None: width, height = version.board_shape self.assertFalse(new_machine.is_chip_at(width + 2, height // 2)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs many boards def test_machine_get_chips_on_board(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) new_machine = virtual_machine_by_boards(3) @@ -263,7 +263,7 @@ def test_machine_get_chips_on_board(self, _: str, ver_num: str) -> None: with self.assertRaises(KeyError): new_machine.get_fpga_link_with_id(3, 3) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_x_y_over_link(self, _: str, ver_num: str) -> None: """ Test the x_y with each wrap around. @@ -292,7 +292,7 @@ def test_x_y_over_link(self, _: str, ver_num: str) -> None: self.assertEqual(machine.xy_over_link(15, 23, 1), (16, 0)) self.assertEqual(machine.wrap, "VerWrap") - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_get_global_xy(self, _: str, ver_num: str) -> None: """ Test get_global_xy with each wrap around. @@ -383,7 +383,7 @@ def test_bad_ethernet_chip_no_chip(self, _: str, ver_num: str) -> None: with self.assertRaises(SpinnMachineException): machine.validate() - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_concentric_xys(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(5, 5) diff --git a/unittests/test_using_virtual_machine.py b/unittests/test_using_virtual_machine.py index f3fb4541..0c953aec 100644 --- a/unittests/test_using_virtual_machine.py +++ b/unittests/test_using_virtual_machine.py @@ -91,7 +91,7 @@ def _check_path(self, source: XY, target: XY, path: Tuple[int, int, int], (source[1] + path[1] - path[2]) % height) self.assertEqual(target, new_target, "{}{}".format(source, path)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_nowrap_shortest_path(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine(16, 28, validate=True) @@ -106,7 +106,7 @@ def test_nowrap_shortest_path(self, _: str, ver_num: str) -> None: mac_len, abs(path[0]) + abs(path[1]) + abs(path[2])) self._check_path(source, target, path, 1000000, 1000000) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_fullwrap_shortest_path(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) width = 12 @@ -124,7 +124,7 @@ def test_fullwrap_shortest_path(self, _: str, ver_num: str) -> None: "{}{}{}".format(source, target, path)) self._check_path(source, target, path, width, height) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_hoizontal_wrap_shortest_path(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) width = 12 @@ -150,7 +150,7 @@ def test_hoizontal_wrap_shortest_path(self, _: str, ver_num: str) -> None: "{}{}{}".format(source, target, path)) self._check_path(source, target, path, width, height) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_vertical_wrap_shortest_path(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) width = 16 @@ -186,7 +186,7 @@ def test_minimize(self, _: str, ver_num: str) -> None: min2 = machine._minimize_vector(x, y) self.assertEqual(min1, min2) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_unreachable_incoming_chips(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(6, 6) @@ -200,7 +200,7 @@ def test_unreachable_incoming_chips(self, _: str, ver_num: str) -> None: unreachable = machine.unreachable_incoming_chips() self.assertListEqual([(3, 3)], unreachable) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_unreachable_outgoing_chips(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_min_size(6, 6) @@ -212,7 +212,7 @@ def test_unreachable_outgoing_chips(self, _: str, ver_num: str) -> None: unreachable = machine.unreachable_outgoing_chips() self.assertListEqual([(3, 3)], unreachable) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_unreachable_incoming_local_chips( self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) @@ -224,7 +224,7 @@ def test_unreachable_incoming_local_chips( unreachable = machine.unreachable_incoming_local_chips() self.assertListEqual([(8, 7)], unreachable) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_unreachable_outgoing_local_chips( self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) @@ -236,7 +236,7 @@ def test_unreachable_outgoing_local_chips( unreachable = machine.unreachable_outgoing_local_chips() self.assertListEqual([(8, 7)], unreachable) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_repair_with_local_orphan(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) # Assumes boards of exactly size 8,8 @@ -252,7 +252,7 @@ def test_repair_with_local_orphan(self, _: str, ver_num: str) -> None: self.assertTrue(machine.is_chip_at(8, 7)) self.assertFalse(repaired.is_chip_at(8, 7)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs multiple boards def test_repair_with_one_way_links_different_boards( self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) @@ -270,7 +270,7 @@ def test_repair_with_one_way_links_different_boards( new_machine = machine_repair(machine) self.assertIsNotNone(new_machine) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_oneway_link_no_repair(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine(8, 8) @@ -288,7 +288,7 @@ def test_oneway_link_no_repair(self, _: str, ver_num: str) -> None: new_machine = machine_repair(machine) self.assertIsNotNone(new_machine) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_removed_chip_repair(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) machine = virtual_machine_by_boards(1) @@ -299,7 +299,7 @@ def test_removed_chip_repair(self, _: str, ver_num: str) -> None: self.assertIsNotNone(new_machine) self.assertFalse(new_machine.is_link_at(2, 2, 1)) - @parameterized.expand(BIG_BOARD_TYPES) + @parameterized.expand(BIG_BOARD_TYPES) # Needs a large board def test_ignores(self, _: str, ver_num: str) -> None: set_config("Machine", "version", ver_num) set_config("Machine", "down_chips", "2,2:4,4:6,6,ignored_ip") From 37535d2462c804fd3c91a4728687350aa37e795d Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Tue, 9 Jun 2026 08:30:25 +0100 Subject: [PATCH 12/13] Which boards are MANY by Environment variable --- spinn_machine/version/version_factory.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/spinn_machine/version/version_factory.py b/spinn_machine/version/version_factory.py index d497819e..e3a5aa1a 100644 --- a/spinn_machine/version/version_factory.py +++ b/spinn_machine/version/version_factory.py @@ -15,6 +15,7 @@ from __future__ import annotations import logging from typing import Optional, TYPE_CHECKING +import os from typing_extensions import Never @@ -43,7 +44,10 @@ BIG_BOARD_TYPES = [["FIVE", str(FIVE)], ["SPIN2_48CHIP", str(SPIN2_48CHIP)]] FPGA_BOARD_TYPES = [["FIVE", str(FIVE)]] -MANY_BOARD_TYPES = ALL_BOARD_TYPES +if os.environ.get("SPINNAKER_TEST_ALL") == "true": + MANY_BOARD_TYPES = ALL_BOARD_TYPES +else: + MANY_BOARD_TYPES = BIG_BOARD_TYPES def version_factory() -> AbstractVersion: From 41ae2edf6edc308f1030131793ec1051add6477c Mon Sep 17 00:00:00 2001 From: "Christian Y. Brenninkmeijer" Date: Tue, 9 Jun 2026 08:37:06 +0100 Subject: [PATCH 13/13] MANY boards is enough --- spinn_machine/version/__init__.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/spinn_machine/version/__init__.py b/spinn_machine/version/__init__.py index 515e4bc3..cbf4aead 100644 --- a/spinn_machine/version/__init__.py +++ b/spinn_machine/version/__init__.py @@ -14,8 +14,9 @@ from .version_factory import ( ALL_BOARD_TYPES, BIG_BOARD_TYPES, FOUR_PLUS_BOARD_TYPES, - FPGA_BOARD_TYPES, FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) + FPGA_BOARD_TYPES, MANY_BOARD_TYPES, + FIVE, SPIN2_1CHIP, SPIN2_48CHIP, THREE, version_factory) __all__ = ["ALL_BOARD_TYPES", "BIG_BOARD_TYPES", "FOUR_PLUS_BOARD_TYPES", - "FPGA_BOARD_TYPES", "version_factory", + "FPGA_BOARD_TYPES", "MANY_BOARD_TYPES", "version_factory", "FIVE", "SPIN2_1CHIP", "SPIN2_48CHIP", "THREE"]