def single_flow_traffic(args: Namespace) -> None:
global run_traffic
if args.dry:
run_traffic = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'cook', 'guard']
root_path = str(Path("experiments") / "traffic")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
instances = [
('--algo', 'robustMpc', 'cubic'),
('--server-algo', 'gap', 'gap'),
('--algo', 'dynamic', 'bbr2'),
('--algo', 'robustMpc', 'bbr2'),
('--algo', 'dynamic', 'cubic'),
]
experiments = []
experiment_path = str(Path(root_path) / 'sft')
subpath = experiment_path
latency = 500
for bandwidth in [2, 3, 4]:
for (where, algo, cc) in instances:
for run_id in range(4):
for video in videos:
server = f"{where} {algo} --name abr --cc {cc} --video {video}"
path = str(
Path(subpath) /
f"{algo}_{cc}_{bandwidth}_{video}_run{run_id}")
runner_log.write(f'> {path}\n')
run_traffic(
path,
f"{server} -l {latency} -b {bandwidth} --single-flow",
headless=args.headless)
cc_name = cc if cc != "gap" else "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "abr_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=["sf", algo, cc_name, f"bw{bandwidth}"],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
def hetero(args: Namespace) -> None:
global run_trace, run_subexp
if args.dry:
run_trace = lambda *args, **kwargs: None
run_subexp = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'guard']
root_path = str(Path("experiments") / "hetero")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
# only for rmpc at the moment
compete1 = [
('robustMpc', 'bbr2'),
('dynamic', 'bbr2'),
('robustMpc', 'cubic'),
('dynamic', 'cubic'),
]
compete2 = [
('gap', 'gap'),
]
minerva = [
('minerva', 'minerva'),
('minervann', 'minerva'),
]
for i, video1 in enumerate(videos):
for j, video2 in enumerate(videos):
if i != j:
shorter_video = video1 if get_video_chunks(
video1) < get_video_chunks(video2) else video2
experiments = []
experiment_path = str(Path(root_path) / f"{video1}_{video2}")
for run_id in range(4):
latency = 500
# robustMpc vs others
for bandwidth in [3, 2, 1]:
subpath = str(Path(experiment_path) / "versus_rmpc")
for (algo1, cc1) in compete1:
for (algo2, cc2) in compete2:
server1 = f"--algo {algo1} --name robustMpc --cc {cc1} --video {video1}"
server2 = f"--server-algo {algo2} --name abrcc --cc {cc2} --video {video2}"
path = str(
Path(subpath) /
f"{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}"
)
if algo1 != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo1}_{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}"
)
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=shorter_video,
headless=args.headless)
if cc2 == "gap":
cc2 = "gap2"
experiments.append(
Experiment(
video=shorter_video,
path=str(
Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
"versus", algo1, cc1, algo2, cc2,
f"{video1}1", f"{video2}2"
],
run_id=run_id,
))
# self
subpath = str(Path(experiment_path) / "versus_self")
for (algo, cc) in compete2 + minerva:
server1 = f"--server-algo {algo} --name abrcc1 --cc {cc} --video {video1}"
server2 = f"--server-algo {algo} --name abrcc2 --cc {cc} --video {video2}"
if algo == "minerva" or algo == "minervann":
server1 += f" --algo {algo}"
server2 += f" --algo {algo}"
path = str(
Path(subpath) /
f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=shorter_video,
headless=args.headless)
if cc == "gap":
cc = "gap2"
experiments.append(
Experiment(
video=shorter_video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
"self", algo, cc, f"{video1}1",
f"{video2}"
],
run_id=run_id,
))
# robustMpc
subpath = str(Path(experiment_path) / "rmpc")
for cc1, cc2 in [('cubic', 'bbr2'), ('bbr2', 'bbr2'),
('cubic', 'cubic')]:
for algo in ['robustMpc', 'dynamic']:
server1 = f"--algo {algo} --name rmpc1 --cc {cc1} --video {video1}"
server2 = f"--algo {algo} --name rmpc2 --cc {cc2} --video {video2}"
path = str(
Path(subpath) /
f"{cc1}_{cc2}_{bandwidth}_run{run_id}")
if algo != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo}_{cc1}_{cc2}_{bandwidth}_run{run_id}"
)
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=shorter_video,
headless=args.headless)
extra = 'rmpc'
if algo == 'dynamic':
extra = 'dynamic'
experiments.append(
Experiment(
video=shorter_video,
path=str(
Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
extra, cc1 + '1', cc2 + '2',
f"{video1}1", f"{video2}2"
],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
def multiple2(args: Namespace) -> None:
global run_trace, run_subexp
if args.dry:
run_trace = lambda *args, **kwargs: None
run_subexp = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'cook', 'guard']
root_path = str(Path("experiments") / "multiple_videos2")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
compete1 = [
('robustMpc', 'cubic'),
('robustMpc', 'bbr2'),
('dynamic', 'bbr2'),
('dynamic', 'cubic'),
]
compete2 = [
('gap', 'gap'),
]
for video in videos:
experiments = []
experiment_path = str(Path(root_path) / video)
for run_id in range(4):
latency = 500
for bandwidth in [4, 3, 2]:
# versus
subpath = str(Path(experiment_path) / "versus")
for (algo1, cc1) in compete1:
for (algo2, cc2) in compete2:
server1 = f"--algo {algo1} --name robustMpc --cc {cc1} --video {video}"
server3 = f"--algo {algo1} --name robustMpc2 --cc {cc1} --video {video}"
server2 = f"--server-algo {algo2} --name abrcc --cc {cc2} --video {video}"
path = str(
Path(subpath) /
f"{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}")
if algo1 != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo1}_{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}"
)
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server3, server2],
burst=2000,
video=video,
headless=args.headless)
if cc2 == "gap":
cc2 = "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
"versus", algo1, cc1, algo2, cc2, video
],
run_id=run_id,
))
# same type
subpath = str(Path(experiment_path) / "rmpc")
for cc in ['cubic', 'bbr2']:
for algo in ['robustMpc', 'dynamic']:
server1 = f"--algo {algo} --name rmpc1 --cc {cc} --video {video}"
server2 = f"--algo {algo} --name rmpc2 --cc {cc} --video {video}"
server3 = f"--algo {algo} --name rmpc3 --cc {cc} --video {video}"
path = str(
Path(subpath) / f"{cc}_{bandwidth}_run{run_id}")
if algo != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2, server3],
burst=2000,
video=video,
headless=args.headless)
extra = 'rmpc'
if algo == 'dynamic':
extra = 'dynamic'
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
extra, cc + '1', cc + '2', cc + '3', video
],
run_id=run_id,
))
# minerva
for cc, algo in [
("minerva", "minerva"),
("minerva", "minervann"),
]:
server1 = f"--algo {algo} --server-algo {algo} --name rmpc1 --cc {cc} --video {video}"
server2 = f"--algo {algo} --server-algo {algo} --name rmpc2 --cc {cc} --video {video}"
server3 = f"--algo {algo} --server-algo {algo} --name rmpc3 --cc {cc} --video {video}"
path = str(
Path(subpath) / f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2, server3],
burst=2000,
video=video,
headless=args.headless)
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[algo, cc + '1', cc + '2', cc + '3', video],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
def multiple(args: Namespace) -> None:
global run_trace, run_subexp
if args.dry:
run_trace = lambda *args, **kwargs: None
run_subexp = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'cook', 'guard']
root_path = str(Path("experiments") / "multiple_videos")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
compete1 = [
('robustMpc', 'cubic'),
('robustMpc', 'bbr2'),
('dynamic', 'bbr2'),
('dynamic', 'cubic'),
]
compete2 = [
('gap', 'gap'),
]
minerva = [
('minervann', 'minerva'),
('minerva', 'minerva'),
]
for video in videos:
experiments = []
experiment_path = str(Path(root_path) / video)
for run_id in range(4):
latency = 500
for bandwidth in [3, 2, 1]:
# versus
subpath = str(Path(experiment_path) / "versus_rmpc")
for (algo1, cc1) in compete1:
for (algo2, cc2) in compete2:
server1 = f"--algo {algo1} --name robustMpc --cc {cc1} --video {video}"
server2 = f"--server-algo {algo2} --name abrcc --cc {cc2} --video {video}"
path = str(
Path(subpath) /
f"{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}")
if algo1 != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo1}_{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}"
)
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=video,
headless=args.headless)
if cc2 == "gap":
cc2 = "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[
"versus", algo1, cc1, algo2, cc2, video
],
run_id=run_id,
))
# self
subpath = str(Path(experiment_path) / "versus_self")
for (algo, cc) in compete2 + minerva:
server1 = f"--server-algo {algo} --name abrcc1 --cc {cc} --video {video}"
server2 = f"--server-algo {algo} --name abrcc2 --cc {cc} --video {video}"
if algo == "minerva" or algo == "minervann":
server1 += f" --algo {algo}"
server2 += f" --algo {algo}"
path = str(
Path(subpath) / f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=video,
headless=args.headless)
if cc == "gap":
cc = "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=["self", algo, cc],
run_id=run_id,
))
# baselines
subpath = str(Path(experiment_path) / "rmpc")
for cc1, cc2 in [('cubic', 'bbr2'), ('bbr2', 'bbr2'),
('cubic', 'cubic')]:
for algo in ['robustMpc', 'dynamic']:
server1 = f"--algo {algo} --name rmpc1 --cc {cc1} --video {video}"
server2 = f"--algo {algo} --name rmpc2 --cc {cc2} --video {video}"
path = str(
Path(subpath) /
f"{cc1}_{cc2}_{bandwidth}_run{run_id}")
if algo != 'robustMpc': # since we don't want to repet old experiments
path = str(
Path(subpath) /
f"{algo}_{cc1}_{algo2}_{cc2}_{bandwidth}_run{run_id}"
)
runner_log.write(f'> {path}\n')
run_subexp(bandwidth,
latency,
path, [server1, server2],
burst=2000,
video=video,
headless=args.headless)
extra = 'rmpc'
if algo == 'dynamic':
extra = 'dynamic'
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[extra, cc1 + '1', cc2 + '2', video],
run_id=run_id,
))
# traces
subpath = str(Path(experiment_path) / "traces")
server1 = f"--cc target --server-algo target2 --name abrcc --video {video}"
server2 = f"--cc bbr2 --algo robustMpc --name robustMpc --video {video}"
server6 = f"--cc bbr2 --algo dynamic --name dynamic --video {video}"
server3 = f"--cc gap --server-algo gap --name abrcc --video {video}"
server4 = f"--cc gap --server-algo remote --name abrcc --video {video}"
server5 = f"--cc cubic --algo robustMpc --name robustMpc --video {video}"
for plot_name, name, server in [
("robustMpc", "rmpc_bbr", server2),
("robustMpc", "rmpc_cubic", server5),
("dynamic", "dynamic_bbr", server6),
("abrcc", "target2", server1),
("abrcc", "gap_pid", server3),
("abrcc", "remote", server4),
]:
traces = Path("network_traces")
for trace in [
str(traces / "norway_train_13.txt"),
str(traces / "car.txt"),
str(traces / "bus.txt"),
str(traces / "bus1.txt"),
str(traces / "norway_train_6.txt"),
str(traces / "norway_ferry_11.txt"),
str(traces / "norway_ferry_20.txt"),
str(traces / "norway_ferry_6.txt"),
str(traces / "norway_metro_6.txt"),
str(traces / "norway_tram_5.txt"),
str(traces / "norway_tram_14.txt"),
str(traces / "norway_tram_16.txt"),
str(traces / "norway_tram_19.txt"),
]:
trace_name = trace.split('/')[-1].split('.')[0]
path = str(Path(subpath) / f'{name}_{trace_name}')
runner_log.write(f'> {path}\n')
run_trace(path,
f"{server} -l {latency} -t {trace}",
headless=args.headless)
experiments.append(
Experiment(
video=video,
path=str(Path(path) / f"{plot_name}_plots.log"),
latency=latency,
trace=trace,
extra=["traces", name, trace, run_id],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
def stream_count(args: Namespace) -> None:
global run_trace, run_subexp
if args.dry:
run_trace = lambda *args, **kwargs: None
run_subexp = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'cook', 'guard']
root_path = str(Path("experiments") / "stream_count")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
algorithms = [
('--server-algo', 'minerva', 'minerva'),
('--server-algo', 'minervann', 'minerva'),
('--server-algo', 'gap', 'gap'),
('--algo', 'robustMpc', 'cubic'),
('--algo', 'robustMpc', 'bbr2'),
('--algo', 'dynamic', 'bbr2'),
('--algo', 'dynamic', 'cubic'),
]
experiments = []
experiment_path = str(Path(root_path))
runs = 20
latency = 500
bandwidth = 4
min_streams, max_streams = 2, 8
for stream_number in range(max_streams, min_streams - 1, -1):
for run_id in range(runs):
for (arg, algo, cc) in algorithms:
run_servers = []
run_videos = []
for i in range(stream_number):
video = random.choice(videos)
server = f"{arg} {algo} --name abr{i + 1} --cc {cc} --video {video}"
if algo == "minerva" or algo == "minervann":
server += f" --algo {algo}"
run_videos.append(video)
run_servers.append(server)
video_length = list(
zip(map(get_video_chunks, run_videos), run_videos))
shortest_video = min(video_length)[1]
path = str(
Path(experiment_path) /
f"{algo}_{cc}_streams{stream_number}_run{run_id}")
runner_log.write(f'> {path}\n')
run_subexp(
bandwidth,
latency,
path,
run_servers,
burst=2000,
video=shortest_video,
headless=args.headless,
)
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "leader_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=[f"streams{stream_number}", algo, cc],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
def traffic(args: Namespace) -> None:
global run_traffic
if args.dry:
run_traffic = lambda *args, **kwargs: None
videos = ['got', 'bojack', 'cook', 'guard']
root_path = str(Path("experiments") / "traffic")
os.system(f"mkdir -p {root_path}")
runner_log = open(str(Path(root_path) / 'exp.log'), 'w')
instances = [
('--algo', 'robustMpc', 'cubic'),
('--algo', 'robustMpc', 'bbr2'),
('--algo', 'dynamic', 'bbr2'),
('--algo', 'dynamic', 'cubic'),
('--server-algo', 'gap', 'gap'),
]
experiments = []
experiment_path = str(Path(root_path) / 'fct')
subpath = experiment_path
latency = 100
for bandwidth in [5, 4, 3]:
for (where, algo, cc) in instances:
for run_id in range(10):
video = random.choice(videos)
server = f"{where} {algo} --name abr --cc {cc} --video {video}"
path = str(
Path(subpath) / f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_traffic(path,
f"{server} -l {latency} -b {bandwidth} --light",
headless=args.headless,
burst=20000)
cc_name = cc if cc != "gap" else "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "abr_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=["fct", algo, cc_name, f"bw{bandwidth}"],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)
latency = 100
for video in videos:
experiments = []
experiment_path = str(Path(root_path) / video)
for run_id in range(4):
for bandwidth in [3, 2, 1]:
# versus
subpath = str(Path(experiment_path) / "versus_rmpc")
for (where, algo, cc) in instances:
server = f"{where} {algo} --name abr --cc {cc} --video {video}"
path = str(
Path(subpath) / f"{algo}_{cc}_{bandwidth}_run{run_id}")
runner_log.write(f'> {path}\n')
run_traffic(path,
f"{server} -l {latency} -b {bandwidth}",
headless=args.headless)
if cc == "gap":
cc = "gap2"
experiments.append(
Experiment(
video=video,
path=str(Path(path) / "abr_plots.log"),
latency=latency,
bandwidth=bandwidth,
extra=["traffic", algo, cc, video],
run_id=run_id,
))
if args.dry:
print(experiments)
print(len(experiments))
else:
save_experiments(experiment_path, experiments)
generate_summary(experiment_path, experiments)