def __call__(self,
machine,
n_machine_time_steps,
n_samples_per_recording,
sampling_frequency,
time_scale_factor,
machine_time_step,
pre_allocated_resources=None):
"""
:param pre_allocated_resources: other preallocated resources
:param machine: the SpiNNaker machine as discovered
:param n_machine_time_steps: the number of machine\
time steps used by the simulation during this phase
:param n_samples_per_recording: how many samples between record entries
:param sampling_frequency: the frequency of sampling
:param time_scale_factor: the time scale factor
:param machine_time_step: the machine time step
:return: preallocated resources
"""
# pylint: disable=too-many-arguments
progress_bar = ProgressBar(
machine.n_chips, "Preallocating resources for chip power monitor")
# store how much SDRAM the power monitor uses per core
resources = ChipPowerMonitor.get_resources(
n_machine_time_steps=n_machine_time_steps,
n_samples_per_recording=n_samples_per_recording,
sampling_frequency=sampling_frequency,
time_scale_factor=time_scale_factor,
time_step=machine_time_step)
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
for chip in progress_bar.over(machine.chips):
sdrams.append(
SpecificChipSDRAMResource(chip, resources.sdram.get_value()))
cores.append(CoreResource(chip, 1))
# create preallocated resource container
cpm_pre_allocated_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams, core_resources=cores)
# add other preallocated resources
if pre_allocated_resources is not None:
cpm_pre_allocated_resource_container.extend(
pre_allocated_resources)
# return preallocated resources
return cpm_pre_allocated_resource_container
def __call__(
self, machine, n_machine_time_steps, n_samples_per_recording,
sampling_frequency, time_scale_factor, machine_time_step,
pre_allocated_resources=None):
"""
:param pre_allocated_resources: other preallocated resources
:param machine: the SpiNNaker machine as discovered
:param n_machine_time_steps: the number of machine\
time steps used by the simulation during this phase
:param n_samples_per_recording: how many samples between record entries
:param sampling_frequency: the frequency of sampling
:param time_scale_factor: the time scale factor
:param machine_time_step: the machine time step
:return: preallocated resources
"""
# pylint: disable=too-many-arguments
progress_bar = ProgressBar(
machine.n_chips, "Preallocating resources for chip power monitor")
# store how much SDRAM the power monitor uses per core
resources = ChipPowerMonitorMachineVertex.get_resources(
n_machine_time_steps=n_machine_time_steps,
n_samples_per_recording=n_samples_per_recording,
sampling_frequency=sampling_frequency,
time_scale_factor=time_scale_factor,
time_step=machine_time_step)
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
for chip in progress_bar.over(machine.chips):
sdrams.append(
SpecificChipSDRAMResource(chip, resources.sdram.get_value()))
cores.append(CoreResource(chip, 1))
# create preallocated resource container
cpm_pre_allocated_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams, core_resources=cores)
# add other preallocated resources
if pre_allocated_resources is not None:
cpm_pre_allocated_resource_container.extend(
pre_allocated_resources)
# return preallocated resources
return cpm_pre_allocated_resource_container
def __call__(
self, machine, n_samples_per_recording,
sampling_frequency, time_scale_factor, machine_time_step,
pre_allocated_resources=None):
"""
:param ~.PreAllocatedResourceContainer pre_allocated_resources:
:param ~.Machine machine:
:param int n_samples_per_recording:
:param int sampling_frequency:
:param int time_scale_factor:
:param int machine_time_step:
:rtype: ~.PreAllocatedResourceContainer
"""
# pylint: disable=too-many-arguments
progress_bar = ProgressBar(
machine.n_chips, "Preallocating resources for chip power monitor")
# store how much SDRAM the power monitor uses per core
resources = ChipPowerMonitorMachineVertex.get_resources(
n_samples_per_recording=n_samples_per_recording,
sampling_frequency=sampling_frequency,
time_scale_factor=time_scale_factor,
time_step=machine_time_step)
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
for chip in progress_bar.over(machine.chips):
sdrams.append(
SpecificChipSDRAMResource(chip, resources.sdram))
cores.append(CoreResource(chip, 1))
# create preallocated resource container
cpm_pre_allocated_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams, core_resources=cores)
# add other preallocated resources
if pre_allocated_resources is not None:
cpm_pre_allocated_resource_container.extend(
pre_allocated_resources)
# return preallocated resources
return cpm_pre_allocated_resource_container
def __call__(self,
live_packet_gatherer_parameters,
machine,
pre_allocated_resources=None):
"""
:param live_packet_gatherer_parameters:
:type live_packet_gatherer_parameters:
dict(LivePacketGatherParameters,
list(tuple(~.AbstractVertex, list(str))))
:param ~.PreAllocatedResourceContainer pre_allocated_resources:
:param ~.Machine machine:
:rtype: ~.PreAllocatedResourceContainer
"""
progress = ProgressBar(len(machine.ethernet_connected_chips),
"Preallocating resources for Live Recording")
# store how much SDRAM the LPG uses per core
sdram_requirement = LPG.get_sdram_usage()
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
iptags = list()
for chip in progress.over(machine.ethernet_connected_chips):
self._add_chip_lpg_reqs(live_packet_gatherer_parameters, chip,
sdram_requirement, sdrams, cores, iptags)
# create preallocated resource container
lpg_prealloc_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams,
core_resources=cores,
specific_iptag_resources=iptags)
# add other preallocated resources
if pre_allocated_resources is not None:
lpg_prealloc_resource_container.extend(pre_allocated_resources)
# return preallocated resources
return lpg_prealloc_resource_container
def __call__(self,
live_packet_gatherer_parameters,
machine,
pre_allocated_resources=None):
"""
:param live_packet_gatherer_parameters:\
the LPG parameters requested by the script
:param previous_allocated_resources: other preallocated resources
:param machine: the SpiNNaker machine as discovered
:return: preallocated resources
"""
progress = ProgressBar(len(machine.ethernet_connected_chips),
"Preallocating resources for Live Recording")
# store how much SDRAM the LPG uses per core
lpg_sdram_requirement = LPGVertex.get_sdram_usage()
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
iptags = list()
for chip in progress.over(machine.ethernet_connected_chips):
self._add_chip_lpg_reqs(live_packet_gatherer_parameters, chip,
lpg_sdram_requirement, sdrams, cores,
iptags)
# create pre allocated resource container
lpg_prealloc_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams,
core_resources=cores,
specific_iptag_resources=iptags)
# add other pre allocated resources
if pre_allocated_resources is not None:
lpg_prealloc_resource_container.extend(pre_allocated_resources)
# return pre allocated resources
return lpg_prealloc_resource_container
def __call__(self,
machine,
pre_allocated_resources=None,
n_cores_to_allocate=1):
"""
:param ~.Machine machine:
:param ~.PreAllocatedResourceContainer pre_allocated_resources:
:param int n_cores_to_allocate:
:rtype: ~.PreAllocatedResourceContainer
"""
progress = ProgressBar(
len(list(machine.ethernet_connected_chips)) + machine.n_chips,
"Preallocating resources for Extra Monitor support vertices")
sdrams = list()
cores = list()
tags = list()
# add resource requirements for the gatherers on each Ethernet
# connected chip. part of data extraction
self._handle_packet_gathering_support(sdrams, cores, tags, machine,
progress, n_cores_to_allocate)
# add resource requirements for re-injector and reader for data
# extractor
self._handle_second_monitor_support(cores, sdrams, machine, progress)
# create pre allocated resource container
extra_monitor_pre_allocations = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams,
core_resources=cores,
specific_iptag_resources=tags)
# add other pre allocated resources
if pre_allocated_resources is not None:
extra_monitor_pre_allocations.extend(pre_allocated_resources)
# return pre allocated resources
return extra_monitor_pre_allocations
def __call__(
self, machine, pre_allocated_resources=None,
n_cores_to_allocate=1):
"""
:param machine: SpiNNaker machine object
:param pre_allocated_resources: resources already pre allocated
:param n_cores_to_allocate: config params for how many gatherers to use
"""
progress = ProgressBar(
len(list(machine.ethernet_connected_chips)) + machine.n_chips,
"Pre allocating resources for Extra Monitor support vertices")
sdrams = list()
cores = list()
tags = list()
# add resource requirements for the gatherers on each Ethernet
# connected chip. part of data extraction
self._handle_packet_gathering_support(
sdrams, cores, tags, machine, progress, n_cores_to_allocate)
# add resource requirements for re-injector and reader for data
# extractor
self._handle_second_monitor_support(cores, sdrams, machine, progress)
# create pre allocated resource container
extra_monitor_pre_allocations = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams, core_resources=cores,
specific_iptag_resources=tags)
# add other pre allocated resources
if pre_allocated_resources is not None:
extra_monitor_pre_allocations.extend(pre_allocated_resources)
# return pre allocated resources
return extra_monitor_pre_allocations
def __call__(self,
machine,
sdram_to_pre_alloc_for_bit_fields,
pre_allocated_resources=None):
"""
:param ~.PreAllocatedResourceContainer pre_allocated_resources:
:param int sdram_to_pre_alloc_for_bit_fields:
:param ~.Machine machine:
:rtype: ~.PreAllocatedResourceContainer
"""
progress_bar = ProgressBar(
machine.n_chips,
"Preallocating resources for bit field compressor")
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
for chip in progress_bar.over(machine.chips):
sdrams.append(
SpecificChipSDRAMResource(
chip,
(SIZE_OF_SDRAM_ADDRESS_IN_BYTES * chip.n_user_processors) +
sdram_to_pre_alloc_for_bit_fields))
# create preallocated resource container
resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams)
# add other preallocated resources
if pre_allocated_resources is not None:
resource_container.extend(pre_allocated_resources)
# return preallocated resources
return resource_container
