def get_maximum_resources_available(self,
chips=None,
processor_id=None,
board_address=None,
ip_tags=None,
reverse_ip_tags=None):
""" Get the maximum resources available
:param chips: An iterable of (x, y) tuples of chips that are to be used
:type chips: iterable of (int, int)
:param processor_id: the processor id
:type processor_id: int
:param board_address: the board address for locating max resources from
:type board_address: str
:param ip_tags: iterable of ip tag constraints
:type ip_tags: iterable of\
:py:class:`pacman.model.constraints.tag_allocator_constraints.tag_allocator_require_iptag_constraint.TagAllocatorRequireIptagConstraint`
:param reverse_ip_tags: iterable of reverse ip tag constraints
:type reverse_ip_tags: iterable of\
:py:class:`pacman.model.constraints.tag_allocator_constraints.tag_allocator_require_reverse_iptag_constraint.TagAllocatorRequireReverseIptagConstraint`
:return: a resource which shows max resources available
:rtype: ResourceContainer
"""
usable_chips = self._get_usable_chips(chips, board_address, ip_tags,
reverse_ip_tags)
# If the chip is not fixed, find the maximum SDRAM
# TODO: Also check for the best core
max_sdram_available = 0
max_dtcm_available = 0
max_cpu_available = 0
for (chip_x, chip_y) in usable_chips:
key = (chip_x, chip_y)
chip = self._machine.get_chip_at(chip_x, chip_y)
sdram_available = self._sdram_available(chip, key)
ip_tags_available = self._are_ip_tags_available(
chip, board_address, ip_tags)
reverse_ip_tags_available = self._are_reverse_ip_tags_available(
chip, board_address, reverse_ip_tags)
if (sdram_available > max_sdram_available and ip_tags_available
and reverse_ip_tags_available):
max_sdram_available = sdram_available
best_processor_id = self._best_core_available(
chip, key, processor_id)
processor = chip.get_processor_with_id(best_processor_id)
max_dtcm_available = processor.dtcm_available
max_cpu_available = processor.cpu_cycles_available
# If all the SDRAM on the chip is available,
# this chip is unallocated, so the max must be the max
# TODO: This assumes that the chips are all the same
if sdram_available == chip.sdram.size:
break
# Send the maximums
return ResourceContainer(DTCMResource(max_dtcm_available),
SDRAMResource(max_sdram_available),
CPUCyclesPerTickResource(max_cpu_available))
def get_resources_used_by_atoms(self, vertex_slice):
# **HACK** only way to force no partitioning is to zero dtcm and cpu
container = ResourceContainer(sdram=SDRAMResource(
self.BANDIT_REGION_BYTES +
front_end_common_constants.SYSTEM_BYTES_REQUIREMENT),
dtcm=DTCMResource(0),
cpu_cycles=CPUCyclesPerTickResource(0))
return container
def resources_required(self):
sdram = self._N_PARAMETER_BYTES + self._data_size
sdram += 1 * self._KEY_ELEMENT_TYPE.size
resources = ResourceContainer(dtcm=DTCMResource(0),
sdram=SDRAMResource(sdram),
cpu_cycles=CPUCyclesPerTickResource(0),
iptags=[],
reverse_iptags=[])
return resources
def test_sdram(self):
"""
test that adding a sdram resource to a resoruce container works
correctly
:return:
"""
sdram = SDRAMResource(128 * (2 ** 20))
self.assertEqual(sdram.get_value(), 128 * (2 ** 20))
sdram = SDRAMResource(128 * (2 ** 19))
self.assertEqual(sdram.get_value(), 128 * (2 ** 19))
sdram = SDRAMResource(128 * (2 ** 21))
self.assertEqual(sdram.get_value(), 128 * (2 ** 21))
def get_resources_used_by_atoms(self, vertex_slice, graph):
""" Get the separate resource requirements for a range of atoms
:param vertex_slice: the low value of atoms to calculate resources from
:param graph: A reference to the graph containing this vertex.
:type vertex_slice: pacman.model.graph_mapper.slice.Slice
:return: a Resource container that contains a \
CPUCyclesPerTickResource, DTCMResource and SDRAMResource
:rtype: ResourceContainer
:raise None: this method does not raise any known exception
"""
cpu_cycles = self.get_cpu_usage_for_atoms(vertex_slice, graph)
dtcm_requirement = self.get_dtcm_usage_for_atoms(vertex_slice, graph)
sdram_requirement = self.get_sdram_usage_for_atoms(vertex_slice, graph)
# noinspection PyTypeChecker
resources = ResourceContainer(cpu=CPUCyclesPerTickResource(cpu_cycles),
dtcm=DTCMResource(dtcm_requirement),
sdram=SDRAMResource(sdram_requirement))
return resources
def __init__(
self, label, machine_time_step, timescale_factor,
use_prefix=False, key_prefix=None, prefix_type=None,
message_type=EIEIOType.KEY_32_BIT, right_shift=0,
payload_as_time_stamps=True, use_payload_prefix=True,
payload_prefix=None, payload_right_shift=0,
number_of_packets_sent_per_time_step=0,
ip_address=None, port=None, strip_sdp=None, board_address=None,
tag=None,
constraints=None):
resources_required = ResourceContainer(
cpu=CPUCyclesPerTickResource(self.get_cpu_usage()),
dtcm=DTCMResource(self.get_dtcm_usage()),
sdram=SDRAMResource(self.get_sdram_usage()))
if constraints is None:
constraints = self.get_constraints(
ip_address, port, strip_sdp, board_address, tag)
PartitionedVertex.__init__(
self, resources_required, label, constraints=constraints)
ProvidesProvenanceDataFromMachineImpl.__init__(
self, self._LIVE_DATA_GATHER_REGIONS.PROVENANCE.value,
self.N_ADDITIONAL_PROVENANCE_ITEMS)
AbstractPartitionedDataSpecableVertex.__init__(
self, machine_time_step, timescale_factor)
self._use_prefix = use_prefix
self._key_prefix = key_prefix
self._prefix_type = prefix_type
self._message_type = message_type
self._right_shift = right_shift
self._payload_as_time_stamps = payload_as_time_stamps
self._use_payload_prefix = use_payload_prefix
self._payload_prefix = payload_prefix
self._payload_right_shift = payload_right_shift
self._number_of_packets_sent_per_time_step = \
number_of_packets_sent_per_time_step