def test(self): wafer = 99999 # a wafer for which no redman data is availale hicann = 82 neuron_number = 12 marocco = PyMarocco() marocco.neuron_placement.default_neuron_size(4) marocco.backend = PyMarocco.Without marocco.default_wafer = C.Wafer(wafer) used_hicann = C.HICANNGlobal(C.HICANNOnWafer(Enum(hicann)), C.Wafer(wafer)) used_hicann # prevent pep8 warning of unused variable pynn.setup(marocco=marocco) pop = pynn.Population(1, pynn.IF_cond_exp) topleft = C.NeuronOnWafer(C.NeuronOnHICANN(X(neuron_number), Y(0)), C.HICANNOnWafer(Enum(hicann))) logical_neuron = LogicalNeuron.rectangular(topleft, size=4) marocco.manual_placement.on_neuron(pop, logical_neuron) with self.assertRaises(RuntimeError): pynn.run(0) pynn.end()
def test_popview_on_hicann(self, size): pynn.setup(marocco=self.marocco) neuron_size = 4 self.marocco.neuron_placement.default_neuron_size(neuron_size) hicann = C.HICANNOnWafer(Enum(122)) hicann_1 = C.HICANNOnWafer(Enum(123)) hicann_2 = C.HICANNOnWafer(Enum(124)) hicann_3 = C.HICANNOnWafer(Enum(125)) pop = pynn.Population(size, pynn.IF_cond_exp, {}) pop_1 = pynn.Population(size, pynn.IF_cond_exp, {}) pop_view = pynn.PopulationView(pop,list(range(0,size,2))) pop_view_1 = pynn.PopulationView(pop,list(range(1,size,2))) pop_1_view = pynn.PopulationView(pop_1,list(range(1,size//2))) pop_1_view_1 = pynn.PopulationView(pop_1,list(range(size-2,size//2,-1))) pop_auto_placement = pynn.PopulationView(pop_1,[0,size//2,size-1]) self.marocco.manual_placement.on_hicann(pop_view, hicann) self.marocco.manual_placement.on_hicann(pop_view_1, hicann_1) self.marocco.manual_placement.on_hicann(pop_1_view, hicann_2) self.marocco.manual_placement.on_hicann(pop_1_view_1, hicann_3) if neuron_size * size//2 > C.NeuronOnHICANN.enum_type.size: with self.assertRaises(RuntimeError): pynn.run(0) pynn.end() return pynn.run(0) pynn.end() results = self.load_results() for nrn in pop_view: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(hicann, denmem.toHICANNOnWafer()) for nrn in pop_view_1: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(hicann_1, denmem.toHICANNOnWafer()) for nrn in pop_1_view: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(hicann_2, denmem.toHICANNOnWafer()) for nrn in pop_1_view_1: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(hicann_3, denmem.toHICANNOnWafer()) for nrn in pop_auto_placement: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertIsNotNone(denmem.toHICANNOnWafer())
def test_L1_detour_at_side_switch_usage(self): """ [155] 191 [223] 224 225 x226x {227} test detour and predecessor settings at the edge of a wafer """ pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.TRACE) pylogging.set_loglevel(pylogging.get("Calibtic"), pylogging.LogLevel.ERROR) self.marocco.persist = '' # or add test suite TestWithRuntime? runtime = Runtime(self.marocco.default_wafer) pynn.setup(marocco=self.marocco, marocco_runtime=runtime) settings = pysthal.Settings.get() settings.synapse_switches.max_switches_per_column_per_side = 1 settings.crossbar_switches.max_switches_per_row = 1 source = pynn.Population(1, pynn.IF_cond_exp, {}) target1 = pynn.Population(1, pynn.IF_cond_exp, {}) target2 = pynn.Population(1, pynn.IF_cond_exp, {}) proj = pynn.Projection( source, target1, pynn.AllToAllConnector(weights=1.)) proj = pynn.Projection( source, target2, pynn.AllToAllConnector(weights=1.)) source_hicann = C.HICANNOnWafer(Enum(227)) target1_hicann = C.HICANNOnWafer(Enum(155)) target2_hicann = C.HICANNOnWafer(Enum(225)) self.marocco.manual_placement.on_hicann(source, source_hicann) self.marocco.manual_placement.on_hicann(target1, target1_hicann) self.marocco.manual_placement.on_hicann(target2, target2_hicann) disabled_hicanns = [226, 263] wafer = self.marocco.default_wafer self.marocco.defects.set(pyredman.Wafer(runtime.wafer().index())) for hicann in C.iter_all(C.HICANNOnWafer): if hicann.toEnum().value() in disabled_hicanns: self.marocco.defects.wafer().hicanns().disable(C.HICANNGlobal(hicann, wafer)) continue pynn.run(0) pynn.end() for hicann in runtime.wafer().getAllocatedHicannCoordinates(): h = runtime.wafer()[hicann] print(hicann, h.check()) self.assertEqual(h.check(), "")
def test_dnc_copy(self): import copy wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNGlobal(C.HICANNOnWafer(Enum(297)), wafer_c) h = w[h_c.toHICANNOnWafer()] d = w[h_c.toFPGAOnWafer()][h_c.toDNCOnFPGA()] d2 = copy.deepcopy(d) self.assertEqual(d, d2) # change something to ensure that it's not a mere pointer copy h2 = w[C.HICANNOnWafer(Enum(298))] self.assertNotEqual(d, d2)
def test_dnc_pickle(self): import pickle wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNGlobal(C.HICANNOnWafer(Enum(297)), wafer_c) h = w[h_c.toHICANNOnWafer()] d = w[h_c.toFPGAOnWafer()][h_c.toDNCOnFPGA()] d_str = pickle.dumps(d) d2 = pickle.loads(d_str) self.assertEqual(d, d2) # change something to ensure that it's not a mere pointer copy h2 = w[C.HICANNOnWafer(Enum(298))] self.assertNotEqual(d, d2)
def test_save_and_load(self): import pysthal from pyhalco_common import Enum import pyhalco_hicann_v2 as Coordinate from pyhalbe import HICANN wafer = pysthal.Wafer(Coordinate.Wafer(3)) hicann1 = wafer[Coordinate.HICANNOnWafer(Enum(30))] for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN): d_pattern = numpy.random.randint(0, 16, 256) d_pattern[d_pattern[0] + 23] = 15 hicann1.synapses[row].decoders[:] = [ HICANN.SynapseDecoder(int(ii)) for ii in d_pattern ] w_pattern = numpy.random.randint(0, 16, 256) w_pattern[w_pattern[0] + 23] = 15 hicann1.synapses[row].weights[:] = [ HICANN.SynapseWeight(int(ii)) for ii in w_pattern ] wafer2 = pysthal.Wafer(Coordinate.Wafer(0)) hicann2 = wafer2[Coordinate.HICANNOnWafer(Enum(42))] self.assertNotEqual(str(wafer.status()), str(wafer2.status())) for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN): d1 = hicann1.synapses[row].decoders d2 = hicann2.synapses[row].decoders self.assertNotEqual(d1, d2) w1 = hicann1.synapses[row].weights w2 = hicann2.synapses[row].weights self.assertNotEqual(w1, w2) with tempfile.NamedTemporaryFile() as f: wafer.dump(f.name, True) wafer2.load(f.name) self.assertEqual(wafer.size(), wafer2.size()) hicann1 = wafer[Coordinate.HICANNOnWafer(Enum(30))] hicann2 = wafer2[Coordinate.HICANNOnWafer(Enum(30))] self.assertEqual(hicann1.index(), hicann2.index()) self.assertEqual(str(wafer.status()), str(wafer2.status())) for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN): d1 = hicann1.synapses[row].decoders d2 = hicann2.synapses[row].decoders self.assertEqual(d1, d2) w1 = hicann1.synapses[row].weights w2 = hicann2.synapses[row].weights self.assertEqual(w1, w2)
def test_same_popview_on_hicann(self, size): pynn.setup(marocco=self.marocco) neuron_size = 4 self.marocco.neuron_placement.default_neuron_size(neuron_size) hicann = C.HICANNOnWafer(Enum(123)) hicann_1 = C.HICANNOnWafer(Enum(122)) pop = pynn.Population(size, pynn.IF_cond_exp, {}) pop_view = pynn.PopulationView(pop,[0]) pop_view_1 = pynn.PopulationView(pop,[0]) self.marocco.manual_placement.on_hicann(pop_view, hicann) self.marocco.manual_placement.on_hicann(pop_view_1, hicann_1) with self.assertRaises(RuntimeError): pynn.run(0) pynn.end()
def test_popview_external_source(self): pynn.setup(marocco=self.marocco) neuron_size = 4 self.marocco.neuron_placement.default_neuron_size(neuron_size) size = 10 pop_ext = pynn.Population(size, pynn.SpikeSourcePoisson, {'rate':2}) pop_ext_1 = pynn.Population(size, pynn.SpikeSourcePoisson, {'rate':2}) pop = pynn.Population(size, pynn.IF_cond_exp, {}) connector = pynn.AllToAllConnector(weights=1) projections = [ pynn.Projection(pop_ext, pop, connector, target='excitatory'), pynn.Projection(pop_ext_1, pop, connector, target='excitatory'), ] hicann = C.HICANNOnWafer(Enum(121)) hicann_1 = C.HICANNOnWafer(Enum(122)) pop_view = pynn.PopulationView(pop_ext,list(range(1,size,2))) pop_view_1 = pynn.PopulationView(pop_ext,list(range(0,size,2))) pop_1_view = pynn.PopulationView(pop_ext_1,list(range(1,size//2))) pop_1_view_1 = pynn.PopulationView(pop_ext_1,list(range(size-2,size//2,-1))) pop_1_auto_placement = pynn.PopulationView(pop_ext_1,[0,size//2,size-1]) self.marocco.manual_placement.on_hicann(pop_view, hicann) self.marocco.manual_placement.on_hicann(pop_view_1, hicann_1) self.marocco.manual_placement.on_hicann(pop_1_view, hicann) self.marocco.manual_placement.on_hicann(pop_1_view_1, hicann_1) pynn.run(0) pynn.end() results = self.load_results() for nrn in pop_view: placement_item, = results.placement.find(nrn) self.assertEqual(hicann, placement_item.dnc_merger().toHICANNOnWafer()) for nrn in pop_view_1: placement_item, = results.placement.find(nrn) self.assertEqual(hicann_1, placement_item.dnc_merger().toHICANNOnWafer()) for nrn in pop_1_view: placement_item, = results.placement.find(nrn) self.assertEqual(hicann, placement_item.dnc_merger().toHICANNOnWafer()) for nrn in pop_1_view_1: placement_item, = results.placement.find(nrn) self.assertEqual(hicann_1, placement_item.dnc_merger().toHICANNOnWafer()) for nrn in pop_1_auto_placement: placement_item, = results.placement.find(nrn) self.assertIsNotNone(placement_item.dnc_merger().toHICANNOnWafer())
def setUp(self): super(TestMultiHICANN, self).setUp() pylogging.set_loglevel(pylogging.get("Default"), pylogging.LogLevel.ERROR) pylogging.set_loglevel(pylogging.get("sthal"), pylogging.LogLevel.INFO) if None in (self.WAFER, self.HICANN): return self.wafer_c = Coord.Wafer(self.WAFER) self.w = pysthal.Wafer(self.wafer_c) self.h1 = self.w[Coord.HICANNOnWafer(Enum(324))] self.h2 = self.w[Coord.HICANNOnWafer(Enum(120))] self.addCleanup(self.w.disconnect)
def __init__(self, *args, **kwargs): super(Test_Pyhwdb, self).__init__(*args, **kwargs) if IS_PYPLUSPLUS: self.WAFER_COORD = coord.Wafer(10) self.WAFER_SETUP_TYPE = coord.SetupType.BSSWafer self.WAFER_MACU_IP = coord.IPv4.from_string("192.168.10.120") self.FPGA_COORD = coord.FPGAOnWafer(0) self.FPGA_HIGHSPEED = True self.FPGA_IP = coord.IPv4.from_string("192.168.10.1") if IS_PYPLUSPLUS: self.RETICLE_COORD = coord.DNCOnWafer(coord.common.Enum(0)) self.RETICLE_TO_BE_POWERED = False self.HICANN_COORD = coord.HICANNOnWafer(coord.common.Enum(144)) self.HICANN_VERSION = 4 self.HICANN_LABEL = "bla" self.ADC_COORD = "B123456" self.ADC_MODE = "LOAD_CALIBRATION" self.ADC_CHAN = coord.ChannelOnADC(0) self.ADC_TRIGGER = coord.TriggerOnADC(1) self.ADC_IP = coord.IPv4.from_string("192.168.10.120") if IS_PYPLUSPLUS: self.ADC_PORT = coord.TCPPort(10101) self.DLS_SETUP_ID = "07_20" self.HXCUBE_ID = 9
def test_on_hicann(self, size): pynn.setup(marocco=self.marocco) neuron_size = 4 self.marocco.neuron_placement.default_neuron_size(neuron_size) hicann = C.HICANNOnWafer(Enum(123)) pop = pynn.Population(size, pynn.IF_cond_exp, {}) self.marocco.manual_placement.on_hicann(pop, hicann) if neuron_size * size > C.NeuronOnHICANN.enum_type.size: with self.assertRaises(RuntimeError): pynn.run(0) pynn.end() return pynn.run(0) pynn.end() results = self.load_results() for nrn in pop: 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())
def test_access_queue(self): """use queue handling""" class myPlacer(placer): def loop(self): print("reversing populations") # b = self.m_queue.access; # use this or the following print((dir(self.m_queue.value()[0]))) b = self.m_queue.value() print((dir(b))) marocco = self.marocco user_strat = myPlacer() marocco.neuron_placement.default_placement_strategy(user_strat) pynn.setup(marocco=marocco) self.network() result = self.load_results() hicann = C.HICANNOnWafer(Enum(42)) nb = C.NeuronBlockOnHICANN(Enum(4)) for pop in self.pops: for nrn in pop: placement_item, = result.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: # all pops shall be on different NBs self.assertFalse(nb == denmem.toNeuronBlockOnHICANN() and hicann == denmem.toHICANNOnWafer()) nb = denmem.toNeuronBlockOnHICANN() hicann = denmem.toHICANNOnWafer()
def test_numpy_policies(self): import numpy import pysthal import pyhalco_hicann_v2 from pyhalbe import HICANN w = pysthal.Wafer(pyhalco_hicann_v2.Wafer()) h = w[pyhalco_hicann_v2.HICANNOnWafer()] addrs = numpy.array(numpy.random.randint(64, size=100), dtype=numpy.ushort) times = numpy.cumsum(numpy.random.poisson(10.0, size=100)) * 1.e-6 in_spikes = pysthal.Vector_Spike() for addr, t in zip(addrs, times): in_spikes.append(pysthal.Spike(HICANN.L1Address(addr), t)) link = pyhalco_hicann_v2.GbitLinkOnHICANN(3) h.sendSpikes(link, in_spikes) h.sortSpikes() x = h.sentSpikes(link) times_t, addrs_t = x.T numpy.testing.assert_allclose(times, times_t, rtol=0.0, atol=1.0 / 250e6) numpy.testing.assert_array_equal( addrs, numpy.array(addrs_t, dtype=numpy.ushort))
def test_hw_merging_spl1_should_merge_some(self): """ some DNCs shall be merged, but not all, because of syndriver requirements on each NB. 2 neurons will be placed (same HICANN). A fully connected network is built. This results in 8*2 = 16 synapses being routed to each neuron. With neuron size 4 and chain length 3 -> 12 synapses can be realised on each neuron. As a result at maximum 12 synapses shall be on the same L1Route. The merger tries to merge them and will fail, then spit it and merge 8 to each merger [3,5]. The result is a better L1 utilisation compared to one-to-one mapping, 2 instead of 8 routes, while staying within hardware constrains, compared to merge all (16 synapses requiring 4 drivers, 1 driver will be lost). """ 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_as_possible) # restrict to 3 driver, so that this test is hardware agnostic self.marocco.synapse_routing.driver_chain_length(3) hicann = C.HICANNOnWafer(Enum(123)) pops = [] # All but the first neuron block are occupied. for nb in range(C.NeuronBlockOnHICANN.end): pop = pynn.Population(2, pynn.IF_cond_exp, {}) self.marocco.manual_placement.on_neuron_block( pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann)) pops.append(pop) for p in pops: for other_p in pops: pynn.Projection(p, other_p, pynn.AllToAllConnector(weights=1.)) pynn.run(0) pynn.end() merged_dncs = [3, 3, 3, 3, 5, 5, 5, 5] 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() # some DNCs shall be merged. dnc = C.DNCMergerOnHICANN(merged_dncs[pop.euter_id()]) self.assertEqual(hicann, address.toHICANNOnWafer()) self.assertEqual(dnc, address.toDNCMergerOnHICANN()) self.assertEqual(C.DNCMergerOnWafer(dnc, hicann), address.toDNCMergerOnWafer())
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(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 must not be on DNC 3 merger, since all other # mergers do not have direct access to a background generator. dnc = C.DNCMergerOnHICANN(3) self.assertEqual(hicann, address.toHICANNOnWafer()) self.assertNotEqual(dnc, address.toDNCMergerOnHICANN()) self.assertNotEqual(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(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_vertical(self): pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.TRACE) marocco = self.marocco user_strat = placer() user_strat.m_hicann_on_wafer_ordering = user_strat.vertical user_strat.m_spiral_center = user_strat.spiral_neighbours marocco.neuron_placement.default_placement_strategy(user_strat) pynn.setup(marocco=marocco) pops = {} pops[0] = pynn.Population(128, pynn.IF_cond_exp, {}) pops[1] = pynn.Population(128, pynn.IF_cond_exp, {}) pops[2] = pynn.Population(128, pynn.IF_cond_exp, {}) proj1 = pynn.Projection(pops[0], pops[1], pynn.OneToOneConnector(weights=0.01)) proj2 = pynn.Projection(pops[1], pops[2], pynn.OneToOneConnector(weights=0.01)) h = {} h[pops[0]] = C.HICANNOnWafer(Enum(100)) # the next free hicann (vertical order) h[pops[1]] = C.HICANNOnWafer(Enum(72)) h[pops[2]] = C.HICANNOnWafer(Enum(48)) marocco.manual_placement.on_hicann(pops[0], h[pops[0]]) pynn.run(0) pynn.end() result = self.load_results() for key in pops: pop = pops[key] for nrn in pop: placement_item, = result.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(h[pop].toEnum(), denmem.toHICANNOnWafer().toEnum())
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(Enum(167)) target_hicann = C.HICANNOnWafer(Enum(240)) self.marocco.manual_placement.on_hicann(source, source_hicann) self.marocco.manual_placement.on_hicann(target, target_hicann) allowed_hicanns = [206] + list(range(167, 171)) + list(range(240, 243)) wafer = self.marocco.default_wafer self.marocco.defects.set(pyredman.Wafer()) for hicann in C.iter_all(C.HICANNOnWafer): if hicann.toEnum().value() in allowed_hicanns: continue self.marocco.defects.wafer().hicanns().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_loop_modularity_nb(self): """tests to override the loop hook with NB handling""" class myPlacer(placer): def initialise(self): b = sorted( self.m_neuron_blocks.access, key=lambda nb: int(nb.toHICANNOnWafer().toEnum().value())) self.m_neuron_blocks.access = b def loop(self): print("removing the last NB") b = self.m_neuron_blocks.access # use this or the following b = self.m_neuron_blocks.value() b = sorted( b, key=lambda nb: int(nb.toHICANNOnWafer().toEnum().value())) c = [] for i in range(len(b) - 1): c.append(b[i]) # use access to set full vector self.m_neuron_blocks.access = c # or use the value() to access single elements for i in range(len(self.m_neuron_blocks.value())): del (self.m_neuron_blocks.value()[0]) for nb in c: self.m_neuron_blocks.value().append(nb) marocco = self.marocco user_strat = myPlacer() marocco.neuron_placement.default_placement_strategy(user_strat) pynn.setup(marocco=marocco) self.network() result = self.load_results() hicann = C.HICANNOnWafer(Enum(42)) nb = C.NeuronBlockOnHICANN(Enum(4)) for pop in self.pops: for nrn in pop: placement_item, = result.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: # all pops must be on different NBs self.assertFalse(nb == denmem.toNeuronBlockOnHICANN() and hicann == denmem.toHICANNOnWafer()) nb = denmem.toNeuronBlockOnHICANN() hicann = denmem.toHICANNOnWafer()
def test_external_sources_projections(self, params): nprojections = params[0] nsources = params[1] print((nprojections, nsources)) """ An external sources has multiple projections so it should be split if it wuld not be of size 1 so unfortunately the users would need to live with that. """ pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.TRACE) pylogging.set_loglevel(pylogging.get("Calibtic"), pylogging.LogLevel.ERROR) pynn.setup(marocco=self.marocco) self.marocco.neuron_placement.default_neuron_size(4) # ensure a limited synapse driver chain length. self.marocco.synapse_routing.driver_chain_length(3) # we expect synapse loss, but we dont care, as the source cant be split. # we want this tests not to throw exceptions. self.marocco.continue_despite_synapse_loss = True target = pynn.Population(1, pynn.IF_cond_exp, {}) hicann = C.HICANNOnWafer(Enum(100)) self.marocco.manual_placement.on_hicann(target, hicann) exsource = pynn.Population(nsources, pynn.SpikeSourcePoisson, {'rate': 1.}) for i in range(nprojections): proj = pynn.Projection(exsource, target, pynn.AllToAllConnector(weights=1.)) # access to proj so flake8 keeps silent proj.size pynn.run(0) pynn.end() results = self.load_results() synapses = results.synapse_routing.synapses() placement = results.placement for dnc in C.iter_all(C.DNCMergerOnWafer): PonDNC = placement.find(dnc) # PopulationOnDNC if PonDNC: ## if driver requirements exceeded, only one source should be ## placed on the DNC, but synapse loss is still expected if (nprojections > 4): # this number is just guessed self.assertTrue(len(PonDNC) <= 1) else: self.assertTrue(len(PonDNC) <= 12)
def test_cluster_target(self): marocco = self.marocco user_strat = placer() user_strat.m_spiral_center = user_strat.spiral_neighbours_target marocco.neuron_placement.default_placement_strategy(user_strat) pynn.setup(marocco=marocco) pops = {} pops[0] = pynn.Population(1, pynn.IF_cond_exp, {}) pops[1] = pynn.Population(1, pynn.IF_cond_exp, {}) pops[2] = pynn.Population(1, pynn.IF_cond_exp, {}) proj1 = pynn.Projection(pops[0], pops[1], pynn.AllToAllConnector(weights=0.01)) proj2 = pynn.Projection(pops[1], pops[2], pynn.AllToAllConnector(weights=0.01)) h = {} h[pops[0]] = C.HICANNOnWafer(Enum(100)) # average positon of target h[pops[1]] = C.HICANNOnWafer(Enum(102)) h[pops[2]] = C.HICANNOnWafer(Enum(102)) marocco.manual_placement.on_hicann(pops[0], h[pops[0]]) marocco.manual_placement.on_hicann(pops[2], h[pops[2]]) pynn.run(0) pynn.end() result = self.load_results() for key in pops: pop = pops[key] for nrn in pop: placement_item, = result.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(h[pop].toEnum(), denmem.toHICANNOnWafer().toEnum())
def test_wafer_copy(self): import copy wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] self.assertTrue(h.has_wafer()) w2 = copy.deepcopy(w) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def test_wafer_pickle(self): import pickle wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] self.assertTrue(h.has_wafer()) w_str = pickle.dumps(w) w2 = pickle.loads(w_str) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def test_external_sources_drivers(self, nsources): """ A lot external sources are placed no error should be thrown the sources should be split """ pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.DEBUG) pylogging.set_loglevel(pylogging.get("Calibtic"), pylogging.LogLevel.ERROR) pynn.setup(marocco=self.marocco) self.marocco.neuron_placement.default_neuron_size(4) # ensure a limited synapse driver chain length. self.marocco.synapse_routing.driver_chain_length(3) # if synapse loss occours we want to handle it on our own self.marocco.continue_despite_synapse_loss = True target = pynn.Population(1, pynn.IF_cond_exp, {}) hicann = C.HICANNOnWafer(Enum(100)) self.marocco.manual_placement.on_hicann(target, hicann) exsource = pynn.Population(nsources, pynn.SpikeSourcePoisson, {'rate': 1.}) proj = pynn.Projection(exsource, target, pynn.AllToAllConnector(weights=1.)) # access to proj so flake8 keeps silent proj.size pynn.run(0) pynn.end() results = self.load_results() synapses = results.synapse_routing.synapses() placement = results.placement # test for synapse loss self.assertEqual(nsources, synapses.size()) for dnc in C.iter_all(C.DNCMergerOnWafer): PonDNC = placement.find(dnc) # PopulationOnDNC if PonDNC: ## with a neuron size of 4 and a chain length of 3, ## around 12 sources can fit into a merger self.assertTrue(len(PonDNC) <= 12)
def test_wafer_dumpnload(self): import tempfile wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] with tempfile.NamedTemporaryFile() as f: w.dump(f.name, True) w2 = pysthal.Wafer(wafer_c) w2.load(f.name) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def test_popview_combinations(self, view_number): # tests all possible combinations of mask lengths for different number of PopulationViews import pylogging from pymarocco import PyMarocco, Defects from pymarocco.results import Marocco pop_size = 5 hicanns = [C.HICANNOnWafer(Enum(180 + view)) for view in range(view_number)] # generate possible mask lengths for Population Views pool = tuple(i for i in range(1, pop_size - view_number + 2)) # generate all possible mask lengths for each PopulationView for a given total number of neurons # [[lengths_of_Popviews],number_of_used_neurons] view_lengths = [([], 0)] for _ in range(view_number): view_lengths = [(x+[y], csum+y) for x, csum in view_lengths for y in pool if csum <= pop_size - y] neurons = list(range(pop_size)) for length in view_lengths: marocco = PyMarocco() marocco.backend = PyMarocco.Without marocco.persist = "results.bin" marocco.defects.backend = Defects.Backend.Without neuron_size = 4 marocco.neuron_placement.default_neuron_size(neuron_size) pynn.setup(marocco=marocco) pop = pynn.Population(pop_size, pynn.IF_cond_exp, {}) pop_views = [] index = 0 for view in range(view_number): # generate PopulationViews with all possible mask lengths # no permutations of neurons are tested pop_views.append(pynn.PopulationView(pop,neurons[index:index+length[0][view]])) marocco.manual_placement.on_hicann(pop_views[view],hicanns[view]) index += length[0][view] pynn.run(0) pynn.end() results = Marocco.from_file(marocco.persist) for view in range(view_number): for nrn in pop_views[view]: placement_item, = results.placement.find(nrn) logical_neuron = placement_item.logical_neuron() for denmem in logical_neuron: self.assertEqual(hicanns[view], denmem.toHICANNOnWafer())
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(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(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())
def test_external_sources_rates(self, nsources): """ A lot external sources are placed no error should be thrown """ pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.DEBUG) pylogging.set_loglevel(pylogging.get("Calibtic"), pylogging.LogLevel.ERROR) pynn.setup(marocco=self.marocco) self.marocco.neuron_placement.default_neuron_size(4) # ignore the synapse driver chain length. self.marocco.synapse_routing.driver_chain_length(100) # we expect synapse loss, but we dont care. # we want this tests not to throw exceptions. self.marocco.continue_despite_synapse_loss = True target = pynn.Population(1, pynn.IF_cond_exp, {}) hicann = C.HICANNOnWafer(Enum(100)) self.marocco.manual_placement.on_hicann(target, hicann) exsource = pynn.Population(nsources, pynn.SpikeSourcePoisson, {'rate': 1.}) proj = pynn.Projection(exsource, target, pynn.AllToAllConnector(weights=1.)) # access to proj so flake8 keeps silent proj.size pynn.run(0) pynn.end() results = self.load_results() synapses = results.synapse_routing.synapses() self.assertEqual(nsources, synapses.size())
def run_experiment(self, marocco, n_stim, rate, poisson=True, shuffle=False): """ runs experiment with `n_stim` SpikeSources, firing at `rate` Hz, all connected to 1 neuron. returns a result dictionary, with keys `hicanns` and `fpgas`, each containing used FPGA/HICANN coords and number of sources mapped per FPGA/HICANN. further params: poisson - if True, use SpikeSourcePoisson, else use SpikeSourceArrays with regular firing shuffle - if True, the spike times used for SpikeSourceArray are shuffled, i.e. they are not sorted. Only valid if poisson=True) """ sim_duration = 200. marocco.persist = os.path.join(self.temporary_directory, "results.bin") pynn.setup(marocco=marocco) exc_pop = pynn.Population(1, pynn.IF_cond_exp, {}) # place target onto a hicann in the center of reticle and at the border of the wafer # such that hicanns from the same reticle are used with preference (1 reticle -> same fpga) marocco.manual_placement.on_hicann( exc_pop, C.HICANNOnWafer(pyhalco_common.Enum(1))) if poisson: pop_stim = pynn.Population(n_stim, pynn.SpikeSourcePoisson, { 'rate': rate, 'duration': sim_duration }) else: pop_stim = pynn.Population(n_stim, pynn.SpikeSourceArray) for i in range(n_stim): isi = 1.e3 / rate spike_times = np.arange((i + 1) * 1. / n_stim * isi, sim_duration, isi) if shuffle: np.random.shuffle(spike_times) pop_stim[i:i + 1].set('spike_times', spike_times.tolist()) a2a = pynn.AllToAllConnector(weights=0.001, delays=2.) pynn.Projection(pop_stim, exc_pop, a2a, target='excitatory') pynn.run(sim_duration) results = Marocco.from_file(marocco.persist) hicanns = {} # count number of stimuli mapped on Hicann fpgas = {} # count number of stimuli mapped on fpga for idx in range(len(pop_stim)): items = list(results.placement.find(pop_stim[idx])) # stim nrns are only placed once per wafer self.assertEqual(1, len(items)) address = items[0].address() hicann_str = str(address.toHICANNOnWafer()) hicanns[hicann_str] = hicanns.get(hicann_str, 0) + 1 hicann_global = C.HICANNGlobal(address.toHICANNOnWafer(), C.Wafer()) fpga_str = str(hicann_global.toFPGAGlobal()) fpgas[fpga_str] = fpgas.get(fpga_str, 0) + 1 pynn.end() return dict(hicanns=hicanns, fpgas=fpgas)