def __call__(self, router_tables, target_length=None):

        # build storage
        compressed_pacman_router_tables = MulticastRoutingTables()

        # create progress bar
        progress_bar = ProgressBar(
            len(router_tables.routing_tables), "Compressing routing Tables")

        # compress each router
        for router_table in 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)

            progress_bar.update()
        progress_bar.end()

        # return
        return {'routing_tables': compressed_pacman_router_tables}
Beispiel #2
0
    def __call__(self, routing_infos, routing_table_by_partitions, machine):
        """

        :param routing_infos:
        :param routing_table_by_partitions:
        :param machine:
        :return:
        """
        progress_bar = ProgressBar(len(list(machine.chips)),
                                   "Generating routing tables")
        routing_tables = MulticastRoutingTables()
        for chip in machine.chips:
            partitions_in_table = routing_table_by_partitions.\
                get_entries_for_router(chip.x, chip.y)
            if len(partitions_in_table) != 0:
                routing_table = MulticastRoutingTable(chip.x, chip.y)
                for partition in partitions_in_table:
                    keys_and_masks = routing_infos.\
                        get_keys_and_masks_from_partition(partition)
                    entry = partitions_in_table[partition]
                    for key_and_mask in keys_and_masks:
                        multicast_routing_entry = MulticastRoutingEntry(
                            routing_entry_key=key_and_mask.key_combo,
                            defaultable=entry.defaultable,
                            mask=key_and_mask.mask,
                            link_ids=entry.out_going_links,
                            processor_ids=entry.out_going_processors)
                        routing_table.add_mutlicast_routing_entry(
                            multicast_routing_entry)
                routing_tables.add_routing_table(routing_table)
            progress_bar.update()
        progress_bar.end()

        return {"router_tables": routing_tables}
Beispiel #3
0
down_chips = "None"
down_cores = "None"
number_of_boards = 1
height = None
width = None
auto_detect_bmp = False
enable_reinjection = True
iptags.append(IPTag("192.168.240.253", 0, "0.0.0.0", 17896, True))
application_data.append(
    ReloadApplicationData("192.168.240.253_appData_0_0_1.dat", 0, 0, 1,
                          1612972032))
application_data.append(
    ReloadApplicationData("192.168.240.253_appData_0_0_2.dat", 0, 0, 2,
                          1612989276))
reload_routing_table = ReloadRoutingTable()
routing_tables.add_routing_table(
    reload_routing_table.reload("picked_routing_table_for_0_0"))
binaries.add_subsets(
    "C:\\Python27\\lib\\site-packages\\spynnaker\\pyNN\\model_binaries\\IF_curr_exp.aplx",
    CoreSubsets([
        CoreSubset(0, 0, [
            2,
        ]),
    ]))
binaries.add_subsets(
    "C:\\Python27\\lib\\site-packages\\spinn_front_end_common\\common_model_binaries\\reverse_iptag_multicast_source.aplx",
    CoreSubsets([
        CoreSubset(0, 0, [
            1,
        ]),
    ]))
vertex = ReloadBufferedVertex("inputSpikes_On:0:255",
Beispiel #4
0
send_start_notification = True

executable_targets = ExecutableTargets()
app_id = 30
runtime = 800000.0
time_scale_factor = 1
total_machine_timesteps = 800000
time_threshold = 5

iptags.append(
    IPTag("192.168.240.253", 2, "0.0.0.0", 17895, True)) 
reverse_iptags.append(
    ReverseIPTag("192.168.240.253", 0, 12346, 0, 0, 1))
reverse_iptags.append(
    ReverseIPTag("192.168.240.253", 1, 12345, 0, 0, 2))
router_tables.add_routing_table(
    ReloadRoutingTable.reload("picked_routing_table_for_0_0"))
database_socket_addresses.append(
    SocketAddress("localhost", 19996, None))
database_socket_addresses.append(
    SocketAddress("localhost", 19999, None))
dsg_targets[0, 0, 5] = \
    r"192.168.240.253_dataSpec_0_0_5.dat"
dsg_targets[0, 0, 1] = \
    r"192.168.240.253_dataSpec_0_0_1.dat"
dsg_targets[0, 0, 2] = \
    r"192.168.240.253_dataSpec_0_0_2.dat"
dsg_targets[0, 0, 3] = \
    r"192.168.240.253_dataSpec_0_0_3.dat"
dsg_targets[0, 0, 4] = \
    r"192.168.240.253_dataSpec_0_0_4.dat"
executable_targets.add_processor(
buffered_tags = Tags()
buffered_placements = Placements()

wait_for_read_confirmation = True
database_socket_addresses = list()
database_file_path = r"None"
send_start_notification = True

executable_targets = ExecutableTargets()
app_id = 30
runtime = 100.0
time_scale_factor = 1
total_machine_timesteps = 100
time_threshold = 5

router_tables.add_routing_table(
    ReloadRoutingTable.reload("picked_routing_table_for_0_0"))
dsg_targets[0, 0, 7] = \
    r"192.168.240.36_dataSpec_0_0_7.dat"
dsg_targets[0, 0, 9] = \
    r"192.168.240.36_dataSpec_0_0_9.dat"
dsg_targets[0, 0, 2] = \
    r"192.168.240.36_dataSpec_0_0_2.dat"
dsg_targets[0, 0, 6] = \
    r"192.168.240.36_dataSpec_0_0_6.dat"
dsg_targets[0, 0, 8] = \
    r"192.168.240.36_dataSpec_0_0_8.dat"
dsg_targets[0, 0, 1] = \
    r"192.168.240.36_dataSpec_0_0_1.dat"
dsg_targets[0, 0, 5] = \
    r"192.168.240.36_dataSpec_0_0_5.dat"
dsg_targets[0, 0, 11] = \