def test_get_level(filename): call_tree = ct.get_call_tree(filename) # testing series version df = ct.calltree_to_df(call_tree).set_index('Cnode ID') parent_series = df['Parent Cnode ID'] levels = ct.get_level(parent_series) for cnode_id in levels.index: assert levels[cnode_id] == 0 or levels[cnode_id] == levels[ parent_series[cnode_id]] + 1 # testing df version df = ct.calltree_to_df(call_tree) parent_series_2 = df[['Cnode ID', 'Parent Cnode ID']] levels_2 = ct.get_level(parent_series_2) for cnode_id in levels_2.index: #assert levels_2[cnode_id] == 0 or levels_2[cnode_id] == levels_2[parent_series_2.set_index('Cnode ID')[cnode_id]] + 1 assert levels_2[cnode_id] == 0 or levels_2[cnode_id] == levels_2[ parent_series_2.set_index('Cnode ID').loc[cnode_id, 'Parent Cnode ID']] + 1
def test_calltree2(filename): call_tree = get_call_tree(filename) call_tree_df = calltree_to_df(call_tree, full_path=True) print("Calltree:") print(call_tree) print("Dataframe representation of calltree:") print(call_tree_df)
def convert_df_to_inclusive(df_convertible, call_tree): """ Converts a DataFrame from exclusive to inclusive. A level named ``Cnode ID``, ``Full Callpath`` or ``Short Callpath`` must be in the index. Parameters ---------- df_convertible : pandas.DataFrame A DataFrame containing only metrics that can be converted safely from exclusive to inclusive. call_tree: CubeTreeNode A recursive representation of the call tree. Returns ------- res : DataFrame A DataFrame """ old_index_name = ic.find_index_col(df_convertible) # dfcr = df_convertible_reindexed tree_df = ct.calltree_to_df(call_tree) dfcr = ic.convert_index(df_convertible, tree_df, target="Cnode ID") levels_to_unstack = [ name for name in df_convertible.index.names if name != "Cnode ID" ] df_transposed = df_convertible.unstack(levels_to_unstack) def aggregate(root): value = df_transposed.loc[root.cnode_id, :] for child in root.children: value += aggregate(child) return value names = df_transposed.columns.names return (pd.concat( objs=[aggregate(n) for n in ct.iterate_on_call_tree(call_tree)], keys=[n.cnode_id for n in ct.iterate_on_call_tree(call_tree)], ).rename_axis(mapper=["Cnode ID"] + names, axis="index").unstack(names).pipe( ic.convert_index, tree_df, old_index_name).stack(levels_to_unstack))
def process_cubex(profile_file, exclusive=True): """ Processes a single ``.cubex`` file, returning the numeric data from the profiling, plus information about the call tree and the metrics. Note: returns a *dict*. Parameters ---------- profile_file : str The name of the ``.cubex`` file. exclusive : bool Whether to ask ``cube_dump`` for exclusive (True) or inclusive (False) metrics. Returns ------- ctree : calltree.CubeTreeNode A call tree recursive object ctree_df : pandas.DataFrame A DataFrame representation of the call tree object df : pandas.DataFrame A dataframe containing the profiling data, from conv_info : list convertibility information (to inclusive) for the metrics contained in the dump. """ # Getting all callgraph information logging.debug(f"Reading {profile_file}...") ctree = ct.get_call_tree(profile_file) ctree_df = ct.calltree_to_df(ctree, full_path=True) dump_df = ( cfu.get_dump(profile_file, exclusive) # .rename_axis('metric', axis='columns') # .set_index(['Cnode ID', 'Thread ID'])) # conv_info = mt.get_inclusive_convertible_metrics(profile_file) return Box({ 'ctree': ctree, 'ctree_df': ctree_df, 'df': dump_df, 'conv_info': conv_info })
def test_calltree1(filename): ''' This script runs the algorithm, prints the results, and checks that the representation of the call tree matches the one that is "scraped" from the cube_dump output. ''' cube_dump_w_text = get_cube_dump_w_text(filename) call_tree_lines = ct.get_call_tree_lines(cube_dump_w_text) calltree = ct.calltree_from_lines(call_tree_lines) max_len = ct.get_max_len(calltree) calltree_repr = ct.calltree_to_string(calltree, max_len) print("Tree Representation:") print(calltree_repr) import pandas as pd data = ct.get_fpath_vs_id(calltree) df = pd.DataFrame(data, columns=['Cnode ID', 'Full Callpath']) print("Cnode ID vs. Full Callpath dictionary:") print(df) df = ct.calltree_to_df(calltree) print("Dataframe representation of the Call Tree:") print(df) # testing that the tree representation matches the one in the # cube_dump output import re def clean_line(line): l1 = re.sub(r'\s*\[\s*\(\s*id=([0-9]+).*$', r'\g<1>', line) return re.sub(r'\s*\[with.*\]\s*','',l1) reference = (re.sub( r'[:|-]', '', '\n'.join([ clean_line(line) for line in ct.get_call_tree_lines(cube_dump_w_text) ]))) calltree_repr = (re.sub(r'[\-:]', '', ct.calltree_to_string(calltree, 0)).replace( '|', ' ').replace(' ', ' ')) for i, (linea, lineb) in enumerate( zip(reference.split('\n'), calltree_repr.split('\n'))): assert linea == lineb, f" Line {i}: '{linea}' != '{lineb}'"
cube_dump_w_text = get_cube_dump_w_text(argv[1]) call_tree_lines = ct.get_call_tree_lines(cube_dump_w_text) calltree = ct.calltree_from_lines(call_tree_lines) max_len = ct.get_max_len(calltree) calltree_repr = ct.calltree_to_string(calltree, max_len) print("Tree Representation:") print(calltree_repr) import pandas as pd data = ct.get_fpath_vs_id(calltree) df = pd.DataFrame(data, columns=['Cnode ID', 'Full Callpath']) print("Cnode ID vs. Full Callpath dictionary:") print(df) df = ct.calltree_to_df(calltree) print("Dataframe representation of the Call Tree:") print(df) # testing that the tree representation matches the one in the # cube_dump output import re reference = (re.sub( '[|-]', '', '\n'.join([ re.sub('\s*\[\s*\(\s*id=([0-9]+).*$', '\g<1>', line) for line in ct.get_call_tree_lines(cube_dump_w_text) ]))) calltree_repr = (re.sub('[\-:]', '', ct.calltree_to_string(calltree, 0)).replace( '|', ' ').replace(' ', ' '))
#!/usr/bin/env python3 ''' This script runs only a convenient function that returns all the info in a pandas dataframe. ''' if __name__ == '__main__': from sys import argv from calltree import get_call_tree, calltree_to_df from cube_file_utils import get_cube_dump_w_text call_tree = get_call_tree(argv[1]) call_tree_df = calltree_to_df(call_tree, full_path=True) print("Calltree:") print(call_tree) print("Dataframe representation of calltree:") print(call_tree_df)