def get_sdram_usage_in_bytes(
self, n_neurons, n_machine_time_steps):
if not self._record_gsyn:
return 0
return recording_utils.get_recording_region_size_in_bytes(
n_machine_time_steps, 8 * n_neurons)
def get_sdram_usage_in_bytes(self, n_neurons, n_machine_time_steps):
if not self._record:
return 0
out_spike_bytes = int(math.ceil(n_neurons / 32.0)) * 4
return recording_utils.get_recording_region_size_in_bytes(
n_machine_time_steps, out_spike_bytes)
def get_gsyn(self, label, n_atoms, transceiver, region,
n_machine_time_steps, placements, graph_mapper,
partitionable_vertex):
ms_per_tick = self._machine_time_step / 1000.0
subvertices = \
graph_mapper.get_subvertices_from_vertex(partitionable_vertex)
tempfilehandle = tempfile.NamedTemporaryFile()
data = numpy.memmap(
tempfilehandle.file, shape=(n_machine_time_steps, n_atoms),
dtype="float64,float64,float64,float64")
data["f0"] = (numpy.arange(
n_atoms * n_machine_time_steps) % n_atoms).reshape(
(n_machine_time_steps, n_atoms))
data["f1"] = numpy.repeat(numpy.arange(
0, n_machine_time_steps * ms_per_tick, ms_per_tick),
n_atoms).reshape((n_machine_time_steps, n_atoms))
progress_bar = ProgressBar(
len(subvertices), "Getting conductance for {}".format(label))
for subvertex in subvertices:
vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
placement = placements.get_placement_of_subvertex(subvertex)
region_size = recording_utils.get_recording_region_size_in_bytes(
n_machine_time_steps, 8 * vertex_slice.n_atoms)
neuron_param_region_data = recording_utils.get_data(
transceiver, placement, region, region_size)
numpy_data = (numpy.asarray(
neuron_param_region_data, dtype="uint8").view(dtype="<i4") /
32767.0).reshape(
(n_machine_time_steps, vertex_slice.n_atoms * 2))
data["f2"][:, vertex_slice.lo_atom:vertex_slice.hi_atom + 1] =\
numpy_data[:, 0::2]
data["f3"][:, vertex_slice.lo_atom:vertex_slice.hi_atom + 1] =\
numpy_data[:, 1::2]
progress_bar.update()
progress_bar.end()
data.shape = n_atoms * n_machine_time_steps
# Sort the data - apparently, using lexsort is faster, but it might
# consume more memory, so the option is left open for sort-in-place
order = numpy.lexsort((data["f1"], data["f0"]))
# data.sort(order=['f0', 'f1'], axis=0)
result = data.view(dtype="float64").reshape(
(n_atoms * n_machine_time_steps, 4))[order]
return result
def get_spikes(self, label, transceiver, region, n_machine_time_steps,
placements, graph_mapper, partitionable_vertex):
spike_times = list()
spike_ids = list()
ms_per_tick = self._machine_time_step / 1000.0
subvertices = \
graph_mapper.get_subvertices_from_vertex(partitionable_vertex)
progress_bar = ProgressBar(len(subvertices),
"Getting spikes for {}".format(label))
for subvertex in subvertices:
placement = placements.get_placement_of_subvertex(subvertex)
subvertex_slice = graph_mapper.get_subvertex_slice(subvertex)
lo_atom = subvertex_slice.lo_atom
# Read the spikes
n_bytes = int(math.ceil(subvertex_slice.n_atoms / 32.0)) * 4
region_size = recording_utils.get_recording_region_size_in_bytes(
n_machine_time_steps, n_bytes)
spike_data = recording_utils.get_data(
transceiver, placement, region, region_size)
numpy_data = numpy.asarray(spike_data, dtype="uint8").view(
dtype="uint32").byteswap().view("uint8")
bits = numpy.fliplr(numpy.unpackbits(numpy_data).reshape(
(-1, 32))).reshape((-1, n_bytes * 8))
times, indices = numpy.where(bits == 1)
times = times * ms_per_tick
indices = indices + lo_atom
spike_ids.append(indices)
spike_times.append(times)
progress_bar.update()
progress_bar.end()
spike_ids = numpy.hstack(spike_ids)
spike_times = numpy.hstack(spike_times)
result = numpy.dstack((spike_ids, spike_times))[0]
return result[numpy.lexsort((spike_times, spike_ids))]
def get_sdram_usage_in_bytes(self, n_neurons, n_machine_time_steps):
if not self._record_gsyn:
return 0
return recording_utils.get_recording_region_size_in_bytes(
n_machine_time_steps, 8 * n_neurons)
