Пример #1
0
    def test_new_multicast_routing_table(self):
        """
        test that creating a multicast routing entry and adding it to the table
        works
        :return:
        """
        key_combo = 0xff000
        mask = 0xff000
        proc_ids = list()
        link_ids = list()
        for i in range(18):
            proc_ids.append(i)
        for i in range(6):
            link_ids.append(i)
        multicast_entries = list()
        for i in range(5):
            multicast_entries.append(
                MulticastRoutingEntry(key_combo + i, mask + i, proc_ids,
                                      link_ids, True))
        mrt = MulticastRoutingTable(0, 0, multicast_entries)
        self.assertEqual(mrt.x, 0)
        self.assertEqual(mrt.y, 0)

        mre = mrt.multicast_routing_entries
        for entry in mre:
            self.assertIn(entry, multicast_entries)
        self.assertEqual(len(mre), len(multicast_entries))
        for i in range(5):
            self.assertEqual(
                mrt.get_multicast_routing_entry_by_routing_entry_key(
                    key_combo + i, mask + i),
                multicast_entries[i])
        self.assertEqual(mrt.get_multicast_routing_entry_by_routing_entry_key(
            key_combo + 5, mask + 5), None)
        self.assertEqual(mrt.get_multicast_routing_entry_by_routing_entry_key(
            key_combo - 1, mask - 1), None)
def add_routing_key_entries(
        routing_paths, subedge_routing_info, out_going_subedge,
        routing_tables):
    """
    creates and adds entries for routing tables as required for the path
    :param routing_paths: the routing paths object generated from routing info
    :param subedge_routing_info: the subedge info object that contains keys
    :param out_going_subedge: the edge this is aossicated with
    :param routing_tables: the routing tables to adjust
    :return: None
    """
    path_entries = routing_paths.get_entries_for_edge(out_going_subedge)

    # iterate through the entries in each path, adding a router entry if
    # required
    for path_entry in path_entries:

        # locate the router
        router = routing_tables.get_routing_table_for_chip(
            path_entry.router_x, path_entry.router_y)
        if router is None:
            router = MulticastRoutingTable(
                path_entry.router_x, path_entry.router_y)
            routing_tables.add_routing_table(router)

        # add entries as required, or merge them if entries already exist
        for key_and_mask in subedge_routing_info.keys_and_masks:
            multicast_routing_entry = MulticastRoutingEntry(
                routing_entry_key=key_and_mask.key_combo,
                defaultable=path_entry.defaultable, mask=key_and_mask.mask,
                link_ids=path_entry.out_going_links,
                processor_ids=path_entry.out_going_processors)
            stored_entry = \
                router.get_multicast_routing_entry_by_routing_entry_key(
                    key_and_mask.key_combo, key_and_mask.mask)
            if stored_entry is None:
                router.add_mutlicast_routing_entry(MulticastRoutingEntry(
                    routing_entry_key=key_and_mask.key_combo,
                    defaultable=path_entry.defaultable,
                    mask=key_and_mask.mask,
                    link_ids=path_entry.out_going_links,
                    processor_ids=path_entry.out_going_processors))
            else:
                merged_entry = stored_entry.merge(multicast_routing_entry)
                router.remove_multicast_routing_entry(stored_entry)
                router.add_mutlicast_routing_entry(merged_entry)