def benchmark_ms(algo_name, data, result_dir): """ Measurement function for finding paths from set of vertices @param algo_name: concrete implementation of the algorithm @param data: dictionary in format {path to graph: list of paths to grammars} @param result_dir: directory for uploading results of measurement """ header_index = ['graph', 'grammar', 'size_chunk', 'time', 'count_S'] chunk_sizes = [1, 2, 4, 8, 16, 32, 50, 100, 500, 1000, 5000, 10000, None] for graph in data: result_index_file_path = result_dir.joinpath( f'{graph.stem}-{algo_name.__name__}-msindex') append_header = False if not exists(result_index_file_path): append_header = True result_csv = open(result_index_file_path, mode='a', newline='\n') csv_writer_index = csv.writer(result_csv, delimiter=',', quoting=csv.QUOTE_NONNUMERIC, escapechar=' ') if append_header: csv_writer_index.writerow(header_index) if not exists(result_index_file_path): csv_writer_index.writerow(header_index) g = LabelGraph.from_txt(graph) for grammar in data[graph]: algo = algo_name() algo.prepare(Graph.from_txt(graph), cfg_from_txt(grammar)) for chunk_size in chunk_sizes: chunks = [] if chunk_size is None: chunks = g.chunkify(g.matrices_size) else: chunks = g.chunkify(chunk_size) for chunk in tqdm(chunks, desc=f'{graph.stem}-{grammar.stem}'): algo.clear_src( ) # Attention (TODO): remove this line if you want to cache the result ! start = time() res = algo.solve(chunk) finish = time() csv_writer_index.writerow([ graph.stem, grammar.stem, chunk_size, finish - start, res.matrix_S.nvals ])
def test_case_1_graph_1(algo): # (0)-[a]->(1)-[a]->(2)-[b]->(3)-[b]->(4) # S -> a S b | a b test_case_1_path = LOCAL_CFPQ_DATA.joinpath('test_case_1') graph = LabelGraph.from_txt( test_case_1_path.joinpath('Matrices/graph_1.txt')) grammar = CnfGrammar.from_cnf( test_case_1_path.joinpath('Grammars/grammar.cnf')) single_source: SingleSourceSolver = algo(graph, grammar) m, _ = single_source.solve([1]) assert vecbool_to_list(m[1]) == [3] m, _ = single_source.solve([0]) assert vecbool_to_list(m[0]) == [4]
def test_single_source_benchmark_total(graph, grammar, algo, chunk_size, benchmark): g = LabelGraph.from_txt(graph) gr = CnfGrammar.from_cnf(grammar) chunks = g.chunkify(g.matrices_size if chunk_size is None else chunk_size) if chunk_size is not None and chunk_size > g.matrices_size: return def run_suite(): a = algo(g, gr) for chunk in tqdm( chunks, desc= f'{get_file_name(graph)}-{get_file_name(grammar)}-{algo.__name__}-{chunk_size}' ): a.solve(chunk) benchmark.pedantic(run_suite, rounds=5, iterations=1, warmup_rounds=0)
def check_single_source_per_chunk(graph, grammar, algo, chunk_count=None, verbose=True): g = LabelGraph.from_txt(graph) gr = CnfGrammar.from_cnf(grammar) a = algo(g, gr) base_algo = MatrixBaseAlgo(graph[:-4], grammar[:-4]) m = base_algo.solve() if chunk_count is None: chunk_count = g.matrices_size chunk_size = max(g.matrices_size // chunk_count, 1) chunks = g.chunkify(chunk_size) for chunk in tqdm(chunks, desc=get_file_name(graph)) if verbose else chunks: m1, _ = a.solve(chunk) assert m1.extract_matrix(chunk).iseq(m.extract_matrix(chunk))
def test_case_1_graph_2(algo): # (6) # / \ # (2) (5) # / \ / \ # (0) (1) (3) (4) # Upstream edges labeled by "a", downstream by "b" # S -> a S b | a b test_case_1_path = LOCAL_CFPQ_DATA.joinpath('test_case_1') graph = LabelGraph.from_txt( test_case_1_path.joinpath('Matrices/graph_2.txt')) grammar = CnfGrammar.from_cnf( test_case_1_path.joinpath('Grammars/grammar.cnf')) single_source: SingleSourceSolver = algo(graph, grammar) m, _ = single_source.solve([0]) assert vecbool_to_list(m[0]) == [0, 1, 3, 4] m, _ = single_source.solve([2]) assert vecbool_to_list(m[2]) == [2, 5]
def test_single_source_benchmark_granularity(graph, grammar, algo, chunk_size, result_folder): g = LabelGraph.from_txt(graph) gr = CnfGrammar.from_cnf(grammar) a = algo(g, gr) gr_name = get_file_name(grammar) a_name = type(a).__name__ if chunk_size is None: chunk_size = g.matrices_size chunks = g.chunkify(chunk_size) result_file = f'{get_file_name(graph)}.csv' result_file_path = os.path.join(result_folder, result_file) append_headers = False if not os.path.exists(result_file_path): append_headers = True with open(result_file_path, mode='a', newline='\n') as csv_file: csv_writer = csv.writer(csv_file, delimiter=',', quoting=csv.QUOTE_NONNUMERIC, escapechar=' ') headers = ['grammar', 'algo', 'chunk_size', 'times'] timer = SimpleTimer() times_of_chunks = [] for chunk in chunks: timer.tic() a.solve(chunk) chunk_time = timer.toc() times_of_chunks.append(chunk_time) if append_headers: csv_writer.writerow(headers) csv_writer.writerow([gr_name, a_name, chunk_size, times_of_chunks])
from src.grammar.cnf_grammar import CnfGrammar from src.graph.label_graph import LabelGraph from src.utils.time_profiler import SimpleTimer from src.algo.matrix_base import matrix_base_algo g = LabelGraph.from_txt('deps/CFPQ_Data/data/WorstCase/Matrices/worstcase_128.txt') gr = CnfGrammar.from_cnf('deps/CFPQ_Data/data/WorstCase/Grammars/Brackets.cnf') with SimpleTimer(): m = matrix_base_algo(g, gr)
def __init__(self, path_to_graph: Path, path_to_grammar: Path): super().__init__(path_to_graph, path_to_grammar) self.graph = LabelGraph.from_txt(str(path_to_graph) + ".txt") self.grammar = CnfGrammar.from_cnf(str(path_to_grammar) + ".cnf")