def range_compressor(router_tables, accept_overflow=True): """ :param MulticastRoutingTables router_tables: :param bool accept_overflow: A flag which should only be used in testing to stop raising an exception if result is too big :rtype: MulticastRoutingTables """ if accept_overflow: message = "Precompressing tables using Range Compressor" else: message = "Compressing tables using Range Compressor" progress = ProgressBar(len(router_tables.routing_tables), message) compressor = RangeCompressor() compressed_tables = MulticastRoutingTables() for table in progress.over(router_tables.routing_tables): new_table = compressor.compress_table(table) if (new_table.number_of_entries > Machine.ROUTER_ENTRIES and not accept_overflow): raise MinimisationFailedError( f"The routing table {table.x} {table.y} with " f"{table.number_of_entries} entries after compression " f"still has {new_table.number_of_entries} so will not fit") compressed_tables.add_routing_table(new_table) logger.info(f"Ranged compressor resulted with the largest table of size " f"{compressed_tables.max_number_of_entries}") return compressed_tables
def __call__(self, router_tables): tables = MulticastRoutingTables() previous_masks = dict() progress = ProgressBar( len(router_tables.routing_tables) * 2, "Compressing Routing Tables") # Create all masks without holes allowed_masks = [_32_BITS - ((2**i) - 1) for i in range(33)] # Check that none of the masks have "holes" e.g. 0xFFFF0FFF has a hole for router_table in router_tables.routing_tables: for entry in router_table.multicast_routing_entries: if entry.mask not in allowed_masks: raise PacmanRoutingException( "Only masks without holes are allowed in tables for" " MallocBasedRouteMerger (disallowed mask={})".format( hex(entry.mask))) for router_table in progress.over(router_tables.routing_tables): new_table = self._merge_routes(router_table, previous_masks) tables.add_routing_table(new_table) n_entries = len([ entry for entry in new_table.multicast_routing_entries if not entry.defaultable ]) print("Reduced from {} to {}".format( len(router_table.multicast_routing_entries), n_entries)) if n_entries > 1023: raise PacmanRoutingException( "Cannot make table small enough: {} entries".format( n_entries)) return tables
def __call__(self, router_tables, target_length=None): # build storage compressed_pacman_router_tables = MulticastRoutingTables() # create progress bar progress = ProgressBar( router_tables.routing_tables, "Compressing routing Tables") # compress each router for router_table in progress.over(router_tables.routing_tables): # convert to rig format entries = self._convert_to_mundy_format(router_table) # compress the router entries compressed_router_table_entries = \ rigs_compressor.minimise(entries, target_length) # convert back to pacman model compressed_pacman_table = self._convert_to_pacman_router_table( compressed_router_table_entries, router_table.x, router_table.y) # add to new compressed routing tables compressed_pacman_router_tables.add_routing_table( compressed_pacman_table) # return return compressed_pacman_router_tables
def __call__(self, router_tables): tables = MulticastRoutingTables() previous_masks = dict() progress = ProgressBar( len(router_tables.routing_tables) * 2, "Compressing Routing Tables") # Create all masks without holes allowed_masks = [_32_BITS - ((2 ** i) - 1) for i in range(33)] # Check that none of the masks have "holes" e.g. 0xFFFF0FFF has a hole for router_table in router_tables.routing_tables: for entry in router_table.multicast_routing_entries: if entry.mask not in allowed_masks: raise PacmanRoutingException( "Only masks without holes are allowed in tables for" " BasicRouteMerger (disallowed mask={})".format( hex(entry.mask))) for router_table in progress.over(router_tables.routing_tables): new_table = self._merge_routes(router_table, previous_masks) tables.add_routing_table(new_table) n_entries = len([ entry for entry in new_table.multicast_routing_entries if not entry.defaultable]) # print("Reduced from {} to {}".format( # len(router_table.multicast_routing_entries), n_entries)) if n_entries > 1023: raise PacmanRoutingException( "Cannot make table small enough: {} entries".format( n_entries)) return tables
def __call__(self, router_tables, target_length=None): # build storage compressed_pacman_router_tables = MulticastRoutingTables() # create progress bar progress = ProgressBar(router_tables.routing_tables, "Compressing routing Tables") # compress each router for router_table in progress.over(router_tables.routing_tables): # convert to rig format entries = self._convert_to_mundy_format(router_table) # compress the router entries compressed_router_table_entries = \ rigs_compressor.minimise(entries, target_length) # convert back to pacman model compressed_pacman_table = self._convert_to_pacman_router_table( compressed_router_table_entries, router_table.x, router_table.y) # add to new compressed routing tables compressed_pacman_router_tables.add_routing_table( compressed_pacman_table) # return return compressed_pacman_router_tables
def test_tables(self): tables = MulticastRoutingTables() path = os.path.dirname(sys.modules[self.__module__].__file__) table_path = os.path.join(path, "table2.csv.gz") table = from_csv(table_path) tables.add_routing_table(table) compressed = range_compressor(tables) c_table = compressed.get_routing_table_for_chip(0, 0) compare_tables(table, c_table)
class TestCompressor(unittest.TestCase): def setUp(self): self.original_tables = MulticastRoutingTables() original_table = UnCompressedMulticastRoutingTable(x=0, y=0) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0101, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1110, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1100, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0010, 0b1011, [4, 5], [], False)) self.original_tables.add_routing_table(original_table) unittest_setup() set_config("Mapping", "router_table_compress_as_far_as_possible", True) def check_compression(self, compressed_tables): for original in self.original_tables: compressed = compressed_tables.get_routing_table_for_chip( original.x, original.y) assert compressed.number_of_entries < original.number_of_entries compare_tables(original, original) def test_pair_compressor(self): compressed_tables = pair_compressor(self.original_tables) self.check_compression(compressed_tables) def test_range_compressor_skipped(self): compressed_tables = range_compressor(self.original_tables) for original in self.original_tables: compressed = compressed_tables.get_routing_table_for_chip( original.x, original.y) self.assertEqual(original, compressed) def test_checked_unordered_pair_compressor(self): compressed_tables = pair_compressor(self.original_tables, ordered=False, accept_overflow=False) self.check_compression(compressed_tables) def test_unordered_pair_compressor(self): compressed_tables = pair_compressor(self.original_tables, ordered=False, accept_overflow=True) self.check_compression(compressed_tables) def test_ordered_covering_compressor(self): compressed_tables = ordered_covering_compressor(self.original_tables) self.check_compression(compressed_tables)
def __call__(self, transceiver, routing_tables, app_id): progress = ProgressBar(routing_tables, "Reading Routing Tables from Machine") machine_routing_tables = MulticastRoutingTables() for routing_table in progress.over(routing_tables): # get multicast entries from machine machine_routing_table = self._read_routing_table( transceiver, routing_table, app_id) machine_routing_tables.add_routing_table(machine_routing_table) return machine_routing_tables
class MyTestCase(unittest.TestCase): def setUp(self): self.original_tables = MulticastRoutingTables() original_table = UnCompressedMulticastRoutingTable(x=0, y=0) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0101, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1110, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1100, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0010, 0b1011, [4, 5], [], False)) self.original_tables.add_routing_table(original_table) def check_compression(self, compressed_tables): for original in self.original_tables: compressed = compressed_tables.get_routing_table_for_chip( original.x, original.y) assert compressed.number_of_entries < original.number_of_entries compare_tables(original, original) def test_pair_compressor(self): compressor = PairCompressor() compressed_tables = compressor(self.original_tables) self.check_compression(compressed_tables) def test_checked_unordered_pair_compressor(self): compressor = CheckedUnorderedPairCompressor() compressed_tables = compressor(self.original_tables) self.check_compression(compressed_tables) def test_unordered_pair_compressor(self): compressor = UnorderedPairCompressor() compressed_tables = compressor(self.original_tables) self.check_compression(compressed_tables) def test_ordered_covering_compressor(self): compressor = OrderedCoveringCompressor() compressed_tables = compressor(self.original_tables) self.check_compression(compressed_tables)
def __call__( self, routing_infos, routing_table_by_partitions, machine): """ :param routing_infos: :param routing_table_by_partitions: :param machine: """ progress = ProgressBar(machine.n_chips, "Generating routing tables") routing_tables = MulticastRoutingTables() for chip in progress.over(machine.chips): partitions_in_table = routing_table_by_partitions.\ get_entries_for_router(chip.x, chip.y) if partitions_in_table: routing_tables.add_routing_table(self._create_routing_table( chip, partitions_in_table, routing_infos)) return routing_tables
def __call__(self, routing_infos, routing_table_by_partitions, machine): """ :param RoutingInfo routing_infos: :param MulticastRoutingTableByPartition routing_table_by_partitions: :param ~spinn_machine.Machine machine: :rtype: MulticastRoutingTables """ progress = ProgressBar(machine.n_chips, "Generating routing tables") routing_tables = MulticastRoutingTables() for chip in progress.over(machine.chips): partitions_in_table = routing_table_by_partitions.\ get_entries_for_router(chip.x, chip.y) if partitions_in_table: routing_tables.add_routing_table(self._create_routing_table( chip, partitions_in_table, routing_infos)) return routing_tables
def compress_tables(self, router_tables, progress): """ Compress all the unordered routing tables Tables who start of smaller than target_length are not compressed :param MulticastRoutingTables router_tables: Routing tables :param ~spinn_utilities.progress_bar.ProgressBar progress: Progress bar to show while working :return: The compressed but still unordered routing tables :rtype: MulticastRoutingTables :raises MinimisationFailedError: on failure """ compressed_tables = MulticastRoutingTables() self._problems = "" if get_config_bool("Mapping", "router_table_compress_as_far_as_possible"): # Compress as much as possible target_length = 0 else: target_length = Machine.ROUTER_ENTRIES for table in progress.over(router_tables.routing_tables): if table.number_of_entries < target_length: new_table = table else: compressed_table = self.compress_table(table) new_table = CompressedMulticastRoutingTable(table.x, table.y) for entry in compressed_table: new_table.add_multicast_routing_entry( entry.to_MulticastRoutingEntry()) if new_table.number_of_entries > Machine.ROUTER_ENTRIES: self._problems += "(x:{},y:{})={} ".format( new_table.x, new_table.y, new_table.number_of_entries) compressed_tables.add_routing_table(new_table) if len(self._problems) > 0: if self._ordered and not self._accept_overflow: raise MinimisationFailedError( "The routing table after compression will still not fit" " within the machines router: {}".format(self._problems)) else: logger.warning(self._problems) return compressed_tables
def __call__(self, report_default_directory, routing_tables, transceiver, app_id): # pylint: disable=protected-access tables = list(routing_tables.routing_tables) progress = ProgressBar(tables, "Reading Routing Tables from Machine") folder_name = os.path.join(report_default_directory, _FOLDER_NAME) os.mkdir(folder_name) machine_routing_tables = MulticastRoutingTables() # generate a file for every multicast entry for routing_table in progress.over(tables): # get multicast entries from machine machine_routing_table = self._read_routing_table( transceiver, routing_table, app_id) machine_routing_tables.add_routing_table(machine_routing_table) reports._generate_routing_table(machine_routing_table, folder_name) return machine_routing_tables
def __call__( self, report_default_directory, routing_tables, transceiver, app_id): # pylint: disable=protected-access tables = list(routing_tables.routing_tables) progress = ProgressBar(tables, "Reading Routing Tables from Machine") folder_name = os.path.join(report_default_directory, _FOLDER_NAME) os.mkdir(folder_name) machine_routing_tables = MulticastRoutingTables() # generate a file for every multicast entry for routing_table in progress.over(tables): # get multicast entries from machine machine_routing_table = self._read_routing_table( transceiver, routing_table, app_id) machine_routing_tables.add_routing_table(machine_routing_table) reports._generate_routing_table(machine_routing_table, folder_name) return machine_routing_tables
def basic_routing_table_generator(routing_infos, routing_table_by_partitions, machine): """ An basic algorithm that can produce routing tables :param RoutingInfo routing_infos: :param MulticastRoutingTableByPartition routing_table_by_partitions: :param ~spinn_machine.Machine machine: :rtype: MulticastRoutingTables """ progress = ProgressBar(machine.n_chips, "Generating routing tables") routing_tables = MulticastRoutingTables() for chip in progress.over(machine.chips): partitions_in_table = routing_table_by_partitions.\ get_entries_for_router(chip.x, chip.y) if partitions_in_table: routing_tables.add_routing_table( __create_routing_table(chip, partitions_in_table, routing_infos)) return routing_tables
def compress_tables(self, router_tables, progress): """ Compress all the unordered routing tables Tables who start of smaller than target_length are not compressed :param MulticastRoutingTables router_tables: Routing tables :param ~spinn_utilities.progress_bar.ProgressBar progress: Progress bar to show while working :return: The compressed but still unordered routing tables :rtype: MulticastRoutingTables :raises MinimisationFailedError: on failure """ compressed_tables = MulticastRoutingTables() self._problems = "" for table in progress.over(router_tables.routing_tables): if table.number_of_entries < self._target_length: new_table = table else: compressed_table = self.compress_table(table) new_table = CompressedMulticastRoutingTable(table.x, table.y) for entry in compressed_table: new_table.add_multicast_routing_entry( entry.to_MulticastRoutingEntry()) if new_table.number_of_entries > self.MAX_SUPPORTED_LENGTH: self._problems += "(x:{},y:{})={} ".format( new_table.x, new_table.y, new_table.number_of_entries) compressed_tables.add_routing_table(new_table) if len(self._problems) > 0: if self._ordered: raise MinimisationFailedError( "The routing table after compression will still not fit" " within the machines router: {}".format(self._problems)) else: logger.warning(self._problems) return compressed_tables
from pacman.operations.router_compressors import pair_compressor from pacman.config_setup import unittest_setup unittest_setup() # original_tables = from_json("routing_table_15_25.json") original_tables = from_json("malloc_hard_routing_tables.json.gz") # original_tables = from_json("routing_tables_speader_big.json.gz") SPLIT = False if SPLIT: bad = MulticastRoutingTables() good = MulticastRoutingTables() for original in original_tables: if original.x == 19 and original.y == 22: good.add_routing_table(original) else: bad.add_routing_table(original) json_obj = to_json(bad) # dump to json file with open("routing_tables_zoned_bad1.json", "w") as f: json.dump(json_obj, f) json_obj = to_json(good) # dump to json file with open("routing_tables_zoned_2000.json", "w") as f: json.dump(json_obj, f) original_tables = bad MUNDY = True PRE = True
def test(self): """Test minimising a table of the form: 0000 -> N NE 0001 -> E 0101 -> SW 1000 -> N NE 1001 -> E 1110 -> SW 1100 -> N NE 0X00 -> S SW The result (worked out by hand) should be: 0000 -> N NE 0X00 -> S SW 1X00 -> N NE X001 -> E X1XX -> SW """ original_tables = MulticastRoutingTables() original_table = MulticastRoutingTable(x=0, y=0) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0101, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1110, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1100, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1011, [4, 5], [], False)) original_tables.add_routing_table(original_table) mundy_compressor = MundyRouterCompressor() compressed_tables = mundy_compressor(original_tables) compressed_table = compressed_tables.get_routing_table_for_chip(0, 0) # TODO: FIX THIS SO THAT WE TEST THAT THE RESULT IS VALID # result_table_expected = MulticastRoutingTable(x=0, y=0) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0000, 0b1011, [4, 5], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b1000, 0b1011, [1, 2], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0001, 0b0111, [0], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0100, 0b0100, [4], [], False)) # Minimise as far as possible assert compressed_table.number_of_entries == 5 # assert compressed_table == result_table_expected compare_table(original_table, compressed_table)
class SystemMulticastRoutingGenerator(object): """ Generates routing table entries used by the data in processes with the\ extra monitor cores. :param ~spinn_machine.Machine machine: :param extra_monitor_cores: :type extra_monitor_cores: dict(tuple(int,int),ExtraMonitorSupportMachineVertex) :param ~pacman.model.placements.Placements placements: :return: routing tables, destination-to-key map, board-locn-to-timeout-key map :rtype: tuple(MulticastRoutingTables, dict(tuple(int,int),int), dict(tuple(int,int),int)) """ __slots__ = ["_monitors", "_machine", "_key_to_destination_map", "_placements", "_routing_tables", "_time_out_keys_by_board"] def __call__(self, machine, extra_monitor_cores, placements): """ :param ~spinn_machine.Machine machine: :param dict(tuple(int,int),ExtraMonitorSupportMachineVertex) \ extra_monitor_cores: :param ~pacman.model.placements.Placements placements: :rtype: tuple(MulticastRoutingTables, dict(tuple(int,int),int), dict(tuple(int,int),int)) """ # pylint: disable=attribute-defined-outside-init self._machine = machine self._placements = placements self._monitors = extra_monitor_cores self._routing_tables = MulticastRoutingTables() self._key_to_destination_map = dict() self._time_out_keys_by_board = dict() # create progress bar progress = ProgressBar( machine.ethernet_connected_chips, "Generating routing tables for data in system processes") for ethernet_chip in progress.over(machine.ethernet_connected_chips): tree = self._generate_routing_tree(ethernet_chip) self._add_routing_entries(ethernet_chip, tree) return (self._routing_tables, self._key_to_destination_map, self._time_out_keys_by_board) def _generate_routing_tree(self, ethernet_chip): """ Generates a map for each chip to over which link it gets its data. :param ~spinn_machine.Chip ethernet_chip: :return: Map of chip.x, chip.y tp (source.x, source.y, source.link) :rtype: dict(tuple(int, int), tuple(int, int, int)) """ eth_x = ethernet_chip.x eth_y = ethernet_chip.y tree = dict() to_reach = set( self._machine.get_existing_xys_by_ethernet(eth_x, eth_y)) reached = set() reached.add((eth_x, eth_y)) to_reach.remove((eth_x, eth_y)) found = set() found.add((eth_x, eth_y)) while len(to_reach) > 0: just_reached = found found = set() for x, y in just_reached: # Check links starting with the most direct from 0,0 for link_id in [1, 0, 2, 5, 3, 4]: # Get protential destination destination = self._machine.xy_over_link(x, y, link_id) # If it is useful if destination in to_reach: # check it actually exits if self._machine.is_link_at(x, y, link_id): # Add to tree and record chip reachable tree[destination] = (x, y, link_id) to_reach.remove(destination) found.add(destination) if len(found) == 0: raise PacmanRoutingException( "Unable to do data in routing on {}.".format( ethernet_chip.ip_address)) return tree def _add_routing_entry(self, x, y, key, processor_id=None, link_ids=None): """ Adds a routing entry on this chip, creating the table if needed. :param int x: chip.x :param int y: chip.y :param int key: The key to use :param int processor_id: placement.p of the monitor vertex if applicable :param int link_id: If of the link out if applicable """ table = self._routing_tables.get_routing_table_for_chip(x, y) if table is None: table = UnCompressedMulticastRoutingTable(x, y) self._routing_tables.add_routing_table(table) if processor_id is None: processor_ids = [] else: processor_ids = [processor_id] if link_ids is None: link_ids = [] entry = MulticastRoutingEntry( routing_entry_key=key, mask=ROUTING_MASK, processor_ids=processor_ids, link_ids=link_ids, defaultable=False) table.add_multicast_routing_entry(entry) def _add_routing_entries(self, ethernet_chip, tree): """ Adds the routing entires based on the tree. For every chip with this ethernet: - A key is generated (and saved) for this chip. - A local route to the monitor core is added. - The tree is walked adding a route on each source to get here :param ~spinn_machine.Chip ethernet_chip: the ethernet chip to make entries for :param dict(tuple(int,int),tuple(int,int,int)) tree: map of chips and links """ eth_x = ethernet_chip.x eth_y = ethernet_chip.y key = KEY_START_VALUE for (x, y) in self._machine.get_existing_xys_by_ethernet( eth_x, eth_y): self._key_to_destination_map[x, y] = key placement = self._placements.get_placement_of_vertex( self._monitors[x, y]) self._add_routing_entry(x, y, key, processor_id=placement.p) while (x, y) in tree: x, y, link = tree[(x, y)] self._add_routing_entry(x, y, key, link_ids=[link]) key += N_KEYS_PER_PARTITION_ID # accum links to make a broad cast links_per_chip = defaultdict(list) for chip_key in tree: x, y, link = tree[chip_key] links_per_chip[x, y].append(link) # add broadcast router timeout keys time_out_key = key for (x, y) in self._machine.get_existing_xys_by_ethernet( eth_x, eth_y): placement = self._placements.get_placement_of_vertex( self._monitors[x, y]) self._add_routing_entry( x, y, time_out_key, processor_id=placement.p, link_ids=links_per_chip[x, y]) # update tracker self._time_out_keys_by_board[(eth_x, eth_y)] = key key += N_KEYS_PER_REINJECTION_PARTITION
def test(self): """Test minimising a table of the form: 0000 -> N NE 0001 -> E 0101 -> SW 1000 -> N NE 1001 -> E 1110 -> SW 1100 -> N NE 0X00 -> S SW The result (worked out by hand) should be: 0000 -> N NE 0X00 -> S SW 1X00 -> N NE X001 -> E X1XX -> SW """ original_tables = MulticastRoutingTables() original_table = MulticastRoutingTable(x=0, y=0) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0101, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1110, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1100, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1011, [4, 5], [], False)) original_tables.add_routing_table(original_table) mundy_compressor = MundyRouterCompressor() compressed_tables = mundy_compressor(original_tables) compressed_table = compressed_tables.get_routing_table_for_chip(0, 0) # TODO: FIX THIS SO THAT WE TEST THAT THE RESULT IS VALID # result_table_expected = MulticastRoutingTable(x=0, y=0) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0000, 0b1011, [4, 5], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b1000, 0b1011, [1, 2], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0001, 0b0111, [0], [], False)) # result_table_expected.add_multicast_routing_entry( # MulticastRoutingEntry(0b0100, 0b0100, [4], [], False)) # Minimise as far as possible assert compressed_table.number_of_entries == 5 # assert compressed_table == result_table_expected compare_table(original_table, compressed_table)