def assign_hilbert_keys(nets, machine): """Return a dictionary mapping a net to a unique key indicating the position of the originating chip along a Hilbert curve mapped to the SpiNNaker machine. """ # Create the Hilbert-formatted bit field hilbert_bf = BitField() hilbert_bf.add_field("index", length=16, start_at=16) hilbert_bf.add_field("p", length=5, start_at=3) hilbert_bf.assign_fields() # Fix the bitfield sizing # Prepare to store the nets and keys net_keys = dict() # Generate an appropriately scaled Hilbert curve curve = {(x, y): i for i, (x, y) in enumerate(chip for chip in hilbert_chip_order(machine) if chip in machine)} # For each net look at the placement of the source vertex and hence # generate a key. for net in nets: # Get the originating co-ordinates x, y, p = net.source # Generate the key and mask bf = hilbert_bf(index=curve[(x, y)], p=p) net_keys[net] = bf.get_value(), bf.get_mask() return net_keys
def test_eq(self): # Create several SignalParameters and ensure that they only # report equal when they are actually equal. ks = BitField() ks.add_field("x") params = ((False, 5, ks(x=2)), (True, 5, ks(x=2)), (False, 4, ks(x=2)), (False, 5, ks(x=3)), ) tps = tuple(model.SignalParameters(*args) for args in params) # None of these transmission parameters should test as equivalent. for a in tps: for b in tps: if a is not b: assert a != b # Create a whole new set of transmission parameters using the same set # of parameters and ensure that they all test equivalent to their # counterparts in the original list. for a, b in zip(tps, tuple(model.SignalParameters(*args) for args in params)): assert a is not b assert a == b
def assign_random_keys(nets, machine, seed, n_bits): """Return a dictionary mapping a net to a unique randomly-assigned key. """ # Ensure sufficient bits available assert n_bits >= np.ceil(np.log2(machine.width * machine.height * 17)) # Create the RND-formatted bit field rnd_bf = BitField() rnd_bf.add_field("index", length=n_bits) rnd_bf.assign_fields() # Fix the bitfield sizing # Prepare to store the nets and keys net_keys = dict() # Assign a unique random ID to each core random.seed(seed) ids = random.sample(range(1 << n_bits), machine.width * machine.height * 17) # For each net look at the placement of the source vertex and hence # generate a key. for net, index in zip(nets, ids): # Generate the key and mask bf = rnd_bf(index=index) net_keys[net] = bf.get_value(), bf.get_mask() return net_keys
def assign_xyzp_keys(nets): """Return a dictionary mapping a net to a unique key indicating the XYZP co-ordinate of the source of the net. """ # Create the XYZP-formatted bit field xyzp_bf = BitField() xyzp_bf.add_field("x", length=8, start_at=24) xyzp_bf.add_field("y", length=8, start_at=16) xyzp_bf.add_field("z", length=8, start_at=8) xyzp_bf.add_field("p", length=5, start_at=3) xyzp_bf.assign_fields() # Fix the bitfield sizing # Prepare to store the nets and keys net_keys = dict() # For each net look at the placement of the source vertex and hence # generate a key. for net in nets: # Get the originating co-ordinates x, y, p = net.source # Get the minimal xyz co-ordinate x, y, z = minimise_xyz(to_xyz((x, y))) # Generate the key and mask bf = xyzp_bf(x=x, y=y, z=abs(z), p=p) net_keys[net] = bf.get_value(), bf.get_mask() return net_keys
def __init__(self, routing_tag="routing", filter_routing_tag="filter_routing"): """Create a new keyspace container with the given tags for routing and filter routing. """ # The tags self._routing_tag = routing_tag self._filter_routing_tag = filter_routing_tag # The keyspaces self._master_keyspace = _master_keyspace = BitField(length=32) _master_keyspace.add_field( "user", tags=[self.routing_tag, self.filter_routing_tag]) # Initialise the defaultdict behaviour super(KeyspaceContainer, self).__init__(self._KeyspaceGetter(_master_keyspace)) # Add the default keyspace nengo_ks = self["nengo"] nengo_ks.add_field("connection_id", tags=[self.routing_tag, self.filter_routing_tag]) nengo_ks.add_field("cluster", tags=[self.routing_tag]) nengo_ks.add_field("index", start_at=0)
def test_sizeof_partitioned(self): r = KeyspacesRegion([(Signal(BitField(32)), {})] * 4, fields=[mock.Mock()], partitioned_by_atom=True, prepend_num_keyspaces=False) assert r.sizeof(slice(1, 2)) == 4 assert r.sizeof(slice(2, 4)) == 8
def ks(): keyspace = BitField() keyspace.add_field("x", length=8, start_at=24, tags="routing") keyspace.add_field("y", length=8, start_at=16, tags="routing") keyspace.add_field("p", length=5, start_at=11, tags="routing") keyspace.add_field("c", length=11, start_at=0) keyspace.assign_fields() return keyspace
def test_sizeof_no_prepends(self, key_bits, n_keys, n_fields, partitioned, vertex_slice): # Generate the list of keys, prepends and fields keys = [(Signal(BitField(key_bits)), {}) for _ in range(n_keys)] fields = [mock.Mock() for _ in range(n_fields)] # Create the region r = KeyspacesRegion(keys, fields, partitioned) # Determine the size n_atoms = (n_keys if not partitioned else vertex_slice.stop - vertex_slice.start) assert r.sizeof(vertex_slice) == n_atoms * n_fields * 4
def test_get_derived_keyspaces(): """Test creation of derived keyspaces.""" ks = BitField() ks.add_field("index") ks.add_field("spam") # General usage kss = keyspaces.get_derived_keyspaces(ks, (slice(5), 5, 6, 7)) for i, x in enumerate(kss): assert x.index == i # Specify a field kss = keyspaces.get_derived_keyspaces(ks, slice(1, 3), field_identifier="spam") for x, i in zip(kss, (1, 2)): assert x.spam == i # Fail when no maximum is specified with pytest.raises(ValueError): list(keyspaces.get_derived_keyspaces(ks, (slice(None))))
def test_write_subregion_calls_fields(self): """Check that writing a subregion to file calls the field functions with each key and that any extra arguments are passed along. """ # Create some keyspaces keys = [(Signal(BitField(32)), {}) for _ in range(10)] # Create two fields fields = [mock.Mock() for _ in range(2)] fields[0].return_value = 0 fields[1].return_value = 0 # Create an UNPARTITIONED region and write out a slice, check that # field methods were called with EACH key and the kwargs. r = KeyspacesRegion(keys, fields) fp = tempfile.TemporaryFile() kwargs = {"spam": "and eggs", "green_eggs": "and ham"} r.write_subregion_to_file(fp, slice(0, 1), **kwargs) for f in fields: f.assert_has_calls( [mock.call(k.keyspace, **kwargs) for k, _ in keys]) f.reset_mock() # Create a PARTITIONED region and write out a slice, check that # field methods were called with EACH key IN THE SLICE and the kwargs. r = KeyspacesRegion(keys, fields, partitioned_by_atom=True) for sl in (slice(0, 1), slice(2, 5)): fp = tempfile.TemporaryFile() kwargs = {"spam": "spam spam spam", "in_a_box": "with a fox"} r.write_subregion_to_file(fp, sl, **kwargs) for f in fields: f.assert_has_calls( [mock.call(k.keyspace, **kwargs) for k, _ in keys[sl]]) f.reset_mock()
def __init__(self, neuron_threshold, neuron_decay, test_data, timer_period_us=20000, sim_ticks=200, num_profile_samples=None): # Cache network parameters self._neuron_threshold = neuron_threshold self._neuron_decay = neuron_decay self._test_data = test_data self._timer_period_us = timer_period_us self._sim_ticks = sim_ticks self._num_profile_samples = num_profile_samples self._vert_index = 0 # Create data structures self._layers = [] self._vertex_applications = {} self._vertex_resources = {} # Create a 32-bit keyspace self._keyspace = BitField(32) self._keyspace.add_field("vert_index", tags="routing") self._keyspace.add_field("z", start_at=16) self._keyspace.add_field("y", length=8, start_at=8) self._keyspace.add_field("x", length=8, start_at=0)
def make_routing_tables(): # Create a perfect SpiNNaker machine to build against machine = Machine(12, 12) # Assign a vertex to each of the 17 application cores on each chip vertices = OrderedDict( ((x, y, p), object()) for x, y in machine for p in range(1, 18)) # Generate the vertex resources, placements and allocations (required for # routing) vertices_resources = OrderedDict((vertex, { Cores: 1 }) for vertex in itervalues(vertices)) placements = OrderedDict( (vertex, (x, y)) for (x, y, p), vertex in iteritems(vertices)) allocations = OrderedDict((vertex, { Cores: slice(p, p + 1) }) for (x, y, p), vertex in iteritems(vertices)) # Compute the distance dependent probabilities - this is a geometric # distribution such that each core has a 50% chance of being connected to # each core on the same chip, 25% on chips one hop away, 12.5% on chips two # hops away, etc. p = 0.5 probs = { d: p * (1 - p)**d for d in range(max(machine.width, machine.height)) } p = 0.3 dprobs = { d: p * (1 - p)**d for d in range(max(machine.width, machine.height)) } # Compute offsets to get to centroids vector_centroids = list() for d in (5, 6, 7): for i in range(d + 1): for j in range(d + 1 - i): vector_centroids.append((i, j, d - i - j)) # Make the nets, each vertex is connected with distance dependent # probability to other vertices. random.seed(123) nets = OrderedDict() for source_coord, source in iteritems(vertices): # Convert source_coord to xyz form source_coord_xyz = minimise_xyz(to_xyz(source_coord[:-1])) # Add a number of centroids x, y, z = source_coord_xyz possible_centroids = [ minimise_xyz((x + i, y + j, z + k)) for i, j, k in vector_centroids ] n_centroids = random.choice(17 * (0, ) + (1, 1) + (2, )) centroids = random.sample(possible_centroids, n_centroids) # Construct the sinks list sinks = list() for sink_coord, sink in iteritems(vertices): # Convert sink_coord to xyz form sink_coord = minimise_xyz(to_xyz(sink_coord[:-1])) # Get the path length to the original source dist = shortest_torus_path_length(source_coord_xyz, sink_coord, machine.width, machine.height) if random.random() < probs[dist]: sinks.append(sink) continue # See if the sink is connected to the centre of any of the # centroids. for coord in centroids: dist = shortest_torus_path_length(coord, sink_coord, machine.width, machine.height) if random.random() < dprobs[dist]: sinks.append(sink) break # Add the net nets[source_coord] = Net(source, sinks) rig_nets = list(itervalues(nets)) # Just the nets # Determine how many bits to use in the keys xyp_fields = BitField(32) xyp_fields.add_field("x", length=8, start_at=24) xyp_fields.add_field("y", length=8, start_at=16) xyp_fields.add_field("p", length=5, start_at=11) xyzp_fields = BitField(32) xyzp_fields.add_field("x", length=8, start_at=24) xyzp_fields.add_field("y", length=8, start_at=16) xyzp_fields.add_field("z", length=8, start_at=8) xyzp_fields.add_field("p", length=5, start_at=3) hilbert_fields = BitField(32) hilbert_fields.add_field("index", length=16, start_at=16) hilbert_fields.add_field("p", length=5, start_at=11) random.seed(321) rnd_fields = BitField(32) rnd_fields.add_field("rnd", length=12, start_at=20) rnd_seen = set() # Generate the routing keys net_keys_xyp = OrderedDict() net_keys_xyzp = OrderedDict() net_keys_hilbert = OrderedDict() net_keys_rnd = OrderedDict() for i, (x, y) in enumerate(chip for chip in hilbert_chip_order(machine) if chip in machine): # Add the key for each net from each processor for p in range(1, 18): # Get the net net = nets[(x, y, p)] # Construct the xyp key/mask net_keys_xyp[net] = xyp_fields(x=x, y=y, p=p) # Construct the xyzp mask x_, y_, z_ = minimise_xyz(to_xyz((x, y))) net_keys_xyzp[net] = xyzp_fields(x=x_, y=y_, z=abs(z_), p=p) # Construct the Hilbert key/mask net_keys_hilbert[net] = hilbert_fields(index=i, p=p) # Construct the random 12 bit value field val = None while val is None or val in rnd_seen: val = random.getrandbits(12) rnd_seen.add(val) net_keys_rnd[net] = rnd_fields(rnd=val) # Route the network and then generate the routing tables constraints = list() print("Routing...") routing_tree = route(vertices_resources, rig_nets, machine, constraints, placements, allocations) # Write the routing tables to file for fields, desc in ((net_keys_xyp, "xyp"), (net_keys_xyzp, "xyzp"), (net_keys_hilbert, "hilbert"), (net_keys_rnd, "rnd")): print("Getting keys and masks...") keys = OrderedDict((net, (bf.get_value(), bf.get_mask())) for net, bf in iteritems(fields)) print("Constructing routing tables for {}...".format(desc)) tables = routing_tree_to_tables(routing_tree, keys) print([len(x) for x in itervalues(tables)]) print("Writing to file...") fn = "uncompressed/centroid_{}_{}_{}.bin".format( machine.width, machine.height, desc) with open(fn, "wb+") as f: dump_routing_tables(f, tables)
def make_routing_tables(): # Create a perfect SpiNNaker machine to build against machine = Machine(12, 12) # Assign a vertex to each of the 17 application cores on each chip vertices = OrderedDict( ((x, y, p), object()) for x, y in machine for p in range(1, 18) ) # Generate the vertex resources, placements and allocations (required for # routing) vertices_resources = OrderedDict( (vertex, {Cores: 1}) for vertex in itervalues(vertices) ) placements = OrderedDict( (vertex, (x, y)) for (x, y, p), vertex in iteritems(vertices) ) allocations = OrderedDict( (vertex, {Cores: slice(p, p+1)}) for (x, y, p), vertex in iteritems(vertices) ) # Compute the distance dependent probabilities probs = {d: .5*math.exp(-.65*d) for d in range(max(machine.width, machine.height))} # Make the nets, each vertex is connected with distance dependent # probability to other vertices. random.seed(123) nets = OrderedDict() for source_coord, source in iteritems(vertices): # Convert source_coord to xyz form source_coord_xyz = minimise_xyz(to_xyz(source_coord[:-1])) # Construct the sinks list sinks = list() for sink_coord, sink in iteritems(vertices): # Convert sink_coord to xyz form sink_coord = minimise_xyz(to_xyz(sink_coord[:-1])) # Get the path length dist = shortest_torus_path_length(source_coord_xyz, sink_coord, machine.width, machine.height) if random.random() < probs[dist]: sinks.append(sink) # Add the net nets[source_coord] = Net(source, sinks) rig_nets = list(itervalues(nets)) # Just the nets # Determine how many bits to use in the keys xyp_fields = BitField(32) xyp_fields.add_field("x", length=8, start_at=24) xyp_fields.add_field("y", length=8, start_at=16) xyp_fields.add_field("p", length=5, start_at=11) xyzp_fields = BitField(32) xyzp_fields.add_field("x", length=8, start_at=24) xyzp_fields.add_field("y", length=8, start_at=16) xyzp_fields.add_field("z", length=8, start_at=8) xyzp_fields.add_field("p", length=5, start_at=3) hilbert_fields = BitField(32) hilbert_fields.add_field("index", length=16, start_at=16) hilbert_fields.add_field("p", length=5, start_at=11) random.seed(321) rnd_fields = BitField(32) rnd_fields.add_field("rnd", length=12, start_at=20) rnd_seen = set() # Generate the routing keys net_keys_xyp = OrderedDict() net_keys_xyzp = OrderedDict() net_keys_hilbert = OrderedDict() net_keys_rnd = OrderedDict() for i, (x, y) in enumerate(chip for chip in hilbert_chip_order(machine) if chip in machine): # Add the key for each net from each processor for p in range(1, 18): # Get the net net = nets[(x, y, p)] # Construct the xyp key/mask net_keys_xyp[net] = xyp_fields(x=x, y=y, p=p) # Construct the xyzp mask x_, y_, z_ = minimise_xyz(to_xyz((x, y))) net_keys_xyzp[net] = xyzp_fields(x=x_, y=y_, z=abs(z_), p=p) # Construct the Hilbert key/mask net_keys_hilbert[net] = hilbert_fields(index=i, p=p) # Construct the random 12 bit value field val = None while val is None or val in rnd_seen: val = random.getrandbits(12) rnd_seen.add(val) net_keys_rnd[net] = rnd_fields(rnd=val) # Route the network and then generate the routing tables constraints = list() print("Routing...") routing_tree = route(vertices_resources, rig_nets, machine, constraints, placements, allocations) # Write the routing tables to file for fields, desc in ((net_keys_xyp, "xyp"), (net_keys_xyzp, "xyzp"), (net_keys_hilbert, "hilbert"), (net_keys_rnd, "rnd")): print("Getting keys and masks...") keys = {net: (bf.get_value(), bf.get_mask()) for net, bf in iteritems(fields)} print("Constructing routing tables for {}...".format(desc)) tables = routing_tree_to_tables(routing_tree, keys) print([len(x) for x in itervalues(tables)]) print("Writing to file...") fn = "uncompressed/gaussian_{}_{}_{}.bin".format( machine.width, machine.height, desc) with open(fn, "wb+") as f: dump_routing_tables(f, tables)
def test_sizeof_with_prepends(self): r = KeyspacesRegion([(Signal(BitField(32)), {})], fields=[], prepend_num_keyspaces=True) assert r.sizeof(slice(None)) == 4