def __init__(self, filename_or_stream, query=""):
"""Read from Caliper files (`cali` or split JSON).
Args:
filename_or_stream (str or file-like): name of a `cali` or
`cali-query` split JSON file, OR an open file object
query (str): cali-query arguments (for cali file)
"""
self.filename_or_stream = filename_or_stream
self.filename_ext = ""
self.query = query
self.json_data = {}
self.json_cols = {}
self.json_cols_mdata = {}
self.json_nodes = {}
self.idx_to_label = {}
self.idx_to_node = {}
self.timer = Timer()
self.nid_col_name = "nid"
if isinstance(self.filename_or_stream, str):
_, self.filename_ext = os.path.splitext(filename_or_stream)
def __init__(self, dir_name):
# this is the name of the HPCToolkit database directory. The directory
# contains an experiment.xml and some metric-db files
self.dir_name = dir_name
root = ET.parse(self.dir_name + "/experiment.xml").getroot()
self.loadmodule_table = next(root.iter("LoadModuleTable"))
self.file_table = next(root.iter("FileTable"))
self.procedure_table = next(root.iter("ProcedureTable"))
self.metricdb_table = next(root.iter("MetricDBTable"))
self.callpath_profile = next(root.iter("SecCallPathProfileData"))
# For a parallel run, there should be one metric-db file per MPI
# process
metricdb_files = glob.glob(self.dir_name + "/*.metric-db")
self.num_metricdb_files = len(metricdb_files)
# We need to know how many threads per rank there are. This counts the
# number of thread 0 metric-db files (i.e., number of ranks), then
# uses this as the divisor to the total number of metric-db files.
metricdb_numranks_files = glob.glob(self.dir_name +
"/*-000-*.metric-db")
self.num_ranks = len(metricdb_numranks_files)
self.num_threads_per_rank = int(self.num_metricdb_files /
len(metricdb_numranks_files))
self.num_cpu_threads_per_rank = self.count_cpu_threads_per_rank()
# Read one metric-db file to extract the number of nodes in the CCT
# and the number of metrics
with open(metricdb_files[0], "rb") as metricdb:
metricdb.read(18) # skip tag
metricdb.read(5) # skip version TODO: should we?
endian = metricdb.read(1)
if endian == b"b":
self.num_nodes = struct.unpack(">i", metricdb.read(4))[0]
self.num_metrics = struct.unpack(">i", metricdb.read(4))[0]
else:
raise ValueError(
"HPCToolkitReader doesn't support endian '%s'" % endian)
self.load_modules = {}
self.src_files = {}
self.procedure_names = {}
self.metric_names = {}
# this list of dicts will hold all the node information such as
# procedure name, load module, filename, etc. for all the nodes
self.node_dicts = []
self.timer = Timer()
def __init__(self, filename_or_caliperreader):
"""Read in a native cali with Caliper's python reader.
Args:
filename_or_caliperreader (str or CaliperReader): name of a `cali` file OR
a CaliperReader object
"""
self.filename_or_caliperreader = filename_or_caliperreader
self.filename_ext = ""
self.metric_columns = set()
self.node_dicts = []
self.timer = Timer()
if isinstance(self.filename_or_caliperreader, str):
_, self.filename_ext = os.path.splitext(filename_or_caliperreader)