def __get_rebalance_request(self):
workload_map = self.get_workload_map_copy()
resource_usage = self.__wmm.get_resource_usage(workload_map.keys())
log.debug("resource_usage: %s", json.dumps(resource_usage.serialize()))
cpu_usage = self.__get_optional_default(resource_usage.get_cpu_usage,
{})
mem_usage = self.__get_optional_default(resource_usage.get_mem_usage,
{})
net_recv_usage = self.__get_optional_default(
resource_usage.get_net_recv_usage, {})
net_trans_usage = self.__get_optional_default(
resource_usage.get_net_trans_usage, {})
disk_usage = self.__get_optional_default(resource_usage.get_disk_usage,
{})
return AllocateRequest(
cpu=self.get_cpu_copy(),
workloads=workload_map,
resource_usage=resource_usage,
cpu_usage=cpu_usage,
mem_usage=mem_usage,
net_recv_usage=net_recv_usage,
net_trans_usage=net_trans_usage,
disk_usage=disk_usage,
metadata=self.__get_request_metadata("rebalance"))
def get_no_usage_rebalance_request(cpu: Cpu, workloads: List[Workload]):
return AllocateRequest(cpu=cpu,
workloads=__workloads_list_to_map(workloads),
resource_usage=GlobalResourceUsage({}),
cpu_usage={},
mem_usage={},
net_recv_usage={},
net_trans_usage={},
disk_usage={},
metadata=DEFAULT_TEST_REQUEST_METADATA)
def __get_rebalance_request(self):
pcp_usage = self.__wmm.get_pcp_usage()
return AllocateRequest(
cpu=self.get_cpu_copy(),
workloads=self.get_workload_map_copy(),
cpu_usage=pcp_usage.get(CPU_USAGE, {}),
mem_usage=pcp_usage.get(MEM_USAGE, {}),
net_recv_usage=pcp_usage.get(NET_RECV_USAGE, {}),
net_trans_usage=pcp_usage.get(NET_TRANS_USAGE, {}),
disk_usage=pcp_usage.get(DISK_USAGE, {}),
metadata=self.__get_request_metadata("rebalance"))
def test_balance_forecast_ip(self):
cpu = get_cpu()
w1 = get_test_workload("a", 2, STATIC)
w2 = get_test_workload("b", 4, BURST)
allocator = forecast_ip_alloc_simple
request = AllocateThreadsRequest(cpu, "a", {"a": w1}, {},
DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.assign_threads(request).get_cpu()
request = AllocateThreadsRequest(cpu, "b", {
"a": w1,
"b": w2
}, {}, DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.assign_threads(request).get_cpu()
request = AllocateRequest(cpu, {
"a": w1,
"b": w2
}, {}, DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.rebalance(request).get_cpu()
self.assertLessEqual(2 + 4, len(cpu.get_claimed_threads()))
w2t = cpu.get_workload_ids_to_thread_ids()
self.assertEqual(2, len(w2t["a"]))
self.assertLessEqual(4, len(w2t["b"])) # burst got at least 4
for _ in range(20):
request = AllocateRequest(cpu, {
"a": w1,
"b": w2
}, {}, DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.rebalance(request).get_cpu()
w2t = cpu.get_workload_ids_to_thread_ids()
self.assertEqual(2, len(w2t["a"]))
self.assertLessEqual(4, len(w2t["b"]))
def test_forecast_ip_big_burst_pool_if_empty_instance(self):
cpu = get_cpu()
allocator = forecast_ip_alloc_simple
w = get_test_workload("a", 1, BURST)
request = AllocateThreadsRequest(cpu, "a", {"a": w}, {},
DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.assign_threads(request).get_cpu()
original_burst_claim_sz = len(cpu.get_claimed_threads())
# should at least consume all the cores:
self.assertLessEqual(
len(cpu.get_threads()) / 2, original_burst_claim_sz)
w2 = get_test_workload("b", 3, STATIC)
request = AllocateThreadsRequest(cpu, "b", {
"a": w,
"b": w2
}, {}, DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.assign_threads(request).get_cpu()
new_burst_claim_sz = len(get_threads_with_workload(cpu, w2.get_id()))
self.assertLess(new_burst_claim_sz, original_burst_claim_sz)
total_claim_sz = len(cpu.get_claimed_threads())
self.assertLessEqual(3 + 1, total_claim_sz)
self.assertLessEqual(1, new_burst_claim_sz)
# there shouldn't be an empty core
for p in cpu.get_packages():
for c in p.get_cores():
self.assertLess(0,
sum(t.is_claimed() for t in c.get_threads()))
request = AllocateThreadsRequest(cpu, "b", {
"a": w,
"b": w2
}, {}, DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.free_threads(request).get_cpu()
request = AllocateRequest(cpu, {"a": w}, {},
DEFAULT_TEST_REQUEST_METADATA)
cpu = allocator.rebalance(request).get_cpu()
self.assertEqual(original_burst_claim_sz,
len(cpu.get_claimed_threads()))
def __get_rebalance_request(self):
return AllocateRequest(
self.get_cpu_copy(),
self.get_workload_map_copy(),
self.__get_cpu_usage(),
self.__get_request_metadata("rebalance"))