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("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_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 add_pattern(self, name, regex, file="run.log", required=False, type=int, flags=""): Parser.add_pattern(self, name, regex, file=file, required=required, type=type, flags=flags)
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()
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()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('generator_computation_time', 'generator computation time: (.+)s', required=False, type=float) parser.add_pattern('cpdbs_computation_time', 'Canonical PDB heuristic computation time: (.+)s', required=False, type=float) parser.add_pattern('dominance_pruning_time', 'Dominance pruning took (.+)s', required=False, type=float) parser.parse()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Done initializing merge-and-shrink heuristic \[(.+)s\]', required=False, type=float) parser.add_pattern( 'ms_memory_delta', 'Final peak memory increase of merge-and-shrink computation: (\d+) KB', required=False, type=int) parser.add_pattern('actual_search_time', 'Actual search time: (.+)s \[t=.+s\]', required=False, type=float) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed
def get_num_novel_features_complexity_5(content, props): # All patterns are parsed before functions are called. if props.get("generate_time_complexity_5") is not None: props["num_novel_features_complexity_5"] = int(re.findall(r"Complexity 5:\nTotal generated features: .+\nTotal novel features: (.+)", content, re.M)[0]) def get_num_generated_features_complexity_10(content, props): # All patterns are parsed before functions are called. if props.get("generate_time_complexity_10") is not None: props["num_generated_features_complexity_10"] = int(re.findall(r"Complexity 10:\nTotal generated features: (.+)", content, re.M)[0]) def get_num_novel_features_complexity_10(content, props): # All patterns are parsed before functions are called. if props.get("generate_time_complexity_10") is not None: props["num_novel_features_complexity_10"] = int(re.findall(r"Complexity 10:\nTotal generated features: .+\nTotal novel features: (.+)", content, re.M)[0]) parser = Parser() parser.add_pattern("generate_time_complexity_5", r"\[t=(.+)s, .+ KB\] Complexity 5:\n", type=float) parser.add_pattern("generate_memory_complexity_5", r"\[t=.+s, (.+) KB\] Complexity 5:\n", type=int) parser.add_pattern("generate_time_complexity_10", r"\[t=(.+)s, .+ KB\] Complexity 10:\n", type=float) parser.add_pattern("generate_memory_complexity_10", r"\[t=.+s, (.+) KB\] Complexity 10:\n", type=int) parser.add_pattern("num_states", r"Number of states: (.+)", type=int) parser.add_pattern("num_dynamic_atoms", r"Number of dynamic atoms: (.+)", type=int) parser.add_pattern("num_static_atoms", r"Number of static atoms: (.+)", type=int) parser.add_pattern("evaluate_time", r"Time to construct and evaluate features: (.+)s", type=float) parser.add_function(get_num_generated_features_complexity_5) parser.add_function(get_num_novel_features_complexity_5) parser.add_function(get_num_generated_features_complexity_10) parser.add_function(get_num_novel_features_complexity_10) parser.parse()
return reduce_to_minimum def add_list_pattern(parser, name, regex, file="run.log", flags="M"): """ *regex* must contain at most one group. """ flags = _get_flags(flags) def parse_repeated_list(content, props): matches = re.findall(regex, content, flags=flags) attr_list = [] for m in matches: items = m.split() items = [float(i) for i in items] attr_list.append(items) props[name] = attr_list parser.add_function(parse_repeated_list, file=file) print("Running Prost parser.") parser = Parser() for name, pattern, pattern_type in SINGLE_PATTERNS: parser.add_pattern(name, pattern, type=pattern_type) for name, pattern, pattern_type in REPEATED_PATTERNS: add_repeated_pattern(parser, name, pattern, type=pattern_type) for name, pattern in LIST_PATTERNS: add_list_pattern(parser, name, pattern) parser.parse()
def add_absolute_and_relative(parser, attribute, pattern): parser.add_pattern(attribute, pattern + ' (\d+) .+', required=False, type=int) parser.add_pattern(attribute + '_rel', pattern + ' \d+ \((.+)\)', required=False, type=float) parser = Parser() parser.add_pattern('sg_construction_time', 'SG construction time: (.+)s', required=False, type=float) parser.add_pattern('sg_peak_mem_diff', 'SG construction peak memory difference: (\d+)', required=False, type=int) parser.add_pattern('sg_size_estimate_total', 'SG size estimates: total: (\d+)', required=False, type=int) add_absolute_and_relative(parser, 'sg_size_estimate_overhead', 'SG size estimates: object overhead:') add_absolute_and_relative(parser, 'sg_size_estimate_operators', 'SG size estimates: operators:') add_absolute_and_relative(parser, 'sg_size_estimate_switch_var', 'SG size estimates: switch var:')
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()
props['false_pos_novelty'] = false_pos_novelty props['tuple_false_pos'] = tuple_false_pos props['h1'] = h1 props['h2'] = h2 flag_new_value = False cost = None generated = None expanded = None runtime = None memory = None plan = None goal = None width = None false_pos_novelty = None tuple_false_pos = None h1 = None h2 = None # parser = Parser() parser.add_pattern('planner_exit_code', r'solve exit code: (.+)\n', type=int, file='driver.log') parser.add_function(fetch_props, 'run.log') parser.add_function(modify_props_for_atomic_goals, 'run.log') parser.parse()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('actual_search_time', 'Actual search time: (.+)s \[.+s\]', required=False, type=float) parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Done initializing merge-and-shrink heuristic \[(.+)s\]', required=False, type=float) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed parser.add_function(check_ms_constructed) def check_proved_unsolvability(content, props):
#! /usr/bin/env python import math from lab.parser import Parser def diff(content, props): pi = props.get('pi') props['diff'] = abs(math.pi - pi) parser = Parser() parser.add_pattern('pi', 'Pi: (.+)', type=float) parser.add_pattern('time', 'Time: (.+)', type=float) parser.add_function(diff) parser.parse()
props["plan"] = re.findall(r"^(?:step)?\s*\d+: (.+)$", content, re.M) def get_times(content, props): props["times"] = re.findall(r"(\d+\.\d+) seconds", content) def trivially_unsolvable(content, props): props["trivially_unsolvable"] = int( "ff: goal can be simplified to FALSE. No plan will solve it" in content) parser = Parser() parser.add_pattern("node", r"node: (.+)\n", type=str, file="driver.log", required=True) parser.add_pattern("planner_exit_code", r"run-planner exit code: (.+)\n", type=int, file="driver.log") parser.add_pattern("evaluations", r"evaluating (\d+) states") parser.add_function(error) parser.add_function(coverage) parser.add_function(get_plan) parser.add_function(get_times) parser.add_function(trivially_unsolvable) parser.parse()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Done initializing merge-and-shrink heuristic \[(.+)s\]', required=False, type=float) parser.add_pattern( 'ms_atomic_construction_time', 't=(.+)s \(after computation of atomic transition systems\)', required=False, type=float) parser.add_pattern( 'ms_memory_delta', 'Final peak memory increase of merge-and-shrink computation: (\d+) KB', required=False, type=int) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Merge-and-shrink algorithm runtime: (.+)s', required=False, type=float) parser.add_pattern( 'ms_atomic_construction_time', 't=(.+)s \(after computation of atomic transition systems\)', required=False, type=float) parser.add_pattern( 'ms_memory_delta', 'Final peak memory increase of merge-and-shrink computation: (\d+) KB', required=False, type=int) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Done initializing merge-and-shrink heuristic \[(.+)s\]', required=False, type=float) parser.add_pattern('ms_memory_delta', 'Final peak memory increase of merge-and-shrink computation: (\d+) KB', required=False, type=int) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed parser.add_function(check_ms_constructed) def check_planner_exit_reason(content, props): ms_abstraction_constructed = props.get('ms_abstraction_constructed') error = props.get('error') if error != 'none' and error != 'timeout' and error != 'out-of-memory': print 'error: %s' % error return # Check whether merge-and-shrink computation or search ran out of # time or memory. ms_out_of_time = False ms_out_of_memory = False search_out_of_time = False search_out_of_memory = False
def solved(content, props): props['solved'] = int('cover' in props) def error(content, props): if props['solved']: props['error'] = 'cover-found' else: props['error'] = 'unsolved' if __name__ == '__main__': parser = Parser() parser.add_pattern('node', r'node: (.+)\n', type=str, file='driver.log', required=True) parser.add_pattern('solver_exit_code', r'solve exit code: (.+)\n', type=int, file='driver.log') parser.add_pattern('cover', r'Cover: set\(\[(.*)\]\)', type=str) parser.add_pattern('cover_size', r'Cover size: (\d+)\n', type=int) parser.add_pattern('solve_time', r'Solve time: (.+)s', type=float) parser.add_function(solved) parser.add_function(error) parser.parse()
props['coverage'] = int(props['planner_exit_code'] == 0) def get_plan(content, props): # All patterns are parsed before functions are called. if props.get('evaluations') is not None: props['plan'] = re.findall(r'^(?:step)?\s*\d+: (.+)$', content, re.M) def get_times(content, props): props['times'] = re.findall(r'(\d+\.\d+) seconds', content) def trivially_unsolvable(content, props): props['trivially_unsolvable'] = int( 'ff: goal can be simplified to FALSE. No plan will solve it' in content) parser = Parser() parser.add_pattern( 'node', r'node: (.+)\n', type=str, file='driver.log', required=True) parser.add_pattern( 'planner_exit_code', r'run-planner exit code: (.+)\n', type=int, file='driver.log') parser.add_pattern('evaluations', r'evaluating (\d+) states') parser.add_function(error) parser.add_function(coverage) parser.add_function(get_plan) parser.add_function(get_times) parser.add_function(trivially_unsolvable) parser.parse()
#! /usr/bin/env python from lab.parser import Parser print 'Running axiom evaluation time parser' parser = Parser() parser.add_pattern('axiom_time_inner', r'AxiomEvaluator time in inner evaluate: (.+)', type=float) parser.add_pattern('axiom_time_outer', r'AxiomEvaluator time in outer evaluate: (.+)', type=float) parser.parse()
#! /usr/bin/env python import math from lab.parser import Parser def diff(content, props): pi = props.get("pi") props["diff"] = abs(math.pi - pi) parser = Parser() parser.add_pattern("pi", "Pi: (.+)", type=float) parser.add_pattern("time", "Time: (.+)", type=float) parser.add_function(diff) parser.parse()
#! /usr/bin/env python """ ======================================================================== Simplifying 29928 unary operators... done! [17292 unary operators] time to simplify: 0.022623s ======================================================================== => Here we want to extract 29928 (simplify_before), 17292 (simplify_after) and 0.022623s (simplify_time). """ import re from lab.parser import Parser print 'Running custom parser' parser = Parser() parser.add_pattern( 'simplify_before', r'^Simplifying (\d+) unary operators\.\.\. done! \[\d+ unary operators\]$', type=int) parser.add_pattern( 'simplify_after', r'^Simplifying \d+ unary operators\.\.\. done! \[(\d+) unary operators\]$', type=int) parser.add_pattern('simplify_time', r'^time to simplify: (.+)s$', type=float) parser.parse()
#print res if len(res) > 0 and props.get('plans') is None: props['unsolvable'] = 1 def total_time(content, props): p = re.findall(r'Total time: (.+)s$', content, re.M) props.pop('total_time', None) if len(p) > 0: props['total_time'] = max([float(i) for i in p]) parser = Parser() parser.add_pattern('evaluations', r'Evaluated (\d+) state\(s\).', required=False) parser.add_pattern('invertible', r'Number of invertible variables is (\d+)', required=False) parser.add_pattern('black', r'Total number of black variables is (\d+)', required=False) parser.add_function(get_plans) parser.add_function(get_best_plan) parser.add_function(unsolvable) parser.add_function(coverage) parser.add_function(total_time) parser.parse()
#! /usr/bin/env python from lab.parser import Parser print("Running average split parser") parser = Parser() parser.add_pattern("average_split_options", r"Average number of possible splits: (.+)", type=float) parser.add_pattern("average_distinct_rated", r"Average number of distinct ratings: (.+)", type=float) parser.parse()
#! /usr/bin/env python from lab.parser import Parser print("Running split time parser") parser = Parser() parser.add_pattern("split_time", r"Time for picking split: (\d+)s", type=float) parser.parse()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('ms_construction_time', 'Merge-and-shrink algorithm runtime: (.+)s', required=False, type=float) parser.add_pattern('ms_atomic_construction_time', 'M&S algorithm timer: (.+)s \(after computation of atomic factors\)', required=False, type=float) parser.add_pattern('ms_memory_delta', 'Final peak memory increase of merge-and-shrink algorithm: (\d+) KB', required=False, type=int) parser.add_pattern('ms_num_remaining_factors', 'Number of remaining factors: (\d+)', required=False, type=int) parser.add_pattern('ms_num_factors_kept', 'Number of factors kept: (\d+)', required=False, type=int) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed parser.add_function(check_ms_constructed) def check_atomic_fts_constructed(content, props): ms_atomic_construction_time = props.get('ms_atomic_construction_time') ms_atomic_fts_constructed = False if ms_atomic_construction_time is not None: ms_atomic_fts_constructed = True props['ms_atomic_fts_constructed'] = ms_atomic_fts_constructed parser.add_function(check_atomic_fts_constructed) def check_planner_exit_reason(content, props): ms_abstraction_constructed = props.get('ms_abstraction_constructed')
#! /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()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('initial_h_value', 'initial h value: (\d+)', required=False, type=int) parser.add_pattern('ms_final_size', 'Final transition system size: (\d+)', required=False, type=int) parser.add_pattern('ms_construction_time', 'Done initializing merge-and-shrink heuristic \[(.+)s\]', required=False, type=float) def check_ms_constructed(content, props): ms_construction_time = props.get('ms_construction_time') abstraction_constructed = False if ms_construction_time is not None: abstraction_constructed = True props['ms_abstraction_constructed'] = abstraction_constructed parser.add_function(check_ms_constructed) 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) def check_planner_exit_reason(content, props): ms_abstraction_constructed = props.get('ms_abstraction_constructed')
def solved(content, props): props["solved"] = int("cover" in props) def error(content, props): if props["solved"]: props["error"] = "cover-found" else: props["error"] = "unsolved" if __name__ == "__main__": parser = Parser() parser.add_pattern("node", r"node: (.+)\n", type=str, file="driver.log", required=True) parser.add_pattern("solver_exit_code", r"solve exit code: (.+)\n", type=int, file="driver.log") parser.add_pattern("cover", r"Cover: set\(\[(.*)\]\)", type=str) parser.add_pattern("cover_size", r"Cover size: (\d+)\n", type=int) parser.add_pattern("solve_time", r"Solve time: (.+)s", type=float) parser.add_function(solved) parser.add_function(error) 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()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('hc_iterations', 'iPDB: iterations = (\d+)', required=False, type=int) parser.add_pattern('hc_num_patters', 'iPDB: number of patterns = (\d+)', required=False, type=int) parser.add_pattern('hc_size', 'iPDB: size = (\d+)', required=False, type=int) parser.add_pattern('hc_num_generated', 'iPDB: generated = (\d+)', required=False, type=int) parser.add_pattern('hc_num_rejected', 'iPDB: rejected = (\d+)', required=False, type=int) parser.add_pattern('hc_max_pdb_size', 'iPDB: maximum pdb size = (\d+)', required=False, type=int) parser.add_pattern('hc_hill_climbing_time', 'iPDB: hill climbing time: (.+)s', required=False, type=float) parser.add_pattern('hc_total_time',
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()
#! /usr/bin/env python from lab.parser import Parser parser = Parser() parser.add_pattern('pi', 'Pi: (.+)', type=float) parser.parse()