def run_tests(self, experiment): from benchbuild.project import wrap wrap(path.join(self.builddir, "usr", "bin", "7z"), experiment, self.builddir) sevenz = uchroot()["/usr/bin/7z"] run(sevenz["b", "-mmt1"])
def configure(self): clang = cc(self) with local.cwd(self.src_dir): configure = local["./configure"] with local.env(CC=str(clang)): run(configure["--disable-dependency-tracking", "--disable-silent-rules", "--with-gnu-ld"])
def compile(self): with local.env(CC="gcc", CXX="g++"): emerge_in_chroot = uchroot.uchroot()["/usr/bin/emerge"] run.run(emerge_in_chroot["app-portage/portage-utils"]) run.run(emerge_in_chroot["app-portage/gentoolkit"]) qgrep_in_chroot = uchroot.uchroot()["/usr/bin/qgrep"] equery_in_chroot = uchroot.uchroot()["/usr/bin/equery"] ebuilds = set() languages = CFG["gentoo"]["autotest_lang"].value use_flags = CFG["gentoo"]["autotest_use"].value file_location = str(CFG["gentoo"]["autotest_loc"]) for language in languages: output = qgrep_in_chroot("-l", get_string_for_language(language)) for line in output.split('\n'): if "ebuild" in line: parts = line.split('.ebuild')[0].split('/') package_atom = '{0}/{1}'.format(parts[0], parts[1]) ebuilds.add(package_atom) for use in use_flags: output = equery_in_chroot("-q", "hasuse", "-p", use) ebuilds_use = set() for line in output.split('\n'): ebuilds_use.add(re.sub(r"(.*)-[0-9]+.*$", r"\1", line)) ebuilds = ebuilds.intersection(ebuilds_use) with open(file_location, "w") as output_file: for ebuild in sorted(ebuilds): output_file.write(str(ebuild) + "\n") output_file.flush()
def build(self): from plumbum.cmd import make from benchbuild.utils.run import run ccrypt_dir = path.join(self.builddir, self.src_dir) with local.cwd(ccrypt_dir): run(make["check"])
def run_tests(self, runner): mcrypt_dir = local.path(self.builddir) / "mcrypt-2.6.8" mcrypt_libs = mcrypt_dir / "src" / ".libs" aestest = wrapping.wrap(mcrypt_libs / "lt-aestest", self) ciphertest = wrapping.wrap(mcrypt_libs / "lt-ciphertest", self) run.run(aestest) run.run(ciphertest)
def run_tests(self, experiment): from plumbum.cmd import mkdir from benchbuild.project import wrap from benchbuild.utils.run import run povray_dir = path.join(self.builddir, self.src_dir) povray_binary = path.join(povray_dir, "unix", self.name) tmpdir = path.join(self.builddir, "tmp") povini = path.join(self.builddir, "cfg", ".povray", "3.6", "povray.ini") scene_dir = path.join(self.builddir, "share", "povray-3.6", "scenes") mkdir(tmpdir, retcode=None) povray = wrap(povray_binary, experiment) pov_files = find(scene_dir, "-name", "*.pov").splitlines() for pov_f in pov_files: from plumbum.cmd import head, grep, sed with local.env(POVRAY=povray_binary, INSTALL_DIR=self.builddir, OUTPUT_DIR=tmpdir, POVINI=povini): options = ((((head["-n", "50", "\"" + pov_f + "\""] | grep["-E", "'^//[ ]+[-+]{1}[^ -]'"]) | head["-n", "1"]) | sed["s?^//[ ]*??"]) & FG) run(povray["+L" + scene_dir, "+L" + tmpdir, "-i" + pov_f, "-o" + tmpdir, options, "-p"], retcode=None)
def run_tests(self, experiment): from benchbuild.project import wrap from benchbuild.utils.run import run exp = wrap(self.run_f, experiment) for i in range(1, 15): run(exp[str(i)])
def download(self): super(PrepareStage3, self).download() with local.cwd(self.builddir + "/usr"): Wget(self.src_uri_portage, self.src_file_portage) run(tar["xfj", self.src_file_portage]) rm(self.src_file_portage)
def build(self): clang = cc(self) with local.cwd(self.src_dir): target_opts = ["-DCPUS=1", "-DSYZYGY", "-DTEST"] crafty_make = make["target=UNIX", "CC="+str(clang), "opt="+" ".join(target_opts), "crafty-make"] run(crafty_make)
def run_tests(self, experiment, run): mozjs_dir = path.join("mozjs-0.0.0", "js", "src", "obj") wrap(path.join(mozjs_dir, "js", "src", "shell", "js"), partial(experiment, may_wrap=False)) with local.cwd(mozjs_dir): run(make["check-jstests"])
def run_tests(self, runner): with local.cwd(path.join(self.src_dir, "tests")): for binary in LibreSSL.BINARIES: wrap(path.abspath(binary), self) with local.cwd(self.src_dir): run(make["V=1", "check", "-i"])
def build(self): from plumbum.cmd import make from benchbuild.utils.run import run gzip_dir = path.join(self.builddir, self.src_dir) with local.cwd(gzip_dir): run(make["-j" + CFG["jobs"], "clean", "all"])
def compile(self): self.download() polybench_opts = CFG["projects"]["polybench"] verify = bool(polybench_opts["verify"]) workload = str(polybench_opts["workload"]) src_dir = local.cwd / self.src_file src_sub = src_dir / self.path_dict[self.name] / self.name src_file = src_sub / (self.name + ".c") kernel_file = src_sub / (self.name + "_kernel.c") utils_dir = src_dir / "utilities" polybench_opts = [ "-D" + str(workload), "-DPOLYBENCH_USE_C99_PROTO", "-DPOLYBENCH_USE_RESTRICT" ] if verify: polybench_opts = self.compile_verify([ "-I", utils_dir, "-I", src_sub, utils_dir / "polybench.c", kernel_file, src_file, "-lm" ], polybench_opts) clang = compiler.cc(self) run.run(clang[ "-I", utils_dir, "-I", src_sub, polybench_opts, utils_dir / "polybench.c", kernel_file, src_file, "-lm", "-o", self.name])
def build(self): from plumbum.cmd import make from benchbuild.utils.run import run sdcc_dir = path.join(self.builddir, self.src_dir) with local.cwd(sdcc_dir): run(make["-j", CFG["jobs"]])
def __str__(self): try: domain, _, name = self.name.partition("_") package = domain + '/' + name _container = self.container() _uchroot = uchroot.no_args() _uchroot = _uchroot["-E", "-A", "-C", "-w", "/", "-r"] _uchroot = _uchroot[_container.local] with local.env(CONFIG_PROTECT="-*"): fake_emerge = _uchroot["emerge", "--autounmask-only=y", "--autounmask-write=y", "--nodeps"] run.run(fake_emerge[package]) emerge_in_chroot = \ _uchroot["emerge", "-p", "--nodeps", package] _, stdout, _ = emerge_in_chroot.run() for line in stdout.split('\n'): if package in line: _, _, package_name = line.partition("/") _, name, version = package_name.partition(name) version, _, _ = version.partition(" ") return version[1:] except ProcessExecutionError: logger = logging.getLogger(__name__) logger.info("This older package might not exist any more.") return ""
def compile(self): self.download() js_dir = local.path(self.src_file) / "js" / "src" clang = compiler.cc(self) clang_cxx = compiler.cxx(self) with local.cwd(js_dir): make_src_pkg = local["./make-source-package.sh"] with local.env( DIST=self.builddir, MOZJS_MAJOR_VERSION=0, MOZJS_MINOR_VERSION=0, MOZJS_PATCH_VERSION=0): make_src_pkg() mozjs_dir = local.path("mozjs-0.0.0") mozjs_src_dir = mozjs_dir / "js" / "src" tar("xfj", mozjs_dir + ".tar.bz2") with local.cwd(mozjs_src_dir): mkdir("obj") autoconf = local["autoconf-2.13"] autoconf() with local.cwd("obj"): with local.env(CC=str(clang), CXX=str(clang_cxx)): configure = local["../configure"] configure = configure["--without-system-zlib"] run.run(configure) mozjs_obj_dir = mozjs_src_dir / "obj" with local.cwd(mozjs_obj_dir): run.run(make["-j", str(CFG["jobs"])])
def configure(self): clang = cc(self) clang_cxx = cxx(self) with local.cwd(self.src_dir): with local.env(CC=str(clang), CXX=str(clang_cxx)): configure = local["./configure"] run(configure["--with-static-linked-ext", "--disable-shared"])
def run_tests(self, runner): leveldb_dir = local.path("leveldb.src") with local.cwd(leveldb_dir): with local.env(LD_LIBRARY_PATH=leveldb_dir): sqlite = wrapping.wrap( leveldb_dir / 'out-static' / 'db_bench_sqlite3', self) run.run(sqlite)
def compile(self): self.download() makefile_config = local.path(self.src_file) / "config" / "make.config" clang = compiler.cc(self) with open(makefile_config, 'w') as config: lines = [ "LABEL=benchbuild", "ENABLE_OMPSS=", "OMPSSC=", "OMPC=", "CC={cc}", "OMPSSLINK=", "OMPLINK={cc} -fopenmp", "CLINK={cc}", "OPT_FLAGS=", "CC_FLAGS=", "OMPC_FLAGS=", "OMPSSC_FLAGS=", "OMPC_FINAL_FLAGS=", "OMPSSC_FINAL_FLAG=", "CLINK_FLAGS=", "OMPLINK_FLAGS=", "OMPSSLINK_FLAGS=", ] lines = [l.format(cc=clang) + "\n" for l in lines] config.writelines(lines) mkdir(local.path(self.src_file) / "bin") with local.cwd(self.src_file): run.run(make["-C", self.path_dict[self.name]])
def run_tests(self, experiment, run): leveldb_dir = "leveldb.src" with local.cwd(leveldb_dir): with local.env(LD_LIBRARY_PATH=path.abspath(self.src_dir)): sqlite = wrap(path.join("out-static", "db_bench_sqlite3"), experiment) run(sqlite)
def run_tests(self, experiment): from benchbuild.project import wrap from benchbuild.utils.run import run p7z_dir = path.join(self.builddir, self.src_dir) exp = wrap(path.join(p7z_dir, "bin", "7za"), experiment) run(exp["b", "-mmt1"])
def build(self): from plumbum.cmd import make from benchbuild.utils.run import run rasdaman_dir = path.join(self.builddir, self.src_dir) with local.cwd(rasdaman_dir): run(make["clean", "all", "-j", CFG["jobs"]])
def run_tests(self, runner): mozjs_dir = path.join("mozjs-0.0.0", "js", "src", "obj") self.runtime_extension = partial(self, may_wrap=False) wrap(path.join(mozjs_dir, "js", "src", "shell", "js"), self) with local.cwd(mozjs_dir): run(make["check-jstests"])
def configure(self): mcrypt_dir = self.src_dir mhash_dir = self.mhash_dir libmcrypt_dir = self.libmcrypt_dir # Build mhash dependency with local.cwd(mhash_dir): configure = local["./configure"] with local.env(CC=cc(self), CXX=cxx(self)): run(configure["--prefix=" + self.builddir]) run(make["-j", CFG["jobs"], "install"]) # Builder libmcrypt dependency with local.cwd(libmcrypt_dir): configure = local["./configure"] with local.env(CC=cc(self), CXX=cxx(self)): run(configure["--prefix=" + self.builddir]) run(make["-j", CFG["jobs"], "install"]) with local.cwd(mcrypt_dir): configure = local["./configure"] with local.env(CC=cc(self), CXX=cxx(self), LD_LIBRARY_PATH=path.join(self.builddir, "lib") + ":" + CFG["ld_library_path"].value(), LDFLAGS="-L" + path.join(self.builddir, "lib"), CFLAGS="-I" + path.join(self.builddir, "include")): run(configure["--disable-dependency-tracking", "--enable-static", "--disable-shared", "--with-libmcrypt=" + self.builddir, "--with-libmhash=" + self.builddir])
def configure(self): from plumbum.cmd import make from benchbuild.utils.run import run minisat_dir = path.join(self.builddir, self.src_dir) with local.cwd(minisat_dir): run(make["config"])
def run_tests(self, experiment): from benchbuild.utils.run import run exp = experiment(self.run_f) pg_ctl = local[path.join(self.builddir, "pg_ctl")] dropdb = local[path.join(self.builddir, "dropdb")] createdb = local[path.join(self.builddir, "createdb")] pgbench = local[path.join(self.builddir, "pgbench")] bin_name = path.join(self.builddir, self.name + ".sh") test_data = path.join(self.testdir, "test-data") (echo["#!/bin/sh"] >> bin_name) & FG (echo[str(exp)] >> bin_name) & FG chmod("+x", bin_name) num_clients = 1 num_transactions = 1000000 pg_ctl("stop", "-t", 360, "-w", "-D", test_data, retcode=None) try: with local.cwd(test_data): pg_ctl("start", "-p", bin_name, "-w", "-D", test_data) dropdb["pgbench"] & FG(retcode=None) createdb("pgbench") run(pgbench["-i", "pgbench"]) run(pgbench[ "-c", num_clients, "-S", "-t", num_transactions, "pgbench"]) dropdb("pgbench") pg_ctl("stop", "-t", 360, "-w", "-D", test_data) except Exception: pg_ctl("stop", "-t", 360, "-w", "-D", test_data) raise
def run_tests(self, experiment): from benchbuild.project import wrap from benchbuild.utils.run import run crafty_dir = path.join(self.builddir, self.src_dir) exp = wrap(path.join(crafty_dir, "crafty"), experiment) run((cat[path.join(self.testdir, "test1.sh")] | exp)) run((cat[path.join(self.testdir, "test2.sh")] | exp))
def build(self): from plumbum.cmd import make from benchbuild.utils.run import run js_dir = path.join(self.builddir, self.src_dir, "js", "src") with local.cwd(path.join(js_dir, "build_OPT.OBJ")): run(make["-j", CFG["available_cpu_count"]])
def configure(self): clang = cc(self) with local.cwd(self.src_dir): mkdir("build") with local.cwd("build"): configure = local["../configure"] run(configure["--cc=" + str(clang), "--with-libgcc"])
def build(self): self.ldflags += ["-lgomp"] clang_cxx = cxx(self) with local.cwd(os.path.join(self.src_dir, "src")): run(make["CC=" + str(clang_cxx), "LINK=" + str(clang_cxx), "clean", "serial"])
def run_tests(self, experiment): from plumbum.cmd import make from benchbuild.project import wrap from benchbuild.utils.run import run wrap(self.run_f, experiment) with local.cwd(self.builddir): run(make["test"])
def configure(self): clang = cc(self) clang_cxx = cxx(self) with local.cwd(self.src_dir): configure = local["./configure"] with local.env(CC=str(clang), CXX=str(clang_cxx)): run(configure["--disable-shared", "--without-gcc"])
def build(self): clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension) with local.cwd(self.src_dir): run(clang["-fPIC", "-I.", "-c", "sqlite3.c"]) run(clang["-shared", "-o", "libsqlite3.so", "sqlite3.o", "-ldl"]) self.build_leveldb()
def build(self): with local.cwd(self.SRC_FILE): clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension) clang_cxx = lt_clang_cxx(self.cflags, self.ldflags, self.compiler_extension) run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean", "lsh", "sh"])
def configure(self): clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension) clang_cxx = lt_clang_cxx(self.cflags, self.ldflags, self.compiler_extension) with local.cwd(self.src_dir): with local.env(CC=str(clang), CXX=str(clang_cxx)): configure = local["./configure"] run(configure["--with-static-linked-ext", "--disable-shared"])
def build(self): src_file = path.join(self.name + ".dir", self.name + ".c") clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension) run(clang["-I", "utilities", "-I", self.name, "-DPOLYBENCH_USE_C99_PROTO", "-DEXTRALARGE_DATASET", "-DPOLYBENCH_USE_RESTRICT", "utilities/polybench.c", src_file, "-lm", "-o", self.run_f])
def build(self): clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension) clang_cxx = lt_clang_cxx(self.cflags, self.ldflags, self.compiler_extension) with local.cwd(self.src_dir): run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean", "all"])
def build(self): emerge_in_chroot = uchroot()["/usr/bin/emerge"] with local.env(USE="server"): run(emerge_in_chroot["dev-db/postgresql:9.4"]) pg_socketdir = "/run/postgresql" if not path.exists(self.outside(pg_socketdir)): run(mkdir["-p", self.outside(pg_socketdir)])
def build(self): from benchbuild.utils.compiler import lt_clang_cxx from benchbuild.utils.run import run with local.cwd(self.builddir): clang_cxx = lt_clang_cxx(self.cflags, self.ldflags, self.compiler_extension) run(clang_cxx["-o", self.run_f, self.src_file])
def build(self): with local.cwd(self.builddir): emerge_in_chroot = uchroot()["/usr/bin/emerge"] prog = self.DOMAIN + "/" + str(self.NAME)[len(self.DOMAIN)+1:] with local.env(CONFIG_PROTECT="-*"): emerge_in_chroot("--autounmask-only=y", "--autounmask-write=y", prog, retcode=None) run(emerge_in_chroot[prog])
def compile(self): self.download() self.ldflags += ["-lgomp"] clang_cxx = compiler.cxx(self) with local.cwd(local.path(self.src_file) / "src"): run.run(make["CC=" + str(clang_cxx), "LINK=" + str(clang_cxx), "clean", "serial"])
def run_tests(self, experiment, run): with local.cwd(path.join(self.src_dir, "tests", ".libs")): files = find(".", "-type", "f", "-executable") for wrap_f in files.split("\n"): if wrap_f: wrap(wrap_f, experiment) with local.cwd(self.src_dir): run(make["V=1", "check"])
def build(self): clang = cc(self) with local.cwd(self.src_dir): run(clang["-fPIC", "-I.", "-c", "sqlite3.c"]) run(clang["-shared", "-o", "libsqlite3.so", "sqlite3.o", "-ldl"]) self.build_leveldb()
def compile(self): self.download() lp_patch = path.template_path("../projects/patches/linpack.patch") (patch["-p0"] < lp_patch)() self.ldflags += ["-lm"] clang = compiler.cc(self) run.run(clang["-o", self.run_f, "linpack.c"])
def run_tests(self, experiment, run): exp = wrap(self.run_f, experiment) programs = glob(path.join(self.testdir, "programs", "*.rml")) projects = glob(path.join(self.testdir, "projects", "*.rsf")) for program in programs: for project in projects: run((cat[project] | exp[program]), None)
def compile(self): self.download() clang = compiler.cc(self) clang_cxx = compiler.cxx(self) with local.cwd(self.src_file): with local.env(CXX=str(clang_cxx), CC=str(clang)): make("clean") run.run(make["all", "-i"])
def run_tests(self, experiment): from benchbuild.project import wrap from benchbuild.utils.run import run mcrypt_dir = path.join(self.builddir, self.src_dir, "src", ".libs") aestest = wrap(path.join(mcrypt_dir, "lt-aestest"), experiment) run(aestest) ciphertest = wrap(path.join(mcrypt_dir, "lt-ciphertest"), experiment) run(ciphertest)
def run_tests(self, experiment): from benchbuild.project import wrap from benchbuild.utils.run import run leveldb_dir = path.join(self.builddir, "leveldb.src") with local.cwd(leveldb_dir): sqlite = wrap( path.join(leveldb_dir, "out-static", "db_bench_sqlite3"), experiment) run(sqlite)
def configure(self): clang = cc(self) clang_cxx = cxx(self) with local.cwd(self.SRC_FILE): configure = local["./configure"] with local.env(CC=str(clang), CXX=str(clang_cxx)): run(configure["--without-ccache", "--disable-pic14-port", "--disable-pic16-port"])
def build(self): emerge_in_chroot = uchroot()["/usr/bin/emerge"] prog = self.DOMAIN + "/" + str(self.NAME)[len(self.DOMAIN) + 1:] with local.env(CONFIG_PROTECT="-*"): emerge_in_chroot("--autounmask-only=y", "--autounmask-write=y", prog, retcode=None) run(emerge_in_chroot[prog])
def compile(self): self.download() testfiles = [local.path(self.testdir) / x for x in self.testfiles] cp(testfiles, '.') clang = compiler.cc(self) with local.cwd(self.src_file): run.run(make["CFLAGS=-O3", "CC=" + str(clang), "clean", "bzip2"])
def build(self): from plumbum.cmd import make, rm from benchbuild.utils.run import run povray_dir = path.join(self.builddir, self.src_dir) povray_binary = path.join(povray_dir, "unix", self.name) with local.cwd(povray_dir): rm("-f", povray_binary) run(make["clean", "all"])