diff --git a/nova/tests/unit/virt/test_hardware.py b/nova/tests/unit/virt/test_hardware.py index a10c4ec4de9a..45c8ae052ac8 100644 --- a/nova/tests/unit/virt/test_hardware.py +++ b/nova/tests/unit/virt/test_hardware.py @@ -2131,12 +2131,12 @@ class VirtNUMATopologyCellUsageTestCase(test.NoDBTestCase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)], siblings=[set([1]), set([2])]) - limit_cell = objects.NUMATopologyLimits( + limits = objects.NUMATopologyLimits( cpu_allocation_ratio=2, ram_allocation_ratio=2) instance_cell = objects.InstanceNUMACell( id=0, cpuset=set([1, 2]), memory=1024) fitted_cell = hw._numa_fit_instance_cell( - host_cell, instance_cell, limit_cell=limit_cell) + host_cell, instance_cell, limits=limits) self.assertIsInstance(fitted_cell, objects.InstanceNUMACell) self.assertEqual(host_cell.id, fitted_cell.id) @@ -2151,12 +2151,12 @@ class VirtNUMATopologyCellUsageTestCase(test.NoDBTestCase): size_kb=4, total=524288, used=0)], siblings=[set([1]), set([2])], pinned_cpus=set()) - limit_cell = objects.NUMATopologyLimits( + limits = objects.NUMATopologyLimits( cpu_allocation_ratio=2, ram_allocation_ratio=2) instance_cell = objects.InstanceNUMACell( id=0, cpuset=set([1, 2, 3]), memory=4096) fitted_cell = hw._numa_fit_instance_cell( - host_cell, instance_cell, limit_cell=limit_cell) + host_cell, instance_cell, limits=limits) self.assertIsNone(fitted_cell) def test_fit_instance_cell_fail_w_limit(self): @@ -2172,16 +2172,16 @@ class VirtNUMATopologyCellUsageTestCase(test.NoDBTestCase): pinned_cpus=set()) instance_cell = objects.InstanceNUMACell( id=0, cpuset=set([1, 2]), memory=4096) - limit_cell = objects.NUMATopologyLimits( + limits = objects.NUMATopologyLimits( cpu_allocation_ratio=2, ram_allocation_ratio=2) fitted_cell = hw._numa_fit_instance_cell( - host_cell, instance_cell, limit_cell=limit_cell) + host_cell, instance_cell, limits=limits) self.assertIsNone(fitted_cell) instance_cell = objects.InstanceNUMACell( id=0, cpuset=set([1, 2, 3, 4, 5]), memory=1024) fitted_cell = hw._numa_fit_instance_cell( - host_cell, instance_cell, limit_cell=limit_cell) + host_cell, instance_cell, limits=limits) self.assertIsNone(fitted_cell) @@ -2671,10 +2671,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)], siblings=[set([0]), set([1]), set([2])]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertIsNone(inst_pin) def test_get_pinning_inst_too_large_mem(self): @@ -2687,10 +2694,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set(), mempages=[], siblings=[set([0]), set([1]), set([2])]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2]), - memory=2048) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertIsNone(inst_pin) def test_get_pinning_inst_not_avail(self): @@ -2704,10 +2718,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)], siblings=[set([0]), set([1]), set([2]), set([3])]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertIsNone(inst_pin) def test_get_pinning_no_sibling_fits_empty(self): @@ -2721,9 +2742,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)], siblings=[set([0]), set([1]), set([2])]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2]), memory=2048) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=3, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2741,9 +2770,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)], siblings=[set([0]), set([1]), set([2]), set([3])]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2]), memory=1024) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2]), + memory=1024, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_pinning = {0: 0, 1: 2, 2: 3} self.assertEqual(got_pinning, inst_pin.cpu_pinning) @@ -2760,9 +2797,16 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), memory=2048) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=4, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2781,9 +2825,16 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), memory=2048) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2802,9 +2853,16 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3, 4, 5, 6, 7]), memory=2048) + cpuset=set([0, 1, 2, 3, 4, 5, 6, 7]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=4, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2822,9 +2880,16 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 1, 2, 3]), set([4, 5, 6, 7])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), memory=2048) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2841,10 +2906,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set(), siblings=[set([0, 1, 2, 3]), set([4, 5, 6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=1, threads=4) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2861,9 +2933,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set(), siblings=[set([0, 1]), set([2, 3])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2881,11 +2961,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([x]) for x in range(0, 8)], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertIsNone(inst_pin) def test_get_pinning_require_policy_too_few_siblings(self): @@ -2899,11 +2985,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 4]), set([1, 5]), set([2, 6]), set([3, 7])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertIsNone(inst_pin) def test_get_pinning_require_policy_fits(self): @@ -2917,11 +3009,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 1]), set([2, 3])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2937,11 +3035,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 4]), set([1, 5]), set([2, 6]), set([3, 7])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1, 2, 3]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.REQUIRE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2956,9 +3060,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set(), siblings=[set([0, 1]), set([2, 3]), set([4, 5]), set([6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3, 4]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3, 4]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=5, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2973,9 +3085,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set(), siblings=[set([0, 1, 2, 3]), set([4, 5, 6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3, 4, 5]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3, 4, 5]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=3, threads=2) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -2990,9 +3110,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set([0, 2, 5]), siblings=[set([0, 1]), set([2, 3]), set([4, 5]), set([6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=3, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3007,9 +3135,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set([0, 1, 2, 5]), siblings=[set([0, 1]), set([2, 3]), set([4, 5]), set([6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=4, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3024,9 +3160,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): pinned_cpus=set([0, 2, 5, 6]), siblings=[set([0, 1]), set([2, 3]), set([4, 5]), set([6, 7])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=4, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3043,9 +3187,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 8]), set([1, 9]), set([2, 10]), set([3, 11]), set([4, 12]), set([5, 13]), set([6, 14]), set([7, 15])], mempages=[]) - inst_pin = objects.InstanceNUMACell(cpuset=set([0, 1, 2, 3, 4]), - memory=2048) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + inst_pin = objects.InstanceNUMACell( + cpuset=set([0, 1, 2, 3, 4]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) self.assertPinningPreferThreads(inst_pin, host_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=5, threads=1) @@ -3062,11 +3214,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 1]), set([2, 3])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertIsNone(inst_pin) def test_get_pinning_isolate_policy_no_fully_free_cores(self): @@ -3080,11 +3238,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 1]), set([2, 3])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertIsNone(inst_pin) def test_get_pinning_isolate_policy_fits(self): @@ -3098,11 +3262,16 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0]), set([1]), set([2]), set([3])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3118,11 +3287,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 1]), set([2, 3])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3138,11 +3313,17 @@ class CPUPinningCellTestCase(test.NoDBTestCase, _CPUPinningTestCaseBase): siblings=[set([0, 4]), set([1, 5]), set([2, 6]), set([3, 7])], mempages=[]) inst_pin = objects.InstanceNUMACell( - cpuset=set([0, 1]), - memory=2048, - cpu_policy=fields.CPUAllocationPolicy.DEDICATED, - cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE) - inst_pin = hw._numa_fit_instance_cell_with_pinning(host_pin, inst_pin) + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + cpu_thread_policy=fields.CPUThreadAllocationPolicy.ISOLATE, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + inst_pin = hw._numa_fit_instance_cell(host_pin, inst_pin, limits) + self.assertInstanceCellPinned(inst_pin) got_topo = objects.VirtCPUTopology(sockets=1, cores=2, threads=1) self.assertEqualTopology(got_topo, inst_pin.cpu_topology) @@ -3583,9 +3764,18 @@ class CPUSReservedCellTestCase(test.NoDBTestCase): siblings=[set([0]), set([1]), set([2])], mempages=[objects.NUMAPagesTopology( size_kb=4, total=524288, used=0)]) - inst_cell = objects.InstanceNUMACell(cpuset=set([0, 1]), memory=2048) - return hw._numa_fit_instance_cell_with_pinning( - host_cell, inst_cell, reserved) + inst_cell = objects.InstanceNUMACell( + cpuset=set([0, 1]), + memory=2048, + cpu_policy=fields.CPUAllocationPolicy.DEDICATED, + ) + limits = objects.NUMATopologyLimits( + cpu_allocation_ratio=2, ram_allocation_ratio=2, + ) + + return hw._numa_fit_instance_cell( + host_cell, inst_cell, limits, reserved, + ) def test_no_reserved(self): inst_cell = self._test_reserved(reserved=0) diff --git a/nova/virt/hardware.py b/nova/virt/hardware.py index ec635552c9ab..bffeafac40f7 100644 --- a/nova/virt/hardware.py +++ b/nova/virt/hardware.py @@ -31,6 +31,7 @@ from nova import exception from nova.i18n import _ from nova import objects from nova.objects import fields +from nova.pci import stats CONF = nova.conf.CONF @@ -998,53 +999,12 @@ def _pack_instance_onto_cores(host_cell, instance_cell, return instance_cell -def _numa_fit_instance_cell_with_pinning(host_cell, instance_cell, - num_cpu_reserved=0): - """Determine if cells can be pinned to a host cell. - - :param host_cell: objects.NUMACell instance - the host cell that - the instance should be pinned to - :param instance_cell: objects.InstanceNUMACell instance without any - pinning information - :param num_cpu_reserved: int - number of pCPUs reserved for hypervisor - - :returns: objects.InstanceNUMACell instance with pinning information, - or None if instance cannot be pinned to the given host - """ - required_cpus = len(instance_cell.cpuset) + num_cpu_reserved - if host_cell.avail_pcpus < required_cpus: - LOG.debug('Not enough available CPUs to schedule instance. ' - 'Oversubscription is not possible with pinned instances. ' - 'Required: %(required)d (%(vcpus)d + %(num_cpu_reserved)d), ' - 'actual: %(actual)d', - {'required': required_cpus, - 'vcpus': len(instance_cell.cpuset), - 'actual': host_cell.avail_pcpus, - 'num_cpu_reserved': num_cpu_reserved}) - return - - if host_cell.avail_memory < instance_cell.memory: - LOG.debug('Not enough available memory to schedule instance. ' - 'Oversubscription is not possible with pinned instances. ' - 'Required: %(required)s, available: %(available)s, ' - 'total: %(total)s. ', - {'required': instance_cell.memory, - 'available': host_cell.avail_memory, - 'total': host_cell.memory}) - return - - # Try to pack the instance cell onto cores - numa_cell = _pack_instance_onto_cores( - host_cell, instance_cell, num_cpu_reserved=num_cpu_reserved) - - if not numa_cell: - LOG.debug('Failed to map instance cell CPUs to host cell CPUs') - - return numa_cell - - -def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, - cpuset_reserved=0): +def _numa_fit_instance_cell( + host_cell: 'objects.NUMACell', + instance_cell: 'objects.InstanceNUMACell', + limits: ty.Optional['objects.NUMATopologyLimit'] = None, + cpuset_reserved: int = 0, +) -> ty.Optional['objects.InstanceNUMACell']: """Ensure an instance cell can fit onto a host cell Ensure an instance cell can fit onto a host cell and, if so, return @@ -1053,7 +1013,7 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, :param host_cell: host cell to fit the instance cell onto :param instance_cell: instance cell we want to fit - :param limit_cell: an objects.NUMATopologyLimit or None + :param limits: an objects.NUMATopologyLimit or None :param cpuset_reserved: An int to indicate the number of CPUs overhead :returns: objects.InstanceNUMACell with the id set to that of the @@ -1072,7 +1032,7 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, LOG.debug('Host does not support requested memory pagesize, ' 'or not enough free pages of the requested size. ' 'Requested: %d kB', instance_cell.pagesize) - return + return None LOG.debug('Selected memory pagesize: %(selected_mem_pagesize)d kB. ' 'Requested memory pagesize: %(requested_mem_pagesize)d ' '(small = -1, large = -2, any = -3)', @@ -1101,7 +1061,7 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, 'available': host_cell.avail_memory, 'total': host_cell.memory, 'pagesize': pagesize}) - return + return None else: # The host does not support explicit page sizes. Ignore pagesizes # completely. @@ -1114,7 +1074,7 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, 'Required: %(required)d, actual: %(actual)d', {'required': instance_cell.memory, 'actual': host_cell.memory}) - return + return None # NOTE(stephenfin): As with memory, do not allow an instance to overcommit # against itself on any NUMA cell @@ -1128,7 +1088,7 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, 'actual': len(host_cell.pcpuset), 'cpuset_reserved': cpuset_reserved }) - return + return None else: required_cpus = len(instance_cell.cpuset) if required_cpus > len(host_cell.cpuset): @@ -1137,36 +1097,60 @@ def _numa_fit_instance_cell(host_cell, instance_cell, limit_cell=None, 'required': len(instance_cell.cpuset), 'actual': len(host_cell.cpuset), }) - return + return None if instance_cell.cpu_policy == fields.CPUAllocationPolicy.DEDICATED: LOG.debug('Pinning has been requested') - new_instance_cell = _numa_fit_instance_cell_with_pinning( - host_cell, instance_cell, cpuset_reserved) - if not new_instance_cell: - return - new_instance_cell.pagesize = instance_cell.pagesize - instance_cell = new_instance_cell + required_cpus = len(instance_cell.cpuset) + cpuset_reserved + if required_cpus > host_cell.avail_pcpus: + LOG.debug('Not enough available CPUs to schedule instance. ' + 'Oversubscription is not possible with pinned ' + 'instances. Required: %(required)d (%(vcpus)d + ' + '%(num_cpu_reserved)d), actual: %(actual)d', + {'required': required_cpus, + 'vcpus': len(instance_cell.cpuset), + 'actual': host_cell.avail_pcpus, + 'num_cpu_reserved': cpuset_reserved}) + return None - elif limit_cell: + if instance_cell.memory > host_cell.avail_memory: + LOG.debug('Not enough available memory to schedule instance. ' + 'Oversubscription is not possible with pinned ' + 'instances. Required: %(required)s, available: ' + '%(available)s, total: %(total)s. ', + {'required': instance_cell.memory, + 'available': host_cell.avail_memory, + 'total': host_cell.memory}) + return None + + # Try to pack the instance cell onto cores + instance_cell = _pack_instance_onto_cores( + host_cell, instance_cell, num_cpu_reserved=cpuset_reserved, + ) + if not instance_cell: + LOG.debug('Failed to map instance cell CPUs to host cell CPUs') + return None + + elif limits: LOG.debug('No pinning requested, considering limitations on usable cpu' ' and memory') - memory_usage = host_cell.memory_usage + instance_cell.memory cpu_usage = host_cell.cpu_usage + len(instance_cell.cpuset) - cpu_limit = len(host_cell.cpuset) * limit_cell.cpu_allocation_ratio - ram_limit = host_cell.memory * limit_cell.ram_allocation_ratio - if memory_usage > ram_limit: - LOG.debug('Host cell has limitations on usable memory. There is ' - 'not enough free memory to schedule this instance. ' - 'Usage: %(usage)d, limit: %(limit)d', - {'usage': memory_usage, 'limit': ram_limit}) - return + cpu_limit = len(host_cell.cpuset) * limits.cpu_allocation_ratio if cpu_usage > cpu_limit: LOG.debug('Host cell has limitations on usable CPUs. There are ' 'not enough free CPUs to schedule this instance. ' 'Usage: %(usage)d, limit: %(limit)d', {'usage': cpu_usage, 'limit': cpu_limit}) - return + return None + + ram_usage = host_cell.memory_usage + instance_cell.memory + ram_limit = host_cell.memory * limits.ram_allocation_ratio + if ram_usage > ram_limit: + LOG.debug('Host cell has limitations on usable memory. There is ' + 'not enough free memory to schedule this instance. ' + 'Usage: %(usage)d, limit: %(limit)d', + {'usage': ram_usage, 'limit': ram_limit}) + return None instance_cell.id = host_cell.id return instance_cell @@ -2038,8 +2022,12 @@ def _numa_cells_support_network_metadata( def numa_fit_instance_to_host( - host_topology, instance_topology, limits=None, - pci_requests=None, pci_stats=None): + host_topology: 'objects.NUMATopology', + instance_topology: 'objects.InstanceNUMATopology', + limits: ty.Optional['objects.NUMATopologyLimit'] = None, + pci_requests: ty.Optional['objects.InstancePCIRequests'] = None, + pci_stats: ty.Optional[stats.PciDeviceStats] = None, +): """Fit the instance topology onto the host topology. Given a host, instance topology, and (optional) limits, attempt to @@ -2084,8 +2072,10 @@ def numa_fit_instance_to_host( # devices attached. Presence of a given numa_node in a PCI pool is # indicative of a PCI device being associated with that node if not pci_requests and pci_stats: + # TODO(stephenfin): pci_stats can't be None here but mypy can't figure + # that out for some reason host_cells = sorted(host_cells, key=lambda cell: cell.id in [ - pool['numa_node'] for pool in pci_stats.pools]) + pool['numa_node'] for pool in pci_stats.pools]) # type: ignore for host_cell_perm in itertools.permutations( host_cells, len(instance_topology)):