def test_make_clean():
fs.cd("lib/labm8/data/test/makeproj")
make.make()
assert fs.isfile("foo")
assert fs.isfile("foo.o")
make.clean()
assert not fs.isfile("foo")
assert not fs.isfile("foo.o")
fs.cdpop()
def test_rm():
system.echo("Hello, world!", "/tmp/labm8.tmp")
assert fs.isfile("/tmp/labm8.tmp")
fs.rm("/tmp/labm8.tmp")
assert not fs.isfile("/tmp/labm8.tmp")
fs.rm("/tmp/labm8.tmp")
fs.rm("/tmp/labm8.tmp")
fs.rm("/tmp/labm8.dir")
fs.mkdir("/tmp/labm8.dir/foo/bar")
system.echo("Hello, world!", "/tmp/labm8.dir/foo/bar/baz")
assert fs.isfile("/tmp/labm8.dir/foo/bar/baz")
fs.rm("/tmp/labm8.dir")
assert not fs.isfile("/tmp/labm8.dir/foo/bar/baz")
assert not fs.isfile("/tmp/labm8.dir/")
def test_rmtrash():
with tempfile.NamedTemporaryFile(prefix='labm8_') as f:
assert fs.isfile(f.name)
fs.rmtrash(f.name)
assert not fs.isfile(f.name)
fs.rmtrash(f.name)
fs.rm(f.name)
with tempfile.TemporaryDirectory() as d:
fs.rm(d)
fs.mkdir(d, "foo/bar")
system.echo("Hello, world!", fs.path(d, "foo/bar/baz"))
assert fs.isfile(f, "foo/bar/baz")
fs.rmtrash(d)
assert not fs.isfile(d, "foo/bar/baz")
assert not fs.isdir(d)
def test_cp_over_dir():
fs.mkdir("/tmp/labm8.tmp.src")
system.echo("Hello, world!", "/tmp/labm8.tmp.src/foo")
fs.rm("/tmp/labm8.tmp.copy")
fs.mkdir("/tmp/labm8.tmp.copy")
assert fs.isdir("/tmp/labm8.tmp.src")
assert fs.isfile("/tmp/labm8.tmp.src/foo")
assert fs.isdir("/tmp/labm8.tmp.copy")
assert not fs.isfile("/tmp/labm8.tmp.copy/foo")
fs.cp("/tmp/labm8.tmp.src", "/tmp/labm8.tmp.copy/")
assert fs.isdir("/tmp/labm8.tmp.src")
assert fs.isfile("/tmp/labm8.tmp.src/foo")
assert fs.isdir("/tmp/labm8.tmp.copy")
assert fs.isfile("/tmp/labm8.tmp.copy/foo")
assert (fs.read("/tmp/labm8.tmp.src/foo") == fs.read(
"/tmp/labm8.tmp.copy/foo"))
def test_set_and_get():
fs.rm("/tmp/labm8-cache-set-and-get")
c = cache.FSCache("/tmp/labm8-cache-set-and-get")
# create file
system.echo("Hello, world!", "/tmp/labm8.testfile.txt")
# sanity check
assert fs.read("/tmp/labm8.testfile.txt") == ["Hello, world!"]
# insert file into cache
c['foobar'] = "/tmp/labm8.testfile.txt"
# file must be in cache
assert fs.isfile(c.keypath("foobar"))
# file must have been moved
assert not fs.isfile("/tmp/labm8.testfile.txt")
# check file contents
assert fs.read(c['foobar']) == ["Hello, world!"]
assert fs.read(c['foobar']) == fs.read(c.get('foobar'))
c.clear()
def assert_program_exists(path):
"""
Assert that a program exists.
If the given path does not exist and is not a file, raises
ProgramNotFoundError.
"""
if not fs.exists(path) or not fs.isfile(path):
raise ProgramNotFoundError(path)
def get_all_sampler_datasets():
datasets = []
sampledirs = []
for versioncache in fs.ls(fs.path("~/.cache/clgen"), abspaths=True):
samplerdir = fs.path(versioncache, "sampler")
if fs.isdir(samplerdir):
sampledirs += fs.ls(samplerdir, abspaths=True)
for samplerdir in sampledirs:
inpath = fs.path(samplerdir, "kernels.db")
if fs.isfile(inpath):
datasets.append(inpath)
return datasets
def test_rm_glob():
fs.mkdir("/tmp/labm8.glob")
system.echo("Hello, world!", "/tmp/labm8.glob/1")
system.echo("Hello, world!", "/tmp/labm8.glob/2")
system.echo("Hello, world!", "/tmp/labm8.glob/abc")
fs.rm("/tmp/labm8.glob/a*", glob=False)
assert fs.isfile("/tmp/labm8.glob/1")
assert fs.isfile("/tmp/labm8.glob/2")
assert fs.isfile("/tmp/labm8.glob/abc")
fs.rm("/tmp/labm8.glob/a*")
assert fs.isfile("/tmp/labm8.glob/1")
assert fs.isfile("/tmp/labm8.glob/2")
assert not fs.isfile("/tmp/labm8.glob/abc")
fs.rm("/tmp/labm8.glob/*")
assert not fs.isfile("/tmp/labm8.glob/1")
assert not fs.isfile("/tmp/labm8.glob/2")
assert not fs.isfile("/tmp/labm8.glob/abc")
def make(target="all", dir=".", **kwargs):
"""
Run make.
Arguments:
target (str, optional): Name of the target to build. Defaults
to "all".
dir (str, optional): Path to directory containing Makefile.
**kwargs (optional): Any additional arguments to be passed to
system.run().
Returns:
(int, str, str): The first element is the return code of the
make command. The second and third elements are the stdout
and stderr of the process.
Raises:
NoMakefileError: In case a Makefile is not found in the target
directory.
NoTargetError: In case the Makefile does not support the
requested target.
MakeError: In case the target rule fails.
"""
if not fs.isfile(fs.path(dir, "Makefile")):
raise NoMakefileError("No makefile in '{}'".format(fs.abspath(dir)))
fs.cd(dir)
# Default parameters to system.run()
if "timeout" not in kwargs: kwargs["timeout"] = 300
ret, out, err = system.run(["make", target], **kwargs)
fs.cdpop()
if ret > 0:
if re.search(_BAD_TARGET_RE, err):
raise NoTargetError("No rule for target '{}'".format(target))
else:
raise MakeError("Target '{}' failed".format(target))
raise MakeError("Failed")
return ret, out, err
def merge(outpath, inpaths=[]):
if not fs.isfile(outpath):
dbutil.create_db(outpath)
log.info("created", outpath)
db = dbutil.connect(outpath)
if not inpaths:
inpaths = get_all_sampler_datasets()
for inpath in inpaths:
log.info("merging from", inpath)
c = db.cursor()
c.execute("ATTACH '{}' AS rhs".format(inpath))
c.execute("INSERT OR IGNORE INTO ContentFiles "
"SELECT * FROM rhs.ContentFiles")
c.execute("INSERT OR IGNORE INTO PreprocessedFiles "
"SELECT * FROM rhs.PreprocessedFiles")
c.execute("DETACH rhs")
db.commit()
explore.explore(outpath)
#!/usr/bin/env python3.6
import sys
from phd.lib.labm8 import crypto
from phd.lib.labm8 import fs
from progressbar import ProgressBar
if __name__ == "__main__":
inpath = sys.argv[1]
outdir = sys.argv[2]
print(f"reading from {inpath} into {outdir}")
assert fs.isfile(inpath)
assert not fs.exists(outdir) or fs.isdir(outdir)
fs.mkdir(outdir)
with open(inpath) as infile:
text = infile.read()
kernels = text.split("// ==== START SAMPLE ====")
kernels = [kernel.strip() for kernel in kernels if kernel.strip()]
print(len(kernels), "kernels")
sha1s = [crypto.sha1_str(kernel) for kernel in kernels]
for kernel, sha1 in ProgressBar()(list(zip(kernels, sha1s))):
with open(f"{outdir}/{sha1}.txt", "w") as outfile:
print(kernel, file=outfile)
def test_make():
ret, out, err = make.make(dir="lib/labm8/data/test/makeproj")
assert not ret
assert out
assert fs.isfile("lib/labm8/data/test/makeproj/foo")
assert fs.isfile("lib/labm8/data/test/makeproj/foo.o")
def test_isfile():
assert fs.isfile(__file__)
assert not fs.isfile("/")
assert not fs.isfile("/not/a/real/path (I hope!)")
def load_config(path="~/.omnitunerc.json"):
path = fs.abspath(path)
if fs.isfile(path):
return json.load(open(path))
else:
raise ConfigNotFoundError("File '{}' not found!".format(path))
def IsRepoMetaFile(f: str):
"""Determine if a path is a GitHubRepoMetadata message."""
return (fs.isfile(f) and pbutil.ProtoIsReadable(
f, scrape_repos_pb2.GitHubRepoMetadata()))
parser.add_argument("--clsmith",
action="store_true",
help="Only reduce CLSmith results")
parser.add_argument("--clgen",
action="store_true",
help="Only reduce CLgen results")
parser.add_argument("--recheck",
action="store_true",
help="Re-check existing errors")
args = parser.parse_args()
db.init(args.hostname) # initialize db engine
clang = fs.abspath(f"../lib/llvm/build/{args.clang}/bin/clang")
if not args.recheck and not fs.isfile(clang):
print(f"fatal: clang '{clang}' does not exist")
sys.exit(1)
if args.clgen and args.clsmith:
tablesets = [CLSMITH_TABLES, CLGEN_TABLES]
elif args.clsmith:
tablesets = [CLSMITH_TABLES]
elif args.clgen:
tablesets = [CLGEN_TABLES]
else:
tablesets = [CLSMITH_TABLES, CLGEN_TABLES]
with Session(commit=True) as s:
def next_batch():
from experimental.dsmith import Colors
runtime_t = NewType('runtime_t', float)
status_t = NewType('status_t', int)
return_t = namedtuple('return_t', ['runtime', 'status', 'stdout', 'stderr'])
# build paths
exec_path = dsmith.root_path("third_party", "clsmith", "build", "CLSmith")
cl_launcher_path = dsmith.root_path("third_party", "clsmith", "build",
"cl_launcher")
include_path = dsmith.root_path("third_party", "clsmith", "runtime")
# sanity checks
assert fs.isexe(exec_path)
assert fs.isexe(cl_launcher_path)
assert fs.isfile(fs.path(include_path, "CLSmith.h"))
def clsmith_cli(*args, timeout: int = 60, exec_path=exec_path) -> List[str]:
return ["timeout", "--signal=9", str(timeout), exec_path] + list(args)
def clsmith(*args, exec_path=exec_path) -> return_t:
"""
Returns:
return_t: A named tuple consisting of runtime (float),
status (int), stdout (str), and stderr (str).
"""
start_time = time()
cli = clsmith_cli(*args)