def make_vertices(self, model, n_steps): """Create the vertices to be simulated on the machine.""" # Create the system region self.system_region = SystemRegion(model.machine_timestep, self.period is not None, n_steps) # Get all the outgoing signals to determine how big the size out is and # to build a list of keys. sigs_conns = model.get_signals_connections_from_object(self) if len(sigs_conns) == 0: return netlistspec([]) keys = list() self.conns_transforms = list() for sig, conns in iteritems(sigs_conns[OutputPort.standard]): assert len(conns) == 1, "Expected a 1:1 mapping" # Add the keys for this connection conn = conns[0] transform, sig_keys = get_transform_keys(model, sig, conn) keys.extend(sig_keys) self.conns_transforms.append((conn, transform)) size_out = len(keys) # Build the keys region self.keys_region = regions.KeyspacesRegion( keys, [regions.KeyField({"cluster": "cluster"})], partitioned_by_atom=True ) # Create the output region self.output_region = regions.MatrixRegion( np.zeros((n_steps, size_out)), sliced_dimension=regions.MatrixPartitioning.columns ) self.regions = [self.system_region, self.keys_region, self.output_region] # Partition by output dimension to create vertices transmit_constraint = partition.Constraint(10) sdram_constraint = partition.Constraint(8*2**20) # Max 8MiB constraints = { transmit_constraint: lambda s: s.stop - s.start, sdram_constraint: lambda s: regions.utils.sizeof_regions(self.regions, s), } for sl in partition.partition(slice(0, size_out), constraints): # Determine the resources resources = { Cores: 1, SDRAM: regions.utils.sizeof_regions(self.regions, sl), } vsl = VertexSlice(sl, get_application("value_source"), resources) self.vertices.append(vsl) # Return the vertices and callback methods return netlistspec(self.vertices, self.load_to_machine, self.before_simulation)
def test_single_vertices(self): """Test that operators which produce single vertices work correctly and that all functions and signals are correctly collected and included in the final netlist. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec(vertex_b, load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connections_signals[None] = signal_ab netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b] assert net.keyspace is keyspace assert net.weight == signal_ab.weight assert set(netlist.vertices) == set([vertex_a, vertex_b]) assert netlist.keyspaces is model.keyspaces assert netlist.groups == list() assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_extra_operators_and_signals(self): """Test the operators and signals in the extra_operators and extra_signals lists are included when building netlists. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec(vertex_b, load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.extra_operators = [operator_a, operator_b] model.extra_signals = [signal_ab] netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b] assert net.keyspace is keyspace assert net.weight == signal_ab.weight assert set(netlist.vertices) == set([vertex_a, vertex_b]) assert netlist.keyspaces is model.keyspaces assert netlist.groups == list() assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def make_vertices(self, model, *args, **kwargs): """Create vertices that will simulate the SDPTransmitter.""" # Build the system region self._sys_region = SystemRegion(model.machine_timestep, self.size_in, 1) # Build the filter regions in_sigs = model.get_signals_connections_to_object(self) self._filter_region, self._routing_region = make_filter_regions( in_sigs[InputPort.standard], model.dt, True, model.keyspaces.filter_routing_tag ) # Get the resources resources = { Cores: 1, SDRAM: region_utils.sizeof_regions( [self._sys_region, self._filter_region, self._routing_region], None ) } # Create the vertex self._vertex = Vertex(get_application("tx"), resources) # Return the netlist specification return netlistspec(self._vertex, load_function=self.load_to_machine)
def test_multiple_sink_vertices(self): # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b0 = mock.Mock(name="vertex B0") vertex_b1 = mock.Mock(name="vertex B1") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec([vertex_b0, vertex_b1], load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=3) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connections_signals[None] = signal_ab netlist = model.make_netlist() # Check that the netlist is as expected assert set(netlist.vertices) == set([vertex_a, vertex_b0, vertex_b1]) assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b0, vertex_b1] assert net.keyspace is keyspace assert net.weight == signal_ab.weight # Check that the groups are correct assert netlist.groups == [set([vertex_b0, vertex_b1])]
def make_vertices(self, model, *args, **kwargs): """Create vertices that will simulate the SDPReceiver.""" # NOTE This approach will result in more routes being created than are # actually necessary; the way to avoid this is to modify how the # builder deals with signals when creating netlists. # Get all outgoing signals and their associated connections (this # SHOULD be a 1:1 mapping) out = model.get_signals_connections_from_object(self) for signal, connections in six.iteritems(out[OutputPort.standard]): assert len(connections) == 1, "Expecting a 1:1 mapping" conn = connections[0] # Get the transform, and from this the keys transform = model.params[conn].transform keys = [signal.keyspace(index=i) for i in range(transform.shape[0])] # Create a vertex for this connection (assuming its size out <= 64) if len(keys) > 64: raise NotImplementedError( "Connection {!s} is too wide to transmit to SpiNNaker. " "Consider breaking the connection up or making the " "originating node a function of time Node.".format(conn) ) # Create the regions for the system sys_region = SystemRegion(model.machine_timestep, len(keys)) keys_region = KeyspacesRegion(keys, [KeyField({"cluster": "cluster"})]) # Get the resources resources = { Cores: 1, SDRAM: region_utils.sizeof_regions([sys_region, keys_region], None) } # Create the vertex v = self.connection_vertices[conn] = Vertex(get_application("rx"), resources) self._sys_regions[v] = sys_region self._key_regions[v] = keys_region # Return the netlist specification return netlistspec(list(self.connection_vertices.values()), load_function=self.load_to_machine)
def make_vertices(self, model, n_steps): # TODO remove n_steps """Construct the data which can be loaded into the memory of a SpiNNaker machine. """ # Build encoders, gain and bias regions params = model.params[self.ensemble] # Convert the encoders combined with the gain to S1615 before creating # the region. encoders_with_gain = params.scaled_encoders self.encoders_region = regions.MatrixRegion( tp.np_to_fix(encoders_with_gain), sliced_dimension=regions.MatrixPartitioning.rows ) # Combine the direct input with the bias before converting to S1615 and # creating the region. bias_with_di = params.bias + np.dot(encoders_with_gain, self.direct_input) assert bias_with_di.ndim == 1 self.bias_region = regions.MatrixRegion( tp.np_to_fix(bias_with_di), sliced_dimension=regions.MatrixPartitioning.rows ) # Convert the gains to S1615 before creating the region self.gain_region = regions.MatrixRegion( tp.np_to_fix(params.gain), sliced_dimension=regions.MatrixPartitioning.rows ) # Extract all the filters from the incoming connections incoming = model.get_signals_connections_to_object(self) self.input_filters, self.input_filter_routing = make_filter_regions( incoming[InputPort.standard], model.dt, True, model.keyspaces.filter_routing_tag, width=self.ensemble.size_in ) self.inhib_filters, self.inhib_filter_routing = make_filter_regions( incoming[EnsembleInputPort.global_inhibition], model.dt, True, model.keyspaces.filter_routing_tag, width=1 ) self.mod_filters, self.mod_filter_routing = make_filter_regions( {}, model.dt, True, model.keyspaces.filter_routing_tag ) # Extract all the decoders for the outgoing connections and build the # regions for the decoders and the regions for the output keys. outgoing = model.get_signals_connections_from_object(self) decoders, output_keys = \ get_decoders_and_keys(model, outgoing[OutputPort.standard], True) size_out = decoders.shape[1] # TODO: Include learnt decoders self.pes_region = PESRegion() self.decoders_region = regions.MatrixRegion( tp.np_to_fix(decoders / model.dt), sliced_dimension=regions.MatrixPartitioning.rows ) self.output_keys_region = regions.KeyspacesRegion( output_keys, fields=[regions.KeyField({'cluster': 'cluster'})] ) # Create the recording regions for locally situated probes self.spike_region = None self.probe_spikes = False self.voltage_region = None self.probe_voltages = False for probe in self.local_probes: # For each probe determine which regions and flags should be set if probe.attr in ("output", "spikes"): # If spikes are being probed then ensure that the flag is set # and a region exists. if not self.probe_spikes: self.spike_region = SpikeRegion(n_steps) self.probe_spikes = True elif probe.attr in ("voltage"): # If voltages are being probed then ensure that the flag is set # and a region exists. if not self.probe_voltages: self.voltage_region = VoltageRegion(n_steps) self.probe_voltages = True # If profiling is enabled num_profiler_samples = 0 if getconfig(model.config, self.ensemble, "profile", False): # Try and get number of samples from config num_profiler_samples = getconfig(model.config, self.ensemble, "profile_num_samples") # If it's not specified, calculate sensible default if num_profiler_samples is None: num_profiler_samples =\ len(EnsembleLIF.profiler_tag_names) * n_steps * 2 # Create profiler region self.profiler_region = regions.Profiler(num_profiler_samples) # Create the regions list self.regions = [ SystemRegion(self.ensemble.size_in, size_out, model.machine_timestep, self.ensemble.neuron_type.tau_ref, self.ensemble.neuron_type.tau_rc, model.dt, self.probe_spikes, self.probe_voltages, num_profiler_samples ), self.bias_region, self.encoders_region, self.decoders_region, self.output_keys_region, self.input_filters, self.input_filter_routing, self.inhib_filters, self.inhib_filter_routing, self.gain_region, self.mod_filters, self.mod_filter_routing, self.pes_region, self.profiler_region, self.spike_region, self.voltage_region, ] # Partition the ensemble and get a list of vertices to load to the # machine. We can expect to be DTCM or CPU bound, so the SDRAM bound # can be quite lax to allow for lots of data probing. # TODO: Include other DTCM usage def cpu_usage(sl): """Calculate the CPU usage (in cycles) based on the number of neurons and the size_in and size_out of the ensemble. The equation and coefficients are taken from: "An Efficient SpiNNaker Implementation of the NEF", Mundy, Knight, Stewart and Furber [IJCNN 2015] """ n_neurons = (sl.stop - sl.start) return (245 + 43*self.ensemble.size_in + 100 + 702*size_out + 188 + 69*n_neurons + 13*n_neurons*self.ensemble.size_in) self.vertices = list() sdram_constraint = partition.Constraint(8*2**20) # Max 8MiB dtcm_constraint = partition.Constraint(64*2**10, .75) # 75% of 64KiB cpu_constraint = partition.Constraint(200000, .8) # 80% of 200k cycles constraints = { sdram_constraint: lambda s: regions.utils.sizeof_regions( self.regions, s), # **HACK** don't include last three regions in DTCM estimate # (profiler and spike recording) dtcm_constraint: lambda s: regions.utils.sizeof_regions( self.regions[:-3], s) + 5*(s.stop - s.start), cpu_constraint: cpu_usage, } app_name = ( "ensemble_profiled" if num_profiler_samples > 0 else "ensemble" ) for sl in partition.partition(slice(0, self.ensemble.n_neurons), constraints): resources = { Cores: 1, SDRAM: regions.utils.sizeof_regions(self.regions, sl), } vsl = VertexSlice(sl, get_application(app_name), resources) self.vertices.append(vsl) # Return the vertices and callback methods return netlistspec(self.vertices, self.load_to_machine, after_simulation_function=self.after_simulation)