use ArchiveArtifacts for all benchmark resources

7 files changed, 90 insertions, 179 deletions

diff --git a/src/artifact.py b/src/artifact.py
index 49530a3..010bc6b 100644
--- a/src/artifact.py
+++ b/src/artifact.py
@@ -124,6 +124,10 @@ class ArchiveArtifact(Artifact):
         if not location:
             location = os.path.join(self.basedir, "content")
 
+        # Check if we already provided the archive at location
+        if os.path.exists(location):
+            return
+
         os.makedirs(location, exist_ok=True)
 
         # Extract archive
diff --git a/src/benchmarks/dj_trace.py b/src/benchmarks/dj_trace.py
index f475223..5cb1b99 100644
--- a/src/benchmarks/dj_trace.py
+++ b/src/benchmarks/dj_trace.py
@@ -25,8 +25,9 @@ from urllib.request import urlretrieve
 import matplotlib.pyplot as plt
 import numpy as np
 
+from src.artifact import ArchiveArtifact
 from src.benchmark import Benchmark
-from src.util import print_status, download_reporthook
+from src.util import print_status
 
 
 COMMA_SEP_NUMBER_RE = "(?:\\d*(?:,\\d*)?)*"
@@ -57,7 +58,7 @@ class BenchmarkDJTrace(Benchmark):
     def __init__(self):
         name = "dj_trace"
 
-        self.cmd = "trace_run{binary_suffix} dj_workloads/{workload}.wl"
+        self.cmd = "trace_run{binary_suffix} {build_dir}/dj_workloads/{workload}.wl"
         self.measure_cmd = ""
 
         self.args = {"workload": ["389-ds-2",
@@ -106,29 +107,11 @@ class BenchmarkDJTrace(Benchmark):
     def prepare(self):
         super().prepare()
 
-        workload_dir = "dj_workloads"
-        workload_archive = f"{workload_dir}.tar.xz"
-
-        if not os.path.isdir(workload_dir):
-            if not os.path.isfile(workload_archive):
-                choice = input("Download missing workloads (367M / ~6GB unpacked) [Y/n] ")
-                if not choice in ['', 'Y', 'y']:
-                    return
-
-                url = f"https://www4.cs.fau.de/~flow/allocbench/{workload_archive}"
-                urlretrieve(url, workload_archive, download_reporthook)
-                sys.stderr.write("\n")
-
-            # Extract workloads
-            proc = subprocess.run(["tar", "xf", workload_archive], stdout=subprocess.PIPE,
-                                  stderr=subprocess.PIPE, universal_newlines=True)
-
-            # delete archive
-            if proc.returncode == 0:
-                os.remove(workload_archive)
-
-        for workload in os.listdir(workload_dir):
-            self.args["workload"].append(os.path.splitext(workload)[0])
+        workloads = ArchiveArtifact("dj_workloads",
+                                    "https://www4.cs.fau.de/~flow/allocbench/dj_workloads.tar.xz",
+                                    "tar",
+                                    "c9bc499eeba8023bca28a755fffbaf9200a335ad")
+        workloads.provide(self.build_dir)
 
     @staticmethod
     def process_output(result, stdout, stderr, allocator, perm):
diff --git a/src/benchmarks/fd.py b/src/benchmarks/fd.py
index 55fe3af..e133e1c 100644
--- a/src/benchmarks/fd.py
+++ b/src/benchmarks/fd.py
@@ -23,13 +23,9 @@ import subprocess
 import sys
 from urllib.request import urlretrieve
 
-from src.artifact import GitArtifact
+from src.artifact import ArchiveArtifact, GitArtifact
 from src.benchmark import Benchmark
-from src.util import print_info, download_reporthook
-
-
-LINUX_ARTIFACT = GitArtifact("linux", "git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git")
-LINUX_VERSION = "v5.3"
+from src.util import print_info
 
 
 class BenchmarkFd(Benchmark):
@@ -38,7 +34,6 @@ class BenchmarkFd(Benchmark):
 
     def __init__(self):
         name = "fd"
-
         super().__init__(name)
         
         self.cmd = "fd -HI -e c '.*[0-9].*' {build_dir}/linux"
@@ -46,42 +41,26 @@ class BenchmarkFd(Benchmark):
     def prepare(self):
         super().prepare()
 
-        fd_tag = "v7.4.0"
-        fd_release =  f"fd-{fd_tag}-x86_64-unknown-linux-gnu"
-        fd_archive = f"{fd_release}.tar.gz"
-        fd_url = f"https://github.com/sharkdp/fd/releases/latest/download/{fd_archive}"
-        fd_dir = os.path.join(self.build_dir, fd_release)
-
-        self.results["facts"]["versions"]["fd"] = fd_tag
-
-        # Create builddir
-        os.makedirs(self.build_dir, exist_ok=True)
-
-        if not os.path.isdir(fd_dir):
-            if not os.path.isfile(fd_archive):
-                print(f"Downloading fd {fd_tag}...")
-                urlretrieve(fd_url, fd_archive, download_reporthook)
-                sys.stderr.write("\n")
-            
-            
-            # Extract redis
-            proc = subprocess.run(["tar", "Cxf", self.build_dir, fd_archive],
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
-            
-            # delete archive
-            if proc.returncode == 0:
-                os.remove(fd_archive)
-
-            
-            # create symlinks
-            for exe in ["fd"]:
-                src = os.path.join(fd_dir, exe)
-                dest = os.path.join(self.build_dir, exe)
-                os.link(src, dest)
+        fd_version = "v7.4.0"
+        self.results["facts"]["versions"]["fd"] = fd_version
+        fd_url = ("https://github.com/sharkdp/fd/releases/latest/download/"
+                  f"fd-{fd_version}-x86_64-unknown-linux-gnu.tar.gz")
+
+        fd = ArchiveArtifact("fd", fd_url, "tar", "a5d8e7c8484449aa324a46abfdfaf026d7de77ee")
+
+        fd_dir = os.path.join(self.build_dir, "fd_sources")
+        fd.provide(fd_dir)
+
+        # create symlinks
+        for exe in ["fd"]:
+            src = os.path.join(fd_dir, f"fd-{fd_version}-x86_64-unknown-linux-gnu", exe)
+            dest = os.path.join(self.build_dir, exe)
+            os.link(src, dest)
         
 
-        LINUX_ARTIFACT.provide(LINUX_VERSION, os.path.join(self.build_dir, "linux"))
+        linux = GitArtifact("linux", "git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git")
+        linux_version = "v5.3"
+        linux.provide(linux_version, os.path.join(self.build_dir, "linux"))
 
     def summary(self):
         self.barplot_single_arg("{task-clock}",
diff --git a/src/benchmarks/lld.py b/src/benchmarks/lld.py
index 7ebca13..0603037 100644
--- a/src/benchmarks/lld.py
+++ b/src/benchmarks/lld.py
@@ -24,9 +24,9 @@ import sys
 
 import matplotlib.pyplot as plt
 
+from src.artifact import ArchiveArtifact
 from src.benchmark import Benchmark
 import src.facter
-from src.util import download_reporthook
 
 
 class BenchmarkLld(Benchmark):
@@ -38,7 +38,7 @@ class BenchmarkLld(Benchmark):
     def __init__(self):
         name = "lld"
 
-        self.run_dir = "lld-speed-test/{test}"
+        self.run_dir = "{build_dir}/lld-speed-test/{test}"
         # TODO: don't hardcode ld.lld location
         self.cmd = "/usr/bin/ld.lld @response.txt"
 
@@ -55,28 +55,11 @@ class BenchmarkLld(Benchmark):
         # save lld version
         self.results["facts"]["versions"]["lld"] = src.facter.exe_version("ld.lld", "-v")
 
-        test_dir = "lld-speed-test"
-        test_archive = f"{test_dir}.tar.xz"
-        if not os.path.isdir(test_dir):
-            if not os.path.isfile(test_archive):
-                choice = input("Download missing test archive (1.1GB) [Y/n/x] ")
-                if not choice in ['', 'Y', 'y']:
-                    return
-
-                url = f"https://s3-us-west-2.amazonaws.com/linker-tests/{test_archive}"
-                urlretrieve(url, test_archive, download_reporthook)
-                sys.stderr.write("\n")
-
-            # Extract tests
-            proc = subprocess.run(["tar", "xf", test_archive], stdout=subprocess.PIPE,
-                                  stderr=subprocess.PIPE, universal_newlines=True)
-
-            # delete archive
-            if proc.returncode == 0:
-                os.remove(test_archive)
-
-        self.args["test"] = os.listdir(test_dir)
-
+        tests = ArchiveArtifact("lld-speed-test",
+                                "https://s3-us-west-2.amazonaws.com/linker-tests/lld-speed-test.tar.xz",
+                                "tar",
+                                "2d449a11109c7363f67fd45513b42270f5ba2a92")
+        tests.provide(self.build_dir)
 
     def cleanup(self):
         for perm in self.iterate_args():
@@ -84,7 +67,6 @@ class BenchmarkLld(Benchmark):
             if os.path.isfile(a_out):
                 os.remove(a_out)
 
-
     def summary(self):
         args = self.results["args"]
         allocators = self.results["allocators"]
diff --git a/src/benchmarks/raxmlng.py b/src/benchmarks/raxmlng.py
index 119bab7..811721a 100644
--- a/src/benchmarks/raxmlng.py
+++ b/src/benchmarks/raxmlng.py
@@ -23,8 +23,9 @@ import subprocess
 import sys
 from urllib.request import urlretrieve
 
+from src.artifact import GitArtifact
 from src.benchmark import Benchmark
-from src.util import print_info, download_reporthook
+from src.util import print_info
 
 
 RUNTIME_RE = re.compile("Elapsed time: (?P<runtime>(\\d*.\\d*)) seconds")
@@ -39,64 +40,51 @@ class BenchmarkRaxmlng(Benchmark):
 
         super().__init__(name)
         
-        self.cmd = (f"raxml-ng --msa {self.build_dir}/ng-tutorial/prim.phy --model GTR+G"
+        self.cmd = (f"raxml-ng --msa {self.build_dir}/data/prim.phy --model GTR+G"
                     " --redo --threads 2 --seed 2")
 
     def prepare(self):
         super().prepare()
 
-        # git clone --recursive 
-        # cd raxml-ng
-        # mkdir build && cd build
-        # cmake ..
-        # make
+        if os.path.exists(self.build_dir):
+            return
 
-        version = "0.9"
-        
-        url = "https://github.com/amkozlov/raxml-ng"
-        data_url = "https://github.com/amkozlov/ng-tutorial"
+        raxmlng_sources = GitArtifact("raxml-ng", "https://github.com/amkozlov/raxml-ng")
+        raxmlng_version = "0.9.0"
         raxmlng_dir = os.path.join(self.build_dir, "raxml-ng-git")
         raxmlng_builddir = os.path.join(raxmlng_dir, "build")
-
-        self.results["facts"]["versions"]["raxml-ng"] = version
-
-        if not os.path.isdir(raxmlng_dir):
-            proc = subprocess.run(["git", "clone", "--recursive", url, raxmlng_dir],
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
+        self.results["facts"]["versions"]["raxml-ng"] = raxmlng_version
+        raxmlng_sources.provide(raxmlng_version, raxmlng_dir)
             
-            # Create builddir
-            os.makedirs(raxmlng_builddir, exist_ok=True)
-
-            # building raxml-ng
-            proc = subprocess.run(["cmake", ".."],
-                                  cwd=raxmlng_builddir,
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
-
-            proc = subprocess.run(["make"],
-                                  cwd=raxmlng_builddir,
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
-            
-            # create symlinks
-            for exe in ["raxml-ng"]:
-                src = os.path.join(raxmlng_dir, "bin", exe)
-                dest = os.path.join(self.build_dir,exe)
-                os.link(src, dest)
-
-            # clone test data
-            proc = subprocess.run(["git", "clone", data_url],
-                                  cwd=self.build_dir,
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
+        # Create builddir
+        os.makedirs(raxmlng_builddir, exist_ok=True)
+
+        # building raxml-ng
+        proc = subprocess.run(["cmake", ".."],
+                              cwd=raxmlng_builddir,
+                              # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                              universal_newlines=True)
+
+        proc = subprocess.run(["make"],
+                              cwd=raxmlng_builddir,
+                              # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                              universal_newlines=True)
+
+        # create symlinks
+        for exe in ["raxml-ng"]:
+            src = os.path.join(raxmlng_dir, "bin", exe)
+            dest = os.path.join(self.build_dir,exe)
+            os.link(src, dest)
+
+        raxmlng_data = GitArtifact("raxml-ng-data", "https://github.com/amkozlov/ng-tutorial")
+        raxmlng_data_dir = os.path.join(self.build_dir, "data")
+        raxmlng_data.provide("f8f0b6a057a11397b4dad308440746e3436db8b4", raxmlng_data_dir)
 
     def cleanup(self):
         for direntry in os.listdir():
             if direntry.startswith("prim.raxml"):
                 os.remove(direntry)
 
-
     @staticmethod
     def process_output(result, stdout, stderr, allocator, perm):
         result["runtime"] = RUNTIME_RE.search(stdout).group("runtime")
diff --git a/src/benchmarks/redis.py b/src/benchmarks/redis.py
index d67559a..80bd244 100644
--- a/src/benchmarks/redis.py
+++ b/src/benchmarks/redis.py
@@ -23,8 +23,9 @@ import subprocess
 import sys
 from urllib.request import urlretrieve
 
+from src.artifact import ArchiveArtifact
 from src.benchmark import Benchmark
-from src.util import print_info, download_reporthook
+from src.util import print_info
 
 
 REQUESTS_RE = re.compile("(?P<requests>(\\d*.\\d*)) requests per second")
@@ -51,40 +52,26 @@ class BenchmarkRedis(Benchmark):
         super().prepare()
 
         redis_version = "5.0.5"
-        redis_archive = f"redis-{redis_version}.tar.gz"
-        redis_url = f"http://download.redis.io/releases/{redis_archive}"
+        self.results["facts"]["versions"]["redis"] = redis_version
+        redis = ArchiveArtifact("redis",
+                                f"http://download.redis.io/releases/redis-{redis_version}.tar.gz",
+                                "tar",
+                                "71e38ae09ac70012b5bc326522b976bcb8e269d6")
+
         redis_dir = os.path.join(self.build_dir, f"redis-{redis_version}")
 
-        self.results["facts"]["versions"]["redis"] = redis_version
+        redis.provide(redis_dir)
+
+        # building redis
+        proc = subprocess.run(["make", "-C", redis_dir],
+                              # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                              universal_newlines=True)
 
-        if not os.path.isdir(redis_dir):
-            if not os.path.isfile(redis_archive):
-                print(f"Downloading redis-{redis_version}...")
-                urlretrieve(redis_url, redis_archive, download_reporthook)
-                sys.stderr.write("\n")
-
-            # Create build_dir
-            os.mkdir(self.build_dir)
-
-            # Extract redis
-            proc = subprocess.run(["tar", "Cxf", self.build_dir, redis_archive],
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
-
-            # delete archive
-            if proc.returncode == 0:
-                os.remove(redis_archive)
-
-            # building redis
-            proc = subprocess.run(["make", "-C", redis_dir],
-                                  # stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                  universal_newlines=True)
-
-            # create symlinks
-            for exe in ["redis-cli", "redis-server", "redis-benchmark"]:
-                src = os.path.join(redis_dir, "src", exe)
-                dest = os.path.join(self.build_dir, exe)
-                os.link(src, dest)
+        # create symlinks
+        for exe in ["redis-cli", "redis-server", "redis-benchmark"]:
+            src = os.path.join(redis_dir, "src", exe)
+            dest = os.path.join(self.build_dir, exe)
+            os.link(src, dest)
 
     @staticmethod
     def process_output(result, stdout, stderr, allocator, perm):
diff --git a/src/util.py b/src/util.py
index 8b9e585..dc66186 100644
--- a/src/util.py
+++ b/src/util.py
@@ -24,18 +24,6 @@ import sys
 
 import src.globalvars
 
-def download_reporthook(blocknum, blocksize, totalsize):
-    """Status report hook for urlretrieve"""
-    readsofar = blocknum * blocksize
-    if totalsize > 0:
-        percent = readsofar * 100 / totalsize
-        status = "\r%5.1f%% %*d / %d" % (
-                  percent, len(str(totalsize)), readsofar, totalsize)
-        sys.stderr.write(status)
-    else:  # total size is unknown
-        sys.stderr.write(f"\rdownloaded {readsofar}")
-
-
 def is_exe(fpath):
     """Check if the given path is an exexutable file"""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)