def test_dead_section(not_there, default_config):
name, place = not_there
default_config = default_config + "[Pets]\nsam=cat\n"
with open(place, "w") as f:
f.write(default_config)
with LogCapture() as lc:
conf_loader.load_config(name, [CFGPATH])
log_checker.assert_logs_warning_contains(lc.records,
"Unexpected Section: [Pets]")
def test_new_option_home(not_there, default_config):
name, place = not_there
default_config = default_config + "sam=cat\n"
with open(place, "w") as f:
f.write(default_config)
with LogCapture() as lc:
conf_loader.load_config(name, [CFGPATH])
log_checker.assert_logs_warning_contains(
lc.records, "Unexpected Option: [sect]sam")
def test_new_option_local(tmpdir, default_config, not_there):
name, place = not_there
with open(place, "w") as f:
f.write(default_config)
with tmpdir.as_cwd():
f = tmpdir.join(name)
default_config = default_config + "sam=cat\n"
f.write(default_config)
with pytest.raises(UnexpectedConfigException):
conf_loader.load_config(name, [CFGPATH])
def test_use_one_default(tmpdir, not_there):
name, place = not_there
with tmpdir.as_cwd():
with pytest.raises(NoConfigFoundException):
conf_loader.load_config(name, [CFGPATH])
# Load the now created file
config = configparser.ConfigParser()
config.read(place)
assert config is not None
assert config.sections() == ["sect"]
assert config.options("sect") == ["foobob"]
assert config.get("sect", "foobob") == "bar"
def setUp(self):
conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg")
self._previous_reportsEnabled = conf.get(
"Reports", "reportsEnabled")
self.previous_defaultReportFilePath = conf.get(
"Reports", "defaultReportFilePath")
def assert_not_spin_three(self):
config = conf_loader.load_config(filename="spynnaker.cfg", defaults=[])
if config.has_option("Machine", "version"):
version = config.get("Machine", "version")
if version in ["2", "3"]:
raise SkipTest(
"This test will not run on a spin {} board".format(
version))
def test_retrieve_direct_block(self):
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
key = 0
n_rows = 2
direct_matrix = bytearray(struct.pack("<IIII", 1, 2, 3, 4))
direct_matrix_1_expanded = bytearray(
struct.pack("<IIIIIIII", 0, 1, 0, 1, 0, 1, 0, 2))
direct_matrix_2_expanded = bytearray(
struct.pack("<IIIIIIII", 0, 1, 0, 3, 0, 1, 0, 4))
synaptic_manager = SynapticManager(
synapse_type=None,
ring_buffer_sigma=5.0,
spikes_per_second=100.0,
config=config,
population_table_type=MockMasterPopulationTable(
{key: [(1, 0, True), (1, n_rows * 4, True)]}),
synapse_io=MockSynapseIO())
transceiver = MockTransceiverRawData(direct_matrix)
placement = Placement(None, 0, 0, 1)
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver,
placement=placement,
master_pop_table_address=0,
indirect_synapses_address=0,
direct_synapses_address=0,
key=key,
n_rows=n_rows,
index=0,
using_extra_monitor_cores=False)
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver,
placement=placement,
master_pop_table_address=0,
indirect_synapses_address=0,
direct_synapses_address=0,
key=key,
n_rows=n_rows,
index=1,
using_extra_monitor_cores=False)
# Row lengths should be 1
assert row_len_1 == 1
assert row_len_2 == 1
# Check the data retrieved
assert data_1 == direct_matrix_1_expanded
assert data_2 == direct_matrix_2_expanded
def test_different_value(not_there, default_config):
name, place = not_there
default_config = default_config.replace("bar", "cat")
with open(place, "w") as f:
f.write(default_config)
config = conf_loader.load_config(name, [CFGPATH])
assert config is not None
assert config.sections() == ["sect"]
assert config.options("sect") == ["foobob"]
assert config.get("sect", "foobob") == "cat"
def test_None_machine_spec_file(tmpdir, default_config, not_there):
name, place = not_there
default_config += "\n[Machine]\nmachine_spec_file=None\n"
with open(place, "w") as f:
f.write(default_config)
with tmpdir.as_cwd():
with LogCapture() as lc:
config = conf_loader.load_config(name, [])
assert config is not None
assert config.sections() == ["sect", "Machine"]
assert config.options("sect") == ["foobob"]
assert config.get("sect", "foobob") == "bar"
log_checker.assert_logs_info_not_contains(lc.records, "None")
def load_config():
"""
Reads in all the config files, resetting all values.
"""
global __config
if not __default_config_files:
raise Exception("No default configs set")
if __config_file:
__config = conf_loader.load_config(filename=__config_file,
defaults=__default_config_files)
else:
__config = CamelCaseConfigParser()
for default in __default_config_files:
__config.read(default)
def test_advanced_use(tmpdir, default_config, not_there):
def parseAbc(parser):
f = parser.getfloat("Abc", "def")
parser.set("Abc", "ghi", f * 3)
parser.remove_option("Abc", "def")
name, place = not_there
default_config += "\n[Abc]\ndef=1.25\n"
with open(place, "w") as f:
f.write(default_config)
with tmpdir.as_cwd():
config = conf_loader.load_config(name, [],
config_parsers=[("Abc", parseAbc)])
assert config.options("Abc") == ["ghi"]
assert config.getfloat("Abc", "ghi") == 3.75
def test_str_list(tmpdir, not_there):
name, place = not_there
with open(place, "w") as f:
f.write("[abc]\n"
"as_list=bacon, is,so ,cool \n"
"as_none=None\n"
"as_empty=\n"
"fluff=more\n")
with tmpdir.as_cwd():
config = conf_loader.load_config(name, [])
assert config.get_str_list("abc", "as_list") == \
["bacon", "is", "so", "cool"]
assert config.get_str_list("abc", "as_none") == []
assert config.get_str_list("abc", "as_empty") == []
assert config.get_str_list("abc", "fluff") == ["more"]
def test_reports_creation_custom_location(self):
conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg")
current_path = os.path.dirname(os.path.abspath(__file__))
conf.set("Reports", "defaultReportFilePath", current_path)
conf.set("Reports", "reportsEnabled", "True")
spinn = Spinnaker(timestep=1, min_delay=1, max_delay=10)
if 'reports' in os.listdir(current_path):
shutil.rmtree(os.path.join(current_path, 'reports'))
spinn._set_up_report_specifics()
self.assertEqual(spinn._report_default_directory,
os.path.join(current_path, 'reports', 'latest'))
# File reports should be in the new location
self.assertIn('reports', os.listdir(current_path))
def test_intermediate_use(tmpdir, default_config, mach_spec, not_there):
name, place = not_there
default_config += "\n[Machine]\nmachine_spec_file=" + mach_spec + "\n"
with open(place, "w") as f:
f.write(default_config)
with tmpdir.as_cwd():
with LogCapture() as lc:
config = conf_loader.load_config(name, [])
assert config is not None
assert config.sections() == ["sect", "Machine"]
assert config.options("sect") == ["foobob"]
assert config.get("sect", "foobob") == "bar"
assert config.options("Machine") == ["machinename", "version"]
assert config.get("Machine", "MachineName") == "foo"
assert config.getint("Machine", "VeRsIoN") == 5
log_checker.assert_logs_info_contains(lc.records, name)
def test_retrieve_synaptic_block(self):
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
key = 0
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0,
config=config,
population_table_type=MockMasterPopulationTable(
{key: [(1, 0, False)]}),
synapse_io=MockSynapseIO())
transceiver = MockTransceiverRawData(bytearray(16))
placement = Placement(None, 0, 0, 1)
first_block, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
same_block, row_len_1_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
synaptic_manager.clear_connection_cache()
different_block, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
# Check that the row lengths are all the same
assert row_len_1 == row_len_1_2
assert row_len_1 == row_len_2
# Check that the block retrieved twice without reset is cached
assert id(first_block) == id(same_block)
# Check that the block after reset is not a copy
assert id(first_block) != id(different_block)
def test_retrieve_synaptic_block(self):
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
key = 0
synaptic_manager = SynapticManager(
synapse_type=None, ring_buffer_sigma=5.0, spikes_per_second=100.0,
config=config,
population_table_type=MockMasterPopulationTable(
{key: [(1, 0, False)]}),
synapse_io=MockSynapseIO())
transceiver = MockTransceiverRawData(bytearray(16))
placement = Placement(None, 0, 0, 1)
first_block, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
same_block, row_len_1_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
synaptic_manager.clear_connection_cache()
different_block, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=1, index=0,
using_extra_monitor_cores=False)
# Check that the row lengths are all the same
assert row_len_1 == row_len_1_2
assert row_len_1 == row_len_2
# Check that the block retrieved twice without reset is cached
assert id(first_block) == id(same_block)
# Check that the block after reset is not a copy
assert id(first_block) != id(different_block)
def test_retrieve_direct_block(self):
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
key = 0
n_rows = 2
direct_matrix = bytearray(struct.pack("<IIII", 1, 2, 3, 4))
direct_matrix_1_expanded = bytearray(
struct.pack("<IIIIIIII", 0, 1, 0, 1, 0, 1, 0, 2))
direct_matrix_2_expanded = bytearray(
struct.pack("<IIIIIIII", 0, 1, 0, 3, 0, 1, 0, 4))
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0, spikes_per_second=100.0,
config=config,
population_table_type=MockMasterPopulationTable(
{key: [(1, 0, True), (1, n_rows * 4, True)]}),
synapse_io=MockSynapseIO())
transceiver = MockTransceiverRawData(direct_matrix)
placement = Placement(None, 0, 0, 1)
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=n_rows, index=0,
using_extra_monitor_cores=False)
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=0, indirect_synapses_address=0,
direct_synapses_address=0, key=key, n_rows=n_rows, index=1,
using_extra_monitor_cores=False)
# Row lengths should be 1
assert row_len_1 == 1
assert row_len_2 == 1
# Check the data retrieved
assert data_1 == direct_matrix_1_expanded
assert data_2 == direct_matrix_2_expanded
def __init__(self, configfile, default_config_paths, validation_cfg):
# global params
if default_config_paths is None:
default_config_paths = []
default_config_paths.insert(
0, os.path.join(os.path.dirname(__file__), CONFIG_FILE))
self._config = conf_loader.load_config(filename=configfile,
defaults=default_config_paths,
validation_cfg=validation_cfg)
# set up machine targeted data
self._use_virtual_board = self._config.getboolean(
"Machine", "virtual_board")
self._app_data_runtime_folder = None
self._app_data_top_simulation_folder = None
self._json_folder = None
self._provenance_file_path = None
self._report_default_directory = None
self._report_simulation_top_directory = None
self._this_run_time_string = None
def __init__(self, configfile, default_config_paths, validation_cfg):
"""
:param str configfile:
The base name of the configuration file(s).
Should not include any path components.
:param list(str) default_config_paths:
The list of files to get default configurations from.
:type default_config_paths: list(str) or None
:param validation_cfg:
The list of files to read a validation configuration from.
If None, no such validation is performed.
:type validation_cfg: list(str) or None
"""
# global params
if default_config_paths is None:
default_config_paths = []
default_config_paths.insert(0, os.path.join(
os.path.dirname(__file__), CONFIG_FILE))
self._config = conf_loader.load_config(
filename=configfile, defaults=default_config_paths,
validation_cfg=validation_cfg)
# set up machine targeted data
self._use_virtual_board = self._config.getboolean(
"Machine", "virtual_board")
# Pass max_machine_cores to Machine so if effects everything!
max_machine_core = self._read_config_int("Machine", "max_machine_core")
if max_machine_core is not None:
Machine.set_max_cores_per_chip(max_machine_core)
self._json_folder = None
self._provenance_file_path = None
self._report_default_directory = None
self._report_simulation_top_directory = None
self._this_run_time_string = None
def __init__(
self, configfile, default_config_paths, validation_cfg):
# global params
if default_config_paths is None:
default_config_paths = []
default_config_paths.insert(0, os.path.join(
os.path.dirname(__file__), CONFIG_FILE))
self._config = conf_loader.load_config(
filename=configfile, defaults=default_config_paths,
validation_cfg=validation_cfg)
# set up machine targeted data
self._use_virtual_board = self._config.getboolean(
"Machine", "virtual_board")
self._app_data_runtime_folder = None
self._app_data_top_simulation_folder = None
self._json_folder = None
self._provenance_file_path = None
self._report_default_directory = None
self._report_simulation_top_directory = None
self._this_run_time_string = None
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex = SimpleMachineVertex(resources=None)
pre_vertex_slice = Slice(0, 9)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex = SimpleMachineVertex(resources=None)
post_vertex_slice = Slice(0, 9)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
one_to_one_connector_1.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_1.set_weights_and_delays(1.5, 1.0)
one_to_one_connector_2 = OneToOneConnector(None)
one_to_one_connector_2.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_2.set_weights_and_delays(2.5, 2.0)
all_to_all_connector = AllToAllConnector(None)
all_to_all_connector.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
all_to_all_connector.set_weights_and_delays(4.5, 4.0)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, SynapseDynamicsStatic(), 0)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, SynapseDynamicsStatic(), 1)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, SynapseDynamicsStatic(), 0)
app_edge = ProjectionApplicationEdge(
pre_app_vertex, post_app_vertex, direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = ProjectionMachineEdge(
app_edge.synapse_information, pre_vertex, post_vertex)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
graph_mapper = GraphMapper()
graph_mapper.add_vertex_mapping(
pre_vertex, pre_vertex_slice, pre_app_vertex)
graph_mapper.add_vertex_mapping(
post_vertex, post_vertex_slice, post_app_vertex)
graph_mapper.add_edge_mapping(machine_edge, app_edge)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
master_pop_region = 0
all_syn_block_sz = 2000
synapse_region = 1
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synapse_type = MockSynapseType()
synaptic_manager = SynapticManager(
synapse_type=synapse_type, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales,
master_pop_region, synapse_region, routing_info, graph_mapper,
graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(
spec_reader, master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
all_data = bytearray()
all_data.extend(master_pop_table.region_data[
:master_pop_table.max_write_pointer])
all_data.extend(synaptic_matrix.region_data[
:synaptic_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = struct.unpack_from(
"<I", synaptic_matrix.region_data)[0]
direct_synapses_address += synaptic_matrix_address + 8
indirect_synapses_address = synaptic_matrix_address + 4
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._poptable_type\
.extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver,
placement.x, placement.y)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
# TODO: This has been changed because direct matrices are disabled!
assert not items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=0,
using_extra_monitor_cores=False)
connections_1 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, 2, weight_scales, data_1, None,
app_edge.n_delay_stages, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=1,
using_extra_monitor_cores=False)
connections_2 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, 2, weight_scales, data_2, None,
app_edge.n_delay_stages, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=2,
using_extra_monitor_cores=False)
connections_3 = synaptic_manager._synapse_io.read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None,
app_edge.n_delay_stages, machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
def DvsEmulatorDevice(n_neurons, machine_time_step, timescale_factor,
label, port=12345, virtual_key=None,
spikes_per_second=0, ring_buffer_sigma=None,
device_id=0, fps=30, mode="128", scale_img=True, polarity="MERGED",
inhibition = False, inh_area_width = 2,
threshold=12, adaptive_threshold = False,
min_threshold= 6, max_threshold=168,
threshold_delta_down = 2, threshold_delta_up = 12,
output_type="TIME", num_bits_per_spike=4,
history_weight=0.99, save_spikes=None, run_time_ms=None,
local_port=19999,
database_notify_host=None, database_notify_port_num=None,
database_ack_port_num=None):
"""
supports adding a spike injector to the applciation graph.
:param n_neurons: the number of neurons the spike injector will emulate
:type n_neurons: int
:param machine_time_step: the time period in ms for each timer callback
:type machine_time_step: int
:param timescale_factor: the amount of scaling needed of the machine time
step (basically a slow down function)
:type timescale_factor: int
:param spikes_per_second: the expected number of spikes per second
:type spikes_per_second: int
:param ring_buffer_sigma: the number of standard divations from a
calcuation on how much safety in percision vs overflowing
(this is deduced from the front end)
:type ring_buffer_sigma: int
:param label: the label given to the population
:type label: str
:param port: the port number used to listen for injections of spikes
:type port: int
:param virtual_key: the virtual key used in the routing system
:type virtual_key: int
:param database_notify_host: the hostnmae for the device which is listening
to the database notifcation.
:type database_notify_host: str
:param database_ack_port_num: the port number to which a external device
will ack that they have finished reading the database and are ready for
it to start execution
:type database_ack_port_num: int
:param database_notify_port_num: The port number to which a external device
will recieve the database is ready command
:type database_notify_port_num: int
:return:
"""
config = conf_loader.load_config(filename="spynnaker.cfg", defaults=[])
if database_notify_port_num is None:
database_notify_port_num = config.getint("Database",
"notify_port")
if database_notify_host is None:
database_notify_host = config.get("Database", "notify_hostname")
if database_ack_port_num is None:
database_ack_port_num = config.get("Database", "listen_port")
if database_ack_port_num == "None":
database_ack_port_num = None
# build the database socket address used by the notifcation interface
database_socket = SocketAddress(
listen_port=database_ack_port_num,
notify_host_name=database_notify_host,
notify_port_no=database_notify_port_num)
# update socket interface with new demands.
spynnaker_external_devices.add_socket_address(database_socket)
return ExternalDvsEmulatorDevice(
n_neurons=n_neurons, machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
database_socket=database_socket,
spikes_per_second=spikes_per_second, ring_buffer_sigma=ring_buffer_sigma,
label=label, port=port, virtual_key=virtual_key,
device_id=device_id, fps=fps, mode=mode, scale_img=scale_img, polarity=polarity,
inhibition=inhibition, inh_area_width = inh_area_width,
threshold=threshold, adaptive_threshold=adaptive_threshold,
min_threshold=min_threshold, max_threshold=max_threshold,
threshold_delta_down=threshold_delta_down, threshold_delta_up=threshold_delta_up,
output_type=output_type, num_bits_per_spike=num_bits_per_spike,
history_weight=history_weight, save_spikes=save_spikes,
run_time_ms=run_time_ms,
local_port=local_port)
def test_set_synapse_dynamics(self):
MockSimulator.setup()
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
static = SynapseDynamicsStatic()
stdp = SynapseDynamicsSTDP(
timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceAdditive())
alt_stdp = SynapseDynamicsSTDP(
timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceMultiplicative())
static_struct = SynapseDynamicsStructuralStatic(
partner_selection=LastNeuronSelection(),
formation=DistanceDependentFormation(),
elimination=RandomByWeightElimination(0.5))
alt_static_struct = SynapseDynamicsStructuralStatic(
partner_selection=RandomSelection(),
formation=DistanceDependentFormation(),
elimination=RandomByWeightElimination(0.5))
stdp_struct = SynapseDynamicsStructuralSTDP(
partner_selection=LastNeuronSelection(),
formation=DistanceDependentFormation(),
elimination=RandomByWeightElimination(0.5),
timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceAdditive())
alt_stdp_struct = SynapseDynamicsStructuralSTDP(
partner_selection=RandomSelection(),
formation=DistanceDependentFormation(),
elimination=RandomByWeightElimination(0.5),
timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceAdditive())
alt_stdp_struct_2 = SynapseDynamicsStructuralSTDP(
partner_selection=LastNeuronSelection(),
formation=DistanceDependentFormation(),
elimination=RandomByWeightElimination(0.5),
timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceMultiplicative())
# This should be fine as it is the first call
synaptic_manager.synapse_dynamics = static
# This should be fine as STDP overrides static
synaptic_manager.synapse_dynamics = stdp
# This should fail because STDP dependences are difference
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp
# This should work because STDP dependences are the same
synaptic_manager.synapse_dynamics = stdp
# This should work because static always works, but the type should
# still be STDP
synaptic_manager.synapse_dynamics = static
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsSTDP)
# This should work but should merge with the STDP rule
synaptic_manager.synapse_dynamics = static_struct
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
# These should work as static / the STDP is the same but neither should
# change anything
synaptic_manager.synapse_dynamics = static
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
synaptic_manager.synapse_dynamics = stdp
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
synaptic_manager.synapse_dynamics = static_struct
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
# These should fail as things are different
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_static_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp
# This should pass as same structural STDP
synaptic_manager.synapse_dynamics = stdp_struct
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
# These should fail as both different
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct_2
# Try starting again to get a couple more combinations
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
# STDP followed by structural STDP should result in Structural STDP
synaptic_manager.synapse_dynamics = stdp
synaptic_manager.synapse_dynamics = stdp_struct
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
# ... and should fail here because of differences
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_static_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct_2
# One more time!
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
# Static followed by static structural should result in static
# structural
synaptic_manager.synapse_dynamics = static
synaptic_manager.synapse_dynamics = static_struct
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralStatic)
# ... and should fail here because of differences
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_static_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct
# This should be fine
synaptic_manager.synapse_dynamics = static
# This should be OK, but should merge with STDP (opposite of above)
synaptic_manager.synapse_dynamics = stdp
self.assertIsInstance(
synaptic_manager.synapse_dynamics, SynapseDynamicsStructuralSTDP)
# ... and now these should fail
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_static_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct
with self.assertRaises(SynapticConfigurationException):
synaptic_manager.synapse_dynamics = alt_stdp_struct_2
# OK, just one more, honest
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
synaptic_manager.synapse_dynamics = static_struct
synaptic_manager.synapse_dynamics = stdp_struct
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
# Add an sdram so maxsdram is high enough
SDRAM(10000)
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex = SimpleMachineVertex(resources=None)
pre_vertex_slice = Slice(0, 9)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex = SimpleMachineVertex(resources=None)
post_vertex_slice = Slice(0, 9)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
one_to_one_connector_1.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_2 = OneToOneConnector(None)
one_to_one_connector_2.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
all_to_all_connector = AllToAllConnector(None)
all_to_all_connector.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, SynapseDynamicsStatic(), 0, 1.5, 1.0)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, SynapseDynamicsStatic(), 1, 2.5, 2.0)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, SynapseDynamicsStatic(), 0, 4.5, 4.0)
app_edge = ProjectionApplicationEdge(
pre_app_vertex, post_app_vertex, direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = ProjectionMachineEdge(
app_edge.synapse_information, pre_vertex, post_vertex)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
graph_mapper = GraphMapper()
graph_mapper.add_vertex_mapping(
pre_vertex, pre_vertex_slice, pre_app_vertex)
graph_mapper.add_vertex_mapping(
post_vertex, post_vertex_slice, post_app_vertex)
graph_mapper.add_edge_mapping(machine_edge, app_edge)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
master_pop_region = 0
all_syn_block_sz = 2000
synapse_region = 1
direct_region = 2
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
# UGLY but the mock transceiver NEED generate_on_machine be False
abstract_generate_connector_on_machine.IS_PYNN_8 = False
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales,
master_pop_region, synapse_region, direct_region, routing_info,
graph_mapper, graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(
spec_reader, master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
direct_matrix = executor.get_region(2)
all_data = bytearray()
all_data.extend(master_pop_table.region_data[
:master_pop_table.max_write_pointer])
all_data.extend(synaptic_matrix.region_data[
:synaptic_matrix.max_write_pointer])
all_data.extend(direct_matrix.region_data[
:direct_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = (
synaptic_matrix_address + synaptic_matrix.max_write_pointer)
direct_synapses_address += 4
indirect_synapses_address = synaptic_matrix_address
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._poptable_type\
.extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver,
placement.x, placement.y)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
assert items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=0,
using_extra_monitor_cores=False)
connections_1 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, 2, weight_scales, data_1, None,
app_edge.n_delay_stages, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=1,
using_extra_monitor_cores=False)
connections_2 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, 2, weight_scales, data_2, None,
app_edge.n_delay_stages, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=2,
using_extra_monitor_cores=False)
connections_3 = synaptic_manager._synapse_io.read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None,
app_edge.n_delay_stages, machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
def tearDown(self):
conf = conf_loader.load_config(spynnaker.pyNN, "spynnaker.cfg")
conf.set("Reports", "defaultReportFilePath",
self.previous_defaultReportFilePath)
conf.set("Reports", "reportsEnabled", self._previous_reportsEnabled)
def test_one_templates(tmpdir, default_config, not_there): # @UnusedVariable
name, place = not_there
with tmpdir.as_cwd():
with pytest.raises(NoConfigFoundException):
conf_loader.load_config(name, [FOURPATH, ONEPATH, THREEPATH])
def test_two_templates(tmpdir, default_config, not_there): # @UnusedVariable
name, place = not_there
with tmpdir.as_cwd():
with pytest.raises(ConfigTemplateException):
conf_loader.load_config(name, [ONEPATH, TWOPATH])
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
# Add an sdram so max SDRAM is high enough
SDRAM(10000)
# UGLY but the mock transceiver NEED generate_on_machine to be False
AbstractGenerateConnectorOnMachine.generate_on_machine = self.say_false
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex_slice = Slice(0, 9)
pre_vertex = pre_app_vertex.create_machine_vertex(
pre_vertex_slice, None)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex_slice = Slice(0, 9)
post_vertex = post_app_vertex.create_machine_vertex(
post_vertex_slice, None)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 0, 1.5, 1.0)
one_to_one_connector_1.set_projection_information(
machine_time_step, direct_synapse_information_1)
one_to_one_connector_2 = OneToOneConnector(None)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 1, 2.5, 2.0)
one_to_one_connector_2.set_projection_information(
machine_time_step, direct_synapse_information_2)
all_to_all_connector = AllToAllConnector(None)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 0, 4.5, 4.0)
all_to_all_connector.set_projection_information(
machine_time_step, all_to_all_synapse_information)
app_edge = ProjectionApplicationEdge(pre_app_vertex, post_app_vertex,
direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = app_edge.create_machine_edge(pre_vertex,
post_vertex,
label=None)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(
PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
all_syn_block_sz = 2000
master_pop_region = 0
synapse_region = 1
direct_region = 2
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synaptic_manager = SynapticManager(n_synapse_types=2,
ring_buffer_sigma=5.0,
spikes_per_second=100.0,
config=config)
# Poke in our testing region IDs
synaptic_manager._pop_table_region = master_pop_region
synaptic_manager._synaptic_matrix_region = synapse_region
synaptic_manager._direct_matrix_region = direct_region
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales, routing_info,
graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(spec_reader,
master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
direct_matrix = executor.get_region(2)
all_data = bytearray()
all_data.extend(
master_pop_table.region_data[:master_pop_table.max_write_pointer])
all_data.extend(
synaptic_matrix.region_data[:synaptic_matrix.max_write_pointer])
all_data.extend(
direct_matrix.region_data[:direct_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = (synaptic_matrix_address +
synaptic_matrix.max_write_pointer)
direct_synapses_address += 4
indirect_synapses_address = synaptic_matrix_address
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver, placement)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
assert items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=0,
using_monitors=False)
connections_1 = synaptic_manager._read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, weight_scales, data_1, None, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=1,
using_monitors=False)
connections_2 = synaptic_manager._read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, weight_scales, data_2, None, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=2,
using_monitors=False)
connections_3 = synaptic_manager._read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, weight_scales, data_3, None,
machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
