def assign(opt_type, physical, flavors):
CPU, MEM = physical[0], physical[1]
fs = []
for f in flavors:
for i in range(f.num):
fs.append(Flavor(f.name, f.cpu, f.mem))
if opt_type == "CPU":
fs.sort(key=lambda x: (-x.cpu, -x.mem))
else:
fs.sort(key=lambda x: (-x.mem, -x.cpu))
number = 0
plan = dict()
while fs:
number += 1
plan[number] = dict()
n = len(fs)
# print n
label = [1] * n # 表示某台虚拟机还未被分配
if opt_type == "CPU":
C, M, K, dp = dp_cpu(CPU, MEM, fs)
# print dp[M][K][0]
for k in range(K, 0, -1):
if dp[M][k][0] != dp[M][k - 1][0]:
f = fs[k - 1]
label[k - 1] = 0
M -= f.mem
if f.name in plan[number]:
plan[number][f.name] += 1
else:
plan[number][f.name] = 1
fs = [f for i, f in zip(label, fs) if i]
else:
C, M, K, dp = dp_mem(CPU, MEM, fs)
# print dp[C][K][0]
for k in range(K, 0, -1):
if dp[C][k] != dp[C][k - 1]:
f = fs[k - 1]
label[k - 1] = 0
C -= f.cpu
if f.name in plan[number]:
plan[number][f.name] += 1
else:
plan[number][f.name] = 1
fs = [f for i, f in zip(label, fs) if i]
result = [number]
for i in plan:
tmp = "{} ".format(i)
for k, v in sorted(plan[i].items()):
tmp += "{} {} ".format(k, v)
result.append(tmp)
return result
def get_flavor(s):
name, n = s.strip().split(":")
n = int(n)
f_id = int(name[6:])
cpu = 2 ** ((f_id - 1) / 3)
tmp = f_id % 3
if tmp == 0:
mem = cpu * 4
elif tmp == 1:
mem = cpu
else:
mem = cpu * 2
return Flavor(name, cpu, mem, n)
def assign(opt_type, physical, flavors):
CPU, MEM = physical[0], physical[1]
fs = []
for f in flavors:
for i in range(f.num):
fs.append(Flavor(f.name, f.cpu, f.mem))
number = 0
plan = dict()
while fs:
number += 1
plan[number] = dict()
n = len(fs)
dp = [[[0 for k in range(n + 1)] for j in range(MEM + 1)]
for i in range(CPU + 1)]
for i in range(1, CPU + 1):
for j in range(1, MEM + 1):
for k in range(1, n + 1):
f = fs[k - 1]
v = f.cpu if opt_type == "CPU" else f.mem
if i >= f.cpu and j >= f.mem:
dp[i][j][k] = max(dp[i - f.cpu][j - f.mem][k - 1] + v,
dp[i][j][k - 1])
else:
dp[i][j][k] = dp[i][j][k - 1]
# 恢复选择项
C, M = CPU, MEM
label = [1] * n
for k in range(n, 0, -1):
if dp[C][M][k] != dp[C][M][k - 1]:
f = fs[k - 1]
label[k - 1] = 0
C -= f.cpu
M -= f.mem
if f.name in plan[number]:
plan[number][f.name] += 1
else:
plan[number][f.name] = 1
fs = [f for i, f in zip(label, fs) if i]
print(CPU - C) * 1.0 / CPU, (MEM - M) * 1.0 / MEM # 打印利用率
result = [number]
for i in plan:
tmp = "{} ".format(i)
for k, v in sorted(plan[i].items()):
tmp += "{} {} ".format(k, v)
result.append(tmp)
return result
def assign(opt_type, physical, flavors):
CPU, MEM = physical[0], physical[1]
fs, plan = [], []
totalCPU, totalMEM = 0, 0
for f in flavors:
for i in range(f.num):
fs.append(Flavor(f.name, f.cpu, f.mem))
plan.append(-1)
totalCPU += f.cpu
totalMEM += f.mem
pnum = max((totalCPU + CPU - 1) / CPU, (totalMEM + MEM - 1) / MEM)
pcpu = [CPU for j in range(pnum)]
pmem = [MEM for j in range(pnum)]
res = [[] for j in range(pnum)]
def put(i):
if i == len(fs):
for k in range(len(plan)):
res[plan[k]].append(fs[k].id)
return True
for j in range(pnum):
if fs[i].cpu <= pcpu[j] and fs[i].mem <= pmem[j]:
plan[i] = j
pcpu[j] -= fs[i].cpu
pmem[j] -= fs[i].mem
if put(i + 1):
return True
pcpu[j] += fs[i].cpu
pmem[j] += fs[i].mem
plan[i] = -1
return False
put(0)
while (len(res) == 0):
pnum += 1
pcpu.append(CPU)
pmem.append(MEM)
put(0)
result = [pnum]
for j in range(pnum):
tmp = "{}".format(j + 1)
rset = set(res[j])
for item in rset:
tmp += " flavor{} {}".format(item, res[j].count(item))
result.append(tmp)
return result
def predict_vm(ecs_lines, input_lines):
# flavor种类数量
flavor_num = int(input_lines[2].strip())
fs = []
for l in input_lines[3:3 + flavor_num]:
f, cpu, mem = l.strip().split()
fl = Flavor(f, cpu, int(mem) / 1024)
fs.append(fl)
start = datetime.datetime.strptime(input_lines[6 + flavor_num].strip(),
"%Y-%m-%d %H:%M:%S")
end = datetime.datetime.strptime(input_lines[7 + flavor_num].strip(),
"%Y-%m-%d %H:%M:%S")
opt_type = input_lines[4 + flavor_num].strip()
# 替换预测方式，在import中修改
fd = pred.predict(ecs_lines, start, end, [f.name for f in fs])
for f in fs:
f.num = fd[f.name]
result = [sum(fd.values())]
for f in fs:
result.append("{} {}".format(f.name, f.num))
result.append("")
physical = [int(i) for i in input_lines[0].strip().split()]
fs = [f for f in fs if f.num > 0]
# 替换分配方式，在import中修改
result += alloc.assign(opt_type, physical, fs)
return result
C, M = CPU, MEM
for k in range(n, 0, -1):
if dp[C][M][k] != dp[C][M][k - 1]:
f = fs.pop(k - 1)
C -= f.cpu
M -= f.mem
if f.name in plan[number]:
plan[number][f.name] += 1
else:
plan[number][f.name] = 1
pass
print(CPU - C) * 1.0 / CPU, (MEM - M) * 1.0 / MEM # 打印利用率
result = [number]
for i in plan:
tmp = "{} ".format(i)
for k, v in sorted(plan[i].items()):
tmp += "{} {} ".format(k, v)
result.append(tmp)
return result
if __name__ == "__main__":
assign("CPU", (7, 16), [
Flavor("flavor1", 1, 1, 1),
Flavor("flavor2", 1, 2, 3),
Flavor("flavor3", 1, 4, 4),
Flavor("flavor4", 1, 2, 2),
Flavor("flavor5", 1, 2, 4),
])