def attach_plot_components(
video: str,
server: Server,
trace: Optional[str] = None,
bandwidth: Optional[int] = None,
no_plot: bool = False,
) -> Dict[str, LivePlot]:
"""
Attach multiple plot components with diverse metrics to react to and plot
Monitor-generated metrics.
"""
segments = get_video_chunks(video) + 1
max_playback = int(1.25 * get_approx_video_length(video))
if no_plot:
(server.add_post('/raw_qoe', do_nothing).add_post(
'/rebuffer', do_nothing).add_post('/quality', do_nothing).add_post(
'/vmaf',
do_nothing).add_post('/vmaf_qoe',
do_nothing).add_post('/bw', do_nothing))
return {}
plots = {
'raw_qoe':
LivePlot(figure_name='qoe', y_label='raw qoe', range_size=segments),
'rebuffer':
LivePlot(figure_name='rebuffer',
y_label='rebuffer',
range_size=segments),
'quality':
LivePlot(figure_name='quality', y_label='quality',
range_size=segments),
'vmaf':
LivePlot(figure_name='vmaf', y_label='vmaf', range_size=segments),
'vmaf_qoe':
LivePlot(figure_name='vmaf_qoe',
y_label='vmaf qoe',
range_size=segments),
'bw':
BandwidthPlot(
figure_name='bw',
y_label='bw estimation(mbps)',
trace=trace,
bandwidth=bandwidth,
range_size=max_playback,
),
}
(server.add_post('/raw_qoe', plots['raw_qoe']).add_post(
'/rebuffer',
plots['rebuffer']).add_post('/quality', plots['quality']).add_post(
'/vmaf', plots['vmaf']).add_post('/vmaf_qoe',
plots['vmaf_qoe']).add_post(
'/bw', plots['bw']))
return plots
def run(args: Namespace) -> None:
path = Path(args.path)
if getattr(args, 'headless', False):
set_headless_plots()
print(f'Running leader with {args.instances} instances.')
shutil.rmtree(path, ignore_errors=True)
os.system(f"mkdir -p {path}")
controller = LeaderController(
instances=args.instances,
network=Network(
bandwidth=getattr(args, 'bandwidth', None),
delay=getattr(args, 'delay', None),
burst=getattr(args, 'burst', 20000),
trace_path=getattr(args, 'trace', None),
),
port=args.port,
)
directory = Path(os.path.dirname(os.path.realpath(__file__)))
script = str(directory / '..' / 'quic' / 'run.sh')
os.system(f'{script} --certs')
server = Server('experiment', args.port)
plots = attach_plot_components(
args.video,
server,
trace=getattr(args, 'trace', None),
bandwidth=getattr(args, 'bandwidth', None),
no_plot=not args.plot,
)
(server.add_post('/start', controller.on_start()).add_post(
'/destroy',
multiple_sync(OnComplete(path, 'leader', plots, args.video),
controller.on_destroy())).add_logger(
'leader', str(Path(path) / f'sanic_leader.log')))
server.run()
def run(args: Namespace) -> None:
# give arguments
directory = Path(args.dir)
video = args.video
name = args.name
print(f'Replaying {directory} @ {video}')
# default arguments
port = 5000
# find the logs
files = [
f for f in listdir(str(directory))
if isfile(str(directory / f)) and "metrics" in f
]
algo_to_log_dir = {f.split('_')[0]: str(directory / f) for f in files}
algo_to_log = {}
for algo, log_path in algo_to_log_dir.items():
log = get_replay_log(algo, log_path)
algo_to_log[algo] = log
monitors = {}
server = Server('experiment', port)
for algo in algo_to_log.keys():
# add post for each metrics
monitors[algo] = Monitor(
video=args.video,
path=directory,
name=algo,
plot=True,
request_port=port,
port=port,
training=False,
log_to_file=False,
)
# attach plotter
plots = attach_plot_components(
video,
server,
trace=getattr(args, 'trace', None),
no_plot=False,
)
server.add_post(
'/complete',
multiple_sync(OnComplete(directory, name, plots, video), on_complete))
futures = []
for algo, log in algo_to_log.items():
futures.append(replay_async(algo, log, monitors[algo]))
# run monitors
def start():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
asyncio.ensure_future(complete_after(futures, port))
loop.run_forever()
multiprocessing.Process(target=start).start()
server.run()
def run(args: Namespace) -> None:
path = Path(args.path)
name = args.name
if getattr(args, 'headless', False):
set_headless_plots()
if not args.leader_port:
shutil.rmtree(path, ignore_errors=True)
os.system(f"mkdir -p {path}")
if args.algo is not None:
if args.dash is None:
args.dash = []
if args.algo in ABR_ALGORITHMS:
args.dash.append(f'fe={args.algo}')
server = Server('experiment', args.port)
# Handle Abr requests
if args.algo in PYTHON_ABR_ALGORITHMS:
if args.algo in ['robustMpc', 'minerva', 'minervann']:
from abr.robust_mpc import RobustMpc
server.add_post('/decision', RobustMpc(args.video))
elif args.algo == 'pensieve':
from abr.pensieve import Pensieve
server.add_post('/decision', Pensieve(args.video))
traffic_generator = EmptyTrafficGenerator()
if getattr(args, 'traffic', False):
traffic_generator = TrafficGenerator(
time_log_path=path,
light=getattr(args, 'light', False),
single_flow=getattr(args, 'single_flow', False),
)
# Add controller for launching the QUIC server and browser
controller = Controller(
name=name,
site=args.site,
cc=args.cc,
abr=args.server_algo,
network=Network(
bandwidth=getattr(args, 'bandwidth', None),
delay=getattr(args, 'delay', None),
trace_path=getattr(args, 'trace', None),
burst=getattr(args, 'burst', None),
ports=[args.quic_port] + traffic_generator.ports,
),
dash=args.dash,
quic_port=args.quic_port,
only_server=args.only_server,
port=args.port,
path=path,
leader_port=args.leader_port,
video=args.video,
headless=getattr(args, 'headless', False),
)
# Handle controller communication and metrics
request_port = args.leader_port if args.leader_port else args.port
(server.add_extra_logger(controller).add_post(
'/init', controller.on_init()).add_post(
'/start',
multiple_sync(
controller.on_start(),
traffic_generator.on_start(),
)).add_post(
'/metrics',
Monitor(
video=args.video,
path=path,
name=name,
plot=args.plot or (args.leader_port != None),
request_port=request_port,
port=args.port,
training=args.training,
)).add_post('/destroy', controller.on_destroy()))
# Handle live plots
plots = attach_plot_components(
args.video,
server,
trace=getattr(args, 'trace', None),
no_plot=not args.plot,
)
# Handle stream completion in the Browser
server.add_post(
'/complete',
multiple_sync(
OnComplete(path, name, plots, args.video),
controller.on_complete(),
traffic_generator.on_complete(),
)).add_logger(name, str(Path(path) / f'sanic_{name}.log'))
server.run()
