def test_fixed_vertex_atoms_constraint(self):
c1 = FixedVertexAtomsConstraint(5)
self.assertEqual(c1.size, 5)
self.assertEqual(c1, FixedVertexAtomsConstraint(5))
self.assertEqual(str(c1), 'FixedVertexAtomsConstraint(size=5)')
c2 = FixedVertexAtomsConstraint(7)
self.assertNotEqual(c1, c2)
self.assertNotEqual(c1, "1.2.3.4")
d = {}
d[c1] = 1
d[c2] = 2
self.assertEqual(len(d), 2)
def constraint_from_json(json_dict, graph=None):
if json_dict["class"] == "BoardConstraint":
return BoardConstraint(json_dict["board_address"])
if json_dict["class"] == "ChipAndCoreConstraint":
if "p" in json_dict:
p = json_dict["p"]
else:
p = None
return ChipAndCoreConstraint(json_dict["x"], json_dict["y"], p)
if json_dict["class"] == "ContiguousKeyRangeContraint":
return ContiguousKeyRangeContraint()
if json_dict["class"] == "FixedKeyAndMaskConstraint":
if "key_list_function" in json_dict:
raise NotImplementedError("key_list_function {}".format(
json_dict["key_list_function"]))
return FixedKeyAndMaskConstraint(
key_masks_from_json(json_dict["keys_and_masks"]))
if json_dict["class"] == "FixedMaskConstraint":
return FixedMaskConstraint(json_dict["mask"])
if json_dict["class"] == "FixedVertexAtomsConstraint":
return FixedVertexAtomsConstraint(json_dict["size"])
if json_dict["class"] == "MaxVertexAtomsConstraint":
return MaxVertexAtomsConstraint(json_dict["size"])
if json_dict["class"] == "RadialPlacementFromChipConstraint":
return RadialPlacementFromChipConstraint(json_dict["x"],
json_dict["y"])
if json_dict["class"] == "SameChipAsConstraint":
return SameChipAsConstraint(vertex_lookup(json_dict["vertex"], graph))
if json_dict["class"] == "SameAtomsAsVertexConstraint":
return SameAtomsAsVertexConstraint(
vertex_lookup(json_dict["vertex"], graph))
raise NotImplementedError("constraint {}".format(json_dict["class"]))
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 = 2 # Remember 1 core is the monitor
sdram_per_chip = 8
machine = virtual_machine(
width=2, height=2, 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)])
vertex.splitter = SplitterSliceLegacy()
app_graph = ApplicationGraph("Test")
app_graph.add_vertex(vertex)
# Do the partitioning - this should just work
partitioner = SplitterPartitioner()
machine_graph, _ = partitioner(app_graph, machine, 3000)
self.assertEqual(4, len(machine_graph.vertices))
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 = virtual_machine(
width=2, height=2, 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)])
vertex.splitter = SplitterSliceLegacy()
app_graph = ApplicationGraph("Test")
app_graph.add_vertex(vertex)
# Do the partitioning - this should result in an error
with self.assertRaises(PacmanValueError):
partitioner = SplitterPartitioner()
partitioner(app_graph, machine, 3000)
def test_fixed_vertex_atoms_constraint(self):
c1 = FixedVertexAtomsConstraint(5)
self.constraint_there_and_back(c1)