def test_min_spl1_should_allow_external_input_on_same_chip(self):
"""
Even when the rightmost neuron block / DNC merger is not reserved for external input, it
should be possible to place external input on the same chip.
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
# Do not reserve rightmost neuron block / DNC merger for external input.
self.marocco.neuron_placement.restrict_rightmost_neuron_blocks(False)
hicann = C.HICANNOnWafer(C.Enum(123))
pops = []
# All but the first neuron block are occupied.
for nb in range(1, C.NeuronBlockOnHICANN.end):
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(
pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann))
pops.append(pop)
in_pop = pynn.Population(1, pynn.SpikeSourceArray, {})
self.marocco.manual_placement.on_hicann(in_pop, hicann)
pynn.run(0)
pynn.end()
results = self.load_results()
for pop in pops:
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
address = placement_item.address()
# All used neuron blocks should be connected to a single DNC merger.
dnc = C.DNCMergerOnHICANN(3)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
nrn = in_pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertTrue(logical_neuron.is_external())
address = placement_item.address()
# External input should be on the leftmost DNC merger, since all other
# mergers do not have direct access to a background generator.
dnc = C.DNCMergerOnHICANN(0)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
def test_min_spl1_is_nongreedy_when_pops_are_placed_to_nbs(self, nbs):
"""
See above. Instead of a single population placed to the HICANN, populations are placed to
specific neuron blocks.
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
self.marocco.neuron_placement.restrict_rightmost_neuron_blocks(True)
hicann = C.HICANNOnWafer(C.Enum(123))
pops = []
for nb in nbs:
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(
pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann))
pops.append(pop)
in_pop = pynn.Population(1, pynn.SpikeSourceArray, {})
self.marocco.manual_placement.on_hicann(in_pop, hicann)
pynn.run(0)
pynn.end()
results = self.load_results()
for pop in pops:
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
address = placement_item.address()
# All used neuron blocks should still be connected to a single DNC merger.
dnc = C.DNCMergerOnHICANN(3)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
nrn = in_pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertTrue(logical_neuron.is_external())
address = placement_item.address()
# External input should be on the rightmost DNC merger since that is tried first.
dnc = C.DNCMergerOnHICANN(7)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
def test_dijkstra_routing(self):
"""
Integration test for Dijkstra-based L1 routing.
Sets up a convoluted case that requires a convex route (which would
not work using the backbone router).
.------->------+
167 168 169 170 |
206 v
240 241 242 |
^---<------+
"""
pynn.setup(marocco=self.marocco)
source = pynn.Population(1, pynn.IF_cond_exp, {})
target = pynn.Population(1, pynn.IF_cond_exp, {})
proj = pynn.Projection(source, target,
pynn.AllToAllConnector(weights=0.004))
source_hicann = C.HICANNOnWafer(C.Enum(167))
target_hicann = C.HICANNOnWafer(C.Enum(240))
self.marocco.manual_placement.on_hicann(source, source_hicann)
self.marocco.manual_placement.on_hicann(target, target_hicann)
allowed_hicanns = [206] + range(167, 171) + range(240, 243)
wafer = self.marocco.default_wafer
for hicann in C.iter_all(C.HICANNOnWafer):
if hicann.id().value() in allowed_hicanns:
continue
self.marocco.defects.disable(C.HICANNGlobal(hicann, wafer))
self.marocco.l1_routing.algorithm(self.marocco.l1_routing.dijkstra)
pynn.run(0)
pynn.end()
results = self.load_results()
synapses = results.synapse_routing.synapses()
self.assertEqual(1, synapses.size())
def test_analog_outputs(self, num_recorded_populations):
"""
Test that analog outputs are correctly assigned and that
mapping fails if per-HICANN constraints are broken.
"""
pynn.setup(marocco=self.marocco)
hicann = C.HICANNOnWafer(C.Enum(210))
pops = []
for i in range(num_recorded_populations):
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_hicann(pop, hicann)
pop.record_v()
pops.append(pop)
if num_recorded_populations > 2:
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
return
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(pop[0])
aouts = list(results.analog_outputs)
self.assertEqual(num_recorded_populations, len(aouts))
for pop in pops:
placement_item, = list(results.placement.find(pop[0]))
logical_neuron = placement_item.logical_neuron()
for aout_item in aouts:
if aout_item.logical_neuron() == logical_neuron:
break
else:
self.fail("logical neuron not found in analog outputs result")
aout_item_ = results.analog_outputs.record(logical_neuron)
self.assertEqual(aout_item.analog_output(),
aout_item_.analog_output())
def test_min_spl1_is_nongreedy(self):
"""
When placing a single population to a HICANN there should still be room for external input.
Previously the default merger routing strategy (min SPL1) merged as many adjacent neuron
blocks as possible. In doing this, the NeuronBlockOnHICANN(7) was connected to
DNCMergerOnHICANN(3).
This prevented the external input to be placed to DNCMergerOnHICANN(7) of the same HICANN,
since the corresponding background generator could not be connected.
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
self.marocco.neuron_placement.restrict_rightmost_neuron_blocks(True)
hicann = C.HICANNOnWafer(C.Enum(123))
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_hicann(pop, hicann)
in_pop = pynn.Population(1, pynn.SpikeSourceArray, {})
self.marocco.manual_placement.on_hicann(in_pop, hicann)
pynn.run(0)
pynn.end()
results = self.load_results()
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
nrn = in_pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertTrue(logical_neuron.is_external())
self.assertEqual(hicann, placement_item.address().toHICANNOnWafer())
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", 33)))
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = C.HICANNOnWafer(C.Enum(297))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
exc_spike_times = [
250,
500,
520,
540,
1250,
]
inh_spike_times = [
750,
1000,
marocco.default_wafer = C.Wafer(33)
marocco.param_trafo.use_big_capacitors = True
marocco.input_placement.consider_firing_rate(True)
marocco.input_placement.bandwidth_utilization(0.8)
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = C.HICANNOnWafer(C.Enum(367))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
exc_spike_times = [
250,
500,
520,
540,
1250,
]
inh_spike_times = [
750,
1000,
def get_hicanns(center_hicann,
n_kenyon,
seed=1,
max_dist=3,
n_per_pop=4,
manual=False):
if manual:
f = open("black_list_stats.txt", "a+")
f.write(u"%s, -*-\n" % seed)
f.close()
np.random.seed(seed)
ID, ROW, COL = range(3)
w = WAL()
hood = w.get_neighbours(center_hicann, max_dist=max_dist)
ids = []
for r in hood:
for c in hood[r]:
ids.append(hood[r][c][ID])
pprint(hood)
print(ids)
pops = [
'antenna',
'decision',
'feedback',
'exciter',
# 'tick', 'exciter_src',
# 'kenyon',
]
### ideal config is in a 3x3 grid
places = {}
blacklist = []
# ## blacklist = [73, 76, 99, 17, 18, 19, 20, 21, 37, 47, 167, 56, 6, 5, 7, 80, 100, 14]
used = [] + blacklist
k_places = []
for i in range(n_kenyon):
avail = np.setdiff1d(ids, used)
np.random.choice(avail, size=n_kenyon, replace=False)
hicann_id = np.random.choice(avail, size=n_per_pop)
hicann = [C.HICANNOnWafer(C.Enum(i)) for i in hicann_id]
for i in hicann_id:
used.append(i)
k_places.append(hicann)
places['kenyon'] = k_places
for p in pops:
avail = np.setdiff1d(ids, used)
hicann_id = np.random.choice(avail, size=n_per_pop)
hicann = [C.HICANNOnWafer(C.Enum(i)) for i in hicann_id]
places[p] = hicann
for i in hicann_id:
used.append(i)
for k in sorted(places):
for p in places[k]:
try:
sys.stdout.write("{},".format(int(p.id())))
except:
for q in p:
sys.stdout.write("{},".format(int(q.id())))
print()
print(places)
else:
places = {
'antenna': None,
'kenyon': [None] * n_kenyon,
'decision': None,
'tick': None,
'feedback': None,
'exciter src': None,
'exciter': None,
}
return places
