def csv_fat_cross_time(arrival_enum: ArrivalEnum,
list_number_servers: List[int],
perform_param: PerformParameter, opt_method: OptMethod,
mc_dist: MonteCarloDist, target_util: float) -> dict:
"""Chooses parameters by Monte Carlo type random choice."""
total_iterations = 10**5
time_ratio = {"Number_of_servers": "Ratio"}
for number_servers in list_number_servers:
print(f"number of servers = {number_servers}")
# 1 Parameter for service
param_array = mc_enum_to_dist(arrival_enum=arrival_enum,
mc_dist=mc_dist,
number_flows=number_servers,
number_servers=number_servers,
total_iterations=total_iterations)
time_array = np.empty([total_iterations, 2])
for i in tqdm(range(total_iterations)):
if arrival_enum == ArrivalEnum.DM1:
arrive_list = [
DM1(lamb=param_array[i, j]) for j in range(number_servers)
]
elif arrival_enum == ArrivalEnum.MMOOFluid:
arrive_list = [
MMOOCont(mu=param_array[i, j],
lamb=param_array[i, number_servers + j],
peak_rate=param_array[i, 2 * number_servers + j])
for j in range(number_servers)
]
else:
raise NotImplementedError(f"Arrival parameter "
f"{arrival_enum.name} is infeasible")
service_list = [
ConstantRateServer(
rate=param_array[i,
arrival_enum.number_parameters() *
number_servers + j])
for j in range(number_servers)
]
fat_cross_setting = FatCrossPerform(arr_list=arrive_list,
ser_list=service_list,
perform_param=perform_param)
computation_necessary = True
# print(res_array[i, ])
if target_util > 0.0:
util = fat_cross_setting.approximate_utilization()
if util < target_util or util > 1:
time_array[i, ] = np.nan
computation_necessary = False
if computation_necessary:
# time_standard, time_lyapunov = compare_time()
time_array[i, 0], time_array[i, 1] = compare_time(
setting=fat_cross_setting,
opt_method=opt_method,
number_l=number_servers - 1)
print(
time_array_to_results(arrival_enum=arrival_enum,
time_array=time_array,
number_servers=number_servers,
time_ratio=time_ratio))
filename = (f"time_{perform_param.to_name()}_{arrival_enum.name}"
f"_{opt_method.name}.csv")
with open(filename, 'w') as csv_file:
writer = csv.writer(csv_file)
for key, value in time_ratio.items():
writer.writerow([key, value])
return time_ratio
def csv_msob_fp_time(name: str, number_flows: int, number_servers: int,
arrival_enum: ArrivalEnum,
perform_param: PerformParameter, opt_method: OptMethod,
mc_dist: MonteCarloDist, comparator: callable,
total_iterations: int, target_util: float) -> dict:
"""Chooses parameters by Monte Carlo type random choice."""
param_array = mc_enum_to_dist(arrival_enum=arrival_enum,
mc_dist=mc_dist,
number_flows=number_flows,
number_servers=number_servers,
total_iterations=total_iterations)
time_array = np.empty([total_iterations, 3])
# 3 approaches to compare
for i in tqdm(range(total_iterations), total=total_iterations):
if arrival_enum == ArrivalEnum.DM1:
arr_list = [
DM1(lamb=param_array[i, j]) for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MD1:
arr_list = [
MD1(lamb=param_array[i, j], mu=1.0)
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOODisc:
arr_list = [
MMOODisc(stay_on=param_array[i, j],
stay_off=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOOFluid:
arr_list = [
MMOOCont(mu=param_array[i, j],
lamb=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
else:
raise NotImplementedError(f"Arrival parameter {arrival_enum.name} "
f"is infeasible")
ser_list = [
ConstantRateServer(
rate=param_array[i,
arrival_enum.number_parameters() *
number_flows + j])
for j in range(number_servers)
]
if name == "overlapping_tandem":
setting = OverlappingTandemPerform(arr_list=arr_list,
ser_list=ser_list,
perform_param=perform_param)
elif name == "square":
setting = SquarePerform(arr_list=arr_list,
ser_list=ser_list,
perform_param=perform_param)
else:
raise NotImplementedError("this topology is not implemented")
computation_necessary = True
if target_util > 0.0:
util = setting.approximate_utilization()
if util < target_util or util > 1:
time_array[i, ] = np.nan
computation_necessary = False
if computation_necessary:
# standard_bound, server_bound, fp_bound = compare_avoid_dep()
time_array[i, 0], time_array[i, 1], time_array[i, 2] = comparator(
setting=setting)
if (perform_param.perform_metric == PerformEnum.DELAY_PROB
and np.nanmin(time_array[i, ]) > 1.0):
# np.nanmin(time_array[i, ]) is the smallest value
time_array[i, ] = np.nan
time_dict = time_array_to_results(title=name, time_array=time_array)
time_dict.update({
"iterations": total_iterations,
"T": perform_param.value,
"optimization": opt_method.name,
"MCDistribution": mc_dist.to_name(),
"MCParam": mc_dist.param_to_string()
})
filename = name
filename += f"_time_{perform_param.to_name()}_{arrival_enum.name}" \
f"_MC{mc_dist.to_name()}_{opt_method.name}_util_{target_util}"
with open(filename + ".csv", 'w') as csv_file:
writer = csv.writer(csv_file)
for key, value in time_dict.items():
writer.writerow([key, value])
return time_dict
# DM1(lamb=4.5),
# DM1(lamb=0.28)]],
# ser_list=[
# ConstantRateServer(rate=1.2),
# ConstantRateServer(rate=6.2),
# ConstantRateServer(rate=7.3)
# ],
# server_index=1,
# perform_param=DELAY3))
print(
arrival_list_to_csv(
prefix="overlapping_tandem_",
data_frame_creator=overlapping_tandem_adjust_arr_df,
list_arr_list=[[
MMOOCont(mu=0.8, lamb=7.0, peak_rate=2.0),
MMOOCont(mu=4.0, lamb=8.5, peak_rate=5.3),
MMOOCont(mu=0.5, lamb=6.0, peak_rate=9.0)
],
[
MMOOCont(mu=0.8, lamb=7.0, peak_rate=2.0),
MMOOCont(mu=4.0, lamb=8.5, peak_rate=5.3),
MMOOCont(mu=0.5, lamb=5.0, peak_rate=9.0)
],
[
MMOOCont(mu=0.8, lamb=7.0, peak_rate=2.0),
MMOOCont(mu=4.0, lamb=8.5, peak_rate=5.3),
MMOOCont(mu=0.5, lamb=4.0, peak_rate=9.0)
],
[
MMOOCont(mu=0.8, lamb=7.0, peak_rate=2.0),
data_frame_creator=overlapping_tandem_df,
arr_list=[DM1(lamb=2.0),
DM1(lamb=2.4),
DM1(lamb=5.3)],
ser_list=[
ConstantRateServer(rate=4.3),
ConstantRateServer(rate=2.1),
ConstantRateServer(rate=5.8)
],
perform_param_list=DELAY_LIST))
print(
perform_param_list_to_csv(prefix="overlapping_tandem_",
data_frame_creator=overlapping_tandem_df,
arr_list=[
MMOOCont(mu=7.3, lamb=3.4,
peak_rate=1.2),
MMOOCont(mu=1.5, lamb=3.6,
peak_rate=8.2),
MMOOCont(mu=1.3, lamb=1.1, peak_rate=0.4)
],
ser_list=[
ConstantRateServer(rate=9.0),
ConstantRateServer(rate=4.1),
ConstantRateServer(rate=4.7)
],
perform_param_list=DELAY_LIST))
print(
perform_param_list_to_csv(prefix="overlapping_tandem_",
data_frame_creator=overlapping_tandem_df,
arr_list=[
def csv_msob_fp_param(name: str,
number_flows: int,
number_servers: int,
arrival_enum: ArrivalEnum,
perform_param: PerformParameter,
opt_method: OptMethod,
mc_dist: MonteCarloDist,
comparator: callable,
compare_metric: ChangeEnum,
total_iterations: int,
target_util: float,
filter_standard_inf=False) -> dict:
"""Chooses parameters by Monte Carlo type random choice."""
param_array = mc_enum_to_dist(arrival_enum=arrival_enum,
mc_dist=mc_dist,
number_flows=number_flows,
number_servers=number_servers,
total_iterations=total_iterations)
res_array = np.empty([total_iterations, 3])
# 3 approaches to compare
for i in tqdm(range(total_iterations), total=total_iterations):
if arrival_enum == ArrivalEnum.DM1:
arr_list = [
DM1(lamb=param_array[i, j]) for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.DGamma1:
arr_list = [
DGamma1(alpha_shape=param_array[i, j],
beta_rate=param_array[i, number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.DWeibull1:
arr_list = [
DWeibull1(lamb=param_array[i, j]) for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MD1:
arr_list = [
MD1(lamb=param_array[i, j], mu=1.0)
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOODisc:
arr_list = [
MMOODisc(stay_on=param_array[i, j],
stay_off=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOOFluid:
arr_list = [
MMOOCont(mu=param_array[i, j],
lamb=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
else:
raise NotImplementedError(f"Arrival parameter {arrival_enum.name} "
f"is infeasible")
ser_list = [
ConstantRateServer(
rate=param_array[i,
arrival_enum.number_parameters() *
number_flows + j])
for j in range(number_servers)
]
if name == "overlapping_tandem":
setting = OverlappingTandemPerform(arr_list=arr_list,
ser_list=ser_list,
perform_param=perform_param)
elif name == "square":
setting = SquarePerform(arr_list=arr_list,
ser_list=ser_list,
perform_param=perform_param)
else:
raise NotImplementedError("this topology is not implemented")
computation_necessary = True
if target_util > 0.0:
util = setting.approximate_utilization()
if util < target_util or util > 1:
res_array[i, ] = np.nan
computation_necessary = False
if computation_necessary:
# standard_bound, server_bound, fp_bound = compare_avoid_dep()
res_array[i, 0], res_array[i, 1], res_array[i, 2] = comparator(
setting=setting)
if (perform_param.perform_metric == PerformEnum.DELAY_PROB
and np.nanmin(res_array[i, ]) > 1.0):
# np.nanmin(res_array[i, ]) is the smallest value
res_array[i, ] = np.nan
elif np.nanmin(res_array[i, ]) == inf:
res_array[i, ] = np.nan
if filter_standard_inf and res_array[i, 0] == inf:
res_array[i, ] = np.nan
res_array_no_full_nan = remove_full_nan_rows(full_array=res_array)
valid_iterations = res_array_no_full_nan.shape[0]
if valid_iterations < total_iterations * 0.2:
warn(f"Many nan's: {total_iterations - valid_iterations} nans "
f"out of {total_iterations}!")
if valid_iterations < 100:
raise NotEnoughResults("result is useless")
res_name = name
res_name += f"_res_array_{perform_param.to_name()}_" \
f"{arrival_enum.name}_validiter_{valid_iterations}"
if filter_standard_inf:
res_name += "_filter_standard_inf"
np.savetxt(fname=res_name + ".csv", X=res_array_no_full_nan, delimiter=",")
res_dict = msob_fp_array_to_results(title=name,
arrival_enum=arrival_enum,
perform_param=perform_param,
opt_method=opt_method,
mc_dist=mc_dist,
param_array=param_array,
res_array=res_array,
number_flows=number_flows,
number_servers=number_servers,
compare_metric=compare_metric)
res_dict.update({
"iterations": total_iterations,
"target_util": target_util,
"T": perform_param.value,
"optimization": opt_method.name,
"compare_metric": compare_metric.name,
"MCDistribution": mc_dist.to_name(),
"MCParam": mc_dist.param_to_string()
})
filename = name
filename += f"_results_{perform_param.to_name()}_{arrival_enum.name}_" \
f"MC{mc_dist.to_name()}_{opt_method.name}_" \
f"{compare_metric.name}_util_{target_util}"
if filter_standard_inf:
filename += "_filter_standard_inf"
with open(filename + ".csv", 'w') as csv_file:
writer = csv.writer(csv_file)
for key, value in res_dict.items():
writer.writerow([key, value])
return res_dict
# lamb=1.3,
# peak_rate=0.7)
# ],
# ser_list=[
# ConstantRateServer(rate=5.0),
# ConstantRateServer(rate=6.5),
# ConstantRateServer(rate=9.1),
# ConstantRateServer(rate=9.9)
# ],
# perform_param_list=DELAY_LIST))
print(
perform_param_list_to_csv(prefix="square_",
data_frame_creator=square_df,
arr_list=[
MMOOCont(mu=7.2, lamb=4.8,
peak_rate=4.9),
MMOOCont(mu=2.5, lamb=2.1,
peak_rate=3.7),
MMOOCont(mu=4.1, lamb=3.1,
peak_rate=1.3),
MMOOCont(mu=3.3, lamb=3.3, peak_rate=1.7)
],
ser_list=[
ConstantRateServer(rate=5.2),
ConstantRateServer(rate=6.5),
ConstantRateServer(rate=9.9),
ConstantRateServer(rate=3.0)
],
perform_param_list=DELAY_LIST))
def csv_fat_cross_param_power(name: str, arrival_enum: ArrivalEnum,
number_flows: int, number_servers: int,
perform_param: PerformParameter,
opt_method: OptMethod, mc_dist: MonteCarloDist,
compare_metric: ChangeEnum,
total_iterations: int,
target_util: float) -> dict:
"""Chooses parameters by Monte Carlo type random choice."""
param_array = mc_enum_to_dist(arrival_enum=arrival_enum,
mc_dist=mc_dist,
number_flows=number_flows,
number_servers=number_servers,
total_iterations=total_iterations)
res_array = np.empty([total_iterations, 2])
# print(res_array)
for i in tqdm(range(total_iterations), total=total_iterations):
if arrival_enum == ArrivalEnum.DM1:
arr_list = [
DM1(lamb=param_array[i, j]) for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.DGamma1:
arr_list = [
DGamma1(alpha_shape=param_array[i, j],
beta_rate=param_array[i, number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.DWeibull1:
arr_list = [
DWeibull1(lamb=param_array[i, j]) for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MD1:
arr_list = [
MD1(lamb=param_array[i, j], mu=1.0)
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOODisc:
arr_list = [
MMOODisc(stay_on=param_array[i, j],
stay_off=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.MMOOFluid:
arr_list = [
MMOOCont(mu=param_array[i, j],
lamb=param_array[i, number_flows + j],
peak_rate=param_array[i, 2 * number_flows + j])
for j in range(number_flows)
]
elif arrival_enum == ArrivalEnum.Massoulie:
arr_list = [
LeakyBucketMassoulie(sigma_single=param_array[i, j],
rho_single=param_array[i,
number_flows + j],
m=20) for j in range(number_flows)
]
# NOTE: n is fixed
elif arrival_enum == ArrivalEnum.TBConst:
arr_list = [
DetermTokenBucket(sigma_single=param_array[i, j],
rho_single=param_array[i, number_flows + j],
m=1) for j in range(number_flows)
]
else:
raise NotImplementedError(f"Arrival parameter {arrival_enum.name} "
f"is infeasible")
ser_list = [
ConstantRateServer(
rate=param_array[i,
arrival_enum.number_parameters() *
number_flows + j])
for j in range(number_servers)
]
fat_cross_setting = FatCrossPerform(arr_list=arr_list,
ser_list=ser_list,
perform_param=perform_param)
computation_necessary = True
if target_util > 0.0:
util = fat_cross_setting.approximate_utilization()
if util < target_util or util > 1:
res_array[i, ] = np.nan
computation_necessary = False
if computation_necessary:
# standard_bound, h_mit_bound = compare_mitigator()
res_array[i, 0], res_array[i, 1] = compare_mitigator(
setting=fat_cross_setting,
opt_method=opt_method,
number_l=number_servers - 1)
if (perform_param.perform_metric == PerformEnum.DELAY_PROB
and res_array[i, 1] > 1.0):
# write as nan if second (in particular both) value(s) are > 1.0
res_array[i, ] = np.nan
if np.isnan(res_array[i, 0]) or np.isnan(res_array[i, 1]):
res_array[i, ] = np.nan
res_array_no_full_nan = remove_full_nan_rows(full_array=res_array)
valid_iterations = res_array_no_full_nan.shape[0]
if valid_iterations < total_iterations * 0.2:
warn(f"Many nan's: {total_iterations - valid_iterations} nans "
f"out of {total_iterations}!")
if valid_iterations < 100:
raise NotEnoughResults("result is useless")
res_dict = two_col_array_to_results(arrival_enum=arrival_enum,
param_array=param_array,
res_array=res_array,
number_servers=number_servers,
compare_metric=compare_metric)
res_dict.update({
"iterations": total_iterations,
"PerformParamValue": perform_param.value,
"optimization": opt_method.name,
"compare_metric": compare_metric.name,
"MCDistribution": mc_dist.to_name(),
"MCParam": mc_dist.param_to_string(),
"number_servers": number_servers
})
filename = name
filename += f"_results_{perform_param.to_name()}_{arrival_enum.name}_" \
f"MC{mc_dist.to_name()}_{opt_method.name}_" \
f"{compare_metric.name}_util_{target_util}"
with open(filename + ".csv", 'w') as csv_file:
writer = csv.writer(csv_file)
for key, value in res_dict.items():
writer.writerow([key, value])
return res_dict
if __name__ == '__main__':
OUTPUT_LIST = PerformParamList(perform_metric=PerformEnum.OUTPUT,
values_list=list(range(4, 15)))
print(
perform_param_list_to_csv(prefix="single_",
data_frame_creator=single_server_df,
arr_list=[DM1(lamb=3.8, m=1)],
ser_list=[ConstantRateServer(rate=3.0)],
perform_param_list=OUTPUT_LIST,
opt_method=OptMethod.GRID_SEARCH))
print(
perform_param_list_to_csv(
prefix="single_",
data_frame_creator=single_server_df,
arr_list=[MMOOCont(mu=8.0, lamb=12.0, peak_rate=3.0, m=1)],
ser_list=[ConstantRateServer(rate=1.5)],
perform_param_list=OUTPUT_LIST,
opt_method=OptMethod.GRID_SEARCH))
RATE_1 = ConstantRateServer(rate=1.0)
print(
perform_param_list_to_csv(prefix="single_",
data_frame_creator=single_server_df,
arr_list=[MD1(lamb=0.5, mu=1.0)],
ser_list=[RATE_1],
perform_param_list=OUTPUT_LIST,
opt_method=OptMethod.GRID_SEARCH))
try:
return self.setting_h_mit.h_mit_bound(param_l_list=param_list)
except (ParameterOutOfBounds, OverflowError):
return inf
if __name__ == '__main__':
from h_mitigator.fat_cross_perform import FatCrossPerform
from utils.perform_parameter import PerformParameter
from nc_operations.perform_enum import PerformEnum
from nc_server.constant_rate_server import ConstantRateServer
from nc_arrivals.markov_modulated import MMOOCont
DELAY_4 = PerformParameter(perform_metric=PerformEnum.DELAY, value=0.0001)
MMOO_1 = MMOOCont(mu=1.0, lamb=2.2, peak_rate=3.4)
MMOO_2 = MMOOCont(mu=3.6, lamb=1.6, peak_rate=0.4)
CONST_RATE_1 = ConstantRateServer(rate=2.0)
CONST_RATE_2 = ConstantRateServer(rate=0.3)
SIMPLEX_START = np.array([[0.1], [0.3]])
# SIMPLEX_START = np.array([[100], [200]])
SIMPLEX_START_NEW = np.array([[0.1, 2.0], [0.3, 1.2], [0.4, 1.1]])
SIMPLEX_RAND = InitialSimplex(parameters_to_optimize=1).uniform_dist(
max_theta=0.6, max_l=2.0)
NM_PARAM_SET = NelderMeadParameters()
SETTING = FatCrossPerform(arr_list=[MMOO_1, MMOO_2],
ser_list=[CONST_RATE_1, CONST_RATE_2],
perform_param=DELAY_4)
# np.seterr("raise")
np.seterr("warn")
res = scipy.optimize.bisect(helper_function,
a=lower_interval,
b=upper_interval,
full_output=True)
return res[0]
if __name__ == '__main__':
print("Single Server Performance Bounds:\n")
DELAY6 = PerformParameter(perform_metric=PerformEnum.DELAY_PROB, value=6)
ARR_LIST = [MMOOCont(mu=0.2, lamb=0.5, peak_rate=2.6)]
SINGLE_SERVER = SingleServerBandwidth(arr_list=ARR_LIST,
s_e2e=ConstantRateServer(rate=2.0),
perform_param=DELAY6)
RESULTING_DELAY_PROB = Optimize(SINGLE_SERVER,
number_param=1,
print_x=True).grid_search(grid_bounds=[
(0.1, 5.0)
],
delta=0.1)
print(f"delay probability = {RESULTING_DELAY_PROB}")
REQUIRED_BANDWIDTH = get_bandwidth_from_delay(arr_list=ARR_LIST,
target_delay=6,
target_delay_prob=0.034,
print("Single Server Performance Bounds:\n")
DELAY_PROB8 = PerformParameter(perform_metric=PerformEnum.DELAY_PROB,
value=8)
SINGLE_SERVER = SingleServerPerform(foi=DM1(lamb=1.0),
server=ConstantRateServer(rate=10.0),
perform_param=DELAY_PROB8)
print(
Optimize(SINGLE_SERVER, number_param=1,
print_x=True).grid_search(grid_bounds=[(0.1, 5.0)],
delta=0.1))
SINGLE_SERVER2 = SingleServerPerform(foi=MMOOCont(mu=0.7,
lamb=0.4,
peak_rate=1.2),
server=ConstantRateServer(rate=1.0),
perform_param=DELAY_PROB8)
print(
Optimize(SINGLE_SERVER2, number_param=1,
print_x=True).grid_search(grid_bounds=[(0.1, 5.0)],
delta=0.1))
DELAY_PROB_REV = PerformParameter(perform_metric=PerformEnum.DELAY,
value=0.0183)
SINGLE_SERVER2 = SingleServerPerform(foi=MMOOCont(mu=0.7,
lamb=0.4,
peak_rate=1.2),
perform_param_list_to_csv(prefix="simple_setting_",
data_frame_creator=fat_cross_perform_df,
arr_list=[DM1(lamb=0.4),
DM1(lamb=3.5)],
ser_list=[
ConstantRateServer(rate=4.5),
ConstantRateServer(rate=0.4)
],
perform_param_list=DELAY_PROB_LIST,
opt_method=OptMethod.GRID_SEARCH))
print(
perform_param_list_to_csv(prefix="simple_setting_",
data_frame_creator=fat_cross_perform_df,
arr_list=[
MMOOCont(mu=1.2, lamb=2.1,
peak_rate=3.5),
MMOOCont(mu=3.7, lamb=1.5, peak_rate=0.4)
],
ser_list=[
ConstantRateServer(rate=2.0),
ConstantRateServer(rate=0.3)
],
perform_param_list=DELAY_PROB_LIST,
opt_method=OptMethod.GRID_SEARCH))
print(
perform_param_list_to_csv(prefix="simple_setting_",
data_frame_creator=fat_cross_perform_df,
arr_list=[
MMOOCont(mu=1.0, lamb=2.2,
peak_rate=3.4),
# MMOOFluid(mu=2.5, lamb=3.3, burst=1.6)]
#
# ],
# ser_list=[
# ConstantRateServer(rate=5.2),
# ConstantRateServer(rate=6.5),
# ConstantRateServer(rate=9.9),
# ConstantRateServer(rate=3.0)
# ],
# perform_param=DELAY3))
print(
arrival_list_to_csv(prefix="square_",
data_frame_creator=square_adjust_arr_df,
list_arr_list=[[
MMOOCont(mu=7.0, lamb=4.8, peak_rate=4.9),
MMOOCont(mu=2.2, lamb=2.1, peak_rate=3.7),
MMOOCont(mu=4.1, lamb=1.0, peak_rate=2.0),
MMOOCont(mu=2.5, lamb=3.3, peak_rate=0.1)
],
[
MMOOCont(mu=7.0,
lamb=4.8,
peak_rate=4.9),
MMOOCont(mu=2.2,
lamb=2.1,
peak_rate=3.7),
MMOOCont(mu=4.1,
lamb=1.0,
peak_rate=2.0),
MMOOCont(mu=2.5,