def test_new_multicast_routing_tables(self):
key_combo = 0xff35
mask = 0xffff
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_entries1 = MulticastRoutingEntry(key_combo, mask, proc_ids,
link_ids, True)
multicast_entries2 = MulticastRoutingEntry(key_combo - 1, mask - 1,
proc_ids, link_ids, True)
mrt = list()
t1 = UnCompressedMulticastRoutingTable(0, 0, [multicast_entries1])
t2 = UnCompressedMulticastRoutingTable(1, 0, [multicast_entries2])
mrt.append(t1)
mrt.append(t2)
tables = MulticastRoutingTables(mrt)
retrieved_tables = tables.routing_tables
self.assertEqual(len(retrieved_tables), len(mrt))
for tab in retrieved_tables:
self.assertIn(tab, mrt)
self.assertEqual(tables.get_routing_table_for_chip(0, 0), t1)
self.assertEqual(tables.get_routing_table_for_chip(1, 0), t2)
self.assertEqual(tables.get_routing_table_for_chip(2, 0), None)
json_obj = to_json(tables)
file_format_schemas.validate(json_obj, "routing_tables.json")
new_tables = from_json(json_obj)
self.assertEqual(new_tables.get_routing_table_for_chip(0, 0), t1)
self.assertEqual(new_tables.get_routing_table_for_chip(1, 0), t2)
self.assertEqual(new_tables.get_routing_table_for_chip(2, 0), None)
def test_onordered_pair_big(self):
class_file = sys.modules[self.__module__].__file__
path = os.path.dirname(os.path.abspath(class_file))
j_router = os.path.join(path, "many_to_one.json.gz")
original_tables = from_json(j_router)
with self.assertRaises(PacmanElementAllocationException):
pair_compressor(
original_tables, ordered=False, accept_overflow=False,
verify=True)
def test_pair_big(self):
class_file = sys.modules[self.__module__].__file__
path = os.path.dirname(os.path.abspath(class_file))
j_router = os.path.join(path,
"many_to_one.json.gz")
original_tables = from_json(j_router)
compressed_tables = pair_compressor(original_tables)
for original in original_tables:
compressed = compressed_tables.get_routing_table_for_chip(
original.x, original.y)
compare_tables(original, compressed)
def test_big(self):
class_file = sys.modules[self.__module__].__file__
path = os.path.dirname(os.path.abspath(class_file))
j_router = os.path.join(path, "malloc_hard_routing_tables.json.gz")
original_tables = from_json(j_router)
mundy_compressor = MundyRouterCompressor()
# Hack to stop it throwing a wobly for too many entries
AbstractCompressor.MAX_SUPPORTED_LENGTH = 5000
pre_compressor = UnorderedCompressor()
start = time.time()
mundy_tables = mundy_compressor(original_tables)
mundy_time = time.time()
pre_tables = pre_compressor(original_tables)
pre_time = time.time()
both_tables = mundy_compressor(pre_tables)
both_time = time.time()
for original in original_tables:
org_routes = set()
for entry in original.multicast_routing_entries:
org_routes.add(entry.spinnaker_route)
mundy = mundy_tables.get_routing_table_for_chip(
original.x, original.y)
mundy_routes = set()
for entry in mundy.multicast_routing_entries:
mundy_routes.add(entry.spinnaker_route)
compare_tables(original, mundy)
pre = pre_tables.get_routing_table_for_chip(original.x, original.y)
pre_routes = set()
for entry in pre.multicast_routing_entries:
pre_routes.add(entry.spinnaker_route)
compare_tables(original, pre)
both = both_tables.get_routing_table_for_chip(
original.x, original.y)
both_routes = set()
for entry in both.multicast_routing_entries:
both_routes.add(entry.spinnaker_route)
compare_tables(original, both)
print("org:", original.number_of_entries,
len(org_routes), "mundy:", mundy.number_of_entries,
len(mundy_routes), "pre:", pre.number_of_entries,
len(pre_routes), "both:", both.number_of_entries,
len(both_routes))
print("Mundy", mundy_time - start)
print("Unordered", pre_time - mundy_time)
print("Mundy after Unordered", both_time - pre_time)
def test_big(self):
set_config("Mapping", "router_table_compress_as_far_as_possible", True)
class_file = sys.modules[self.__module__].__file__
path = os.path.dirname(os.path.abspath(class_file))
j_router = os.path.join(path, "malloc_hard_routing_tables.json.gz")
original_tables = from_json(j_router)
mundy_compressor = OrderedCoveringCompressor()
pre_compressor = UnorderedPairCompressor()
start = time.time()
mundy_tables = mundy_compressor(original_tables, True)
mundy_time = time.time()
pre_tables = pre_compressor(original_tables, True)
pre_time = time.time()
both_tables = mundy_compressor(pre_tables, True)
both_time = time.time()
for original in original_tables:
org_routes = set()
for entry in original.multicast_routing_entries:
org_routes.add(entry.spinnaker_route)
mundy = mundy_tables.get_routing_table_for_chip(
original.x, original.y)
mundy_routes = set()
for entry in mundy.multicast_routing_entries:
mundy_routes.add(entry.spinnaker_route)
compare_tables(original, mundy)
pre = pre_tables.get_routing_table_for_chip(original.x, original.y)
pre_routes = set()
for entry in pre.multicast_routing_entries:
pre_routes.add(entry.spinnaker_route)
compare_tables(original, pre)
both = both_tables.get_routing_table_for_chip(
original.x, original.y)
both_routes = set()
for entry in both.multicast_routing_entries:
both_routes.add(entry.spinnaker_route)
compare_tables(original, both)
print("org:", original.number_of_entries,
len(org_routes), "mundy:", mundy.number_of_entries,
len(mundy_routes), "pre:", pre.number_of_entries,
len(pre_routes), "both:", both.number_of_entries,
len(both_routes))
print("Mundy", mundy_time - start)
print("Unordered", pre_time - mundy_time)
print("Mundy after Unordered", both_time - pre_time)
from spinn_utilities.config_holder import set_config
from spinn_machine import Machine
from pacman.model.routing_tables.multicast_routing_tables import (from_json)
from pacman.model.routing_tables.multicast_routing_tables import (to_json)
from pacman.model.routing_tables import (MulticastRoutingTables)
from pacman.operations.router_compressors.routing_compression_checker import (
compare_tables)
from pacman.operations.router_compressors.ordered_covering_router_compressor \
import ordered_covering_compressor
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: