def getInitialPopulation(sr, rbsc, populationSize, delta=0.000000001):
m = np.size(sr, 0)
n = np.size(rbsc, 0)
chromosomes_list = []
####################################################################################
cost, rbsc_realtime, solution = greedy_resource.greedy_min_cost(
sr, rbsc, delta)
if check(sr, rbsc, solution):
chromosomes_list.append(solution)
populationSize -= 1
cost, rbsc_realtime, solution = greedy.greedy_min_cost(sr, rbsc, delta)
if check(sr, rbsc, solution):
chromosomes_list.append(solution)
populationSize -= 1
cost, rbsc_realtime, solution = greedy_down_bandwidth.greedy_min_down_bandwidth_cost(
sr, rbsc, delta)
if check(sr, rbsc, solution):
chromosomes_list.append(solution)
populationSize -= 1
cost, rbsc_realtime, solution = greedy_up_bandwidth.greedy_min_up_bandwidth_cost(
sr, rbsc, delta)
if check(sr, rbsc, solution):
chromosomes_list.append(solution)
populationSize -= 1
cost, rbsc_realtime, solution = greedy_computing.greedy_min_compute_cost(
sr, rbsc, delta)
if check(sr, rbsc, solution):
chromosomes_list.append(solution)
populationSize -= 1
####################################################################################
for i in range(populationSize):
# 随机产生一个染色体
chromosome = np.zeros((m, n), dtype=int)
rbsc_realtime = np.array(rbsc)
# flag_of_matrix = 1
# 产生一个染色体矩阵中的其中一行
l = np.arange(m)
if i != 0:
np.random.shuffle(l)
else:
l = l[::-1]
for j in l:
min_cost_j = sys.maxsize
min_bs_j = -1
for bs_of_select in range(n):
if sr[j][0] < rbsc_realtime[bs_of_select][0] and sr[j][
1] < rbsc_realtime[bs_of_select][1] and sr[j][
2] < rbsc_realtime[bs_of_select][2]:
if (sr[j][0] / rbsc_realtime[bs_of_select][0] + sr[j][1] <
rbsc_realtime[bs_of_select][1] + sr[j][2] /
rbsc_realtime[bs_of_select][2]) < min_cost_j:
min_cost_j = sr[j][0] / rbsc_realtime[bs_of_select][
0] + sr[j][1] + rbsc_realtime[bs_of_select][
1] + sr[j][2] / rbsc_realtime[bs_of_select][2]
min_bs_j = bs_of_select
if min_bs_j != -1:
chromosome[j][min_bs_j] = 1
rbsc_realtime[min_bs_j][0] -= sr[j][0]
rbsc_realtime[min_bs_j][1] -= sr[j][1]
rbsc_realtime[min_bs_j][2] -= sr[j][2]
# 将产生的染色体加入到chromosomes_list中
chromosomes_list.append(chromosome)
chromosomes = np.array(chromosomes_list)
return chromosomes
def simu(request_num=15, req_num_eachtime=4, sigma=500000, max_iter=1, bs_num=6):
# bs_num = 6
# BSC：base station capacity
# RBSC: residuary base station capacity
# SR: slice request
# max_iter = 1 # ------------------------
delta = 0.000000001
pc = 0.8
pm = 0.01
# req_num_eachtime = 4
# 构造request_num次请求
# request_num = 15 # --------------------------
values = np.zeros((request_num), dtype=np.float)
solutions = []
sr_all = []
rbscs = []
# 每轮处理请求失败的切片请求数，fails[0]是遗传、fails[1]是贪心总代价、fails[2]是贪心下行带宽、fails[3]是贪心上行带宽、fails[4]是贪心计算资源
fails = np.zeros((7, request_num))
# 记录7中算法每次迭代得到下行，上行，计算，总代价
cost_result = np.zeros((7, request_num, 4), dtype=np.float)
resource_used_radio = np.zeros((7, bs_num, 3), dtype=np.float)
time_resouce_used = request_num - 1
# sigma = 50000
# 构造m个切片请求
m = req_num_eachtime * request_num
sr_total = np.zeros((m, 3), dtype=np.float)
for i in range(m):
s = np.abs(np.random.normal(1000, sigma, 3))
s = 1.5 * s / (sum(s))
sr_total[i] = s
for iter in range(request_num):
# 随机构造每次请求的切片数
m = (iter + 1) * req_num_eachtime
# 构造基站资源
rbsc = getRbsc(bs_num)
total_rbsc = np.sum(rbsc, 0) # 求每列之和，得到1*3向量，分别表示下行，上行，计算资源总量
# 构造m个切片请求
sr = np.zeros((m, 3), dtype=np.float)
for i in range(m):
s = sr_total[i]
sr[i] = s
rbscs.append(rbsc)
print("rbsc:")
print(rbsc)
print("sr:")
print(sr)
sr_all.append(sr) # 记录请求，为其他算法提供相同的请求环境
populationSize = min(50, m * bs_num)
solution, value = ga(sr, rbsc, max_iter, delta, pc, pm, populationSize)
# 资源紧张的时候，采用greedy算法，得到可以满足的情况
while solution == "failed" and np.size(sr, 0) >= 2:
cost, rbsc_r, solution = greedy.greedy_min_cost(sr, rbsc, delta)
x1 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_resource.greedy_min_cost(sr, rbsc, delta)
x2 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_down_bandwidth.greedy_min_down_bandwidth_cost(sr, rbsc, delta)
x3 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_up_bandwidth.greedy_min_up_bandwidth_cost(sr, rbsc, delta)
x4 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_computing.greedy_min_compute_cost(sr, rbsc, delta)
x5 = np.sum(solution, 1) # 求每行之和
XX = np.array((x1, x2, x3, x4, x5))
X = np.array((np.sum(x1), np.sum(x2), np.sum(x3), np.sum(x4), np.sum(x5)))
x = np.max(X)
if x == 0:
solution == "failed"
value = 0
sr = np.array([])
break
index = np.where(X == x)
x = XX[index[0][0]]
sr_list = []
for s in range(np.size(x)):
if x[s] == 1:
sr_list.append(sr[s])
sr = np.array(sr_list)
solution, value = ga(sr, rbsc, max_iter, delta, pc, pm, populationSize)
# 记录失败数目
fails[0][iter] = np.size(sr_all[iter], 0) - np.sum(np.sum(solution))
print('最优目标函数值:', value)
values[iter] = value
print('solution:')
print(solution)
##############################
# 持久化结果
fit = getFitnessValue(sr, rbsc, [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[0][iter][0] = fit[0, 0]
cost_result[0][iter][1] = fit[0, 1]
cost_result[0][iter][2] = fit[0, 2]
cost_result[0][iter][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
##############################
solutions.append(np.copy(solution))
if iter == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[0][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("ga总结果")
print(values)
# print(rbsc)
###########################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy.greedy_min_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[1][i][0] = fit[0, 0]
cost_result[1][i][1] = fit[0, 1]
cost_result[1][i][2] = fit[0, 2]
cost_result[1][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
##############################
# 记录失败数
fails[1][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[1][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("greedy_min_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
# cost, rbsc, solution = greedy_down_bandwidth.greedy_min_down_bandwidth_cost(sr, rbsc, delta)
cost, rbsc, solution = greedy_bandwidth.greedy_min_bandwidth_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[2][i][0] = fit[0, 0]
cost_result[2][i][1] = fit[0, 1]
cost_result[2][i][2] = fit[0, 2]
cost_result[2][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
##############################
# 记录失败数
fails[2][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[2][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("greedy_min_bandwidth_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_up_bandwidth.greedy_min_up_bandwidth_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[3][i][0] = fit[0, 0]
cost_result[3][i][1] = fit[0, 1]
cost_result[3][i][2] = fit[0, 2]
cost_result[3][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
##############################
# 记录失败数
fails[3][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[3][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("greedy_min_up_bandwidth_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_computing.greedy_min_compute_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[4][i][0] = fit[0, 0]
cost_result[4][i][1] = fit[0, 1]
cost_result[4][i][2] = fit[0, 2]
cost_result[4][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
##############################
# 记录失败数
fails[4][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0))
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[4][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("greedy_min_compute_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_resource.greedy_min_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[5][i][0] = fit[0, 0]
cost_result[5][i][1] = fit[0, 1]
cost_result[5][i][2] = fit[0, 2]
cost_result[5][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
# 记录失败数
fails[5][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[5][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("greedy_min_max_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = random_select.random_select(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[6][i][0] = fit[0, 0]
cost_result[6][i][1] = fit[0, 1]
cost_result[6][i][2] = fit[0, 2]
cost_result[6][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
# 记录失败数
fails[6][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
if i == time_resouce_used:
rbsc_init = getRbsc(bs_num)
rbsc = update_rbsc(sr, rbsc_init, solution)
for bs in range(bs_num):
for resource_type in range(3):
resource_used_radio[6][bs][resource_type] = rbsc[bs][resource_type] / rbsc_init[bs][resource_type]
print("random总结果")
print(values)
##############################################################################################################
print(fails)
return cost_result, fails, resource_used_radio
def simu(request_num=15, req_num_eachtime=4, sigma=50000, max_iter=1):
bs_num = 6
# BSC：base station capacity
# RBSC: residuary base station capacity
# SR: slice request
max_iter = 1 # ------------------------
delta = 0.000000001
pc = 0.8
pm = 0.01
# req_num_eachtime = 4
# 构造request_num次请求
# request_num = 15 # --------------------------
values = np.zeros((request_num), dtype=np.float)
solutions = []
sr_all = []
rbscs = []
# 每轮处理请求失败的切片请求数，fails[0]是遗传、fails[1]是贪心总代价、fails[2]是贪心下行带宽、fails[3]是贪心上行带宽、fails[4]是贪心计算资源
fails = np.zeros((7, request_num))
# 记录7中算法每次迭代得到下行，上行，计算，总代价
cost_result = np.zeros((7, request_num, 4), dtype=np.float)
# sigma = 50000
# 构造m个切片请求
m = req_num_eachtime * request_num
sr_total = np.zeros((m, 3), dtype=np.float)
for i in range(m):
s = np.abs(np.random.normal(100, sigma, 3)) + 1
s = s / (sum(s))
sr_total[i] = s
for iter in range(request_num):
print('iter')
print(iter)
# 随机构造每次请求的切片数
m = (iter + 1) * req_num_eachtime
# 构造基站资源
rbsc = getRbsc(bs_num)
total_rbsc = np.sum(rbsc, 0) # 求每列之和，得到1*3向量，分别表示下行，上行，计算资源总量
# 构造m个切片请求
sr = np.zeros((m, 3), dtype=np.float)
for i in range(m):
s = sr_total[i]
sr[i] = s
rbscs.append(rbsc)
print("rbsc:")
print(rbsc)
print("sr:")
print(sr)
sr_all.append(sr) # 记录请求，为其他算法提供相同的请求环境
populationSize = min(m * bs_num, 50)
solution, value = ga(sr, rbsc, max_iter, delta, pc, pm, populationSize)
# 资源紧张的时候，采用greedy算法，得到可以满足的情况
while solution == "failed" and np.size(sr, 0) >= 2:
cost, rbsc_r, solution = greedy.greedy_min_cost(sr, rbsc, delta)
x1 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_resource.greedy_min_cost(
sr, rbsc, delta)
x2 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_down_bandwidth.greedy_min_down_bandwidth_cost(
sr, rbsc, delta)
x3 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_up_bandwidth.greedy_min_up_bandwidth_cost(
sr, rbsc, delta)
x4 = np.sum(solution, 1) # 求每行之和
cost, rbsc_r, solution = greedy_computing.greedy_min_compute_cost(
sr, rbsc, delta)
x5 = np.sum(solution, 1) # 求每行之和
XX = np.array((x1, x2, x3, x4, x5))
X = np.array(
(np.sum(x1), np.sum(x2), np.sum(x3), np.sum(x4), np.sum(x5)))
x = np.max(X)
if x == 0:
solution == "failed"
value = 0
sr = np.array([])
break
index = np.where(X == x)
x = XX[index[0][0]]
sr_list = []
for s in range(np.size(x)):
if x[s] == 1:
sr_list.append(sr[s])
sr = np.array(sr_list)
solution, value = ga(sr, rbsc, max_iter, delta, pc, pm,
populationSize)
# 记录失败数目
fails[0][iter] = np.size(sr_all[iter], 0) - np.sum(np.sum(solution))
print('最优目标函数值:', value)
values[iter] = value
print('solution:')
print(solution)
##############################
# 持久化结果
fit = getFitnessValue(sr, rbsc, [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[0][iter][0] = fit[0, 0]
cost_result[0][iter][1] = fit[0, 1]
cost_result[0][iter][2] = fit[0, 2]
cost_result[0][iter][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {iter: o}
# json.dump(result, fp1)
##############################
solutions.append(np.copy(solution))
# rbsc = update_rbsc(sr, rbsc, solution)
print("ga总结果")
print(values)
# print(rbsc)
###########################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy.greedy_min_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[1][i][0] = fit[0, 0]
cost_result[1][i][1] = fit[0, 1]
cost_result[1][i][2] = fit[0, 2]
cost_result[1][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
##############################
# 记录失败数
fails[1][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
print("greedy_min_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
# cost, rbsc, solution = greedy_down_bandwidth.greedy_min_down_bandwidth_cost(sr, rbsc, delta)
cost, rbsc, solution = greedy_bandwidth.greedy_min_bandwidth_cost(
sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[2][i][0] = fit[0, 0]
cost_result[2][i][1] = fit[0, 1]
cost_result[2][i][2] = fit[0, 2]
cost_result[2][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
##############################
# 记录失败数
fails[2][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
print("greedy_min_bandwidth_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_up_bandwidth.greedy_min_up_bandwidth_cost(
sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[3][i][0] = fit[0, 0]
cost_result[3][i][1] = fit[0, 1]
cost_result[3][i][2] = fit[0, 2]
cost_result[3][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
##############################
# 记录失败数
fails[3][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
print("greedy_min_up_bandwidth_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_computing.greedy_min_compute_cost(
sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[4][i][0] = fit[0, 0]
cost_result[4][i][1] = fit[0, 1]
cost_result[4][i][2] = fit[0, 2]
cost_result[4][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
##############################
# 记录失败数
fails[4][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0))
print("greedy_min_compute_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = greedy_resource.greedy_min_cost(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[5][i][0] = fit[0, 0]
cost_result[5][i][1] = fit[0, 1]
cost_result[5][i][2] = fit[0, 2]
cost_result[5][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
# 记录失败数
fails[5][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
print("greedy_min_max_cost总结果")
print(values)
##############################################################################################################
for i in range(request_num):
sr = sr_all[i]
rbsc = rbscs[i]
cost, rbsc, solution = random_select.random_select(sr, rbsc, delta)
values[i] = cost
##############################
# 持久化结果
fit = getFitnessValue(sr, rbscs[i], [solution], delta)
o = [fit[0, 0], fit[0, 1], fit[0, 2], fit[0, 3]]
cost_result[6][i][0] = fit[0, 0]
cost_result[6][i][1] = fit[0, 1]
cost_result[6][i][2] = fit[0, 2]
cost_result[6][i][3] = fit[0, 0] + fit[0, 1] + fit[0, 2]
result = {i: o}
# 记录失败数
fails[6][i] = np.size(sr, 0) - np.sum(np.sum(solution, 0), 0)
print("random总结果")
print(values)
##############################################################################################################
print(fails)
# nowtime = (lambda: int(round(time.time() * 1000)))
# nowtime = nowtime()
# print(cost_result[:, :, 0])
# print(cost_result[:, :, 1])
# print(cost_result[:, :, 2])
# print(cost_result[:, :, 3])
# pt.plot_fun_slot(cost_result[:, :, 0], fails, req_num_eachtime, '切片请求数量（个）', '平均下行带宽映射代价',
# str(nowtime) + '下行带宽映射代价' + '_' + str(sigma))
# pt.plot_fun_slot(cost_result[:, :, 1], fails, req_num_eachtime, '切片请求数量（个）', '平均上行带宽映射代价',
# str(nowtime) + '上行带宽映射代价' + '_' + str(sigma))
# pt.plot_fun_slot(cost_result[:, :, 2], fails, req_num_eachtime, '切片请求数量（个）', '平均计算资源映射代价',
# str(nowtime) + '计算资源映射代价' + '_' + str(sigma))
# pt.plot_fun_slot(cost_result[:, :, 3], fails, req_num_eachtime, '切片请求数量（个）', '平均总映射代价',
# str(nowtime) + '总映射代价' + '_' + str(sigma))
# pt.plot_fun_fail_slot(fails, req_num_eachtime, '切片请求数量（个）', '失败率（%）', str(nowtime) + '失败率' + '_' + str(sigma))
return cost_result, fails