def test_sdram(self):
"""
test that adding a SDRAM resource to a resource container works
correctly
"""
const1 = ConstantSDRAM(128)
self.assertEqual(const1.get_total_sdram(None), 128)
const2 = ConstantSDRAM(256)
combo = const1 + const2
self.assertEqual(combo.get_total_sdram(None), 128+256)
combo = const1 - const2
self.assertEqual(combo.get_total_sdram(None), 128-256)
combo = const2 + const1
self.assertEqual(combo.get_total_sdram(None), 256+128)
combo = const2 - const1
self.assertEqual(combo.get_total_sdram(None), 256-128)
var1 = VariableSDRAM(124, 8)
self.assertEqual(var1.get_total_sdram(100), 124 + 8 * 100)
combo = var1 + const1
self.assertEqual(combo.get_total_sdram(100), 124 + 8 * 100 + 128)
combo = var1 - const1
self.assertEqual(combo.get_total_sdram(100), 124 + 8 * 100 - 128)
combo = const1 + var1
self.assertEqual(combo.get_total_sdram(100), 128 + 124 + 8 * 100)
combo = const1 - var1
self.assertEqual(combo.get_total_sdram(100), 128 - (124 + 8 * 100))
var2 = VariableSDRAM(234, 6)
combo = var2 + var1
self.assertEqual(combo.get_total_sdram(150), 234 + 124 + (6 + 8) * 150)
combo = var2 - var1
self.assertEqual(combo.get_total_sdram(150), 234 - 124 + (6 - 8) * 150)
def test_sdram(self):
"""
test that adding a SDRAM resource to a resource container works
correctly
"""
const1 = ConstantSDRAM(128)
self.assertEqual(const1.get_total_sdram(None), 128)
const2 = ConstantSDRAM(256)
combo = const1 + const2
self.assertEqual(combo.get_total_sdram(None), 128 + 256)
combo = const1 - const2
self.assertEqual(combo.get_total_sdram(None), 128 - 256)
combo = const2 + const1
self.assertEqual(combo.get_total_sdram(None), 256 + 128)
combo = const2 - const1
self.assertEqual(combo.get_total_sdram(None), 256 - 128)
var1 = VariableSDRAM(124, 8)
self.assertEqual(var1.get_total_sdram(100), 124 + 8 * 100)
combo = var1 + const1
self.assertEqual(combo.get_total_sdram(100), 124 + 8 * 100 + 128)
combo = var1 - const1
self.assertEqual(combo.get_total_sdram(100), 124 + 8 * 100 - 128)
combo = const1 + var1
self.assertEqual(combo.get_total_sdram(100), 128 + 124 + 8 * 100)
combo = const1 - var1
self.assertEqual(combo.get_total_sdram(100), 128 - (124 + 8 * 100))
var2 = VariableSDRAM(234, 6)
combo = var2 + var1
self.assertEqual(combo.get_total_sdram(150), 234 + 124 + (6 + 8) * 150)
combo = var2 - var1
self.assertEqual(combo.get_total_sdram(150), 234 - 124 + (6 - 8) * 150)
multi1 = MultiRegionSDRAM()
multi1.add_cost(1, 100, 4)
multi1.add_cost(2, 50, 3)
multi1.add_cost("overheads", 20)
multi2 = MultiRegionSDRAM()
multi2.add_cost(MockEnum.ZERO, 88)
multi2.add_cost(MockEnum.ONE, 72)
multi2.add_cost("overheads", 22)
combo = multi1 + multi2
self.assertEqual(combo.get_total_sdram(150),
100 + 50 + 20 + 88 + 72 + 22 + (4 + 3) * 150)
multi3 = MultiRegionSDRAM()
multi3.nest("foo", multi1)
multi3.nest("bar", multi2)
multi1.merge(multi2)
self.assertEqual(len(multi1.regions), 5)
self.assertEqual(multi1.regions["overheads"], ConstantSDRAM(20 + 22))
self.assertEqual(multi1.get_total_sdram(150),
100 + 50 + 20 + 88 + 72 + 22 + (4 + 3) * 150)
self.assertEqual(multi1, combo)
self.assertEqual(multi1, multi3)
with tempfile.TemporaryFile(mode="w") as target:
multi3.report(1000, target=target)
def get_resources(time_step, time_scale_factor, n_samples_per_recording,
sampling_frequency):
""" Get the resources used by this vertex
:return: Resource container
"""
# pylint: disable=too-many-locals
step_in_microseconds = (time_step * time_scale_factor)
# The number of sample per step CB believes does not have to be an int
samples_per_step = (step_in_microseconds / sampling_frequency)
recording_per_step = (samples_per_step / n_samples_per_recording)
max_recording_per_step = math.ceil(recording_per_step)
overflow_recordings = max_recording_per_step - recording_per_step
system = SYSTEM_BYTES_REQUIREMENT
config = CONFIG_SIZE_IN_BYTES
recording = recording_utilities.get_recording_header_size(1)
recording += recording_utilities.get_recording_data_constant_size(1)
fixed_sdram = system + config + recording
with_overflow = (fixed_sdram +
overflow_recordings * RECORDING_SIZE_PER_ENTRY)
per_timestep = recording_per_step * RECORDING_SIZE_PER_ENTRY
container = ResourceContainer(sdram=VariableSDRAM(
with_overflow, per_timestep),
cpu_cycles=CPUCyclesPerTickResource(100),
dtcm=DTCMResource(100))
return container
def resources_required(self):
fixed = (
SYSTEM_BYTES_REQUIREMENT +
recording_utilities.get_recording_header_size(len(Channels)) +
self.PARAMS_BASE_SIZE + len(self._text))
variable = len(self._text)
return ResourceContainer(sdram=VariableSDRAM(fixed, variable))
def get_sdram_usage(cls, send_buffer_times, recording_enabled,
machine_time_step, receive_rate, n_keys):
"""
:param send_buffer_times: When events will be sent
:type send_buffer_times:
~numpy.ndarray(~numpy.ndarray(numpy.int32)) or
list(~numpy.ndarray(numpy.int32)) or None
:param bool recording_enabled: Whether recording is done
:param int machine_time_step: What the machine timestep is
:param float receive_rate: What the expected message receive rate is
:param int n_keys: How many keys are being sent
:rtype: ~pacman.model.resources.VariableSDRAM
"""
static_usage = (SYSTEM_BYTES_REQUIREMENT +
cls._CONFIGURATION_REGION_SIZE +
get_recording_header_size(1) +
get_recording_data_constant_size(1) +
cls.get_provenance_data_size(0))
per_timestep = (
cls._send_buffer_sdram_per_timestep(send_buffer_times, n_keys) +
cls._recording_sdram_per_timestep(machine_time_step,
recording_enabled, receive_rate,
send_buffer_times, n_keys))
static_usage += per_timestep
return VariableSDRAM(static_usage, per_timestep)
def resources_required(self):
fixed_sdram = (SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE +
self.STATE_DATA_SIZE +
self.NEIGHBOUR_INITIAL_STATES_SIZE +
self.RECORDING_HEADER_SIZE)
per_timestep_sdram = self.RECORDING_ELEMENT_SIZE
return ResourceContainer(
sdram=VariableSDRAM(fixed_sdram, per_timestep_sdram))
def resources_required(self):
if self.group.output_grp:
resources = ResourceContainer(
sdram=VariableSDRAM(self._sdram_fixed, self._sdram_variable))
else:
resources = ResourceContainer(
sdram=ConstantSDRAM(self._sdram_fixed))
return resources
def resources_required(self):
fixed_sdram = (SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE +
self.STATE_DATA_SIZE +
self.NEIGHBOUR_INITIAL_STATES_SIZE +
get_recording_header_size(len(Channels)) +
get_recording_data_constant_size(len(Channels)))
per_timestep_sdram = self.RECORDING_ELEMENT_SIZE
return ResourceContainer(
sdram=VariableSDRAM(fixed_sdram, per_timestep_sdram))
def resources_required(self):
constant_sdram = (
SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_REGION_N_BYTES +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1))
variable_sdram = self.N_RECORDED_PER_TIMESTEP
return ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45),
dtcm=DTCMResource(100),
sdram=VariableSDRAM(constant_sdram,
variable_sdram))
def resource_container_from_json(json_dict):
if json_dict is None:
return None
dtcm = DTCMResource(json_dict["dtcm"])
sdram = VariableSDRAM(json_dict["fixed_sdram"],
json_dict["per_timestep_sdram"])
cpu_cycles = CPUCyclesPerTickResource(json_dict["cpu_cycles"])
iptags = iptag_resources_from_json(json_dict["iptags"])
reverse_iptags = iptag_resources_from_json(json_dict["reverse_iptags"])
return ResourceContainer(dtcm, sdram, cpu_cycles, iptags, reverse_iptags)
def resources_required(self, app_graph):
out_edges = app_graph.get_edges_starting_at_vertex(self.app_vertex)
in_edges = app_graph.get_edges_starting_at_vertex(self.app_vertex)
return ResourceContainer(sdram=VariableSDRAM(fixed_sdram=(
SIMULATION_N_BYTES +
(len(out_edges) * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
(len(in_edges) * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
(self.SDRAM_PARTITION_COUNTERS * 2) + SARK_PER_MALLOC_SDRAM_USAGE +
recording_utilities.get_recording_header_size(len(Channels)) +
recording_utilities.get_recording_data_constant_size(len(Channels))
),
per_timestep_sdram=self.
RECORDING_ELEMENT_SIZE))
def resources_required(self):
"""
Reserve resources for data regions
"""
fixed_sdram = (SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE +
self.POSITION_DATA_SIZE +
self.NEIGHBOUR_KEYS_SIZE +
self.VELOCITY_SIZE +
self.VERTEX_INDEX_SIZE +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1))
per_timestep_sdram = self.RECORDING_ELEMENT_SIZE
return ResourceContainer(
sdram=VariableSDRAM(fixed_sdram, per_timestep_sdram))
def get_sdram_usage(send_buffer_times, recording_enabled,
machine_time_step, receive_rate, n_keys):
static_usage = (SYSTEM_BYTES_REQUIREMENT +
(ReverseIPTagMulticastSourceMachineVertex.
_CONFIGURATION_REGION_SIZE) +
get_recording_header_size(1) +
get_recording_data_constant_size(1) +
(ReverseIPTagMulticastSourceMachineVertex.
get_provenance_data_size(0)))
per_timestep = (
ReverseIPTagMulticastSourceMachineVertex.
send_buffer_sdram_per_timestep(send_buffer_times, n_keys) +
ReverseIPTagMulticastSourceMachineVertex.
recording_sdram_per_timestep(machine_time_step, recording_enabled,
receive_rate, send_buffer_times,
n_keys))
static_usage += per_timestep
return VariableSDRAM(static_usage, per_timestep)