From f5001bbdc35937ded24d5b3850b04e52b90d153b Mon Sep 17 00:00:00 2001 From: Yadong Ding Date: Thu, 30 Nov 2023 10:24:28 +0800 Subject: [PATCH] misc: delete python version benchmark Signed-off-by: Yadong Ding --- misc/benchmark/bench.py | 418 ----------------------- misc/benchmark/benchmark.py | 99 ------ misc/benchmark/benchmark_summary.py | 193 ----------- misc/benchmark/cni_bridge.conf | 15 - misc/benchmark/config.yml | 5 - misc/benchmark/containerd_config.toml | 9 - misc/benchmark/convert.py | 66 ---- misc/benchmark/go/main.go | 6 - misc/benchmark/java/Main.java | 5 - misc/benchmark/metrics.py | 383 --------------------- misc/benchmark/node/index.js | 10 - misc/benchmark/nydus-snapshotter.service | 18 - misc/benchmark/nydusd_config.json | 30 -- misc/benchmark/prefetch_list.py | 76 ----- misc/benchmark/prepare_env.sh | 44 --- misc/benchmark/util.py | 63 ---- 16 files changed, 1440 deletions(-) delete mode 100644 misc/benchmark/bench.py delete mode 100644 misc/benchmark/benchmark.py delete mode 100644 misc/benchmark/benchmark_summary.py delete mode 100644 misc/benchmark/cni_bridge.conf delete mode 100644 misc/benchmark/config.yml delete mode 100644 misc/benchmark/containerd_config.toml delete mode 100644 misc/benchmark/convert.py delete mode 100644 misc/benchmark/go/main.go delete mode 100644 misc/benchmark/java/Main.java delete mode 100755 misc/benchmark/metrics.py delete mode 100644 misc/benchmark/node/index.js delete mode 100644 misc/benchmark/nydus-snapshotter.service delete mode 100644 misc/benchmark/nydusd_config.json delete mode 100755 misc/benchmark/prefetch_list.py delete mode 100644 misc/benchmark/prepare_env.sh delete mode 100644 misc/benchmark/util.py diff --git a/misc/benchmark/bench.py b/misc/benchmark/bench.py deleted file mode 100644 index 1abc9448c32..00000000000 --- a/misc/benchmark/bench.py +++ /dev/null @@ -1,418 +0,0 @@ -#!/usr/bin/env python3 -""" - bench.py references the repo[https://github.com/nydusaccelerator/hello-bench]. -""" -import copy -import json -import logging -import os -import posixpath -import subprocess -import sys -import time -import urllib.request -from contextlib import contextmanager -from datetime import datetime -from io import TextIOWrapper - -import metrics - - -def logging_setup(logging_stream=sys.stderr): - root = logging.getLogger() - - if root.hasHandlers(): - return - - verbose = True - - handler = logging.StreamHandler(logging_stream) - - if verbose: - root.setLevel(logging.DEBUG) - handler.setLevel(logging.DEBUG) - else: - root.setLevel(logging.INFO) - handler.setLevel(logging.INFO) - - formatter = logging.Formatter( - "[%(asctime)s] %(levelname)s " - "[%(module)s - %(lineno)s:%(funcName)s] " - "- %(message)s" - ) - handler.setFormatter(formatter) - root.addHandler(handler) - - -logging_setup() - - -def run(cmd, wait: bool = True, verbose=True, **kwargs): - - shell = kwargs.pop("shell", False) - if shell: - cmd = " ".join(cmd) - - if verbose: - logging.info(cmd) - else: - logging.debug(cmd) - - popen_obj = subprocess.Popen(cmd, shell=shell, **kwargs) - if wait: - popen_obj.wait() - return popen_obj.returncode, popen_obj - - -def get_current_time(): - return datetime.now() - - -def delta_time(t_end, t_start): - delta = t_end - t_start - return delta.total_seconds(), delta.microseconds - - -@contextmanager -def timer(cmd): - start = get_current_time() - try: - rc = os.system(cmd) - assert rc == 0 - end = get_current_time() - sec, usec = delta_time(end, start) - yield sec + usec / 1e6 - logging.info("%s, Takes time %u.%u seconds", cmd, sec, usec) - finally: - pass - - -class RunArgs: - def __init__( - self, env={}, arg="", stdin="", stdin_sh="sh", waitline="", mount=[], waitURL="" - ): - self.env = env - self.arg = arg - self.stdin = stdin - self.stdin_sh = stdin_sh - self.waitline = waitline - self.mount = mount - self.waitURL = waitURL - - -class Bench: - def __init__(self, name, category="other"): - self.name = name - self.category = category - - def __str__(self): - return json.dumps(self.__dict__) - - def set_tag(self, tag): - self.name = f"{self.name}:{tag}" - - -class BenchRunner: - CMD_URL_WAIT = { - "wordpress": RunArgs(waitURL="http://localhost:80"), - "node": RunArgs( - arg="node /src/index.js", - mount=[("node", "/src")], - waitURL="http://localhost:80", - ), - } - - CMD_STDIN = { - "golang": RunArgs( - stdin="cd /src; go run main.go", mount=[("go", "/src")] - ), - "amazoncorretto": RunArgs( - stdin="cd /src; javac Main.java; java Main", mount=[("java", "/src")] - ), - "ruby": RunArgs(stdin='ruby -e "puts \\"hello\\""') - } - - CMD_ARG = { - "python": RunArgs(arg="python -c 'print(\"hello\")'"), - } - - # support images - ALL = dict( - [ - (b.name, b) - for b in [ - Bench("golang", "language"), - Bench("python", "language"), - Bench("ruby", "language"), - Bench("amazoncorretto", "language"), - Bench("node", "web-framework"), - Bench("wordpress", "web-framework"), - ] - ] - ) - - def __init__( - self, - registry="localhost:5000", - snapshotter="overlayfs", - cleanup=True, - insecure_registry=False, - ): - self.registry = registry - if self.registry != "": - self.registry += "/" - - self.snapshotter = snapshotter - self.insecure_registry = insecure_registry - - self.cleanup = cleanup - - def image_ref(self, repo): - return posixpath.join(self.registry, repo) - - def run(self, bench): - repo = image_repo(bench.name) - if repo in BenchRunner.CMD_URL_WAIT: - return self.run_cmd_url_wait(repo=bench.name, runargs=BenchRunner.CMD_URL_WAIT[repo]) - elif repo in BenchRunner.CMD_ARG: - return self.run_cmd_arg(repo=bench.name, runargs=BenchRunner.CMD_ARG[repo]) - elif repo in BenchRunner.CMD_STDIN: - return self.run_cmd_stdin(repo=bench.name, runargs=BenchRunner.CMD_STDIN[repo]) - else: - print("Unknown bench: " + repo) - sys.exit(1) - - def run_cmd_url_wait(self, repo, runargs): - image_ref = self.image_ref(repo) - container_id = repo.replace(":", "-") - - pull_cmd = self.pull_cmd(image_ref) - print(pull_cmd) - print("Pulling image %s ..." % image_ref) - with timer(pull_cmd) as t: - pull_elapsed = t - - create_cmd = self.create_cmd_url_wait_cmd(image_ref, container_id, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - with timer(create_cmd) as t: - create_elapsed = t - - run_cmd = self.task_start_cmd(container_id, iteration=False) - print(run_cmd) - - print("Running container %s ..." % container_id) - start_run = datetime.now() - - _ = subprocess.Popen(run_cmd, shell=True) - while True: - try: - req = urllib.request.urlopen(runargs.waitURL) - print(req.status) - req.close() - break - except: - time.sleep(0.01) - - end_run = datetime.now() - run_elapsed = datetime.timestamp(end_run) - datetime.timestamp(start_run) - - print("Run time: %f s" % run_elapsed) - - read_amount, read_count = "-", "-" - if self.snapshotter == "nydus": - read_amount, read_count = metrics.collect_backend() - try: - image_size = metrics.collect_size(image_repo(repo), image_tag(repo)) - except Exception: - image_size = 0 - - if self.cleanup: - self.clean_up(image_ref, container_id) - - return pull_elapsed, create_elapsed, run_elapsed, image_size, read_amount, read_count - - def run_cmd_arg(self, repo, runargs): - assert len(runargs.mount) == 0 - - image_ref = self.image_ref(repo) - container_name = repo.replace(":", "-") - - pull_cmd = self.pull_cmd(image_ref) - print(pull_cmd) - - print("Pulling image %s ..." % image_ref) - with timer(pull_cmd) as t: - pull_elapsed = t - - create_cmd = self.create_cmd_arg_cmd(image_ref, container_name, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - with timer(create_cmd) as t: - create_elapsed = t - - run_cmd = self.task_start_cmd(container_name, iteration=False) - print(run_cmd) - - with timer(run_cmd) as t: - run_elapsed = t - - print("Run time: %f s" % run_elapsed) - - read_amount, read_count = "-", "-" - if self.snapshotter == "nydus": - read_amount, read_count = metrics.collect_backend() - try: - image_size = metrics.collect_size(image_repo(repo), image_tag(repo)) - except Exception: - image_size = 0 - - if self.cleanup: - self.clean_up(image_ref, container_name) - - return pull_elapsed, create_elapsed, run_elapsed, image_size, read_amount, read_count - - def run_cmd_stdin(self, repo, runargs): - image_ref = self.image_ref(repo) - container_name = repo.replace(":", "-") - - pull_cmd = self.pull_cmd(image_ref) - print(pull_cmd) - - print("Pulling image %s ..." % image_ref) - with timer(pull_cmd) as t: - pull_elapsed = t - - create_cmd = self.create_cmd_stdin_cmd(image_ref, container_name, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - with timer(create_cmd) as t: - create_elapsed = t - - run_cmd = self.task_start_cmd(container_name, iteration=True) - print(run_cmd) - - print("Running container %s ..." % container_name) - start_run = datetime.now() - - p = subprocess.Popen( - run_cmd, - shell=True, - stdin=subprocess.PIPE, - stdout=sys.stdout, - stderr=sys.stdout, - bufsize=0, - ) - - print(runargs.stdin) - stdin = runargs.stdin + "\nexit\n" - p.communicate(stdin.encode()) - end_run = datetime.now() - run_elapsed = datetime.timestamp(end_run) - datetime.timestamp(start_run) - print("p.returncode:", p.returncode) - # assert(p.returncode == 0) - - print("Run time: %f s" % run_elapsed) - - read_amount, read_count = "-", "-" - if self.snapshotter == "nydus": - read_amount, read_count = metrics.collect_backend() - try: - image_size = metrics.collect_size(image_repo(repo), image_tag(repo)) - except Exception: - image_size = 0 - - if self.cleanup: - self.clean_up(image_ref, container_name) - - return pull_elapsed, create_elapsed, run_elapsed, image_size, read_amount, read_count - - def pull_cmd(self, image_ref): - insecure_flag = "--insecure-registry" if self.insecure_registry else "" - return ( - f"sudo nerdctl --snapshotter {self.snapshotter} pull {insecure_flag} {image_ref}" - ) - - def create_cmd_url_wait_cmd(self, image_ref, container_id, runargs): - cmd = f"sudo nerdctl --snapshotter {self.snapshotter} create --net=host " - for a, b in runargs.mount: - a = os.path.join(os.path.dirname(os.path.abspath(__file__)), a) - cmd += f"--volume {a}:{b} " - cmd += f"--name={container_id} {image_ref}" - if len(runargs.arg) > 0: - cmd += f" -- {runargs.arg} " - return cmd - - def create_cmd_arg_cmd(self, image_ref, container_id, runargs): - cmd = f"sudo nerdctl --snapshotter {self.snapshotter} create --net=host --name={container_id} {image_ref} " - return cmd + runargs.arg - - def create_cmd_stdin_cmd(self, image_ref, container_id, runargs): - cmd = f"sudo nerdctl --snapshotter {self.snapshotter} create --net=host " - for a, b in runargs.mount: - a = os.path.join(os.path.dirname(os.path.abspath(__file__)), a) - cmd += f"--volume {a}:{b} " - cmd += f"--name={container_id} {image_ref}" - return cmd - - def task_start_cmd(self, container_id, iteration: bool): - if iteration: - return f"sudo nerdctl --snapshotter {self.snapshotter} start -a {container_id}" - else: - return f"sudo nerdctl --snapshotter {self.snapshotter} start {container_id}" - - def task_kill_cmd(self, container_id): - return f"sudo nerdctl --snapshotter {self.snapshotter} stop {container_id}" - - def clean_up(self, image_ref, container_id): - print("Cleaning up environment for %s ..." % container_id) - cmd = self.task_kill_cmd(container_id) - print(cmd) - rc = os.system(cmd) # sometimes containers already exit. we ignore the failure. - cmd = f"sudo nerdctl --snapshotter {self.snapshotter} rm -f {container_id}" - print(cmd) - rc = os.system(cmd) - assert rc == 0 - cmd = f"sudo nerdctl --snapshotter {self.snapshotter} rmi -f {image_ref}" - print(cmd) - rc = os.system(cmd) - assert rc == 0 - - -def image_repo(ref: str): - return ref.split(":")[0] - - -def image_tag(ref: str) -> str: - try: - return ref.split(":")[1] - except IndexError: - return None - - -def bench_image(local_registry, insecure_local_registry, image, f: TextIOWrapper, snapshotter="overlayfs"): - try: - bench = copy.deepcopy(BenchRunner.ALL[image_repo(image)]) - tag = image_tag(image) - if tag is not None: - bench.set_tag(tag) - except KeyError: - logging.warning("image %s not supported, skip", image) - sys.exit(1) - runner = BenchRunner( - registry=local_registry, - snapshotter=snapshotter, - cleanup=True, - insecure_registry=insecure_local_registry, - ) - pull_elapsed, create_elapsed, run_elapsed, image_size, read_amount, read_count = runner.run(bench) - total_elapsed = f"{pull_elapsed + create_elapsed + run_elapsed: .2f}" - pull_elapsed = f"{pull_elapsed: .2f}" - create_elapsed = f"{create_elapsed: .2f}" - run_elapsed = f"{run_elapsed: .2f}" - line = f"{pull_elapsed},{create_elapsed},{run_elapsed},{total_elapsed},{image_size},{read_amount},{read_count}" - f.writelines(line + "\n") - f.flush() diff --git a/misc/benchmark/benchmark.py b/misc/benchmark/benchmark.py deleted file mode 100644 index 8693a165a9a..00000000000 --- a/misc/benchmark/benchmark.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python3 -import os -from argparse import ArgumentParser - -import bench as bench -import convert as cvt -import metrics -import prefetch_list as alg -import util -import yaml - -CONFIG = "config.yml" -PREFETCH_FILE_LIST = "out_list.txt" - - -def main(): - """ - 1. read config file to knows the images:tag and registry and if we need convert to nydus image or not - 2. we have four modes for benchmark, the first is oci, the second is nydus without prefetch, the third is nydus with prefetch all, the latest is nydus with prefetch file list - """ - parser = ArgumentParser() - parser.add_argument( - "--mode", - choices=["oci", "nydus-no-prefetch", "nydus-all-prefetch", "nydus-filelist-prefetch"], - dest="mode", - type=str, - required=True, - help="The mode of benchmark. Available modes are: oci, nydus-none_prefetch, nydus-all-prefetch, nydus-filelist-prefetch." - ) - parser.add_argument( - "--image", - dest="image", - type=str, - required=True, - help="The benchmark image." - ) - args = parser.parse_args() - mode = args.mode - image = args.image - - # read config.yml - cfg = {} - with open(CONFIG, 'r', encoding='utf-8') as f: - try: - cfg = yaml.load(stream=f, Loader=yaml.FullLoader) - except Exception as inst: - print('error reading config file') - print(inst) - exit(-1) - # bench - start_bench(cfg, image, mode) - - -def collect_metrics(cfg: dict, image: str) -> str: - """ - collect container access metrics - """ - return metrics.collect_access(cfg["local_registry"], cfg["insecure_local_registry"], util.image_nydus(image)) - - -def start_bench(cfg: dict, image: str, mode: str): - """ - bench oci, nydus without prefetch, nydus with all prefetch, nydus witch prefetch file list - """ - f = open(util.image_repo(image) + ".csv", "w") - if mode == "oci": - util.enable_wondersphaper(cfg["bandwith"]) - bench.bench_image(cfg["local_registry"], cfg["insecure_local_registry"], image, f) - elif mode == "nydus-no-prefetch": - util.enable_wondersphaper(cfg["bandwith"]) - bench.bench_image(cfg["local_registry"], cfg["insecure_local_registry"], util.image_nydus(image), f, "nydus") - elif mode == "nydus-all-prefetch": - # open prefetch enable - util.switch_config_prefetch_enable() - util.reload_nydus() - util.enable_wondersphaper(cfg["bandwith"]) - bench.bench_image(cfg["local_registry"], cfg["insecure_local_registry"], util.image_nydus(image), f, "nydus") - else: - # opne the metrics colletc api - util.switch_config_access_pattern() - util.reload_nydus() - # collect metrics data - file = collect_metrics(cfg, image) - # generate prefetch list - _ = alg.get_prefetch_list(file) - os.remove(file) - # rebuild - cvt.convert_nydus_prefetch(cfg["source_registry"], cfg["insecure_source_registry"], cfg["local_registry"], cfg["insecure_local_registry"], image, PREFETCH_FILE_LIST) - # open prefetch enable - util.switch_config_prefetch_enable() - # close the metrics colletc api - util.switch_config_access_pattern() - util.reload_nydus() - util.enable_wondersphaper(cfg["bandwith"]) - bench.bench_image(cfg["local_registry"], cfg["insecure_local_registry"], util.image_nydus_prefetch(image), f, "nydus") - - -if __name__ == "__main__": - main() diff --git a/misc/benchmark/benchmark_summary.py b/misc/benchmark/benchmark_summary.py deleted file mode 100644 index b6bedaa92a4..00000000000 --- a/misc/benchmark/benchmark_summary.py +++ /dev/null @@ -1,193 +0,0 @@ -#!/usr/bin/env python3 - -import csv -import os -import subprocess -from argparse import ArgumentParser - -COMMANDS_BENCHMARK = [ - "sudo install -m 755 benchmark-oci/*.csv oci.csv", - "sudo install -m 755 benchmark-nydus-all-prefetch/*.csv nydus-all-prefetch.csv", - "sudo install -m 755 benchmark-nydus-no-prefetch/*.csv nydus-no-prefetch.csv", - "sudo install -m 755 benchmark-zran-all-prefetch/*.csv zran-all-prefetch.csv", - "sudo install -m 755 benchmark-zran-no-prefetch/*.csv zran-no-prefetch.csv", - "sudo install -m 755 benchmark-nydus-filelist-prefetch/*.csv nydus-filelist-prefetch.csv" -] - -COMMANDS_BENCHMARK_COMPARE = [ - "sudo install -m 755 benchmark-zran-all-prefetch-master/*.csv zran-all-prefetch-master.csv", - "sudo install -m 755 benchmark-zran-no-prefetch-master/*.csv zran-no-prefetch-master.csv", - "sudo install -m 755 benchmark-nydus-no-prefetch-master/*.csv nydus-no-prefetch-master.csv", - "sudo install -m 755 benchmark-nydus-all-prefetch-master/*.csv nydus-all-prefetch-master.csv", - "sudo install -m 755 benchmark-nydus-filelist-prefetch-master/*.csv nydus-filelist-prefetch-master.csv" -] - -FILE_LIST = [ - "oci.csv", - "nydus-all-prefetch.csv", - "zran-all-prefetch.csv", - "nydus-no-prefetch.csv", - "zran-no-prefetch.csv", - "nydus-filelist-prefetch.csv" -] - -FILE_LIST_COMPARE = [ - "oci.csv", - ("nydus-all-prefetch-master.csv", "nydus-all-prefetch.csv"), - ("zran-all-prefetch-master.csv", "zran-all-prefetch.csv"), - ("nydus-no-prefetch-master.csv", "nydus-no-prefetch.csv"), - ("zran-no-prefetch-master.csv", "zran-no-prefetch.csv"), - ("nydus-filelist-prefetch-master.csv", "nydus-filelist-prefetch.csv") -] - -BENCHMARK_CACHE = "benchmark-result/result.md" - - -class BenchmarkSummary: - def __init__(self, mode): - self.mode = mode - - def summary(self): - self.prepare_csv() - if self.mode == "benchmark-result": - self.print_csv_result() - elif self.mode == "benchmark-compare": - self.print_csv_compare() - else: - self.print_csv_schedule() - - def print_csv_result(self): - print("| bench-result | pull(s) | create(s) | run(s) | total(s) | size(MB) | read-amount(MB) | read-count |") - print("|:-------------|:-------:|:---------:|:------:|:--------:|:--------:|:---------------:|:----------:|") - for file in FILE_LIST: - print_csv(file) - - def print_csv_compare(self): - print("| bench-result(current vs master) | pull(s) | create(s) | run(s) | total(s) | size(MB) | read-amount(MB) | read-count |") - print("|:--------------------------------|:-------:|:---------:|:------:|:--------:|:--------:|:---------------:|:----------:|") - for item in FILE_LIST_COMPARE: - if isinstance(item, str): - print_csv(item) - else: - print_compare(item[0], item[1]) - - def print_csv_schedule(self): - data = [] - if os.path.exists(BENCHMARK_CACHE): - print("| bench-result(current vs last) | pull(s) | create(s) | run(s) | total(s) | size(MB) | read-amount(MB) | read-count |") - print("|:------------------------------|:-------:|:---------:|:------:|:--------:|:--------:|:---------------:|:----------:|") - with open(BENCHMARK_CACHE, "r", newline='') as f: - reader = csv.reader(f, delimiter='|') - next(reader) # head - next(reader) # line - next(reader) # oci - for row in reader: - data.append(row[2:-1]) - for index, file in enumerate(FILE_LIST): - if (file == "oci.csv"): - print_schedule(file) - else: - print_schedule(file, data[index-1]) - else: - self.print_csv_result() - self.save_cache() - - def prepare_csv(self): - """ - move the csv to current workdir - """ - for cmd in COMMANDS_BENCHMARK: - subprocess.run(cmd, shell=True) - if self.mode == "benchmark-compare": - for cmd in COMMANDS_BENCHMARK_COMPARE: - subprocess.run(cmd, shell=True) - - def save_cache(self): - with open(BENCHMARK_CACHE, 'w') as cache: - print("| bench-result | pull(s) | create(s) | run(s) | total(s) | size(MB) | read-amount(MB) | read-count |", file=cache) - print("|:-------------|:-------:|:---------:|:------:|:--------:|:--------:|:---------------:|:----------:|", file=cache) - for file in FILE_LIST: - with open(file, 'r') as f: - filename = file.rstrip(".csv") - rows = csv.reader(f) - for row in rows: - pull_elapsed, create_elapsed, run_elapsed, total_elapsed, image_size, read_amount, read_count = row - print(f"|{filename}|{pull_elapsed}|{create_elapsed}|{run_elapsed}|{total_elapsed}|{image_size}|{read_amount}|{read_count}|", file=cache) - - -def print_csv(file: str): - with open(file, 'r', newline='') as f: - filename = file.rstrip(".csv") - rows = csv.reader(f) - for row in rows: - pull_elapsed, create_elapsed, run_elapsed, total_elapsed, image_size, read_amount, read_count = row - print(f"|{filename}|{pull_elapsed}|{create_elapsed}|{run_elapsed}|{total_elapsed}|{image_size}|{read_amount}|{read_count}|") - - -def print_compare(file_master: str, file: str): - with open(file, 'r', newline='') as f: - filename = file.rstrip(".csv") - rows = csv.reader(f) - for row in rows: - pull_elapsed, create_elapsed, run_elapsed, total_elapsed, image_size, read_amount, read_count = row - with open(file_master, 'r', newline='') as f: - rows = csv.reader(f) - for row in rows: - pull_elapsed_master, create_elapsed_master, run_elapsed_master, total_elapsed_master, image_size_master, read_amount_master, read_count_master = row - pull_elapsed_compare = compare(pull_elapsed, pull_elapsed_master) - create_elapsed_compare = compare(create_elapsed, create_elapsed_master) - run_elapsed_compare = compare(run_elapsed, run_elapsed_master) - total_elapsed_compare = compare(total_elapsed, total_elapsed_master, True) - image_size_compare = compare(image_size, image_size_master, True) - read_amount_compare = compare(read_amount, read_amount_master, True) - read_count_compare = compare(read_count, read_count_master, True) - - print(f"|{filename}|{pull_elapsed_compare}|{create_elapsed_compare}|{run_elapsed_compare}|{total_elapsed_compare}|{image_size_compare}|{read_amount_compare}|{read_count_compare}|") - - -def print_schedule(file: str, data=[]): - with open(file, 'r', newline='') as f: - filename = file.rstrip(".csv") - rows = csv.reader(f) - for row in rows: - pull_elapsed, create_elapsed, run_elapsed, total_elapsed, image_size, read_amount, read_count = row - if filename != "oci": - pull_elapsed = compare(pull_elapsed, data[0]) - create_elapsed = compare(create_elapsed, data[1]) - run_elapsed = compare(run_elapsed, data[2]) - total_elapsed = compare(total_elapsed, data[3], True) - image_size = compare(image_size, data[4], True) - read_amount = compare(read_amount, data[5], True) - read_count = compare(read_count, data[6], True) - - print(f"|{filename}|{pull_elapsed}|{create_elapsed}|{run_elapsed}|{total_elapsed}|{image_size}|{read_amount}|{read_count}|") - - -def compare(data_current: str, data_master: str, compare: bool = False) -> str: - data_current = float(data_current) - data_master = float(data_master) - if abs(data_current - data_master) > data_master * 0.05 and compare: - if data_current > data_master: - return f"{data_current}/{data_master}↑" - else: - return f"{data_current}/{data_master}↓" - return f"{data_current}/{data_master}" - - -def main(): - parser = ArgumentParser() - parser.add_argument( - "--mode", - choices=["benchmark-result", "benchmark-compare", "benchmark-schedule"], - dest="mode", - type=str, - required=True, - help="The mode of benchmark summary" - ) - args = parser.parse_args() - mode = args.mode - BenchmarkSummary(mode=mode).summary() - - -if __name__ == "__main__": - main() diff --git a/misc/benchmark/cni_bridge.conf b/misc/benchmark/cni_bridge.conf deleted file mode 100644 index faff51944af..00000000000 --- a/misc/benchmark/cni_bridge.conf +++ /dev/null @@ -1,15 +0,0 @@ -{ - "cniVersion": "0.4.0", - "name": "bridge", - "type": "bridge", - "bridge": "cni0", - "isGateway": true, - "ipMasq": true, - "ipam": { - "type": "host-local", - "subnet": "10.10.0.0/16", - "routes": [ - { "dst": "0.0.0.0/0" } - ] - } -} diff --git a/misc/benchmark/config.yml b/misc/benchmark/config.yml deleted file mode 100644 index b1aa9c6fb4b..00000000000 --- a/misc/benchmark/config.yml +++ /dev/null @@ -1,5 +0,0 @@ -source_registry: docker.io -insecure_source_registry: False -local_registry: localhost:5000 -insecure_local_registry: True -bandwith: 81920 diff --git a/misc/benchmark/containerd_config.toml b/misc/benchmark/containerd_config.toml deleted file mode 100644 index a17dadf9cd8..00000000000 --- a/misc/benchmark/containerd_config.toml +++ /dev/null @@ -1,9 +0,0 @@ -[proxy_plugins] -[proxy_plugins.nydus] - type = "snapshot" - address = "/run/containerd-nydus/containerd-nydus-grpc.sock" - -[plugins.cri] -[plugins.cri.containerd] - snapshotter = "nydus" - disable_snapshot_annotations = false diff --git a/misc/benchmark/convert.py b/misc/benchmark/convert.py deleted file mode 100644 index 81c68d20ed8..00000000000 --- a/misc/benchmark/convert.py +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env python3 -import os - - -class Image: - def __init__(self, source_registry, insecure_source_registry, target_registry, insecure_target_registry, image, prefetch=""): - """ - the prefetch is the file path of prefetch list file,and it is optional - """ - self.source_registry = source_registry - self.insecure_source_registry = insecure_source_registry - self.target_registry = target_registry - self.insecure_target_registry = insecure_target_registry - self.image = image - self.prefetch = prefetch - - def image_repo(self): - return self.image.split(":")[0] - - def image_tag(self) -> str: - try: - return self.image.split(":")[1] - except IndexError: - return None - - def convert_cmd(self): - if self.prefetch == "": - target_image = self.image_repo() + ":" + self.image_tag() + "_nydus" - if self.insecure_source_registry and self.insecure_target_registry: - return f"sudo nydusify convert --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --source-insecure --target-insecure" - elif self.insecure_source_registry: - return f"sudo nydusify convert --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --source-insecure" - elif self.insecure_target_registry: - return f"sudo nydusify convert --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --target-insecure" - else: - return f"sudo nydusify convert --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image}" - else: - target_image = self.image_repo() + ":" + self.image_tag() + "_nydus_prefetch" - if self.insecure_source_registry and self.insecure_target_registry: - return f"sudo cat {self.prefetch} | nydusify convert --prefetch-patterns --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --source-insecure --target-insecure" - elif self.insecure_source_registry: - return f"sudo cat {self.prefetch} | nydusify convert --prefetch-patterns --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --source-insecure" - elif self.insecure_target_registry: - return f"sudo cat {self.prefetch} | nydusify convert --prefetch-patterns --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image} --target-insecure" - else: - return f"sudo cat {self.prefetch} | nydusify convert --prefetch-patterns --source {self.source_registry}/{self.image} --target {self.target_registry}/{target_image}" - - def nydus_convert(self): - """ - convert oci image to nydus image (prefetchfile is optional) - """ - print(self.convert_cmd()) - rc = os.system(f"sudo cat {self.prefetch}") - rc = os.system(self.convert_cmd()) - assert rc == 0 - - -def convert_nydus_prefetch(source_registry: str, insecure_source_registry: bool, target_registry: str, insecure_target_registry: bool, image: str, prefetch: str): - """ - convert nydus with prefetch image api - """ - Image(source_registry, - insecure_source_registry, - target_registry, - insecure_target_registry, - image, prefetch).nydus_convert() diff --git a/misc/benchmark/go/main.go b/misc/benchmark/go/main.go deleted file mode 100644 index dff1726de45..00000000000 --- a/misc/benchmark/go/main.go +++ /dev/null @@ -1,6 +0,0 @@ -package main -import "fmt" - -func main() { - fmt.Println("hello") -} diff --git a/misc/benchmark/java/Main.java b/misc/benchmark/java/Main.java deleted file mode 100644 index fd6e78f6641..00000000000 --- a/misc/benchmark/java/Main.java +++ /dev/null @@ -1,5 +0,0 @@ -class Main { - public static void main(String[] args) { - System.out.println("hello"); - } -} diff --git a/misc/benchmark/metrics.py b/misc/benchmark/metrics.py deleted file mode 100755 index 7cf3d5898ad..00000000000 --- a/misc/benchmark/metrics.py +++ /dev/null @@ -1,383 +0,0 @@ -#!/usr/bin/env python3 -import csv -import json -import os -import posixpath -import random -import re -import shutil -import string -import subprocess -import sys -import time -import urllib.request -from typing import Tuple - -import bench - -""" -define some file path, and sock api url -""" -LOG_DIR = "log" -TEMP_DIR = "tmp" -URL_PREFIX = "http://localhost/api" -ACCESS_PATTERN_METRICS = "/v1/metrics/pattern" -BACKEND_METRICS = "/v1/metrics/backend" -BOOTSTRAP_DIR = "/var/lib/containerd-nydus/snapshots" -API_DIR = "/var/lib/containerd-nydus/socket" - - -class MetricsCollector: - def __init__(self, cfg: dict): - self.registry = cfg["registry"] - self.insecure_registry = cfg["insecure_registry"] - self.image = cfg["image"] - - def start_collet(self) -> str: - runner = bench.BenchRunner( - registry=self.registry, - snapshotter="nydus", - insecure_registry=self.insecure_registry, - ) - image_ref = self.image_ref(self.image) - container_name = self.image.replace(":", "-") + random_string() - pull_cmd = self.pull_cmd(image_ref) - print(pull_cmd) - print("Pulling image %s ..." % image_ref) - rc = os.system(pull_cmd) - assert rc == 0 - repo = bench.image_repo(self.image) - if repo in bench.BenchRunner.CMD_URL_WAIT: - self.run_cmd_url_wait(runner=runner, runargs=bench.BenchRunner.CMD_URL_WAIT[repo], image_ref=image_ref, container_name=container_name) - elif repo in bench.BenchRunner.CMD_ARG: - self.run_cmd_arg(runner=runner, runargs=bench.BenchRunner.CMD_ARG[repo], image_ref=image_ref, container_name=container_name) - elif repo in bench.BenchRunner.CMD_STDIN: - self.run_cmd_stdin(runner=runner, runargs=bench.BenchRunner.CMD_STDIN[repo], image_ref=image_ref, container_name=container_name) - else: - print("Unknown bench: " + repo) - os.exit(1) - file = self.collect(self.image) - self.clean_up(image_ref, container_name) - return file - - def image_ref(self, repo): - return posixpath.join(self.registry, repo) - - def pull_cmd(self, image_ref): - insecure_flag = "--insecure-registry" if self.insecure_registry else "" - return ( - f"sudo nerdctl --snapshotter nydus pull {insecure_flag} {image_ref}" - ) - - def stop_container_cmd(self, container_id): - return f"sudo nerdctl --snapshotter nydus stop {container_id}" - - def run_cmd_url_wait(self, runner, runargs, image_ref, container_name): - - create_cmd = runner.create_cmd_url_wait_cmd(image_ref, container_name, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - rc = os.system(create_cmd) - assert rc == 0 - - run_cmd = runner.task_start_cmd(container_name, iteration=False) - print(run_cmd) - - print("Running container %s ..." % container_name) - - _ = subprocess.Popen(run_cmd, shell=True) - while True: - try: - req = urllib.request.urlopen(runargs.waitURL) - print(req.status) - req.close() - break - except: - time.sleep(0.01) - - def run_cmd_arg(self, runner, runargs, image_ref, container_name): - assert len(runargs.mount) == 0 - - create_cmd = runner.create_cmd_arg_cmd(image_ref, container_name, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - rc = os.system(create_cmd) - assert rc == 0 - - run_cmd = runner.task_start_cmd(container_name, iteration=False) - print(run_cmd) - rc = os.system(run_cmd) - assert rc == 0 - - def run_cmd_stdin(self, runner, runargs, image_ref, container_name): - - create_cmd = runner.create_cmd_stdin_cmd(image_ref, container_name, runargs) - print(create_cmd) - - print("Creating container for image %s ..." % image_ref) - rc = os.system(create_cmd) - assert rc == 0 - - run_cmd = runner.task_start_cmd(container_name, iteration=True) - print(run_cmd) - - print("Running container %s ..." % container_name) - - p = subprocess.Popen( - run_cmd, - shell=True, - stdin=subprocess.PIPE, - stdout=sys.stdout, - stderr=sys.stdout, - bufsize=0, - ) - - print(runargs.stdin) - stdin = runargs.stdin + "\nexit\n" - p.communicate(stdin.encode()) - assert p.returncode == 0 - - def clean_up(self, image_ref, container_id): - print("Cleaning up environment for %s ..." % container_id) - cmd = self.stop_container_cmd(container_id) - print(cmd) - rc = os.system(cmd) - assert rc == 0 - cmd = f"sudo nerdctl --snapshotter nydus rm -f {container_id}" - print(cmd) - rc = os.system(cmd) - assert rc == 0 - cmd = f"sudo nerdctl --snapshotter nydus rmi -f {image_ref}" - print(cmd) - rc = os.system(cmd) - assert rc == 0 - - def collect(self, repo) -> str: - """ - collect the access files - """ - socket = search_file(API_DIR, "api.sock") - if socket == None: - print("can't find the api.sock") - exit(1) - bootstrap = search_file(BOOTSTRAP_DIR, "image.boot") - if bootstrap == None: - print("can't find the bootstrap") - exit(1) - - # bootstrap - bootstap_data = check_bootstrap(bootstrap) - - # access_pattern - access_pattern = get_access_pattern(socket, bootstap_data) - - header = ["file_path", "first_access_time", "file_size"] - - file_name = posixpath.join(repo + ".csv") - if not os.path.exists(file_name): - os.mknod(file_name) - with open(file_name, 'w', newline='') as f: - writer = csv.writer(f) - writer.writerow(header) - for item in access_pattern: - writer.writerow( - [item.file_path, item.first_access_time_secs * 10**9 + item.first_access_time_nanos, item.file_size]) - return file_name - - -def get_file_by_bootstrap(bootstrap, inode): - """ - load the data of bootstrap - """ - with open(bootstrap, 'r') as file: - for line in file: - if line.startswith("inode:"): - result = re.search(r'"([^"]+)".*ino (\d+).*i_size (\d+)', line) - value_file_path = result.group(1) - value_ino = result.group(2) - value_file_size = result.group(3) - if int(value_ino) == inode: - return value_file_path, value_file_size - return None, None - - -def check_bootstrap(bootstrap): - """ - use nydus-image to get the data of bootstap - """ - file_path = random_string() - cmd = ["sudo", "nydus-image", "check"] - cmd.extend(["-B", bootstrap, "-v"]) - with open(TEMP_DIR + "/" + file_path, 'w') as f: - _ = run_cmd( - cmd, - shell=True, - stdout=f, - stderr=f, - ) - return TEMP_DIR + "/" + file_path - - -class AccessPattern: - def __init__(self, file_path, first_access_time_secs, first_access_time_nanos, file_size): - self.file_path = file_path - self.first_access_time_secs = first_access_time_secs - self.first_access_time_nanos = first_access_time_nanos - self.file_size = file_size - - -def get_access_pattern(sock, bootstap_data): - """ - get the file access pattern from the sock - """ - contents = "" - # The api occasionally returns incomplete information - while contents.endswith("]") == False: - with open(send_request(sock, ACCESS_PATTERN_METRICS), 'r') as file: - contents = file.read() - resp = json.loads(contents) - access_pattern_list = [] - for item in resp: - item['first_access_time_secs'] = item['first_access_time_secs'] - item["first_access_time_nanos"] = item["first_access_time_nanos"] - file_path, file_size = get_file_by_bootstrap(bootstap_data, item['ino']) - access_pattern_list.append(AccessPattern( - file_path, item['first_access_time_secs'], item['first_access_time_nanos'], file_size)) - return access_pattern_list - - -def get_backend_metrics(sock) -> dict: - """ - get the backend metrics from the sock - """ - with open(send_request(sock, BACKEND_METRICS), 'r') as file: - content = file.read() - - return eval(content) - - -def random_string(): - """ - generate a random string of fixed length - """ - return "".join(random.choice(string.ascii_lowercase) for _ in range(10)) - - -def search_file(root_dir, file_name): - """ - search the bootsatrap and api.scok of the image, but only return the first match file, - so we need to clear the images and containers befor we start metrics.py - """ - for subdir, _, files in os.walk(root_dir): - if file_name in files: - return os.path.join(subdir, file_name) - return None - - -def send_request(sock_path, url): - """ - send request to the local socket with the url. - save the response in the file. - """ - file_path = random_string() - cmd = ["sudo", "curl", "--unix-socket", sock_path] - cmd.extend(["-X", "GET", URL_PREFIX + url]) - with open(TEMP_DIR + "/" + file_path, 'w') as f: - _ = run_cmd( - cmd, - shell=True, - stdout=f, - stderr=subprocess.PIPE - ) - return TEMP_DIR + "/" + file_path - - -def run_cmd(cmd, wait: bool = True, **kwargs): - """ - run a cmd with the subprocess - """ - shell = kwargs.pop("shell", False) - if shell: - cmd = " ".join(cmd) - popen_obj = subprocess.Popen(cmd, shell=shell, **kwargs) - if wait: - popen_obj.wait() - return popen_obj.returncode, popen_obj - - -def init(): - if os.path.exists(TEMP_DIR): - if os.path.isdir(TEMP_DIR): - shutil.rmtree(TEMP_DIR) - else: - os.remove(TEMP_DIR) - os.mkdir(TEMP_DIR) - - -def collect_access(local_registry, insecure_local_registry, image) -> str: - """ - collect access pattern for benchmark.py - """ - init() - cfg = {"registry": local_registry, "insecure_registry": insecure_local_registry, "image": image} - file = MetricsCollector(cfg).start_collet() - shutil.rmtree(TEMP_DIR) - return file - - -def collect_backend() -> Tuple[str, str]: - """ - collect backend metrics for benchmark.py - - return (Read Amount, Read Count) - """ - init() - socket = search_file(API_DIR, "api.sock") - if socket == None: - print("can't find the api.sock") - exit(1) - backend = get_backend_metrics(socket) - shutil.rmtree(TEMP_DIR) - return round(backend["read_amount_total"] / 1024 / 1024, 2), backend["read_count"] - - -def collect_size(repo: str, tag: str): - """ - collect image size for benchmark - - return the image size - """ - init() - file_path = random_string() - cmd = ["sudo", "curl", "-H", "'Accept: application/vnd.docker.distribution.manifest.v2+json'"] - cmd.extend([f"localhost:5000/v2/{repo}/manifests/{tag}"]) - with open(TEMP_DIR + "/" + file_path, 'w') as f: - _ = run_cmd( - cmd, - shell=True, - stdout=f, - stderr=subprocess.PIPE - ) - with open(TEMP_DIR + "/" + file_path, 'r') as file: - content = file.read() - if "errors" in content: - file_path_zran = random_string() - cmd = ["sudo", "curl", "-H", "'Accept: application/vnd.oci.image.manifest.v1+json'"] - cmd.extend([f"localhost:5000/v2/{repo}/manifests/{tag}"]) - with open(TEMP_DIR + "/" + file_path_zran, 'w') as f: - _ = run_cmd( - cmd, - shell=True, - stdout=f, - stderr=subprocess.PIPE - ) - with open(TEMP_DIR + "/" + file_path_zran, 'r') as file_zran: - content = file_zran.read() - manifest = json.loads(content) - size = 0 - for item in manifest["layers"]: - size += item["size"] - shutil.rmtree(TEMP_DIR) - return round(size / 1024 / 1024, 2) diff --git a/misc/benchmark/node/index.js b/misc/benchmark/node/index.js deleted file mode 100644 index 9dc329b2ff3..00000000000 --- a/misc/benchmark/node/index.js +++ /dev/null @@ -1,10 +0,0 @@ -// Load the http module to create an http server. -var http = require('http'); - -// Configure our HTTP server to respond with Hello World to all requests. -var server = http.createServer(function (request, response) { - response.writeHead(200, {"Content-Type": "text/plain"}); - response.end("hello\n"); -}); - -server.listen(80); diff --git a/misc/benchmark/nydus-snapshotter.service b/misc/benchmark/nydus-snapshotter.service deleted file mode 100644 index ba35f7ef31b..00000000000 --- a/misc/benchmark/nydus-snapshotter.service +++ /dev/null @@ -1,18 +0,0 @@ -[Unit] -Description=nydus snapshotter -After=network.target -Before=containerd.service - -[Service] -Type=simple -Environment=HOME=/root -ExecStart=/usr/local/bin/containerd-nydus-grpc --config-path /etc/nydus/config.json -Restart=always -RestartSec=1 -KillMode=process -OOMScoreAdjust=-999 -StandardOutput=journal -StandardError=journal - -[Install] -WantedBy=multi-user.target diff --git a/misc/benchmark/nydusd_config.json b/misc/benchmark/nydusd_config.json deleted file mode 100644 index 8e5cfe957bc..00000000000 --- a/misc/benchmark/nydusd_config.json +++ /dev/null @@ -1,30 +0,0 @@ -{ - "device": { - "backend": { - "type": "registry", - "config": { - "scheme": "http", - "host": "localhost:5000" - } - }, - "cache": { - "type": "blobcache", - "config": { - "work_dir": "/var/lib/nydus/cache/" - } - } - }, - "mode": "direct", - "digest_validate": false, - "enable_xattr": true, - "iostats_files": false, - "access_pattern": false, - "latest_read_files": false, - "fs_prefetch": { - "enable": false, - "threads_count": 10, - "merging_size": 1048576, - "bandwidth_rate": 10485760, - "prefetch_all": false - } -} diff --git a/misc/benchmark/prefetch_list.py b/misc/benchmark/prefetch_list.py deleted file mode 100755 index 4ce8aaddd1e..00000000000 --- a/misc/benchmark/prefetch_list.py +++ /dev/null @@ -1,76 +0,0 @@ -#!/usr/bin/env python3 -import csv -from functools import cmp_to_key -from typing import Tuple - - -def read_csv(csv_path: str) -> dict: - """ - convert csv to dictionary - """ - file_dict = {} - with open(csv_path, 'r') as fp: - reader = csv.DictReader(fp) - for x in reader: - temp = {} - temp['file_size'] = str(x['file_size']) - temp['first_access_time'] = str(x['first_access_time']) - file_dict[x['file_path']] = temp - return file_dict - - -def sort_list(csv_path: str) -> Tuple[dict, list]: - """ - sort access_files - """ - file_dict = read_csv(csv_path) - file_list = list(file_dict.keys()) - - def comp(a, b): - at = file_dict[a]['first_access_time'] - bt = file_dict[b]['first_access_time'] - if len(at) > len(bt): - return 1 - elif len(at) < len(bt): - return -1 - else: - for i in range(len(at)): - if i == len(at)-1: - return -1 - if int(at[i]) > int(bt[i]): - return 1 - elif int(at[i]) < int(bt[i]): - return -1 - else: - continue - - file_list.sort(key=cmp_to_key(comp)) - - return file_dict, file_list - - -def optimize_list(csv_path: str) -> list: - """ - optimize sorted list - only sort - """ - _, file_list = sort_list(csv_path) - - return file_list - - -def to_txt(file_list: list, outpath: str): - """ - prefetch_list to txt - """ - with open(outpath, 'w')as f: - for k in file_list: - f.write(k + '\n') - - -def get_prefetch_list(csv_path: str) -> list: - """ - get prefetch_list - """ - optimized_list = optimize_list(csv_path) - to_txt(optimized_list, 'out_list.txt') - return optimized_list diff --git a/misc/benchmark/prepare_env.sh b/misc/benchmark/prepare_env.sh deleted file mode 100644 index 3c2e87591bf..00000000000 --- a/misc/benchmark/prepare_env.sh +++ /dev/null @@ -1,44 +0,0 @@ -#!/bin/bash - -readonly SNAPSHOOTER_VERSION=0.7.3 -readonly NERDCTL_VERSION=1.3.0 -readonly CNI_PLUGINS_VERSION=1.2.0 - -# setup nerdctl and nydusd env -case "$1" in - "oci") - sudo install -D -m 755 contrib/nydusify/cmd/nydusify /usr/local/bin - sudo install -D -m 755 target/release/nydusd target/release/nydus-image /usr/local/bin - sudo wget https://github.com/containerd/nerdctl/releases/download/v$NERDCTL_VERSION/nerdctl-$NERDCTL_VERSION-linux-amd64.tar.gz - sudo tar -xzvf nerdctl-$NERDCTL_VERSION-linux-amd64.tar.gz -C /usr/local/bin - sudo mkdir -p /opt/cni/bin - sudo wget https://github.com/containernetworking/plugins/releases/download/v$CNI_PLUGINS_VERSION/cni-plugins-linux-amd64-v$CNI_PLUGINS_VERSION.tgz - sudo tar -xzvf cni-plugins-linux-amd64-v$CNI_PLUGINS_VERSION.tgz -C /opt/cni/bin - sudo install -D misc/benchmark/cni_bridge.conf /etc/cni/net.d/bridge.conf - ;; - "nydus") - sudo install -D -m 755 contrib/nydusify/cmd/nydusify /usr/local/bin - sudo install -D -m 755 target/release/nydusd target/release/nydus-image /usr/local/bin - wget https://github.com/containerd/nydus-snapshotter/releases/download/v$SNAPSHOOTER_VERSION/nydus-snapshotter-v$SNAPSHOOTER_VERSION-x86_64.tgz - tar zxvf nydus-snapshotter-v$SNAPSHOOTER_VERSION-x86_64.tgz - sudo install -D -m 755 nydus-snapshotter/containerd-nydus-grpc /usr/local/bin/ - sudo wget https://github.com/containerd/nerdctl/releases/download/v$NERDCTL_VERSION/nerdctl-$NERDCTL_VERSION-linux-amd64.tar.gz - sudo tar -xzvf nerdctl-$NERDCTL_VERSION-linux-amd64.tar.gz -C /usr/local/bin - sudo mkdir -p /opt/cni/bin - sudo wget https://github.com/containernetworking/plugins/releases/download/v$CNI_PLUGINS_VERSION/cni-plugins-linux-amd64-v$CNI_PLUGINS_VERSION.tgz - sudo tar -xzvf cni-plugins-linux-amd64-v$CNI_PLUGINS_VERSION.tgz -C /opt/cni/bin - sudo install -D misc/benchmark/cni_bridge.conf /etc/cni/net.d/bridge.conf - sudo install -D misc/benchmark/nydusd_config.json /etc/nydus/config.json - sudo install -D misc/benchmark/containerd_config.toml /etc/containerd/config.toml - sudo systemctl restart containerd - sudo install -D misc/benchmark/nydus-snapshotter.service /etc/systemd/system/nydus-snapshotter.service - sudo systemctl start nydus-snapshotter - ;; - *) - echo "Unknown command: $1" - ;; -esac -# setup registry env -sudo docker run -d --restart=always -p 5000:5000 --name registry registry -git clone https://github.com/magnific0/wondershaper.git -sudo install -D -m 755 wondershaper/wondershaper /usr/local/bin diff --git a/misc/benchmark/util.py b/misc/benchmark/util.py deleted file mode 100644 index 25fe2de8487..00000000000 --- a/misc/benchmark/util.py +++ /dev/null @@ -1,63 +0,0 @@ -#!/usr/bin/env python3 -import csv -import json -import os - -NYDUSD_CONFIG = "/etc/nydus/config.json" - - -def get_nydusd_config() -> dict: - config = [] - with open(NYDUSD_CONFIG, 'r', encoding='utf-8') as f: - config = json.load(f) - return config - - -def switch_config_prefetch_enable(): - """ - switch the fs_prefetch.enable status - """ - config = get_nydusd_config() - config["fs_prefetch"]["enable"] = not config["fs_prefetch"]["enable"] - with open(NYDUSD_CONFIG, 'w', encoding='utf-8') as f: - json.dump(config, f, ensure_ascii=False, indent=4) - - -def switch_config_access_pattern(): - """ - switch the status of access pattern used by metrics.py - """ - config = get_nydusd_config() - config["iostats_files"] = not config["iostats_files"] - config["access_pattern"] = not config["access_pattern"] - config["latest_read_files"] = not config["latest_read_files"] - with open(NYDUSD_CONFIG, 'w', encoding='utf-8') as f: - json.dump(config, f, ensure_ascii=False, indent=4) - - -def reload_nydus(): - rc = os.system("systemctl restart nydus-snapshotter.service") - assert rc == 0 - - -def image_repo(ref: str): - return ref.split(":")[0] - - -def image_tag(ref: str) -> str: - try: - return ref.split(":")[1] - except IndexError: - return None - - -def image_nydus(ref: str): - return image_repo(ref) + ":" + image_tag(ref) + "_nydus" - - -def image_nydus_prefetch(ref: str) -> str: - return image_repo(ref) + ":" + image_tag(ref) + "_nydus_prefetch" - - -def enable_wondersphaper(bandwith: int): - os.system("sudo wondershaper -a docker0 -u " + str(bandwith) + " -d" + str(bandwith))