Repository: spinnakermanchester/spinnfrontendcommon
Issue: InsertLivePacketGatherersToGraphs Too many update steps in progress bar

Found with script in spynnaker_integration_tests/test_external_devices/test_live_neuron_voltage.py

This test has two live_packet_gatherer_parameters

InsertLivePacketGatherersToGraphs adds one vertex for each 

So either that is incorrect and only one vertex is needed or more likely the progress bar calc is wrong.

I note: InsertLivePacketGatherersToGraphs reserves one core per parameter so it is likely the second option.

Changed files:
spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_chip_power_monitor.py
spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_live_packet_gatherers.py
spinn_front_end_common/interface/interface_functions/insert_live_packet_gatherers_to_graphs.py
spinn_front_end_common/utilities/utility_objs/live_packet_gather_parameters.py
fec_integration_tests/interface/interface_functions/test_front_end_common_insert_lpgs.py
fec_integration_tests/interface/interface_functions/test_front_end_common_insert_edges_to_live_packet_gatherers.py
spinn_front_end_common/interface/interface_functions/pre_allocate_for_bit_field_router_compressor.py
spinn_front_end_common/interface/interface_functions/preallocate_resources_for_extra_monitor_support.py
fec_integration_tests/interface/interface_functions/test_front_end_common_create_pre_allocated_res_for_lpg.py
spinn_front_end_common/interface/interface_functions/graph_measurer.py
spinn_front_end_common/interface/abstract_spinnaker_base.py

diff --git a/fec_integration_tests/interface/interface_functions/test_front_end_common_create_pre_allocated_res_for_lpg.py b/fec_integration_tests/interface/interface_functions/test_front_end_common_create_pre_allocated_res_for_lpg.py
index 56924a37a..ec14e2a89 100644
--- a/fec_integration_tests/interface/interface_functions/test_front_end_common_create_pre_allocated_res_for_lpg.py
+++ b/fec_integration_tests/interface/interface_functions/test_front_end_common_create_pre_allocated_res_for_lpg.py
@@ -16,9 +16,7 @@
 import unittest
 from spinn_machine import virtual_machine
 from spinnman.messages.eieio import EIEIOType
-from pacman.model.resources import (
-    ConstantSDRAM, CoreResource, PreAllocatedResourceContainer,
-    SpecificChipSDRAMResource)
+from pacman.model.resources import PreAllocatedResourceContainer
 from spinn_front_end_common.interface.config_setup import unittest_setup
 from spinn_front_end_common.interface.interface_functions import (
     PreAllocateResourcesForLivePacketGatherers)
@@ -66,182 +64,15 @@ class TestLPGPreAllocateRes(unittest.TestCase):
             machine=machine,
             pre_allocated_resources=PreAllocatedResourceContainer())
 
-        locs = list()
-        locs.append((0, 0))
-        locs.append((4, 8))
-        locs.append((8, 4))
-
-        # verify sdram
-        sdrams = pre_res.specific_sdram_usage
-        for sdram in sdrams:
-            locs.remove((sdram.chip.x, sdram.chip.y))
-            self.assertEqual(
-                sdram.sdram_usage.get_total_sdram(0),
-                LivePacketGatherMachineVertex.get_sdram_usage())
-        self.assertEqual(len(locs), 0)
-
-        locs = list()
-        locs.append((0, 0))
-        locs.append((4, 8))
-        locs.append((8, 4))
-        # verify cores
-        cores = pre_res.core_resources
-        for core in cores:
-            locs.remove((core.chip.x, core.chip.y))
-            self.assertEqual(core.n_cores, 1)
-        self.assertEqual(len(locs), 0)
-
-        # verify specific cores
-        self.assertEqual(len(pre_res.specific_core_resources), 0)
-
-    def test_one_lpg_params_and_3_specific(self):
-        machine = virtual_machine(width=12, height=12)
-
-        default_params = {
-            'use_prefix': False,
-            'key_prefix': None,
-            'prefix_type': None,
-            'message_type': EIEIOType.KEY_32_BIT,
-            'right_shift': 0,
-            'payload_as_time_stamps': True,
-            'use_payload_prefix': True,
-            'payload_prefix': None,
-            'payload_right_shift': 0,
-            'number_of_packets_sent_per_time_step': 0,
-            'hostname': None,
-            'port': None,
-            'strip_sdp': None,
-            'tag': None,
-            'label': "Test"}
-
-        # data stores needed by algorithm
-        live_packet_gatherers = dict()
-        default_params_holder = LivePacketGatherParameters(**default_params)
-        live_packet_gatherers[default_params_holder] = list()
-
-        # and special LPG on Ethernet connected chips
-        for chip in machine.ethernet_connected_chips:
-            extended = dict(default_params)
-            extended['board_address'] = chip.ip_address
-            default_params_holder2 = LivePacketGatherParameters(**extended)
-            live_packet_gatherers[default_params_holder2] = list()
-
-        pre_alloc = PreAllocateResourcesForLivePacketGatherers()
-        pre_res = pre_alloc(
-            live_packet_gatherer_parameters=live_packet_gatherers,
-            machine=machine,
-            pre_allocated_resources=PreAllocatedResourceContainer())
-
-        # verify sdram
-        locs = [(0, 0), (4, 8), (8, 4)]
-        sdrams = pre_res.specific_sdram_usage
-        for sdram in sdrams:
-            locs.remove((sdram.chip.x, sdram.chip.y))
-            self.assertEqual(
-                sdram.sdram_usage.get_total_sdram(0),
-                LivePacketGatherMachineVertex.get_sdram_usage() * 2)
-        self.assertEqual(len(locs), 0)
-
-        # verify cores
-        locs = {(0, 0): 0, (4, 8): 0, (8, 4): 0}
-        cores = pre_res.core_resources
-        for core in cores:
-            locs[core.chip.x, core.chip.y] += core.n_cores
-
-        for (x, y) in [(0, 0), (4, 8), (8, 4)]:
-            self.assertEqual(locs[x, y], 2)
-
-        # verify specific cores
-        self.assertEqual(len(pre_res.specific_core_resources), 0)
-
-    def test_added_pre_res(self):
-        machine = virtual_machine(width=12, height=12)
-
-        default_params = {
-            'use_prefix': False,
-            'key_prefix': None,
-            'prefix_type': None,
-            'message_type': EIEIOType.KEY_32_BIT,
-            'right_shift': 0,
-            'payload_as_time_stamps': True,
-            'use_payload_prefix': True,
-            'payload_prefix': None,
-            'payload_right_shift': 0,
-            'number_of_packets_sent_per_time_step': 0,
-            'hostname': None,
-            'port': None,
-            'strip_sdp': None,
-            'tag': None,
-            'label': "Test"}
-
-        # data stores needed by algorithm
-        live_packet_gatherers = dict()
-        default_params_holder = LivePacketGatherParameters(**default_params)
-        live_packet_gatherers[default_params_holder] = list()
-
-        # create pre res
-        sdram_requirements = {machine.get_chip_at(2, 2): 30000,
-                              machine.get_chip_at(7, 7): 50000}
-        core_requirements = {machine.get_chip_at(3, 3): 2}
-
-        sdrams = list()
-        cores = list()
-        for chip in sdram_requirements:
-            sdrams.append(SpecificChipSDRAMResource(
-                chip, ConstantSDRAM(sdram_requirements[chip])))
-        for chip in core_requirements:
-            cores.append(CoreResource(chip, core_requirements[chip]))
-        pre_pre_res = PreAllocatedResourceContainer(
-            core_resources=cores, specific_sdram_usage=sdrams)
-
-        # run  pre allocator
-        pre_alloc = PreAllocateResourcesForLivePacketGatherers()
-        pre_res = pre_alloc(
-            live_packet_gatherer_parameters=live_packet_gatherers,
-            machine=machine, pre_allocated_resources=pre_pre_res)
-
-        locs = list()
-        locs.append((0, 0))
-        locs.append((4, 8))
-        locs.append((8, 4))
-        locs.append((2, 2))
-        locs.append((7, 7))
-
         # verify sdram
-        sdrams = pre_res.specific_sdram_usage
-        for sdram in sdrams:
-            locs.remove((sdram.chip.x, sdram.chip.y))
-            if sdram.sdram_usage.get_total_sdram(0) != \\
-                    LivePacketGatherMachineVertex.get_sdram_usage():
-                self.assertIn(sdram.chip.x, (2, 7))
-                self.assertIn(sdram.chip.y, (2, 7))
-                self.assertEqual(sdram.chip.x, sdram.chip.y)
-                if sdram.chip.x == 2 and sdram.chip.y == 2:
-                    self.assertEqual(sdram.sdram_usage.get_total_sdram(0),
-                                     30000)
-                elif sdram.chip.x == 7 and sdram.chip.y == 7:
-                    self.assertEqual(sdram.sdram_usage.get_total_sdram(0),
-                                     50000)
-        self.assertEqual(len(locs), 0)
-
-        locs = list()
-        locs.append((0, 0))
-        locs.append((4, 8))
-        locs.append((8, 4))
-        locs.append((3, 3))
-
-        # verify cores
-        cores = pre_res.core_resources
-        for core in cores:
-            locs.remove((core.chip.x, core.chip.y))
-            if core.n_cores != 1:
-                self.assertEqual(core.chip.x, 3)
-                self.assertEqual(core.chip.y, 3)
-                self.assertEqual(core.n_cores, 2)
-        self.assertEqual(len(locs), 0)
+        self.assertEqual(
+            pre_res.sdram_all.get_total_sdram(0), 0)
+        self.assertEqual(
+            pre_res.sdram_ethernet.get_total_sdram(0),
+            LivePacketGatherMachineVertex.get_sdram_usage())
 
-        # verify specific cores
-        self.assertEqual(len(pre_res.specific_core_resources), 0)
+        self.assertEqual(pre_res.cores_all, 0)
+        self.assertEqual(pre_res.cores_ethernet, 1)
 
     def test_none(self):
         machine = virtual_machine(width=12, height=12)
@@ -252,9 +83,13 @@ class TestLPGPreAllocateRes(unittest.TestCase):
             live_packet_gatherer_parameters=live_packet_gatherers,
             machine=machine,
             pre_allocated_resources=PreAllocatedResourceContainer())
-        self.assertEqual(len(pre_res.specific_core_resources), 0)
-        self.assertEqual(len(pre_res.core_resources), 0)
-        self.assertEqual(len(pre_res.specific_sdram_usage), 0)
+        self.assertEqual(
+            pre_res.sdram_all.get_total_sdram(0), 0)
+        self.assertEqual(
+            pre_res.sdram_ethernet.get_total_sdram(0), 0)
+
+        self.assertEqual(pre_res.cores_all, 0)
+        self.assertEqual(pre_res.cores_ethernet, 0)
 
     def test_fail(self):
         machine = virtual_machine(width=12, height=12)
@@ -267,7 +102,7 @@ class TestLPGPreAllocateRes(unittest.TestCase):
                 pre_allocated_resources=PreAllocatedResourceContainer())
         # Make sure we know what the exception was; NOT an important test!
         self.assertEqual(
-            "'str' object has no attribute 'board_address'",
+            "'str' object has no attribute 'hostname'",
             str(exn.exception))
 
 
diff --git a/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_edges_to_live_packet_gatherers.py b/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_edges_to_live_packet_gatherers.py
index 1055c21e7..6eb63f26c 100644
--- a/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_edges_to_live_packet_gatherers.py
+++ b/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_edges_to_live_packet_gatherers.py
@@ -126,125 +126,6 @@ class TestInsertLPGEdges(unittest.TestCase):
             for edge in edges:
                 self.assertIn(edge.pre_vertex, verts_expected[chip.x, chip.y])
 
-    def test_local_verts_when_multiple_lpgs_are_local(self):
-        machine = virtual_machine(width=12, height=12)
-        graph = MachineGraph("Test")
-
-        default_params = {
-            'use_prefix': False,
-            'key_prefix': None,
-            'prefix_type': None,
-            'message_type': EIEIOType.KEY_32_BIT,
-            'right_shift': 0,
-            'payload_as_time_stamps': True,
-            'use_payload_prefix': True,
-            'payload_prefix': None,
-            'payload_right_shift': 0,
-            'number_of_packets_sent_per_time_step': 0,
-            'hostname': None,
-            'port': None,
-            'strip_sdp': None,
-            'tag': None,
-            'label': "Test"}
-
-        # data stores needed by algorithm
-        live_packet_gatherers = dict()
-        default_params_holder = LivePacketGatherParameters(**default_params)
-        live_packet_gatherers[default_params_holder] = list()
-
-        live_packet_gatherers_to_vertex_mapping = dict()
-        mac_vtxs_1 = dict()
-        live_packet_gatherers_to_vertex_mapping[default_params_holder] = (
-            None, mac_vtxs_1)
-
-        placements = Placements()
-
-        # add LPG's (1 for each Ethernet connected chip)
-
-        specific_data_holders = dict()
-        index = 1
-        for chip in machine.ethernet_connected_chips:
-            extended = dict(default_params)
-            vertex = LivePacketGatherMachineVertex(
-                LivePacketGatherParameters(**extended), label='test')
-            graph.add_vertex(vertex)
-            placements.add_placement(
-                Placement(x=chip.x, y=chip.y, p=2, vertex=vertex))
-            live_packet_gatherers_to_vertex_mapping[
-                default_params_holder][1][chip.x, chip.y] = vertex
-
-            # Add another on each chip separately
-            index += 1
-            extended = dict(default_params)
-            extended['board_address'] = chip.ip_address
-            default_params_holder2 = LivePacketGatherParameters(**extended)
-
-            extended = dict(default_params)
-            extended.update({'label': "test"})
-            vertex = LivePacketGatherMachineVertex(
-                LivePacketGatherParameters(**extended))
-            specific_data_holders[(chip.x, chip.y)] = default_params_holder2
-            placements.add_placement(Placement(
-                x=chip.x, y=chip.y, p=3, vertex=vertex))
-            graph.add_vertex(vertex)
-
-            mac_vtxs_2 = dict()
-            live_packet_gatherers_to_vertex_mapping[default_params_holder2] = (
-                None, mac_vtxs_2)
-            mac_vtxs_2[chip.x, chip.y] = vertex
-            live_packet_gatherers[default_params_holder2] = list()
-
-        # tracker of wirings
-        verts_expected = defaultdict(list)
-
-        positions = list()
-        positions.append([0, 0, 0, 0, 2, default_params_holder])
-        positions.append([4, 4, 0, 0, 2, default_params_holder])
-        positions.append(
-            [1, 1, 0, 0, 3, specific_data_holders[(0, 0)]])
-        positions.append(
-            [2, 2, 0, 0, 3, specific_data_holders[(0, 0)]])
-        positions.append([8, 4, 8, 4, 2, default_params_holder])
-        positions.append([11, 4, 8, 4, 2, default_params_holder])
-        positions.append([4, 11, 4, 8, 2, default_params_holder])
-        positions.append([4, 8, 4, 8, 2, default_params_holder])
-        positions.append([0, 11, 8, 4, 3, specific_data_holders[(8, 4)]])
-        positions.append([11, 11, 4, 8, 3, specific_data_holders[(4, 8)]])
-        positions.append([8, 8, 4, 8, 3, specific_data_holders[(4, 8)]])
-        positions.append([4, 0, 0, 0, 3, specific_data_holders[(0, 0)]])
-        positions.append([7, 7, 0, 0, 2, default_params_holder])
-
-        # add graph vertices which reside on areas of the machine to ensure
-        #  spread over boards.
-        for x, y, eth_x, eth_y, eth_p, params in positions:
-            vertex = SimpleMachineVertex(resources=ResourceContainer())
-            graph.add_vertex(vertex)
-            live_packet_gatherers[params].append((vertex, ["EVENTS"]))
-            verts_expected[eth_x, eth_y, eth_p].append(vertex)
-            placements.add_placement(Placement(x=x, y=y, p=5, vertex=vertex))
-
-        # run edge inserter that should go boom
-        edge_inserter = InsertEdgesToLivePacketGatherers()
-        edge_inserter(
-            live_packet_gatherer_parameters=live_packet_gatherers,
-            placements=placements,
-            live_packet_gatherers_to_vertex_mapping=(
-                live_packet_gatherers_to_vertex_mapping),
-            machine=machine, machine_graph=graph, application_graph=None)
-
-        # verify edges are in the right place
-        for chip in machine.ethernet_connected_chips:
-            for params, p in zip(
-                    (default_params_holder,
-                     specific_data_holders[chip.x, chip.y]),
-                    (2, 3)):
-                edges = graph.get_edges_ending_at_vertex(
-                    live_packet_gatherers_to_vertex_mapping[
-                        params][1][chip.x, chip.y])
-                for edge in edges:
-                    self.assertIn(
-                        edge.pre_vertex, verts_expected[chip.x, chip.y, p])
-
     def test_local_verts_go_to_local_lpgs_app_graph(self):
         machine = virtual_machine(width=12, height=12)
         app_graph = ApplicationGraph("Test")
diff --git a/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_lpgs.py b/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_lpgs.py
index 037171c35..23196dc74 100644
--- a/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_lpgs.py
+++ b/fec_integration_tests/interface/interface_functions/test_front_end_common_insert_lpgs.py
@@ -137,122 +137,6 @@ class TestInsertLPGs(unittest.TestCase):
         # Should only be a single app vertex for one set of params
         self.assertEqual(len(app_verts), 1)
 
-    def test_that_6_lpgs_are_generated_2_on_each_eth_chip(self):
-        machine = virtual_machine(width=12, height=12)
-        graph = MachineGraph("Test")
-
-        default_params = {
-            'use_prefix': False,
-            'key_prefix': None,
-            'prefix_type': None,
-            'message_type': EIEIOType.KEY_32_BIT,
-            'right_shift': 0,
-            'payload_as_time_stamps': True,
-            'use_payload_prefix': True,
-            'payload_prefix': None,
-            'payload_right_shift': 0,
-            'number_of_packets_sent_per_time_step': 0,
-            'hostname': None,
-            'port': None,
-            'strip_sdp': None,
-            'tag': None,
-            'label': "Test"}
-
-        # data stores needed by algorithm
-        live_packet_gatherers = dict()
-        default_params_holder = LivePacketGatherParameters(**default_params)
-        live_packet_gatherers[default_params_holder] = list()
-
-        # and special LPG on Ethernet connected chips
-        chip_special = dict()
-        for chip in machine.ethernet_connected_chips:
-            extended = dict(default_params)
-            extended['board_address'] = chip.ip_address
-            default_params_holder2 = LivePacketGatherParameters(**extended)
-            live_packet_gatherers[default_params_holder2] = list()
-            chip_special[(chip.x, chip.y)] = default_params_holder2
-
-        # run edge inserter that should go boom
-        edge_inserter = InsertLivePacketGatherersToGraphs()
-        lpg_verts_mapping = edge_inserter(
-            live_packet_gatherer_parameters=live_packet_gatherers,
-            machine=machine, machine_graph=graph, application_graph=None)
-
-        self.assertEqual(len(lpg_verts_mapping[default_params_holder][1]), 3)
-
-        for eth_chip in chip_special:
-            params = chip_special[eth_chip]
-            self.assertEqual(len(lpg_verts_mapping[params][1]), 1)
-            vertex = lpg_verts_mapping[params][1][eth_chip]
-            self.assertEqual(eth_chip[0], list(vertex.constraints)[0].x)
-            self.assertEqual(eth_chip[1], list(vertex.constraints)[0].y)
-
-    def test_that_6_lpgs_are_generated_2_on_each_eth_chip_app_graph(self):
-        machine = virtual_machine(width=12, height=12)
-        app_graph = ApplicationGraph("Test")
-        graph = MachineGraph("Test", app_graph)
-
-        default_params = {
-            'use_prefix': False,
-            'key_prefix': None,
-            'prefix_type': None,
-            'message_type': EIEIOType.KEY_32_BIT,
-            'right_shift': 0,
-            'payload_as_time_stamps': True,
-            'use_payload_prefix': True,
-            'payload_prefix': None,
-            'payload_right_shift': 0,
-            'number_of_packets_sent_per_time_step': 0,
-            'hostname': None,
-            'port': None,
-            'strip_sdp': None,
-            'tag': None,
-            'label': "Test"}
-
-        # data stores needed by algorithm
-        live_packet_gatherers = dict()
-        default_params_holder = LivePacketGatherParameters(**default_params)
-        live_packet_gatherers[default_params_holder] = list()
-
-        # and special LPG on Ethernet connected chips
-        chip_special = dict()
-        for chip in machine.ethernet_connected_chips:
-            extended = dict(default_params)
-            extended['board_address'] = chip.ip_address
-            default_params_holder2 = LivePacketGatherParameters(**extended)
-            live_packet_gatherers[default_params_holder2] = list()
-            chip_special[(chip.x, chip.y)] = default_params_holder2
-
-        # run edge inserter that should go boom
-        edge_inserter = InsertLivePacketGatherersToGraphs()
-        lpg_verts_mapping = edge_inserter(
-            live_packet_gatherer_parameters=live_packet_gatherers,
-            machine=machine, machine_graph=graph, application_graph=app_graph)
-
-        self.assertEqual(len(lpg_verts_mapping[default_params_holder][1]), 3)
-
-        for eth_chip in chip_special:
-            params = chip_special[eth_chip]
-            self.assertEqual(len(lpg_verts_mapping[params][1]), 1)
-            vertex = lpg_verts_mapping[params][1][eth_chip]
-            self.assertEqual(eth_chip[0], list(vertex.constraints)[0].x)
-            self.assertEqual(eth_chip[1], list(vertex.constraints)[0].y)
-
-        verts = list(lpg_verts_mapping[default_params_holder][1].values())
-        for params in chip_special.values():
-            verts.extend(lpg_verts_mapping[params][1].values())
-
-        for vertex in graph.vertices:
-            self.assertIn(vertex, verts)
-
-        app_verts = set()
-        for vertex in verts:
-            app_vertex = vertex.app_vertex
-            self.assertIsInstance(app_vertex, ApplicationVertex)
-            app_verts.add(app_vertex)
-        # One for the global one, one for each chip-level one
-        self.assertEqual(len(app_verts), 4)
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/spinn_front_end_common/interface/abstract_spinnaker_base.py b/spinn_front_end_common/interface/abstract_spinnaker_base.py
index 63e323437..94ac84e03 100644
--- a/spinn_front_end_common/interface/abstract_spinnaker_base.py
+++ b/spinn_front_end_common/interface/abstract_spinnaker_base.py
@@ -45,7 +45,7 @@ from pacman.model.graphs.application import (
 from pacman.model.graphs.machine import (
     MachineGraph, MachineGraphView, MachineVertex)
 from pacman.model.resources import (
-    PreAllocatedResourceContainer, ConstantSDRAM)
+    ConstantSDRAM, PreAllocatedResourceContainer)
 from pacman import __version__ as pacman_version
 from spinn_utilities.config_holder import (
     get_config_bool, get_config_int, get_config_str, get_config_str_list,
diff --git a/spinn_front_end_common/interface/interface_functions/graph_measurer.py b/spinn_front_end_common/interface/interface_functions/graph_measurer.py
index 06f09a0df..737bc0397 100644
--- a/spinn_front_end_common/interface/interface_functions/graph_measurer.py
+++ b/spinn_front_end_common/interface/interface_functions/graph_measurer.py
@@ -49,4 +49,4 @@ class GraphMeasurer(object):
         for vertex in progress.over(ordered_vertices):
             resource_tracker.allocate_constrained_resources(
                 vertex.resources_required, vertex.constraints)
-        return len(resource_tracker.keys)
+        return resource_tracker.chips_used
diff --git a/spinn_front_end_common/interface/interface_functions/insert_live_packet_gatherers_to_graphs.py b/spinn_front_end_common/interface/interface_functions/insert_live_packet_gatherers_to_graphs.py
index 7672ac0bf..b00a11d5e 100644
--- a/spinn_front_end_common/interface/interface_functions/insert_live_packet_gatherers_to_graphs.py
+++ b/spinn_front_end_common/interface/interface_functions/insert_live_packet_gatherers_to_graphs.py
@@ -71,19 +71,15 @@ class InsertLivePacketGatherersToGraphs(object):
                 self._application_graph.add_vertex(lpg_app_vtx)
                 mac_vtxs = dict()
                 for chip in progress.over(machine.ethernet_connected_chips):
-                    if (params.board_address is None or
-                            params.board_address == chip.ip_address):
-                        mac_vtxs[chip.x, chip.y] = self._add_app_lpg_vertex(
-                            lpg_app_vtx, chip)
+                    mac_vtxs[chip.x, chip.y] = self._add_app_lpg_vertex(
+                        lpg_app_vtx, chip)
                 lpg_params_to_vertices[params] = (lpg_app_vtx, mac_vtxs)
         else:
             for params in live_packet_gatherer_parameters:
                 mac_vtxs = dict()
                 for chip in progress.over(machine.ethernet_connected_chips):
-                    if (params.board_address is None or
-                            params.board_address == chip.ip_address):
-                        mac_vtxs[chip.x, chip.y] = self._add_mach_lpg_vertex(
-                            chip, params)
+                    mac_vtxs[chip.x, chip.y] = self._add_mach_lpg_vertex(
+                        chip, params)
                 lpg_params_to_vertices[params] = (None, mac_vtxs)
 
         return lpg_params_to_vertices
diff --git a/spinn_front_end_common/interface/interface_functions/pre_allocate_for_bit_field_router_compressor.py b/spinn_front_end_common/interface/interface_functions/pre_allocate_for_bit_field_router_compressor.py
index 3e6ad667d..fc437d1bb 100644
--- a/spinn_front_end_common/interface/interface_functions/pre_allocate_for_bit_field_router_compressor.py
+++ b/spinn_front_end_common/interface/interface_functions/pre_allocate_for_bit_field_router_compressor.py
@@ -14,9 +14,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from spinn_utilities.config_holder import get_config_int
-from spinn_utilities.progress_bar import ProgressBar
-from pacman.model.resources import (
-    ConstantSDRAM, SpecificChipSDRAMResource, PreAllocatedResourceContainer)
+from spinn_machine.machine import Machine
+from pacman.model.resources import (ConstantSDRAM)
 from spinn_front_end_common.interface.interface_functions. \\
     machine_bit_field_router_compressor import (
         SIZE_OF_SDRAM_ADDRESS_IN_BYTES)
@@ -37,24 +36,16 @@ class PreAllocateForBitFieldRouterCompressor(object):
         :rtype: ~pacman.model.resources.PreAllocatedResourceContainer
         """
 
-        progress_bar = ProgressBar(
-            machine.n_chips,
-            "Preallocating resources for bit field compressor")
-
         # for every Ethernet connected chip, get the resources needed by the
         # live packet gatherers
-        sdrams = list()
         sdram_to_pre_alloc_for_bit_fields = get_config_int(
             "Mapping",
             "router_table_compression_with_bit_field_pre_alloced_sdram")
-        for chip in progress_bar.over(machine.chips):
-            sdram = ConstantSDRAM(
-                (SIZE_OF_SDRAM_ADDRESS_IN_BYTES * chip.n_user_processors) +
-                sdram_to_pre_alloc_for_bit_fields)
-            sdrams.append(SpecificChipSDRAMResource(chip, sdram))
+        sdram = ConstantSDRAM(
+            (SIZE_OF_SDRAM_ADDRESS_IN_BYTES * Machine.max_cores_per_chip()) +
+            sdram_to_pre_alloc_for_bit_fields)
 
         # note what has been preallocated
-        allocated = PreAllocatedResourceContainer(
-            specific_sdram_usage=sdrams)
-        allocated.extend(pre_allocated_resources)
-        return allocated
+        pre_allocated_resources.add_sdram_all(sdram)
+
+        return pre_allocated_resources
diff --git a/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_chip_power_monitor.py b/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_chip_power_monitor.py
index 9f835a59c..2536a1253 100644
--- a/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_chip_power_monitor.py
+++ b/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_chip_power_monitor.py
@@ -13,9 +13,6 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from spinn_utilities.progress_bar import ProgressBar
-from pacman.model.resources import (
-    CoreResource, PreAllocatedResourceContainer, SpecificChipSDRAMResource)
 from spinn_front_end_common.utility_models import (
     ChipPowerMonitorMachineVertex)
 
@@ -38,24 +35,10 @@ class PreAllocateResourcesForChipPowerMonitor(object):
         """
         # pylint: disable=too-many-arguments
 
-        progress_bar = ProgressBar(
-            machine.n_chips, "Preallocating resources for chip power monitor")
-
         # store how much SDRAM the power monitor uses per core
         resources = ChipPowerMonitorMachineVertex.get_resources(
             sampling_frequency=sampling_frequency)
+        pre_allocated_resources.add_sdram_all(resources.sdram)
+        pre_allocated_resources.add_cores_all(1)
 
-        # for every Ethernet connected chip, get the resources needed by the
-        # live packet gatherers
-        sdrams = list()
-        cores = list()
-        for chip in progress_bar.over(machine.chips):
-            sdrams.append(
-                SpecificChipSDRAMResource(chip, resources.sdram))
-            cores.append(CoreResource(chip, 1))
-
-        # note what has been preallocated
-        allocated = PreAllocatedResourceContainer(
-            specific_sdram_usage=sdrams, core_resources=cores)
-        allocated.extend(pre_allocated_resources)
-        return allocated
+        return pre_allocated_resources
diff --git a/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_live_packet_gatherers.py b/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_live_packet_gatherers.py
index 63cf3f41f..e27cc48c1 100644
--- a/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_live_packet_gatherers.py
+++ b/spinn_front_end_common/interface/interface_functions/pre_allocate_resources_for_live_packet_gatherers.py
@@ -13,10 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from spinn_utilities.progress_bar import ProgressBar
-from pacman.model.resources import (
-    ConstantSDRAM, CoreResource, PreAllocatedResourceContainer,
-    SpecificChipSDRAMResource, SpecificBoardIPtagResource)
+from pacman.model.resources import ConstantSDRAM, IPtagResource
 from spinn_front_end_common.utility_models import (
     LivePacketGatherMachineVertex)
 
@@ -43,62 +40,15 @@ class PreAllocateResourcesForLivePacketGatherers(object):
         :rtype: ~pacman.model.resources.PreAllocatedResourceContainer
         """
 
-        progress = ProgressBar(
-            len(machine.ethernet_connected_chips),
-            "Preallocating resources for Live Recording")
-
         # store how much SDRAM the LPG uses per core
-        sdram_requirement = LivePacketGatherMachineVertex.get_sdram_usage()
-
-        # for every Ethernet connected chip, get the resources needed by the
-        # live packet gatherers
-        sdrams = list()
-        cores = list()
-        iptags = list()
-        for chip in progress.over(machine.ethernet_connected_chips):
-            self._add_chip_lpg_reqs(
-                live_packet_gatherer_parameters, chip, sdram_requirement,
-                sdrams, cores, iptags)
-
-        # note what has been preallocated
-        allocated = PreAllocatedResourceContainer(
-            specific_sdram_usage=sdrams, core_resources=cores,
-            specific_iptag_resources=iptags)
-        allocated.extend(pre_allocated_resources)
-        return allocated
-
-    @staticmethod
-    def _add_chip_lpg_reqs(
-            lpg_parameters, chip, lpg_sdram, sdrams, cores, iptags):
-        """
-        :param lpg_parameters:
-        :type lpg_parameters:
-            dict(LivePacketGatherParameters,
-            list(tuple(~.AbstractVertex, list(str))))
-        :param ~.Chip chip:
-        :param int lpg_sdram:
-        :param list(~.SpecificChipSDRAMResource) sdrams:
-        :param list(~.CoreResource) cores:
-        :param list(~.SpecificBoardIPtagResource) iptags:
-        """
-        # pylint: disable=too-many-arguments
-        sdram_reqs = 0
-        core_reqs = 0
-
-        for lpg_params in lpg_parameters:
-            if (lpg_params.board_address is None or
-                    lpg_params.board_address == chip.ip_address):
-                sdram_reqs += lpg_sdram
-                core_reqs += 1
-                iptags.append(SpecificBoardIPtagResource(
-                    board=chip.ip_address,
-                    ip_address=lpg_params.hostname, port=lpg_params.port,
-                    strip_sdp=lpg_params.strip_sdp, tag=lpg_params.tag,
-                    traffic_identifier=(
-                        LivePacketGatherMachineVertex.TRAFFIC_IDENTIFIER)))
-
-        if sdram_reqs:
-            sdrams.append(SpecificChipSDRAMResource(
-                chip, ConstantSDRAM(sdram_reqs)))
-        if core_reqs:
-            cores.append(CoreResource(chip, core_reqs))
+        sdram = ConstantSDRAM(LivePacketGatherMachineVertex.get_sdram_usage())
+        for lpg_params in live_packet_gatherer_parameters:
+            pre_allocated_resources.add_sdram_ethernet(sdram)
+            pre_allocated_resources.add_cores_ethernet(1)
+            pre_allocated_resources.add_iptag_resource(IPtagResource(
+                ip_address=lpg_params.hostname, port=lpg_params.port,
+                strip_sdp=lpg_params.strip_sdp, tag=lpg_params.tag,
+                traffic_identifier=(
+                    LivePacketGatherMachineVertex.TRAFFIC_IDENTIFIER)))
+
+        return pre_allocated_resources
diff --git a/spinn_front_end_common/interface/interface_functions/preallocate_resources_for_extra_monitor_support.py b/spinn_front_end_common/interface/interface_functions/preallocate_resources_for_extra_monitor_support.py
index 1942a1be4..b1b646518 100644
--- a/spinn_front_end_common/interface/interface_functions/preallocate_resources_for_extra_monitor_support.py
+++ b/spinn_front_end_common/interface/interface_functions/preallocate_resources_for_extra_monitor_support.py
@@ -13,10 +13,6 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from spinn_utilities.progress_bar import ProgressBar
-from pacman.model.resources import (
-    SpecificChipSDRAMResource, CoreResource,
-    PreAllocatedResourceContainer, SpecificBoardIPtagResource)
 from spinn_front_end_common.utility_models import (
     ExtraMonitorSupportMachineVertex)
 from spinn_front_end_common.utility_models import (
@@ -38,83 +34,15 @@ class PreAllocateResourcesForExtraMonitorSupport(object):
         :rtype: ~pacman.model.resources.PreAllocatedResourceContainer
         """
 
-        progress = ProgressBar(
-            len(list(machine.ethernet_connected_chips)) + machine.n_chips,
-            "Preallocating resources for Extra Monitor support vertices")
-
-        sdrams = list()
-        cores = list()
-        tags = list()
-
-        # add resource requirements for the gatherers on each Ethernet
-        # connected chip. part of data extraction
-        self._handle_packet_gathering_support(
-            sdrams, cores, tags, machine, progress, n_cores_to_allocate)
-
-        # add resource requirements for re-injector and reader for data
-        # extractor
-        self._handle_second_monitor_support(cores, sdrams, machine, progress)
-
-        # note what has been preallocated
-        allocated = PreAllocatedResourceContainer(
-            specific_sdram_usage=sdrams, core_resources=cores,
-            specific_iptag_resources=tags)
-        allocated.extend(pre_allocated_resources)
-        return allocated
-
-    @staticmethod
-    def _handle_second_monitor_support(cores, sdrams, machine, progress):
-        """ Adds the second monitor preallocations, which reflect the\\
-            reinjector and data extractor support
+        resources = DataSpeedUpPacketGatherMachineVertex.\\
+            static_resources_required()
+        pre_allocated_resources.add_sdram_ethernet(resources.sdram)
+        pre_allocated_resources.add_cores_ethernet(n_cores_to_allocate)
+        pre_allocated_resources.add_iptag_resource(resources.iptags[0])
 
-        :param list(~.CoreResource) cores: the storage of core requirements
-        :param ~.Machine machine: the spinnMachine instance
-        :param ~.ProgressBar progress: the progress bar to operate one
-        """
         extra_usage = \\
             ExtraMonitorSupportMachineVertex.static_resources_required()
-        for chip in progress.over(machine.chips):
-            cores.append(CoreResource(chip=chip, n_cores=1))
-            sdrams.append(SpecificChipSDRAMResource(
-                chip=chip, sdram_usage=extra_usage.sdram))
-
-    @staticmethod
-    def _handle_packet_gathering_support(
-            sdrams, cores, tags, machine, progress, n_cores_to_allocate):
-        """ Adds the packet gathering functionality tied into the data\\
-            extractor within each chip
-
-        :param list(~.SpecificChipSDRAMResource) sdrams:
-            the preallocated SDRAM requirement for these vertices
-        :param list(~.CoreResource) cores:
-            the preallocated cores requirement for these vertices
-        :param list(~.SpecificBoardIPtagResource) tags:
-            the preallocated tags requirement for these vertices
-        :param ~.Machine machine: the spinnMachine instance
-        :param ~.ProgressBar progress: the progress bar to update as needed
-        :param int n_cores_to_allocate:
-            how many packet gathers to allocate per chip
-        """
-        # pylint: disable=too-many-arguments
-
-        # get resources from packet gatherer
-        resources = DataSpeedUpPacketGatherMachineVertex.\\
-            static_resources_required()
+        pre_allocated_resources.add_sdram_all(extra_usage.sdram)
+        pre_allocated_resources.add_cores_all(1)
 
-        # locate Ethernet connected chips that the vertices reside on
-        for ethernet_connected_chip in \\
-                progress.over(machine.ethernet_connected_chips,
-                              finish_at_end=False):
-            # do resources. SDRAM, cores, tags
-            sdrams.append(SpecificChipSDRAMResource(
-                chip=ethernet_connected_chip,
-                sdram_usage=resources.sdram))
-            cores.append(CoreResource(
-                chip=ethernet_connected_chip, n_cores=n_cores_to_allocate))
-            tags.append(SpecificBoardIPtagResource(
-                board=ethernet_connected_chip.ip_address,
-                ip_address=resources.iptags[0].ip_address,
-                port=resources.iptags[0].port,
-                strip_sdp=resources.iptags[0].strip_sdp,
-                tag=resources.iptags[0].tag,
-                traffic_identifier=resources.iptags[0].traffic_identifier))
+        return pre_allocated_resources
diff --git a/spinn_front_end_common/utilities/utility_objs/live_packet_gather_parameters.py b/spinn_front_end_common/utilities/utility_objs/live_packet_gather_parameters.py
index d1b58d3a1..c41912e7c 100644
--- a/spinn_front_end_common/utilities/utility_objs/live_packet_gather_parameters.py
+++ b/spinn_front_end_common/utilities/utility_objs/live_packet_gather_parameters.py
@@ -29,11 +29,10 @@ class LivePacketGatherParameters(object):
     """
 
     __slots__ = [
-        '_port', '_hostname', "_tag", "_board_address", "_strip_sdp",
-        "_use_prefix", "_key_prefix", "_prefix_type", "_message_type",
-        "_right_shift", "_payload_as_time_stamps", "_use_payload_prefix",
-        "_payload_prefix",  "_payload_right_shift",
-        "_n_packets_per_time_step", "_label"
+        '_port', '_hostname', "_tag", "_strip_sdp", "_use_prefix",
+        "_key_prefix", "_prefix_type", "_message_type", "_right_shift",
+        "_payload_as_time_stamps", "_use_payload_prefix", "_payload_prefix",
+        "_payload_right_shift", "_n_packets_per_time_step", "_label"
     ]
 
     def __init__(
@@ -42,8 +41,7 @@ class LivePacketGatherParameters(object):
             message_type=EIEIOType.KEY_32_BIT, right_shift=0,
             payload_as_time_stamps=True, use_payload_prefix=True,
             payload_prefix=None, payload_right_shift=0,
-            number_of_packets_sent_per_time_step=0, label=None,
-            board_address=None):
+            number_of_packets_sent_per_time_step=0, label=None):
         """
         :raises ConfigurationException:
             If the parameters passed are known to be an invalid combination.
@@ -71,7 +69,6 @@ class LivePacketGatherParameters(object):
         self._port = port
         self._hostname = hostname
         self._tag = tag
-        self._board_address = board_address
         self._strip_sdp = strip_sdp
         self._use_prefix = use_prefix
         self._key_prefix = key_prefix
@@ -97,10 +94,6 @@ class LivePacketGatherParameters(object):
     def tag(self):
         return self._tag
 
-    @property
-    def board_address(self):
-        return self._board_address
-
     @property
     def strip_sdp(self):
         return self._strip_sdp
@@ -164,7 +157,6 @@ class LivePacketGatherParameters(object):
         return (self._port == other.port and
                 self._hostname == other.hostname and
                 self._tag == other.tag and
-                self._board_address == other.board_address and
                 self._strip_sdp == other.strip_sdp and
                 self._use_prefix == other.use_prefix and
                 self._key_prefix == other.key_prefix and
@@ -185,10 +177,10 @@ class LivePacketGatherParameters(object):
 
     def __hash__(self):
         data = (
-            self._port, self._tag, self._board_address, self._strip_sdp,
-            self._use_prefix, self._key_prefix, self._prefix_type,
-            self._message_type, self._right_shift,
-            self._payload_as_time_stamps, self._use_payload_prefix,
-            self._payload_prefix, self._payload_right_shift,
-            self._n_packets_per_time_step, self._label)
+            self._port, self._tag, self._strip_sdp, self._use_prefix,
+            self._key_prefix, self._prefix_type, self._message_type,
+            self._right_shift, self._payload_as_time_stamps,
+            self._use_payload_prefix, self._payload_prefix,
+            self._payload_right_shift, self._n_packets_per_time_step,
+            self._label)
         return hash(data)