def test_partition_with_fixed_atom_constraints_at_limit(self):
"""
test a partitioning with a graph with fixed atom constraint which\
should fit but is close to the limit
"""
# Create a 2x2 machine with 1 core per chip (so 4 cores),
# and 8MB SDRAM per chip
n_cores_per_chip = 1
sdram_per_chip = 8
machine = VirtualMachine(width=2,
height=2,
with_monitors=False,
n_cpus_per_chip=n_cores_per_chip,
sdram_per_chip=sdram_per_chip)
# Create a vertex which will need to be split perfectly into 4 cores
# to work and which max atoms per core must be ignored
vertex = SimpleTestVertex(
sdram_per_chip * 2,
max_atoms_per_core=sdram_per_chip,
constraints=[FixedVertexAtomsConstraint(sdram_per_chip // 2)])
app_graph = ApplicationGraph("Test")
app_graph.add_vertex(vertex)
# Do the partitioning - this should just work
partitioner = BasicPartitioner()
machine_graph, _, _ = partitioner(app_graph, machine)
self.assert_(len(machine_graph.vertices) == 4)
def test_partition_with_fixed_atom_constraints(self):
"""
test a partitioning with a graph with fixed atom constraint
"""
# Create a 2x2 machine with 10 cores per chip (so 40 cores),
# but 1MB off 2MB per chip (so 19MB per chip)
n_cores_per_chip = 10
sdram_per_chip = (n_cores_per_chip * 2) - 1
machine = VirtualMachine(width=2,
height=2,
with_monitors=False,
n_cpus_per_chip=n_cores_per_chip,
sdram_per_chip=sdram_per_chip)
# Create a vertex where each atom requires 1MB (default) of SDRAM
# but which can't be subdivided lower than 2 atoms per core.
# The vertex has 1 atom per MB of SDRAM, and so would fit but will
# be disallowed by the fixed atoms per core constraint
vertex = SimpleTestVertex(sdram_per_chip * machine.n_chips,
max_atoms_per_core=2,
constraints=[FixedVertexAtomsConstraint(2)])
app_graph = ApplicationGraph("Test")
app_graph.add_vertex(vertex)
# Do the partitioning - this should result in an error
with self.assertRaises(PacmanValueError):
partitioner = BasicPartitioner()
partitioner(app_graph, machine)
def _execute_partitioner(self, pacman_report_state):
""" executes the partitioner function
:param pacman_report_state:
:return:
"""
# execute partitioner or default partitioner (as seen fit)
if self._partitioner_algorithm is None:
self._partitioner_algorithm = BasicPartitioner()
else:
self._partitioner_algorithm = self._partitioner_algorithm()
# execute partitioner
self._partitioned_graph, self._graph_mapper = \
self._partitioner_algorithm.partition(self._partitionable_graph,
self._machine)
# execute reports
if (pacman_report_state is not None
and pacman_report_state.partitioner_report):
pacman_reports.partitioner_reports(self._report_default_directory,
self._hostname,
self._partitionable_graph,
self._graph_mapper)
def test_partition_with_unsupported_constraints(self):
"""
test that when a vertex has a constraint that is unrecognised,
it raises an error
"""
self.setup()
constrained_vertex = SimpleTestVertex(13, "Constrained")
constrained_vertex.add_constraint(
NewPartitionerConstraint("Mock constraint"))
graph = ApplicationGraph("Graph")
graph.add_vertex(constrained_vertex)
partitioner = BasicPartitioner()
with self.assertRaises(PacmanInvalidParameterException):
partitioner(graph, self.machine)
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()
