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 build(self):
from benchbuild.utils.run import run
src_file = path.join(self.name + ".dir", self.name + ".c")
kernel_file = path.join("{name}.dir".format(name=self.name),
"{name}_kernel.c".format(name=self.name))
cflags = self.cflags
ldflags = self.ldflags
self.cflags = []
self.ldflags = []
clang_no_opts = cc(self)
self.cflags = cflags
self.ldflags = ldflags
polybench_opts = [
"-DEXTRALARGE_DATASET", "-DPOLYBENCH_USE_C99_PROTO",
"-DPOLYBENCH_DUMP_ARRAYS", "-DPOLYBENCH_USE_RESTRICT"
]
run(clang_no_opts["-I", "utilities", "-I", self.name, polybench_opts,
"utilities/polybench.c", kernel_file, src_file,
"-lm", "-o", self.run_f + ".no-opts"])
clang = cc(self)
run(clang["-I", "utilities", "-I", self.name, polybench_opts,
"utilities/polybench.c", kernel_file, src_file, "-lm", "-o",
self.run_f])
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 build(self):
clang = cc(self)
clang_cxx = cxx(self)
with local.cwd(self.src_dir):
run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean",
"all"])
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):
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):
makefile_config = os.path.join(self.SRC_FILE, "config", "make.config")
clang = 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)
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 compile(self):
self.download()
download.Git(self.gdal_uri, self.gdal_dir)
rasdaman_dir = local.path(self.src_file)
gdal_dir = local.path(self.gdal_dir) / self.gdal_dir
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(gdal_dir):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run.run(configure["--with-pic", "--enable-static",
"--disable-debug", "--with-gnu-ld",
"--without-ld-shared", "--without-libtool"])
run.run(make["-j", CFG["jobs"]])
with local.cwd(rasdaman_dir):
autoreconf("-i")
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run.run(configure["--without-debug-symbols",
"--enable-benchmark", "--with-static-libs",
"--disable-java", "--with-pic",
"--disable-debug", "--without-docs"])
run.run(make["clean", "all", "-j", CFG["jobs"]])
def configure(self):
clang = cc(self)
with local.cwd(self.src_dir):
configure = local["./configure"]
run(configure["--disable-shared", "--cc=" + str(
clang), "--extra-ldflags=" + " ".join(self.ldflags),
"--samples=" + self.fate_dir])
def compile(self):
self.download()
download.Git(self.test_suite_uri, self.test_suite_dir)
venv_path = local.cwd / "local"
virtualenv(venv_path, "--python=python2")
pip_path = local.cwd / "local" / "bin" / "pip"
pip = local[pip_path]
with local.cwd(self.SRC_FILE):
pip("install", "--no-cache-dir", "--disable-pip-version-check",
"-e", ".")
self.sandbox_dir = local.cwd / "run"
if self.sandbox_dir.exists():
rm("-rf", self.sandbox_dir)
mkdir(self.sandbox_dir)
self.lnt = local[local.path("./local/bin/lnt")]
self.clang = compiler.cc(self, detect_project=True)
self.clang_cxx = compiler.cxx(self, detect_project=True)
self.lnt("runtest", "test-suite", "-v", "-j1", "--sandbox",
self.sandbox_dir, "--benchmarking-only",
"--only-compile", "--cc", str(self.clang), "--cxx",
str(self.clang_cxx), "--test-suite", self.test_suite_dir,
"--only-test=" + self.SUBDIR)
def compile(self):
self.download()
tar("xfz", self.src_file)
unpack_dir = "CLAPACK-{0}".format(self.version)
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(unpack_dir):
with open("make.inc", 'w') as makefile:
content = [
"SHELL = /bin/sh\n", "PLAT = _LINUX\n",
"CC = " + str(clang) + "\n",
"CXX = " + str(clang_cxx) + "\n",
"CFLAGS = -I$(TOPDIR)/INCLUDE\n",
"LOADER = " + str(clang) + "\n", "LOADOPTS = \n",
"NOOPT = -O0 -I$(TOPDIR)/INCLUDE\n",
"DRVCFLAGS = $(CFLAGS)\n", "F2CCFLAGS = $(CFLAGS)\n",
"TIMER = INT_CPU_TIME\n", "ARCH = ar\n",
"ARCHFLAGS = cr\n", "RANLIB = ranlib\n",
"BLASLIB = ../../blas$(PLAT).a\n", "XBLASLIB = \n",
"LAPACKLIB = lapack$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n",
"TMGLIB = tmglib$(PLAT).a\n",
"EIGSRCLIB = eigsrc$(PLAT).a\n",
"LINSRCLIB = linsrc$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n"
]
makefile.writelines(content)
run.run(make["-j", CFG["jobs"], "f2clib", "blaslib"])
with local.cwd(local.path("BLAS") / "TESTING"):
run.run(make["-j", CFG["jobs"], "-f", "Makeblat2"])
run.run(make["-j", CFG["jobs"], "-f", "Makeblat3"])
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 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 compile(self):
self.download()
tar("xfz", self.src_file)
unpack_dir = "CLAPACK-{0}".format(self.version)
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(unpack_dir):
with open("make.inc", 'w') as makefile:
content = [
"SHELL = /bin/sh\n", "PLAT = _LINUX\n",
"CC = " + str(clang) + "\n", "CXX = " +
str(clang_cxx) + "\n", "CFLAGS = -I$(TOPDIR)/INCLUDE\n",
"LOADER = " + str(clang) + "\n", "LOADOPTS = \n",
"NOOPT = -O0 -I$(TOPDIR)/INCLUDE\n",
"DRVCFLAGS = $(CFLAGS)\n", "F2CCFLAGS = $(CFLAGS)\n",
"TIMER = INT_CPU_TIME\n", "ARCH = ar\n",
"ARCHFLAGS = cr\n", "RANLIB = ranlib\n",
"BLASLIB = ../../blas$(PLAT).a\n", "XBLASLIB = \n",
"LAPACKLIB = lapack$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n",
"TMGLIB = tmglib$(PLAT).a\n",
"EIGSRCLIB = eigsrc$(PLAT).a\n",
"LINSRCLIB = linsrc$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n"
]
makefile.writelines(content)
run.run(make["-j", CFG["jobs"], "f2clib", "blaslib"])
with local.cwd(local.path("BLAS") / "TESTING"):
run.run(make["-j", CFG["jobs"], "-f", "Makeblat2"])
run.run(make["-j", CFG["jobs"], "-f", "Makeblat3"])
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 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 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 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 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 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 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 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 configure(self):
clang = cc(self)
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--disable-thread", "--disable-opencl",
"--enable-pic"])
def configure(self):
clang = cc(self)
clang_cxx = cxx(self)
ccrypt_dir = path.join('.', self.src_dir)
with local.cwd(ccrypt_dir):
configure = local["./configure"]
with local.env(CC=str(clang),
CXX=str(clang_cxx)):
run(configure)
def configure(self):
self.cflags += ["-fPIC"]
clang = cc(self)
configure = local[path.join(self.src_dir, "configure")]
with local.cwd(self.src_dir):
with local.env(CC=str(clang)):
run(configure["--disable-asm", "--disable-shared",
"--enable-static",
"--disable-dependency-tracking",
"--with-pic=yes"])
def configure(self):
clang = cc(self)
with local.cwd(self.src_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--enable-threads=no", "--with-gnu-ld=yes",
"--disable-shared",
"--disable-dependency-tracking",
"--disable-xzdec", "--disable-lzmadec",
"--disable-lzmainfo", "--disable-lzma-links",
"--disable-scripts", "--disable-doc"])
def compile(self):
self.download()
with local.cwd(self.src_file):
git("fetch", "origin", "pull/17/head:clang")
git("checkout", "clang")
run.run(make["config"])
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
run.run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean",
"lsh", "sh"])
def build(self):
c_compiler = cc(self)
cxx_compiler = cxx(self)
with local.cwd(self.in_src_dir):
for outfile, srcfiles in self.config['src'].items():
cls = type(self)
compiler = cls.select_compiler(c_compiler, cxx_compiler)
if "flags" in self.config:
compiler = compiler[self.config["flags"]]
compiler = compiler[srcfiles]
compiler = compiler["-o", outfile]
run(compiler)
def compile(self):
self.download()
tar("xfz", self.src_file)
unpack_dir = local.path('ruby-{0}'.format(self.version))
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(unpack_dir):
with local.env(CC=str(clang), CXX=str(clang_cxx)):
configure = local["./configure"]
run.run(configure["--with-static-linked-ext",
"--disable-shared"])
run.run(make["-j", CFG["jobs"]])
def build_leveldb(self):
sqlite_dir = self.src_dir
leveldb_dir = "leveldb.src"
# We need to place sqlite3 in front of all other flags.
self.ldflags += ["-L{0}".format(path.abspath(sqlite_dir))]
self.cflags += ["-I{0}".format(path.abspath(sqlite_dir))]
clang_cxx = cxx(self)
clang = cc(self)
with local.cwd(leveldb_dir):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
run(make["clean", "out-static/db_bench_sqlite3"])
def compile(self):
download.Svn(self.src_uri, self.SRC_FILE)
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run.run(configure["--without-ccache", "--disable-pic14-port",
"--disable-pic16-port"])
run.run(make["-j", CFG["jobs"]])
def build_leveldb(self):
sqlite_dir = local.path('sqlite-amalgamation-{0}'.format(self.version))
leveldb_dir = "leveldb.src"
# We need to place sqlite3 in front of all other flags.
self.ldflags += ["-L{0}".format(sqlite_dir)]
self.cflags += ["-I{0}".format(sqlite_dir)]
clang_cxx = compiler.cxx(self)
clang = compiler.cc(self)
with local.cwd(leveldb_dir):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
run.run(make["clean", "out-static/db_bench_sqlite3"])
def compile(self):
self.download()
download.Wget(self.libmcrypt_uri, self.libmcrypt_file)
download.Wget(self.mhash_uri, self.mhash_file)
tar('xfz', self.src_file)
tar('xfz', self.libmcrypt_file)
tar('xfz', self.mhash_file)
builddir = local.path(self.builddir)
mcrypt_dir = builddir / "mcrypt-2.6.8"
mhash_dir = builddir / self.mhash_dir
libmcrypt_dir = builddir / self.libmcrypt_dir
_cc = compiler.cc(self)
_cxx = compiler.cxx(self)
# Build mhash dependency
with local.cwd(mhash_dir):
configure = local["./configure"]
with local.env(CC=_cc, CXX=_cxx):
run.run(configure["--prefix=" + builddir])
run.run(make["-j", CFG["jobs"], "install"])
# Builder libmcrypt dependency
with local.cwd(libmcrypt_dir):
configure = local["./configure"]
with local.env(CC=_cc, CXX=_cxx):
run.run(configure["--prefix=" + builddir])
run.run(make["-j", CFG["jobs"], "install"])
with local.cwd(mcrypt_dir):
configure = local["./configure"]
lib_dir = builddir / "lib"
inc_dir = builddir / "include"
env = CFG["env"].value
mod_env = dict(
CC=_cc,
CXX=_cxx,
LD_LIBRARY_PATH=path.list_to_path(
[str(lib_dir)] + env.get("LD_LIBRARY_PATH", [])),
LDFLAGS="-L" + str(lib_dir),
CFLAGS="-I" + str(inc_dir))
env.update(mod_env)
with local.env(**env):
run.run(configure["--disable-dependency-tracking",
"--enable-static", "--disable-shared",
"--with-libmcrypt=" +
builddir, "--with-libmhash=" + builddir])
run.run(make["-j", CFG["jobs"]])
def compile(self):
self.download()
tar("xfJ", self.src_file)
unpack_dir = local.path('Python-{0}'.format(self.version))
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
with local.cwd(unpack_dir):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run.run(configure["--disable-shared", "--without-gcc"])
run.run(make)
def compile(self):
self.download()
tar('xfj', self.src_file)
unpack_dir = "ffmpeg-{0}".format(self.version)
clang = compiler.cc(self)
with local.cwd(unpack_dir):
download.Rsync(self.fate_uri, self.fate_dir)
configure = local["./configure"]
run.run(configure[
"--disable-shared", "--cc=" + str(clang), "--extra-ldflags=" +
" ".join(self.ldflags), "--samples=" + self.fate_dir])
run.run(make["clean"])
run.run(make["-j{0}".format(str(CFG["jobs"])), "all"])
def compile(self):
self.download()
tar("xf", self.src_file)
unpack_dir = local.path('tcc-{0}.tar.bz2'.format(self.version))
clang = compiler.cc(self)
with local.cwd(unpack_dir):
mkdir("build")
with local.cwd("build"):
configure = local["../configure"]
run.run(configure["--cc=" + str(clang), "--with-libgcc"])
run.run(make)
def compile(self):
self.download()
unzip(self.src_file)
unpack_dir = local.path('sqlite-amalgamation-{0}'.format(self.version))
SQLite3.fetch_leveldb()
clang = compiler.cc(self)
with local.cwd(unpack_dir):
run.run(clang["-fPIC", "-I.", "-c", "sqlite3.c"])
run.run(
clang["-shared", "-o", "libsqlite3.so", "sqlite3.o", "-ldl"])
self.build_leveldb()
def compile(self):
package_atom = "{domain}/{name}".format(
domain=self.domain, name=self.name)
LOG.debug('Installing dependencies.')
emerge(package_atom, '--onlydeps', env=self.emerge_env)
c_compiler = local.path(str(compiler.cc(self)))
cxx_compiler = local.path(str(compiler.cxx(self)))
setup_compilers('/etc/portage/make.conf')
ln("-sf", str(c_compiler), local.path('/') / c_compiler.basename)
ln('-sf', str(cxx_compiler), local.path('/') / cxx_compiler.basename)
LOG.debug('Installing %s.', package_atom)
emerge(package_atom, env=self.emerge_env)
def compile(self):
self.download()
tar("xfJ", self.src_file)
unpack_dir = "gzip-{0}.tar.xz".format(self.version)
testfiles = [local.path(self.testdir) / x for x in self.testfiles]
cp(testfiles, '.')
clang = compiler.cc(self)
with local.cwd(unpack_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run.run(configure["--disable-dependency-tracking",
"--disable-silent-rules", "--with-gnu-ld"])
run.run(make["-j" + str(CFG["jobs"]), "clean", "all"])
def compile_verify(self, compiler_args, polybench_opts):
polybench_opts.append("-DPOLYBENCH_DUMP_ARRAYS")
cflags = self.cflags
ldflags = self.ldflags
self.cflags = []
self.ldflags = []
clang_no_opts = compiler.cc(self)
self.cflags = cflags
self.ldflags = ldflags
run.run(clang_no_opts[polybench_opts, compiler_args, "-o", self.name +
".no-opts", "-lm"])
return polybench_opts
def compile(self):
self.download()
testfiles = [local.path(self.testdir) / x for x in self.inputfiles]
for testfile in testfiles:
cp(testfile, self.builddir)
clang = compiler.cc(self)
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(CC=str(clang)):
run.run(configure["--disable-thread", "--disable-opencl",
"--enable-pic"])
run.run(make["clean", "all", "-j", CFG["jobs"]])
def compile(self):
self.download()
book_file = "book.bin"
book_bin = "http://www.craftychess.com/downloads/book/" + book_file
download.Wget(book_bin, book_file)
unpack_dir = "crafty.src"
mkdir(unpack_dir)
with local.cwd(unpack_dir):
unzip(local.path("..") / self.src_file)
mv(book_file, unpack_dir)
clang = compiler.cc(self)
with local.cwd(unpack_dir):
target_opts = ["-DCPUS=1", "-DSYZYGY", "-DTEST"]
crafty_make = make["target=UNIX", "CC=" + str(clang), "opt=" +
" ".join(target_opts), "crafty-make"]
run.run(crafty_make)
def compile(self):
self.download()
tar("xf", self.src_file)
unpack_dir = local.path('rodinia_{0}'.format(self.version))
c_compiler = compiler.cc(self)
cxx_compiler = compiler.cxx(self)
config_dir = self.config['dir']
config_src = self.config['src']
config_flags = self.config['flags']
with local.cwd(unpack_dir / config_dir):
for outfile, srcfiles in config_src.items():
cls = type(self)
_cc = cls.select_compiler(c_compiler, cxx_compiler)
if "flags" in self.config:
_cc = _cc[config_flags]
_cc = _cc[srcfiles]
_cc = _cc["-o", outfile]
run.run(_cc)
def compile(self):
self.download()
download.Wget(self.boost_src_uri, self.boost_src_file)
tar("xfj", self.boost_src_file)
cp("-ar", local.path(self.testdir) / "cfg", '.')
cp("-ar", local.path(self.testdir) / "etc", '.')
cp("-ar", local.path(self.testdir) / "scenes", '.')
cp("-ar", local.path(self.testdir) / "share", '.')
cp("-ar", local.path(self.testdir) / "test", '.')
clang = compiler.cc(self)
clang_cxx = compiler.cxx(self)
# First we have to prepare boost for lady povray...
boost_prefix = "boost-install"
with local.cwd(self.boost_src_dir):
mkdir(boost_prefix)
bootstrap = local["./bootstrap.sh"]
run.run(bootstrap["--with-toolset=clang",
"--prefix=\"{0}\"".format(boost_prefix)])
_b2 = local["./b2"]
run.run(
_b2["--ignore-site-config", "variant=release", "link=static",
"threading=multi", "optimization=speed", "install"])
src_file = local.path(self.src_file)
with local.cwd(src_file):
with local.cwd("unix"):
sh("prebuild.sh")
configure = local["./configure"]
with local.env(
COMPILED_BY="BB <*****@*****.**>",
CC=str(clang),
CXX=str(clang_cxx)):
run.run(configure["--with-boost=" + boost_prefix])
run.run(make["all"])
def compile(self):
self.download()
unzip(local.cwd / self.src_file)
clang = cc(self)
run(make["CC=" + str(clang), "scimark2"])
def test_create(self):
with local.cwd(self.tmp_dir):
cmd = compilers.cc(EmptyProject(empty.Empty()))
self.assertTrue(os.path.exists(str(cmd)))
def compile(self):
self.download()
clang = compiler.cc(self)
with local.cwd(self.src_file):
run.run(make["CC=" + str(clang)])
