def main():
print("Running singularity parser")
parser = Parser()
parser.add_pattern(
"planner_exit_code",
r"run-planner exit code: (.+)\n",
type=int,
file="driver.log",
required=True,
)
parser.add_pattern("node",
r"node: (.+)\n",
type=str,
file="driver.log",
required=True)
parser.add_pattern(
"planner_wall_clock_time",
r"run-planner wall-clock time: (.+)s",
type=float,
file="driver.log",
required=True,
)
parser.add_pattern("runtime", r"Singularity runtime: (.+?)s", type=float)
parser.add_pattern("raw_memory", r"Peak memory: (\d+) KB", type=int)
parser.add_pattern("cost", r"\nFinal value: (.+)\n", type=int)
parser.add_function(coverage)
parser.add_function(unsolvable)
parser.add_function(error)
parser.add_function(parse_g_value_over_time)
parser.parse()
def main():
print("Running singularity parser")
parser = Parser()
parser.add_pattern(
"planner_exit_code",
r"run-planner exit code: (.+)\n",
type=int,
file="driver.log",
required=True,
)
parser.add_pattern(
"node", r"node: (.+)\n", type=str, file="driver.log", required=True
)
parser.add_pattern(
"planner_wall_clock_time",
r"run-planner wall-clock time: (.+)s",
type=float,
file="driver.log",
required=True,
)
parser.add_pattern("search_time", r"Search time: (.+)s", type=float)
parser.add_pattern("total_time", r"Total time: (.+)s\n", type=float)
# The Singularity runtime only has a granularity of seconds.
parser.add_pattern("singularity_runtime", r"Singularity runtime: (.+)s", type=int)
parser.add_pattern("raw_memory", r"Peak memory: (\d+) KB", type=int)
parser.add_pattern("cost", r"\nFinal value: (.+)\n", type=int)
parser.add_function(coverage)
parser.add_function(unsolvable)
parser.add_function(error)
parser.parse()
def main():
print 'Running custom parser'
parser = Parser()
parser.add_pattern('time_for_pruning_operators',
r'^Time for pruning operators: (.+)s$',
type=float,
flags="M")
parser.parse()
def main():
parser = Parser()
parser.add_pattern("raw_memory", r"Peak memory: (.+) KB", type=int),
parser.add_function(find_all_matches("cost:all", r"Plan cost: (.+)\n", type=float))
parser.add_function(
find_all_matches("steps:all", r"Plan length: (.+) step\(s\).\n", type=float)
)
parser.add_function(reduce_to_min("cost:all", "cost"))
parser.add_function(reduce_to_min("steps:all", "steps"))
parser.add_function(coverage)
parser.add_function(add_memory)
parser.parse()
def main():
parser = Parser()
parser.add_pattern("int_hash_set_load_factor",
"Int hash set load factor: \d+/\d+ = (.+)",
required=False,
type=float)
parser.add_pattern("int_hash_set_resizes",
"Int hash set resizes: (\d+)",
required=False,
type=int)
print "Running custom parser"
parser.parse()
def main():
parser = Parser()
parser.add_function(
find_all_matches("cost:all", r"Plan cost: (.+)\n", type=float))
parser.add_function(
find_all_matches("steps:all",
r"Plan length: (.+) step\(s\).\n",
type=float))
parser.add_function(reduce_to_min("cost:all", "cost"))
parser.add_function(reduce_to_min("steps:all", "steps"))
parser.add_function(coverage)
parser.parse()
def main():
print("Running singularity parser")
parser = Parser()
parser.add_pattern(
"planner_exit_code",
r"run-planner exit code: (.+)\n",
type=int,
file="driver.log",
required=True,
)
parser.add_pattern("node",
r"node: (.+)\n",
type=str,
file="driver.log",
required=True)
parser.add_pattern(
"planner_wall_clock_time",
r"run-planner wall-clock time: (.+)s",
type=float,
file="driver.log",
required=True,
)
parser.add_pattern("runtime", r"Singularity runtime: (.+?)s", type=float)
parser.add_pattern(
"time_limit",
r"Enforcing CPUTime limit \(soft limit, will send "
r"SIGTERM then SIGKILL\): (\d+) seconds",
type=int,
file="watch.log",
required=True,
)
# Cumulative runtime and virtual memory of the solver and all child processes.
parser.add_pattern("runtime",
r"WCTIME=(.+)",
type=float,
file="values.log",
required=True)
parser.add_pattern("virtual_memory",
r"MAXVM=(\d+)",
type=int,
file="values.log",
required=True)
parser.add_pattern("raw_memory", r"Peak memory: (\d+) KB", type=int)
parser.add_pattern("cost", r"\nFinal value: (.+)\n", type=int)
parser.add_function(coverage)
parser.add_function(unsolvable)
parser.add_function(parse_g_value_over_time)
parser.add_function(set_outcome, file="values.log")
parser.parse()
def main():
print "Running custom parser"
parser = Parser()
parser.add_pattern("pdb_collection_construction_time",
"^PDB collection construction time: (.+)s$",
type=float,
flags="M",
required=False)
parser.add_pattern("dominance_pruning_time",
"^Dominance pruning took (.+)s$",
type=float,
flags="M",
required=False)
parser.add_pattern("dominance_pruning_pruned_subsets",
"Pruned (\d+) of \d+ maximal additive subsets",
type=int,
required=False)
parser.add_pattern("dominance_pruning_pruned_pdbs",
"Pruned (\d+) of \d+ PDBs",
type=int,
required=False)
parser.add_function(add_dominance_pruning_failed)
parser.parse()
parser.add_function(check_planner_exit_reason)
def check_perfect_heuristic(content, props):
plan_length = props.get('plan_length')
expansions = props.get('expansions')
if plan_length != None:
perfect_heuristic = False
if plan_length + 1 == expansions:
perfect_heuristic = True
props['perfect_heuristic'] = perfect_heuristic
parser.add_function(check_perfect_heuristic)
def check_proved_unsolvability(content, props):
proved_unsolvability = False
if props['coverage'] == 0:
for line in content.splitlines():
if line == 'Completely explored state space -- no solution!':
proved_unsolvability = True
break
props['proved_unsolvability'] = proved_unsolvability
parser.add_function(check_proved_unsolvability)
parser.parse()
#! /usr/bin/env python
from lab.parser import Parser
def wordcount(content, props):
props["number_of_files"] = len(content.splitlines())
parser = Parser()
parser.add_function(wordcount)
parser.add_pattern("first_number", "(\d+)")
parser.parse()
