def test_csa_block_connector():
MockSimulator.setup()
try:
# This creates a block of size (2, 5) with a probability of 0.5; then
# within the block an individual connection has a probability of 0.3
connector = CSAConnector(
csa.block(2, 5) * csa.random(0.5) * csa.random(0.3))
weight = 1.0
delay = 2.0
mock_synapse_info = MockSynapseInfo(MockPopulation(10, "pre"),
MockPopulation(10, "post"), weight,
delay)
connector.set_projection_information(1000.0, mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice], 0,
[post_vertex_slice], 0,
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) >= 0)
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
except TypeError:
raise SkipTest("https://github.com/INCF/csa/issues/17")
except RuntimeError:
if sys.version_info >= (3, 7):
raise SkipTest("https://github.com/INCF/csa/issues/16")
raise
def test_csa_from_list_connector():
unittest_setup()
conn_list = [(i, i + 1 % 10) for i in range(10)]
connector = CSAConnector(conn_list)
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) > 0)
assert (all(item["source"] == conn[0]
for item, conn in zip(block, conn_list)))
assert (all(item["target"] == conn[1]
for item, conn in zip(block, conn_list)))
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_csa_random_connector():
unittest_setup()
connector = CSAConnector(csa.random(0.05))
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) >= 0)
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_csa_one_to_one_connector():
unittest_setup()
connector = CSAConnector(csa.oneToOne)
weight = 1.0
delay = 2.0
synapse_info = SynapseInformation(connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(
10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weight,
delays=delay)
connector.set_projection_information(synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0, synapse_info)
assert (len(block) > 0)
assert (all(item["source"] == item["target"] for item in block))
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_connector(clist, column_names, weights, delays, expected_clist,
expected_weights, expected_delays,
expected_extra_parameters, expected_extra_parameter_names):
MockSimulator.setup()
connector = FromListConnector(clist, column_names=column_names)
if expected_clist is not None:
assert (numpy.array_equal(connector.conn_list, expected_clist))
else:
assert (numpy.array_equal(connector.conn_list, clist))
# Check extra parameters are as expected
extra_params = connector.get_extra_parameters()
extra_param_names = connector.get_extra_parameter_names()
assert (numpy.array_equal(extra_params, expected_extra_parameters))
assert (numpy.array_equal(extra_param_names,
expected_extra_parameter_names))
if extra_params is not None:
assert (len(extra_params.shape) == 2)
assert (extra_params.shape[1] == len(extra_param_names))
for i in range(len(extra_param_names)):
assert (extra_params[:, i].shape == (len(clist), ))
# Check weights and delays are used or ignored as expected
pre_slice = Slice(0, 10)
post_slice = Slice(0, 10)
mock_synapse_info = MockSynapseInfo(MockPopulation(10, "Pre"),
MockPopulation(10, "Post"), weights,
delays)
block = connector.create_synaptic_block([pre_slice], 0, [post_slice], 0,
pre_slice, post_slice, 1,
mock_synapse_info)
assert (numpy.array_equal(block["weight"], numpy.array(expected_weights)))
assert (numpy.array_equal(block["delay"], numpy.array(expected_delays)))
def test_connector_split():
unittest_setup()
n_sources = 1000
n_targets = 1000
n_connections = 10000
pre_neurons_per_core = 57
post_neurons_per_core = 59
sources = numpy.random.randint(0, n_sources, n_connections)
targets = numpy.random.randint(0, n_targets, n_connections)
pre_slices = [
Slice(i, i + pre_neurons_per_core - 1)
for i in range(0, n_sources, pre_neurons_per_core)
]
post_slices = [
Slice(i, i + post_neurons_per_core - 1)
for i in range(0, n_targets, post_neurons_per_core)
]
connection_list = numpy.dstack((sources, targets))[0]
connector = MockFromListConnector(connection_list)
weight = 1.0
delay = 1.0
synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(n_sources, "Pre"),
post_population=MockPopulation(n_targets, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
has_block = set()
try:
# Check each connection is in the right place
for pre_slice in pre_slices:
for post_slice in post_slices:
block = connector.create_synaptic_block(
pre_slices, post_slices, pre_slice, post_slice, 1,
synapse_info)
for source in block["source"]:
assert (pre_slice.lo_atom <= source <= pre_slice.hi_atom)
for target in block["target"]:
assert (post_slice.lo_atom <= target <= post_slice.hi_atom)
for item in block:
has_block.add((item["source"], item["target"]))
# Check each connection has a place
for source, target in zip(sources, targets):
assert (source, target) in has_block
# Check the split only happens once
assert connector._split_count == 1
except AssertionError as e:
print(connection_list)
raise e
def test_connector(clist, column_names, weights, delays, expected_clist,
expected_weights, expected_delays,
expected_extra_parameters, expected_extra_parameter_names):
spynnaker8.setup()
temp = tempfile.NamedTemporaryFile(delete=False)
with temp as f:
header = ''
if column_names is not None:
columns = ["i", "j"]
columns.extend(column_names)
header = 'columns = {}'.format(columns)
if clist is not None and len(clist):
numpy.savetxt(f, clist, header=header)
elif len(header):
f.write("# {}\n".format(header))
connector = FromFileConnector(temp.name)
if expected_clist is not None:
assert (numpy.array_equal(connector.conn_list, expected_clist))
else:
assert (numpy.array_equal(connector.conn_list, clist))
# Check extra parameters are as expected
extra_params = connector.get_extra_parameters()
extra_param_names = connector.get_extra_parameter_names()
assert (numpy.array_equal(extra_params, expected_extra_parameters))
assert (numpy.array_equal(extra_param_names,
expected_extra_parameter_names))
if extra_params is not None:
assert (len(extra_params.shape) == 2)
assert (extra_params.shape[1] == len(extra_param_names))
for i in range(len(extra_param_names)):
assert (extra_params[:, i].shape == (len(clist), ))
# Check weights and delays are used or ignored as expected
pre_slice = Slice(0, 10)
post_slice = Slice(0, 10)
synapse_info = SynapseInformation(connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(
10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weights,
delays=delays)
block = connector.create_synaptic_block([pre_slice], [post_slice],
pre_slice, post_slice, 1,
synapse_info)
assert (numpy.array_equal(block["weight"], numpy.array(expected_weights)))
assert (numpy.array_equal(block["delay"], numpy.array(expected_delays)))
def test_csa_random_connector():
MockSimulator.setup()
connector = CSAConnector(csa.random(0.05))
connector.set_projection_information(
MockPopulation(10, "pre"), MockPopulation(10, "post"),
MockRNG(), 1000.0)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block(
1.0, 2.0, [pre_vertex_slice], 0, [post_vertex_slice], 0,
pre_vertex_slice, post_vertex_slice, 0)
assert(len(block) >= 0)
assert(all(item["weight"] == 1.0 for item in block))
assert(all(item["delay"] == 2.0 for item in block))
def test_connector_split():
MockSimulator.setup()
n_sources = 1000
n_targets = 1000
n_connections = 10000
pre_neurons_per_core = 57
post_neurons_per_core = 59
sources = numpy.random.randint(0, n_sources, n_connections)
targets = numpy.random.randint(0, n_targets, n_connections)
pre_slices = [
Slice(i, i + pre_neurons_per_core - 1)
for i in range(0, n_sources, pre_neurons_per_core)
]
post_slices = [
Slice(i, i + post_neurons_per_core - 1)
for i in range(0, n_targets, post_neurons_per_core)
]
connection_list = numpy.dstack((sources, targets))[0]
connector = MockFromListConnector(connection_list)
weight = 1.0
delay = 1.0
mock_synapse_info = MockSynapseInfo(MockPopulation(n_sources, "Pre"),
MockPopulation(n_targets, "Post"),
weight, delay)
has_block = set()
try:
# Check each connection is in the right place
for i, pre_slice in enumerate(pre_slices):
for j, post_slice in enumerate(post_slices):
block = connector.create_synaptic_block(
pre_slices, i, post_slices, j, pre_slice, post_slice, 1,
mock_synapse_info)
for source in block["source"]:
assert (pre_slice.lo_atom <= source <= pre_slice.hi_atom)
for target in block["target"]:
assert (post_slice.lo_atom <= target <= post_slice.hi_atom)
for item in block:
has_block.add((item["source"], item["target"]))
# Check each connection has a place
for source, target in zip(sources, targets):
assert (source, target) in has_block
# Check the split only happens once
assert connector._split_count == 1
except AssertionError:
print(connection_list)
reraise(*sys.exc_info())
def test_csa_block_connector():
MockSimulator.setup()
# This creates a block of size (2, 5) with a probability of 0.5; then
# within the block an individual connection has a probability of 0.3
connector = CSAConnector(
csa.block(2, 5) * csa.random(0.5) * csa.random(0.3))
connector.set_projection_information(
MockPopulation(10, "pre"), MockPopulation(10, "post"),
MockRNG(), 1000.0)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block(
1.0, 2.0, [pre_vertex_slice], 0, [post_vertex_slice], 0,
pre_vertex_slice, post_vertex_slice, 0)
assert(len(block) >= 0)
assert(all(item["weight"] == 1.0 for item in block))
assert(all(item["delay"] == 2.0 for item in block))
def test_csa_from_list_connector():
MockSimulator.setup()
conn_list = [(i, i + 1 % 10) for i in range(10)]
connector = CSAConnector(conn_list)
connector.set_projection_information(
MockPopulation(10, "pre"), MockPopulation(10, "post"),
MockRNG(), 1000.0)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block(
1.0, 2.0, [pre_vertex_slice], 0, [post_vertex_slice], 0,
pre_vertex_slice, post_vertex_slice, 0)
assert(len(block) > 0)
assert(all(item["source"] == conn[0]
for item, conn in zip(block, conn_list)))
assert(all(item["target"] == conn[1]
for item, conn in zip(block, conn_list)))
assert(all(item["weight"] == 1.0 for item in block))
assert(all(item["delay"] == 2.0 for item in block))
def test_connector(clist, column_names, weights, delays, expected_clist,
expected_weights, expected_delays,
expected_extra_parameters, expected_extra_parameter_names):
unittest_setup()
connector = FromListConnector(clist, column_names=column_names)
if expected_clist is not None:
assert (numpy.array_equal(connector.conn_list, expected_clist))
else:
assert (numpy.array_equal(connector.conn_list, clist))
# Check extra parameters are as expected
extra_params = connector.get_extra_parameters()
extra_param_names = connector.get_extra_parameter_names()
assert (numpy.array_equal(extra_params, expected_extra_parameters))
assert (numpy.array_equal(extra_param_names,
expected_extra_parameter_names))
if extra_params is not None:
assert (len(extra_params.shape) == 2)
assert (extra_params.shape[1] == len(extra_param_names))
for i in range(len(extra_param_names)):
assert (extra_params[:, i].shape == (len(clist), ))
# Check weights and delays are used or ignored as expected
pre_slice = Slice(0, 10)
post_slice = Slice(0, 10)
synapse_info = SynapseInformation(connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(
10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weights,
delays=delays)
block = connector.create_synaptic_block([pre_slice], [post_slice],
pre_slice, post_slice, 1,
synapse_info)
assert (numpy.array_equal(block["weight"], numpy.array(expected_weights)))
assert (numpy.array_equal(block["delay"], numpy.array(expected_delays)))
def test_csa_one_to_one_connector():
MockSimulator.setup()
connector = CSAConnector(csa.oneToOne)
weight = 1.0
delay = 2.0
mock_synapse_info = MockSynapseInfo(MockPopulation(10, "pre"),
MockPopulation(10, "post"), weight,
delay)
connector.set_projection_information(1000.0, mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice], 0,
[post_vertex_slice], 0,
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) > 0)
assert (all(item["source"] == item["target"] for item in block))
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_csa_block_connector():
unittest_setup()
try:
# This creates a block of size (2, 5) with a probability of 0.5; then
# within the block an individual connection has a probability of 0.3
connector = CSAConnector(
csa.block(2, 5) * csa.random(0.5) * csa.random(0.3))
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice], 0,
[post_vertex_slice], 0,
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) >= 0)
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
except TypeError as e:
raise SkipTest("https://github.com/INCF/csa/issues/17") from e
except RuntimeError as e:
if sys.version_info >= (3, 7):
raise SkipTest("https://github.com/INCF/csa/issues/16") from e
raise e
def test_connectors(
n_pre, n_post, n_in_slice, create_connector, weight, delay):
MockSimulator.setup()
max_target = 0
max_source = 0
max_row_length = None
max_col_length = None
for seed in range(10):
numpy.random.seed(random.randint(0, 1000))
connector = create_connector()
mock_synapse_info = MockSynapseInfo(MockPopulation(n_pre, "Pre"),
MockPopulation(n_post, "Post"),
weight, delay)
connector.set_projection_information(
machine_time_step=1000, synapse_info=mock_synapse_info)
pre_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_pre, n_in_slice)]
post_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_post, n_in_slice)]
pre_slice_index = 0
post_slice_index = 0
pre_vertex_slice = pre_slices[pre_slice_index]
post_vertex_slice = post_slices[post_slice_index]
synapse_type = 0
pre_slice = pre_slices[pre_slice_index]
post_slice = post_slices[post_slice_index]
pre_range = numpy.arange(pre_slice.lo_atom, pre_slice.hi_atom + 2)
post_range = numpy.arange(post_slice.lo_atom, post_slice.hi_atom + 2)
max_delay = connector.get_delay_maximum(mock_synapse_info)
max_weight = connector.get_weight_maximum(mock_synapse_info)
if max_row_length is None:
max_row_length = connector.\
get_n_connections_from_pre_vertex_maximum(
post_vertex_slice, mock_synapse_info)
else:
assert(max_row_length == connector.
get_n_connections_from_pre_vertex_maximum(
post_vertex_slice, mock_synapse_info))
if max_col_length is None:
max_col_length = connector.\
get_n_connections_to_post_vertex_maximum(mock_synapse_info)
else:
assert(max_col_length == connector.
get_n_connections_to_post_vertex_maximum(mock_synapse_info))
synaptic_block = connector.create_synaptic_block(
pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice,
synapse_type, mock_synapse_info)
source_histogram = numpy.histogram(
synaptic_block["source"], pre_range)[0]
target_histogram = numpy.histogram(
synaptic_block["target"], post_range)[0]
matrix_max_weight = (
max(synaptic_block["weight"]) if len(synaptic_block) > 0 else 0)
matrix_max_delay = (
max(synaptic_block["delay"]) if len(synaptic_block) > 0 else 0)
max_source = max((max(source_histogram), max_source))
max_target = max((max(target_histogram), max_target))
if len(post_slices) > post_slice_index + 1:
test_post_slice = post_slices[post_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
pre_slices, pre_slice_index, post_slices,
post_slice_index + 1, pre_vertex_slice, test_post_slice,
synapse_type, mock_synapse_info)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(
test_synaptic_block, synaptic_block)
if len(pre_slices) > pre_slice_index + 1:
test_pre_slice = pre_slices[pre_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
pre_slices, pre_slice_index + 1, post_slices,
post_slice_index, test_pre_slice, post_vertex_slice,
synapse_type, mock_synapse_info)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(
test_synaptic_block, synaptic_block)
try:
assert max(source_histogram) <= max_row_length
assert max(target_histogram) <= max_col_length
assert matrix_max_weight <= max_weight
assert matrix_max_delay <= max_delay
except Exception:
print(connector, n_pre, n_post, n_in_slice)
print(max_row_length, max(source_histogram), source_histogram)
print(max_col_length, max(target_histogram), target_histogram)
print(max_weight, matrix_max_weight, synaptic_block["weight"])
print(max_delay, matrix_max_delay, synaptic_block["delay"])
print(connector, n_pre, n_post, n_in_slice, max_row_length,
max_source, max_col_length, max_target)
def test_connectors(n_pre, n_post, n_in_slice, create_connector, weight,
delay):
MockSimulator.setup()
max_target = 0
max_source = 0
max_row_length = None
max_col_length = None
for seed in range(1000):
numpy.random.seed(seed)
connector = create_connector()
connector.set_projection_information(
pre_population=MockPopulation(n_pre, "Pre"),
post_population=MockPopulation(n_post, "Post"),
rng=None,
machine_time_step=1000)
pre_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_pre, n_in_slice)
]
post_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_post, n_in_slice)
]
pre_slice_index = 0
post_slice_index = 0
pre_vertex_slice = pre_slices[pre_slice_index]
post_vertex_slice = post_slices[post_slice_index]
synapse_type = 0
pre_slice = pre_slices[pre_slice_index]
post_slice = post_slices[post_slice_index]
pre_range = numpy.arange(pre_slice.lo_atom, pre_slice.hi_atom + 2)
post_range = numpy.arange(post_slice.lo_atom, post_slice.hi_atom + 2)
max_delay = connector.get_delay_maximum(delay)
max_weight = connector.get_weight_maximum(weight)
if max_row_length is None:
max_row_length = connector.\
get_n_connections_from_pre_vertex_maximum(
delay, post_vertex_slice)
else:
assert (max_row_length ==
connector.get_n_connections_from_pre_vertex_maximum(
delay, post_vertex_slice))
if max_col_length is None:
max_col_length = connector.\
get_n_connections_to_post_vertex_maximum()
else:
assert (max_col_length ==
connector.get_n_connections_to_post_vertex_maximum())
synaptic_block = connector.create_synaptic_block(
weight, delay, pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice,
synapse_type)
source_histogram = numpy.histogram(synaptic_block["source"],
pre_range)[0]
target_histogram = numpy.histogram(synaptic_block["target"],
post_range)[0]
matrix_max_weight = (max(synaptic_block["weight"])
if len(synaptic_block) > 0 else 0)
matrix_max_delay = (max(synaptic_block["delay"])
if len(synaptic_block) > 0 else 0)
max_source = max((max(source_histogram), max_source))
max_target = max((max(target_histogram), max_target))
if len(post_slices) > post_slice_index + 1:
test_post_slice = post_slices[post_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
weight, delay, pre_slices, pre_slice_index, post_slices,
post_slice_index + 1, pre_vertex_slice, test_post_slice,
synapse_type)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(test_synaptic_block,
synaptic_block)
if len(pre_slices) > pre_slice_index + 1:
test_pre_slice = pre_slices[pre_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
weight, delay, pre_slices, pre_slice_index + 1, post_slices,
post_slice_index, test_pre_slice, post_vertex_slice,
synapse_type)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(test_synaptic_block,
synaptic_block)
try:
assert max(source_histogram) <= max_row_length
assert max(target_histogram) <= max_col_length
assert matrix_max_weight <= max_weight
assert matrix_max_delay <= max_delay
except Exception:
print(connector, n_pre, n_post, n_in_slice)
print(max_row_length, max(source_histogram), source_histogram)
print(max_col_length, max(target_histogram), target_histogram)
print(max_weight, matrix_max_weight, synaptic_block["weight"])
print(max_delay, matrix_max_delay, synaptic_block["delay"])
raise SkipTest(
"https://github.com/SpiNNakerManchester/sPyNNaker/issues/587")
print(connector, n_pre, n_post, n_in_slice, max_row_length, max_source,
max_col_length, max_target)
