def test_partition_with_more_sdram_than_default(self):
"""
test that the partitioner works when its machine is slightly malformed
in that it has more sdram avilable
"""
self.setup()
flops = 20000000
(e, _, n, w, _, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
links = list()
links.append(Link(0, 0, 0, 0, 1, s, s))
_sdram = SDRAM(128 * (2**21))
links = list()
links.append(Link(0, 0, 0, 1, 1, n, n))
links.append(Link(0, 1, 1, 1, 0, s, s))
links.append(Link(1, 1, 2, 0, 0, e, e))
links.append(Link(1, 0, 3, 0, 1, w, w))
r = Router(links, False, 100, 1024)
ip = TestBasicPartitioner.TheTestAddress
chips = list()
for x in range(5):
for y in range(5):
chips.append(Chip(x, y, processors, r, _sdram, 0, 0, ip))
self.machine = Machine(chips, 0, 0)
self.bp(self.graph, self.machine)
def __init__(self, configfile, default_config_paths, validation_cfg):
"""
:param str configfile:
The base name of the configuration file(s).
Should not include any path components.
:param list(str) default_config_paths:
The list of files to get default configurations from.
:type default_config_paths: list(str) or None
:param validation_cfg:
The list of files to read a validation configuration from.
If None, no such validation is performed.
:type validation_cfg: list(str) or None
"""
# global params
if default_config_paths is None:
default_config_paths = []
default_config_paths.insert(0, os.path.join(
os.path.dirname(__file__), CONFIG_FILE))
self._config = conf_loader.load_config(
filename=configfile, defaults=default_config_paths,
validation_cfg=validation_cfg)
# set up machine targeted data
self._use_virtual_board = self._config.getboolean(
"Machine", "virtual_board")
# Pass max_machine_cores to Machine so if effects everything!
max_machine_core = self._read_config_int("Machine", "max_machine_core")
if max_machine_core is not None:
Machine.set_max_cores_per_chip(max_machine_core)
self._json_folder = None
self._provenance_file_path = None
self._report_default_directory = None
self._report_simulation_top_directory = None
self._this_run_time_string = None
def setup(self):
"""
setup for all basic partitioner tests
"""
self.vert1 = SimpleTestVertex(10, "New AbstractConstrainedVertex 1")
self.vert2 = SimpleTestVertex(5, "New AbstractConstrainedVertex 2")
self.vert3 = SimpleTestVertex(3, "New AbstractConstrainedVertex 3")
self.edge1 = ApplicationEdge(self.vert1, self.vert2, None,
"First edge")
self.edge2 = ApplicationEdge(self.vert2, self.vert1, None,
"Second edge")
self.edge3 = ApplicationEdge(self.vert1, self.vert3, None,
"Third edge")
self.verts = [self.vert1, self.vert2, self.vert3]
self.edges = [self.edge1, self.edge2, self.edge3]
self.graph = ApplicationGraph("Graph")
self.graph.add_vertices(self.verts)
self.graph.add_edges(self.edges, "foo")
flops = 200000000
(e, _, n, w, _, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
links = list()
links.append(Link(0, 0, 0, 0, 1, s, s))
_sdram = SDRAM(128 * (2**20))
links = list()
links.append(Link(0, 0, 0, 1, 1, n, n))
links.append(Link(0, 1, 1, 1, 0, s, s))
links.append(Link(1, 1, 2, 0, 0, e, e))
links.append(Link(1, 0, 3, 0, 1, w, w))
r = Router(links, False, 100, 1024)
ip = TestBasicPartitioner.TheTestAddress
chips = list()
for x in range(5):
for y in range(5):
chips.append(Chip(x, y, processors, r, _sdram, 0, 0, ip))
self.machine = Machine(chips, 0, 0)
self.bp = BasicPartitioner()
def _make_chip(self, chip_info, machine):
""" Creates a chip from a ChipSummaryInfo structure.
:param ChipSummaryInfo chip_info:
The ChipSummaryInfo structure to create the chip from
:return: The created chip
:rtype: ~spinn_machine.Chip
"""
# Create the down cores set if any
n_cores = min(chip_info.n_cores, Machine.max_cores_per_chip())
core_states = chip_info.core_states
down_cores = self._ignore_cores_map.get((chip_info.x, chip_info.y),
None)
for i in range(1, n_cores):
if core_states[i] != CPUState.IDLE:
self._report_ignore("Not using core {}, {}, {} in state {}",
chip_info.x, chip_info.y, i,
core_states[i])
if down_cores is None:
down_cores = set()
down_cores.add(i)
# Create the router
router = self._make_router(chip_info, machine)
# Create the chip's SDRAM object
sdram_size = chip_info.largest_free_sdram_block
max_sdram_size = get_config_int("Machine",
"max_sdram_allowed_per_chip")
if (max_sdram_size is not None and sdram_size > max_sdram_size):
sdram_size = max_sdram_size
sdram = SDRAM(size=sdram_size)
# Create the chip
return Chip(x=chip_info.x,
y=chip_info.y,
n_processors=n_cores,
router=router,
sdram=sdram,
ip_address=chip_info.ethernet_ip_address,
nearest_ethernet_x=chip_info.nearest_ethernet_x,
nearest_ethernet_y=chip_info.nearest_ethernet_y,
down_cores=down_cores,
parent_link=chip_info.parent_link)
def __locate_destination(self, chip):
""" Locate destination vertex on (Ethernet-connected) chip to send
fixed data to
:param ~spinn_machine.Chip chip:
:return: processor ID as a int
:rtype: int
:raises PacmanConfigurationException: if no placement processor found
"""
x = chip.x
y = chip.y
for p in range(Machine.max_cores_per_chip()):
# check if occupied and by the right vertex type
if self._placements.is_processor_occupied(x, y, p) and isinstance(
self._placements.get_vertex_on_processor(x, y, p),
self._destination_class):
return p
raise PacmanConfigurationException(
"no destination vertex found on Ethernet chip {}:{}".format(
chip.x, chip.y))
def test_partition_with_insufficient_space(self):
"""
test that if there's not enough space, the test the partitioner will
raise an error
"""
self.setup()
flops = 1000
(e, _, n, w, _, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
links = list()
links.append(Link(0, 0, 0, 0, 1, s, s))
_sdram = SDRAM(2**11)
links = list()
links.append(Link(0, 0, 0, 1, 1, n, n))
links.append(Link(0, 1, 1, 1, 0, s, s))
links.append(Link(1, 1, 2, 0, 0, e, e))
links.append(Link(1, 0, 3, 0, 1, w, w))
r = Router(links, False, 100, 1024)
ip = TestBasicPartitioner.TheTestAddress
chips = list()
for x in range(5):
for y in range(5):
chips.append(Chip(x, y, processors, r, _sdram, 0, 0, ip))
self.machine = Machine(chips, 0, 0)
large_vertex = SimpleTestVertex(3000,
"Large vertex",
max_atoms_per_core=1)
self.assertEqual(large_vertex._model_based_max_atoms_per_core, 1)
self.graph = ApplicationGraph("Graph with large vertex")
self.graph.add_vertex(large_vertex)
with self.assertRaises(PacmanPartitionException):
self.bp(self.graph, self.machine)
def test_partition_with_barely_sufficient_space(self):
"""
test that partitioning will work when close to filling the machine
"""
self.setup()
flops = 20000000
(e, _, n, w, _, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
links = list()
links.append(Link(0, 0, 0, 0, 1, s, s))
_sdram = SDRAM(2**12)
links = list()
links.append(Link(0, 0, 0, 1, 1, n, n))
links.append(Link(0, 1, 1, 1, 0, s, s))
links.append(Link(1, 1, 2, 0, 0, e, e))
links.append(Link(1, 0, 3, 0, 1, w, w))
r = Router(links, False, 100, 1024)
ip = TestBasicPartitioner.TheTestAddress
chips = list()
for x in range(5):
for y in range(5):
chips.append(Chip(x, y, processors, r, _sdram, 0, 0, ip))
self.machine = Machine(chips, 0, 0)
singular_vertex = SimpleTestVertex(450,
"Large vertex",
max_atoms_per_core=1)
self.assertEqual(singular_vertex._model_based_max_atoms_per_core, 1)
self.graph = ApplicationGraph("Graph with large vertex")
self.graph.add_vertex(singular_vertex)
graph, _, _ = self.bp(self.graph, self.machine)
self.assertEqual(singular_vertex._model_based_max_atoms_per_core, 1)
self.assertEqual(len(list(graph.vertices)), 450)
def __call__(self,
hbp_server_url,
total_run_time,
max_machine_core_reduction=0):
"""
:param str hbp_server_url:
:param int total_run_time:
:param int max_machine_core_reduction:
:rtype: ~.Machine
"""
max_machine = self._max_machine_request(hbp_server_url, total_run_time)
n_cpus_per_chip = (Machine.max_cores_per_chip() -
max_machine_core_reduction)
# Return the width and height and assume that it has wrap arounds
return virtual_machine(width=max_machine["width"],
height=max_machine["height"],
n_cpus_per_chip=n_cpus_per_chip,
validate=False)
def setUp(self):
#######################################################################
# Setting up vertices, edges and graph #
#######################################################################
self.vert1 = T_AppVertex(100, "New AbstractConstrainedVertex 1")
self.vert2 = T_AppVertex(5, "New AbstractConstrainedVertex 2")
self.vert3 = T_AppVertex(3, "New AbstractConstrainedVertex 3")
self.edge1 = ApplicationEdge(self.vert1, self.vert2, "First edge")
self.edge2 = ApplicationEdge(self.vert2, self.vert1, "Second edge")
self.edge3 = ApplicationEdge(self.vert1, self.vert3, "Third edge")
self.verts = [self.vert1, self.vert2, self.vert3]
self.edges = [self.edge1, self.edge2, self.edge3]
self.graph = ApplicationGraph("Graph", self.verts, self.edges)
#######################################################################
# Setting up machine #
#######################################################################
flops = 1000
(_, _, n, _, _, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
_sdram = SDRAM(128 * (2**20))
ip = "192.168.240.253"
chips = list()
for x in range(10):
for y in range(10):
links = list()
links.append(Link(x, y, 0, (x + 1) % 10, y, n, n))
links.append(Link(x, y, 1, (x + 1) % 10, (y + 1) % 10, s, s))
links.append(Link(x, y, 2, x, (y + 1) % 10, n, n))
links.append(Link(x, y, 3, (x - 1) % 10, y, s, s))
links.append(Link(x, y, 4, (x - 1) % 10, (y - 1) % 10, n, n))
links.append(Link(x, y, 5, x, (y - 1) % 10, s, s))
r = Router(links, False, 100, 1024)
chips.append(Chip(x, y, processors, r, _sdram, ip))
self.machine = Machine(chips)
#######################################################################
# Setting up graph and graph_mapper #
#######################################################################
self.vertices = list()
self.vertex1 = T_MachineVertex(0, 1,
get_resources_used_by_atoms(0, 1, []),
"First vertex")
self.vertex2 = T_MachineVertex(1, 5,
get_resources_used_by_atoms(1, 5, []),
"Second vertex")
self.vertex3 = T_MachineVertex(5, 10,
get_resources_used_by_atoms(5, 10, []),
"Third vertex")
self.vertex4 = T_MachineVertex(
10, 100, get_resources_used_by_atoms(10, 100, []), "Fourth vertex")
self.vertices.append(self.vertex1)
self.vertices.append(self.vertex2)
self.vertices.append(self.vertex3)
self.vertices.append(self.vertex4)
self.edges = list()
self.graph = MachineGraph(self.vertices, self.edges)
self.graph_mapper = GraphMapper()
self.graph_mapper.add_vertices(self.vertices)
def __call__(
self, width=None, height=None, version=None,
down_chips=None, down_cores=None, down_links=None,
max_sdram_size=None,
router_entries_per_chip=Router.ROUTER_DEFAULT_AVAILABLE_ENTRIES,
json_path=None):
"""
:param int width:
:param int height:
:param int version:
:param list(tuple(int,int)) down_chips:
:param list(tuple(int,int,int)) down_cores:
:param list(tuple(int,int,int)) down_links:
:param int max_sdram_size:
:param int router_entries_per_chip:
:param str json_path:
:rtype: ~.Machine
:raises Exception:
"""
# For backward compatibility support version in csf files for now
if version is not None:
if version in [2, 3]:
if height is None:
height = 2
else:
assert height == 2
if width is None:
width = 2
else:
assert width == 2
logger.warning("For virtual Machines version is deprecated."
"use width=2, height=2 instead")
elif version in [4, 5]:
if height is None:
height = 8
else:
assert height == 8
if width is None:
width = 8
else:
assert width == 8
logger.warning("For virtual Machines version is deprecated."
"use width=8, height=8 instead")
else:
raise Exception("Unknown version {}".format(version))
if json_path is None:
# pylint: disable=too-many-arguments
machine = virtual_machine(
width=width, height=height,
n_cpus_per_chip=Machine.max_cores_per_chip(),
down_chips=down_chips, down_cores=down_cores,
down_links=down_links, sdram_per_chip=max_sdram_size,
router_entries_per_chip=router_entries_per_chip, validate=True)
else:
if (height is not None or width is not None or
version is not None or down_chips is not None or
down_cores is not None or down_links is not None):
logger.warning("As json_path specified all other virtual "
"machine settings ignored.")
machine = json_machine.machine_from_json(json_path)
# Work out and add the SpiNNaker links and FPGA links
machine.add_spinnaker_links()
machine.add_fpga_links()
logger.info(
"Created a virtual machine which has {}".format(
machine.cores_and_link_output_string()))
return machine