diff --git a/hatchet/graphframe.py b/hatchet/graphframe.py
index ee81e773..70727d6c 100644
--- a/hatchet/graphframe.py
+++ b/hatchet/graphframe.py
@@ -39,6 +39,8 @@
     traceback.print_exc()
     raise
 
+from typing import Dict, List
+
 
 def parallel_apply(filter_function, dataframe, queue):
     """A function called in parallel, which does a pandas apply on part of a
@@ -113,18 +115,44 @@ def from_hpctoolkit(dirname):
     @staticmethod
     def from_hpctoolkit_latest(
         dirname: str,
+        directory_mapping: Dict[str, str] = None,
+        parallel_profiles_mode: bool = False,
         max_depth: int = None,
         min_percentage_of_application_time: int = None,
-        min_percentage_of_parent_time: int = None,
+        exclude_mpi_function_details: bool = False,
+        exclude_openmp_function_details: bool = False,
+        exclude_cuda_function_details: bool = False,
+        exclude_system_libraries_source_code: bool = False,
+        exclude_function_call_lines: bool = False,
+        exclude_no_source_code_instructions: bool = False,
+        exclude_instructions: bool = False,
+        exclude_non_function_nodes: bool = False,
+        label_function_nodes: bool = True,
+        metric_names: List[str] = None,
+        metric_scopes: List[str] = None,
+        summary_metrics: List[str] = None,
+        profile_ranks: List[int] = None,
     ):
         """
         Read an HPCToolkit database directory into a new GraphFrame
 
         Arguments:
             dirname (str): directory of an HPCToolkit performance database
-            max_depth (int): maximum depth that nodes in the CCT can have to be imported in Hatchet
-            min_percentage_of_application_time (int): minimum percentage of application time that nodes in the CCT must have to be imported in Hatchet
-            min_percentage_of_parent_time (int): minimum percentage of parent time that nodes in the CCT must have to be imported in Hatchet
+            directory_mapping (dict): Python dictionary that maps file system location to a name
+            parallel_profiles_mode (bool): flag whether the reader should extract parallel profiles from the database (true) or the summary profile (false)
+            max_depth (int): maximum depth that nodes in the tree should have
+            min_percentage_of_application_time (int): minimum percentage of the application time that nodes in the tree should have
+            exclude_mpi_function_details (bool): flag whether to exclude subtrees of MPI function nodes
+            exclude_openmp_function_details (bool): flag whether to exclude subtrees of OpenMP function nodes
+            exclude_cuda_function_details (bool): flag whether to exclude subtrees of CUDA function nodes
+            exclude_system_libraries_source_code (bool): flag whether the reader should exclude subtree of a system library node
+            exclude_function_call_lines (bool): flag whether to exclude source line nodes that represent place of a function call
+            exclude_no_source_code_instructions (bool): flag whether to exclude nodes with no source code mapping information
+            label_function_nodes (bool): flag whether to label function nodes with 'function' prefix
+            metric_names (list): list of metrics to extract for selected profiles
+            metric_scopes (list): list of metric scopes to extract for selected profiles
+            summary_metrics (list): list of summary metrics to extract from the summary profile
+            profile_ranks (list): list of MPI ranks that specify which parallel profiles to extract
 
         Returns:
             (GraphFrame): new GraphFrame containing HPCToolkit profile data
@@ -134,9 +162,23 @@ def from_hpctoolkit_latest(
 
         return HPCToolkitReaderLatest(
             dirname,
+            directory_mapping=directory_mapping,
+            parallel_profiles_mode=parallel_profiles_mode,
             max_depth=max_depth,
             min_application_percentage_time=min_percentage_of_application_time,
-            min_parent_percentage_time=min_percentage_of_parent_time,
+            exclude_mpi_function_details=exclude_mpi_function_details,
+            exclude_openmp_function_details=exclude_openmp_function_details,
+            exclude_cuda_function_details=exclude_cuda_function_details,
+            exclude_system_libraries_source_code=exclude_system_libraries_source_code,
+            exclude_function_call_lines=exclude_function_call_lines,
+            exclude_no_source_code_instructions=exclude_no_source_code_instructions,
+            exclude_instructions=exclude_instructions,
+            exclude_non_function_nodes=exclude_non_function_nodes,
+            label_function_nodes=label_function_nodes,
+            metric_names=metric_names,
+            metric_scopes=metric_scopes,
+            summary_metrics=summary_metrics,
+            profile_ranks=profile_ranks,
         ).read()
 
     @staticmethod
diff --git a/hatchet/readers/hpctoolkit_reader_latest.py b/hatchet/readers/hpctoolkit_reader_latest.py
index 237d47dd..968c3db6 100644
--- a/hatchet/readers/hpctoolkit_reader_latest.py
+++ b/hatchet/readers/hpctoolkit_reader_latest.py
@@ -6,7 +6,8 @@
 import os
 import re
 import struct
-from typing import Dict, Union
+from datetime import datetime
+from typing import Dict, List, Tuple, Union
 
 import pandas as pd
 
@@ -16,6 +17,28 @@
 from hatchet.node import Node
 
 
+def binary_search(
+    format: str, data: bytes, low: int, high: int, target: int
+) -> Union[int, Tuple[int, int, Union[int, float]]]:
+
+    if high >= low:
+
+        mid = (low + high) // 2
+        (id, idValue) = safe_unpack(format, data, 0, mid)
+
+        if id == target:
+            return (mid, id, idValue)
+
+        elif id > target:
+            return binary_search(format, data, low, mid - 1, target)
+
+        else:
+            return binary_search(format, data, mid + 1, high, target)
+
+    else:
+        return -1
+
+
 def safe_unpack(
     format: str, data: bytes, offset: int, index: int = None, index_length: int = None
 ) -> tuple:
@@ -36,6 +59,8 @@ def read_string(data: bytes, offset: int) -> str:
         offset += 1
 
 
+NODE_TYPE_MAPPING = {0: "function", 1: "loop", 2: "line", 3: "instruction"}
+
 METRIC_SCOPE_MAPPING = {
     "execution": "i",
     "function": "e",
@@ -43,7 +68,11 @@ def read_string(data: bytes, offset: int) -> str:
     "lex_aware": "c",
 }
 
-NODE_TYPE_MAPPING = {0: "function", 1: "loop", 2: "line", 3: "instruction"}
+SUMMARY_METRIC_MAPPING = {
+    0: "sum",
+    1: "min",
+    2: "max",
+}
 
 FILE_HEADER_OFFSET = 16
 
@@ -53,30 +82,64 @@ class HPCToolkitReaderLatest:
     def __init__(
         self,
         dir_path: str,
+        directory_mapping: Dict[str, str] = None,
+        parallel_profiles_mode: bool = False,
         max_depth: int = None,
         min_application_percentage_time: int = None,
-        min_parent_percentage_time: int = None,
+        exclude_mpi_function_details: bool = False,
+        exclude_openmp_function_details: bool = False,
+        exclude_cuda_function_details: bool = False,
+        exclude_system_libraries_source_code: bool = False,
+        exclude_function_call_lines: bool = False,
+        exclude_no_source_code_instructions: bool = False,
+        exclude_instructions: bool = False,
+        exclude_non_function_nodes: bool = False,
+        label_function_nodes: bool = True,
+        metric_names: List[str] = ["time"],
+        metric_scopes: List[str] = ["i", "e"],
+        summary_metrics: List[str] = ["sum", "min", "max"],
+        profile_ranks: List[int] = None,
     ) -> None:
         self._dir_path = dir_path
+        self._directory_mapping = directory_mapping or {}
+        self._parallel_profiles_mode = parallel_profiles_mode
         self._max_depth = max_depth
-        self._application_percentage = min_application_percentage_time
-        self._parent_percentage = min_parent_percentage_time
+        self._min_application_percentage_time = min_application_percentage_time
+
+        self._exclude_mpi_function_details = exclude_mpi_function_details
+        self._exclude_openmp_function_details = exclude_openmp_function_details
+        self._exclude_cuda_function_details = exclude_cuda_function_details
+        self._exclude_system_libraries_source_code = (
+            exclude_system_libraries_source_code
+        )
+        self._exclude_function_call_lines = exclude_function_call_lines
+        self._exclude_no_source_code_instructions = exclude_no_source_code_instructions
+        self._exclude_instructions = exclude_instructions
+        self._exclude_non_function_nodes = exclude_non_function_nodes
+
+        self._metric_names = metric_names or ["time"]
+        self._metric_scopes = metric_scopes or ["i", "e"]
+        self._summary_metrics = summary_metrics or ["sum", "min", "max"]
+        self._profile_ranks = profile_ranks or []
 
         self._meta_file = None
         self._profile_file = None
+        self._cct_file = None
 
         self._functions = {}
         self._source_files = {}
         self._load_modules = {}
-        self._metric_descriptions = {}
+        self._graph_roots = []
+        self._profiles_data = []
         self._summary_profile = {}
 
+        self._label_function_nodes = label_function_nodes
+        self._profile_ids = []
+        self._metric_ids = []
+        self._metric_descriptions = {}
         self._time_metric = None
-        self._inclusive_metrics = {}
-        self._exclusive_metrics = {}
-
-        self._cct_roots = []
-        self._metrics_table = []
+        self._total_execution_time = 0
+        self._profiles_metadata: pd.DataFrame = None
 
         for file_path in os.listdir(self._dir_path):
             if file_path.split(".")[-1] == "db":
@@ -90,6 +153,9 @@ def __init__(
                         self._meta_file = file_path
                     elif format == "prof":
                         self._profile_file = file_path
+                    elif format == "ctxt":
+                        self._cct_file = file_path
+
                 except Exception:
                     pass
 
@@ -99,52 +165,8 @@ def __init__(
         if self._profile_file is None:
             raise ValueError("ERROR: profile.db not found.")
 
-    def _read_metric_descriptions(self) -> None:
-        with open(self._meta_file, "rb") as file:
-            file.seek(FILE_HEADER_OFFSET + 4 * 8)
-            formatMetrics = "<QQ"
-            meta_db = file.read(struct.calcsize(formatMetrics))
-            (
-                szMetrics,
-                pMetrics,
-            ) = safe_unpack(formatMetrics, meta_db, 0)
-
-            file.seek(pMetrics)
-            meta_db = file.read(szMetrics)
-
-        pMetrics_old = pMetrics
-        (pMetrics, nMetrics, szMetric, szScopeInst) = safe_unpack("<QLBB", meta_db, 0)
-
-        for i in range(nMetrics):
-            (pName, pScopeInsts, _, nScopeInsts) = safe_unpack(
-                "<QQQH", meta_db, pMetrics - pMetrics_old, i, szMetric
-            )
-
-            name = read_string(meta_db, pName - pMetrics_old).lower().strip()
-            # unit = None
-            if name.endswith(")"):
-                name = name[:-1]
-                # unit = name.split("(")[1].lower().strip()
-                name = name.split("(")[0].lower().strip()
-
-            for j in range(nScopeInsts):
-                (pScope, propMetricId) = safe_unpack(
-                    "<QH", meta_db, pScopeInsts - pMetrics_old, j, szScopeInst
-                )
-                (pScopeName,) = safe_unpack("<Q", meta_db, pScope - pMetrics_old)
-                scope_name = METRIC_SCOPE_MAPPING[
-                    read_string(meta_db, pScopeName - pMetrics_old).lower().strip()
-                ]
-
-                if scope_name in ["i", "e"]:
-                    if name in ["cputime", "realtime", "cycles"]:
-                        name = "time"
-
-                    metric_full_name = f"{name} (inc)" if scope_name == "i" else name
-                    if metric_full_name == "time (inc)":
-                        self._time_metric = metric_full_name
-
-                    self._metric_descriptions[propMetricId] = metric_full_name
+        if self._cct_file is None:
+            raise ValueError("ERROR: cct.db not found.")
 
     def _parse_source_file(self, meta_db: bytes, pFile: int) -> Dict[str, str]:
         if pFile not in self._source_files:
@@ -153,10 +175,25 @@ def _parse_source_file(self, meta_db: bytes, pFile: int) -> Dict[str, str]:
                 meta_db,
                 pFile + struct.calcsize("<Q"),
             )
-            self._source_files[pFile] = {
-                "id": pFile,
-                "file_path": read_string(meta_db, pPath),
-            }
+
+            file_path = read_string(meta_db, pPath)
+
+            if file_path.startswith("src"):
+                file_path = file_path[3:]
+
+            for item in self._directory_mapping:
+                new_item = item
+                if not item.startswith("/"):
+                    new_item = f"/{item}"
+                if not item.endswith("/"):
+                    new_item = f"{new_item}/"
+                if file_path.startswith(new_item):
+                    file_path = (
+                        f"{self._directory_mapping[item]}/{file_path[len(new_item):]}"
+                    )
+                    break
+
+            self._source_files[pFile] = {"id": pFile, "file_path": file_path}
 
         return self._source_files[pFile]
 
@@ -190,14 +227,9 @@ def _parse_function(
             ):
                 name = name[: re.match("^P?MPI_[a-zA-Z_]+", name).end()]
 
-            if " [" in name:
-                name = name[: name.index(" [")]
-
-            if "." in name:
-                name = name[: name.index(".")]
-
-            if "@" in name:
-                name = name[: name.index("@")]
+            for item in [" [", ".", "@", "(", "<"]:
+                if item in name and not name.startswith(item):
+                    name = name[: name.index(item)]
 
             self._functions[pFunction] = {
                 "id": pFunction,
@@ -216,153 +248,402 @@ def _parse_function(
 
         return self._functions[pFunction]
 
-    def _store_cct_node(
-        self, ctxId: int, frame: dict, parent: Node = None, depth: int = 0
-    ) -> Node:
-        node = Node(Frame(frame), parent=parent, hnid=ctxId, depth=depth)
-        if parent is None:
-            self._cct_roots.append(node)
-        else:
-            parent.add_child(node)
-        node_value = {
-            "node": node,
-            "name": (
-                # f"{frame['type']}: {frame['name']}"
-                frame["name"]
-                if frame["name"] != 1
-                else "entry"
-            ),
-        }
-
-        if ctxId in self._summary_profile:
-            node_value.update(self._summary_profile[ctxId])
-
-        self._metrics_table.append(node_value)
-
-        return node
-
     def _parse_context(
         self,
         current_offset: int,
         total_size: int,
         parent: Node,
         meta_db: bytes,
-        parent_time: int,
     ) -> None:
-
         final_offset = current_offset + total_size
 
         while current_offset < final_offset:
             (szChildren, pChildren, ctxId, _, lexicalType, nFlexWords) = safe_unpack(
                 "<QQLHBB", meta_db, current_offset
             )
+
             flex_offset = current_offset + 32
             current_offset += 32 + nFlexWords * 8
 
-            try:
-                my_time = self._summary_profile[ctxId][self._time_metric]
-            except Exception:
-                my_time = None
+            my_time = (
+                self._summary_profile[ctxId][self._time_metric]
+                if ctxId in self._summary_profile
+                and self._time_metric in self._summary_profile[ctxId]
+                else None
+            )
 
-            if (
+            if self._min_application_percentage_time is not None and (
                 my_time is None
-                or (
-                    self._parent_percentage is not None
-                    and my_time / parent_time * 100.0 < self._parent_percentage
-                )
-                or (
-                    self._application_percentage is not None
-                    and my_time / self._total_execution_time * 100
-                    < self._application_percentage
-                )
+                or my_time / self._total_execution_time * 100
+                < self._min_application_percentage_time
             ):
                 continue
 
-            frame = {"type": NODE_TYPE_MAPPING[lexicalType]}
+            node_type = NODE_TYPE_MAPPING[lexicalType]
+            frame = {"type": node_type}
 
-            if nFlexWords:
-                if lexicalType == 0:
-                    (pFunction,) = safe_unpack("<Q", meta_db, flex_offset)
-                    frame["name"] = self._parse_function(meta_db, pFunction)["name"]
+            include_node = True and not (
+                self._exclude_non_function_nodes and node_type != "function"
+            )
+            include_subtree = True
 
-                elif lexicalType == 3:
+            if include_node and nFlexWords:
+                if node_type == "function":
+                    (pFunction,) = safe_unpack("<Q", meta_db, flex_offset)
+                    function_data = self._parse_function(meta_db, pFunction)
+                    frame["name"] = function_data["name"]
+
+                    if self._exclude_mpi_function_details and (
+                        frame["name"].startswith("MPI_")
+                        or frame["name"].startswith("PMPI_")
+                    ):
+                        include_subtree = False
+
+                    if "file_id" in function_data:
+                        file_data = self._source_files[function_data["file_id"]]
+
+                        if (
+                            self._exclude_openmp_function_details
+                            and "/openmp/" in file_data["file_path"]
+                        ):
+                            include_subtree = False
+                            frame["name"] = f"<omp> {frame['name']}"
+
+                        if self._exclude_cuda_function_details:
+                            for item in [
+                                "libcuda.so",
+                                "libcudart.so",
+                                "libcusparse.so",
+                                "libcublas.so",
+                                "libcurand.so",
+                                "libcusolver.so",
+                                "libcufft.so",
+                                "/cuda/",
+                            ]:
+                                if item in file_data["file_path"]:
+                                    include_subtree = False
+
+                    if self._label_function_nodes:
+                        frame["name"] = f"function: {frame['name']}"
+
+                elif node_type == "instruction":
                     (pModule, offset) = safe_unpack("<QQ", meta_db, flex_offset)
                     frame["name"] = (
                         f"{self._parse_load_module(meta_db, pModule)['module_path']}:{offset}"
                     )
 
+                    if self._exclude_instructions:
+                        include_node = False
+
                 else:
                     (pFile, line) = safe_unpack("<QL", meta_db, flex_offset)
-                    frame["name"] = (
-                        f"{self._parse_source_file(meta_db, pFile)['file_path']}:{line}"
-                    )
-
-            node = self._store_cct_node(ctxId, frame, parent, parent._depth + 1)
+                    file_data = self._parse_source_file(meta_db, pFile)
+                    frame["name"] = f"{frame['type']} {file_data['file_path']}:{line}"
+
+                    if self._exclude_system_libraries_source_code:
+                        for item in ["/usr/src/debug", "/usr/tce"]:
+                            if file_data["file_path"].startswith(item):
+                                include_node = False
+
+                    if self._exclude_no_source_code_instructions and line == 0:
+                        include_node = False
+
+                    if (
+                        self._exclude_function_call_lines
+                        and frame["type"] == "line"
+                        and szChildren > 0
+                    ):
+                        include_node = False
+
+            if not include_node:
+                node = parent
+
+            else:
+                node = self._store_cct_node(
+                    ctxId,
+                    frame,
+                    parent,
+                )
 
-            if self._max_depth is None or node._depth < self._max_depth:
+            if include_subtree and (
+                self._max_depth is None or node._depth < self._max_depth
+            ):
                 self._parse_context(
                     pChildren,
                     szChildren,
                     node,
                     meta_db,
-                    my_time,
                 )
 
-    def _read_summary_profile(
+    def _store_cct_node(
         self,
-    ) -> None:
+        ctxId: int,
+        frame: dict,
+        parent: Node = None,
+    ) -> Node:
+        node = Node(
+            Frame(frame),
+            parent=parent,
+            hnid=ctxId,
+            depth=0 if parent is None else parent._depth + 1,
+        )
 
-        with open(self._profile_file, "rb") as file:
-            file.seek(FILE_HEADER_OFFSET)
-            formatProfileInfos = "<QQ"
-            profile_db = file.read(struct.calcsize(formatProfileInfos))
-            (szProfileInfos, pProfileInfos) = safe_unpack(
-                formatProfileInfos, profile_db, 0
+        if not self._parallel_profiles_mode:
+            record = self._summary_profile.get(ctxId, {})
+            record["node"] = node
+            record["name"] = node.frame["name"]
+            record["profile"] = 0
+            self._profiles_data.append(record)
+
+        else:
+            metric_ids = self._metric_ids[:]
+            # TODO: what if metric list is empty?
+
+            with open(self._cct_file, "rb") as file:
+                file.seek(FILE_HEADER_OFFSET)
+                formatCtxInfos = "<QQ"
+                cct_db = file.read(struct.calcsize(formatCtxInfos))
+                (szCtxInfos, pCtxInfos) = safe_unpack(formatCtxInfos, cct_db, 0)
+
+                file.seek(pCtxInfos)
+                cct_db = file.read(szCtxInfos)
+                (pCtxs, nCtxs, szCtx) = safe_unpack("<QLB", cct_db, 0)
+
+                file.seek(pCtxs + ctxId * szCtx)
+                cct_db = file.read(szCtx)
+                (nValues, pValues, nMetrics, _, _, pMetricIndices) = safe_unpack(
+                    "<QQHHLQ", cct_db, 0
+                )
+
+                file.seek(pMetricIndices)
+                formatMetrics = "<HQ"
+                metrics_sub_db = file.read(nMetrics * struct.calcsize(formatMetrics))
+
+                file.seek(pValues)
+                formatValues = "<Ld"
+                values_sub_db = file.read(nValues * struct.calcsize(formatValues))
+
+                records = {}
+
+                low = 0
+                high = nMetrics
+
+                while len(metric_ids):
+                    metric_id = metric_ids.pop()
+                    profile_ids = self._profile_ids[:]
+
+                    result = binary_search(
+                        formatMetrics, metrics_sub_db, low, high, metric_id
+                    )
+
+                    if result != -1:
+                        (mid, metricId, startIndex) = result
+                        high = mid
+
+                        if mid == nMetrics - 1:
+                            end_index = nValues
+                        else:
+                            (_, end_index) = safe_unpack(
+                                formatMetrics, metrics_sub_db, 0, mid + 1
+                            )
+
+                        if len(profile_ids):
+
+                            while len(profile_ids):
+
+                                profile_id = profile_ids.pop()
+                                result_2 = binary_search(
+                                    formatValues,
+                                    values_sub_db,
+                                    startIndex,
+                                    end_index,
+                                    profile_id,
+                                )
+
+                                if result_2 != -1:
+                                    (mid, profIndex, value) = result_2
+
+                                    if profIndex not in records:
+                                        records[profIndex] = {
+                                            "node": node,
+                                            "profile": profIndex,
+                                            "name": node.frame["name"],
+                                        }
+
+                                    records[profIndex][
+                                        self._metric_descriptions[metricId]
+                                    ] = value
+
+                                    end_index = mid
+
+                        else:
+                            for j in range(startIndex, end_index):
+                                (profIndex, value) = safe_unpack(
+                                    formatValues, values_sub_db, 0, j
+                                )
+
+                                if profIndex not in records:
+                                    records[profIndex] = {
+                                        "node": node,
+                                        "profile": profIndex,
+                                        "name": node.frame["name"],
+                                    }
+
+                                records[profIndex][
+                                    self._metric_descriptions[metricId]
+                                ] = value
+
+                self._profiles_data.extend(records.values())
+
+        if parent is None:
+            self._graph_roots.append(node)
+        else:
+            parent.add_child(node)
+
+        return node
+
+    def _read_metric_descriptions(self) -> None:
+        with open(self._meta_file, "rb") as file:
+            file.seek(FILE_HEADER_OFFSET + 4 * 8)
+            formatMetrics = "<QQ"
+            meta_db = file.read(struct.calcsize(formatMetrics))
+            (
+                szMetrics,
+                pMetrics,
+            ) = safe_unpack(formatMetrics, meta_db, 0)
+
+            file.seek(pMetrics)
+            meta_db = file.read(szMetrics)
+
+        pMetrics_old = pMetrics
+        (pMetrics, nMetrics, szMetric, szScopeInst, szSummary) = safe_unpack(
+            "<QLBBB", meta_db, 0
+        )
+
+        for i in range(nMetrics):
+            (pName, pScopeInsts, pSummaries, nScopeInsts, nSummaries) = safe_unpack(
+                "<QQQHH", meta_db, pMetrics - pMetrics_old, i, szMetric
             )
 
-            file.seek(pProfileInfos)
-            profile_db = file.read(szProfileInfos)
-            (pProfiles,) = safe_unpack("<Q", profile_db, 0)
+            name = read_string(meta_db, pName - pMetrics_old).lower().strip()
+            # unit = None
+            if name.endswith(")"):
+                name = name[:-1]
+                # unit = name.split("(")[1].lower().strip()
+                name = name.split("(")[0].lower().strip()
 
-            (nValues, pValues, nCtxs, _, pCtxIndices) = safe_unpack(
-                "<QQLLQ", profile_db, pProfiles - pProfileInfos
+            if name in ["cputime", "realtime", "cycles"]:
+                name = "time"
+
+            if name not in self._metric_names:
+                continue
+
+            def store_metric(
+                metricName: str, metricId: int, pScope: int, store: bool = True
+            ) -> None:
+                (pScopeName,) = safe_unpack("<Q", meta_db, pScope - pMetrics_old)
+                scope_name = METRIC_SCOPE_MAPPING[
+                    read_string(meta_db, pScopeName - pMetrics_old).lower().strip()
+                ]
+
+                if scope_name in self._metric_scopes:
+                    metric_full_name = (
+                        f"{metricName} (inc)" if scope_name == "i" else metricName
+                    )
+
+                    if metric_full_name == "time (inc)":
+                        self._time_metric = metric_full_name
+                        # TODO: is the logic correct to use this metric for verifying min application percentage time filter?
+
+                    if store:
+                        self._metric_descriptions[metricId] = metric_full_name
+
+            if self._parallel_profiles_mode:
+                for j in range(nScopeInsts):
+                    (pScope, propMetricId) = safe_unpack(
+                        "<QH", meta_db, pScopeInsts - pMetrics_old, j, szScopeInst
+                    )
+                    store_metric(name, propMetricId, pScope)
+
+            else:
+                for j in range(nSummaries):
+                    (pScope, _, combine, _, statMetricId) = safe_unpack(
+                        "<QQBBH", meta_db, pSummaries - pMetrics_old, j, szSummary
+                    )
+                    summary_name = SUMMARY_METRIC_MAPPING[combine]
+                    if summary_name in self._summary_metrics or (
+                        self._min_application_percentage_time is not None
+                        and summary_name == "sum"
+                    ):
+                        store_metric(
+                            f"{name}:{summary_name}" if summary_name != "sum" else name,
+                            statMetricId,
+                            pScope,
+                            store=summary_name in self._summary_metrics,
+                        )
+
+        self._metric_ids = list(self._metric_descriptions.keys())
+        self._metric_ids.sort()
+
+    def _read_profiles_metadata(self) -> None:
+        identifiers = {}
+
+        with open(self._meta_file, "rb") as file:
+            file.seek(FILE_HEADER_OFFSET + 2 * 8)
+            formatIdNames = "<QQ"
+            meta_db = file.read(struct.calcsize(formatIdNames))
+            (szIdNames, pIdNames) = safe_unpack(formatIdNames, meta_db, 0)
+
+            file.seek(pIdNames)
+            meta_db = file.read(szIdNames)
+            (ppNames, nKinds) = safe_unpack("<QB", meta_db, 0)
+
+            for i in range(nKinds):
+                (pName,) = safe_unpack("<Q", meta_db, ppNames - pIdNames, i)
+                identifiers[i] = read_string(meta_db, pName - pIdNames).lower().strip()
+
+        profiles = []
+
+        with open(self._profile_file, "rb") as file:
+            file.seek(FILE_HEADER_OFFSET + 2 * 8)
+            formatProfileInfosIdTuples = "<QQ"
+            profile_db = file.read(struct.calcsize(formatProfileInfosIdTuples))
+            (szIdTuples, pIdTuples) = safe_unpack(
+                formatProfileInfosIdTuples, profile_db, 0
             )
 
-            file.seek(pCtxIndices)
-            formatCtxs = "<LQ"
-            cct_sub_db = file.read(nCtxs * struct.calcsize(formatCtxs))
+            file.seek(pIdTuples)
+            profile_db = file.read(szIdTuples)
 
-            file.seek(pValues)
-            formatValues = "<Hd"
-            values_sub_db = file.read(nValues * struct.calcsize(formatValues))
+            current_offset = 0
+            current_index = 1
 
-            for i in range(nCtxs):
-                (ctxId, startIndex) = safe_unpack("<LQ", cct_sub_db, 0, i)
-                cct_id = ctxId
+            while current_offset < szIdTuples:
+                row = {"profile": current_index}
+                profiles.append(row)
 
-                if i == nCtxs - 1:
-                    end_index = nValues
-                else:
-                    (_, end_index) = safe_unpack(formatCtxs, cct_sub_db, 0, i + 1)
+                (nIds,) = safe_unpack("<H", profile_db, current_offset)
+                current_offset += 8
 
-                self._summary_profile[cct_id] = {}
+                for i in range(nIds):
+                    formatIds = "<BBHLQ"
+                    (kind, _, _, logicalId, physicalId) = safe_unpack(
+                        formatIds, profile_db, current_offset
+                    )
+                    row[identifiers[kind]] = physicalId if kind in [1, 7] else logicalId
+                    current_offset += struct.calcsize(formatIds)
 
-                for j in range(startIndex, end_index):
-                    (metricId, value) = safe_unpack("<Hd", values_sub_db, 0, j)
+                current_index += 1
 
-                    if metricId in self._metric_descriptions:
-                        self._summary_profile[cct_id][
-                            self._metric_descriptions[metricId]
-                        ] = value
+        self._profiles_metadata = pd.DataFrame(profiles).set_index("profile")
 
-                        if self._metric_descriptions[metricId].endswith("(i)"):
-                            self._inclusive_metrics[metricId] = (
-                                self._metric_descriptions[metricId]
-                            )
-                        else:
-                            self._exclusive_metrics[metricId] = (
-                                self._metric_descriptions[metricId]
-                            )
+        if len(self._profile_ranks):
+            temp = self._profiles_metadata[
+                self._profiles_metadata["rank"].isin(self._profile_ranks)
+            ]
+            self._profile_ids = temp.index.unique().tolist()
+            self._profile_ids.sort()
+            # TODO: what if there are no ranks in profiles?
 
     def _read_cct(
         self,
@@ -384,49 +665,121 @@ def _read_cct(
                 szEntryPoint,
             )
 
-            if entryPoint != 1:
-                continue
+            if entryPoint == 1:
+                if (
+                    not self._parallel_profiles_mode
+                    or self._min_application_percentage_time is not None
+                ):
+                    self._total_execution_time = self._summary_profile[ctxId][
+                        self._time_metric
+                    ]
+
+                node = self._store_cct_node(
+                    ctxId,
+                    {"type": "entry", "name": "entry"},
+                )
+                self._parse_context(
+                    pChildren,
+                    szChildren,
+                    node,
+                    meta_db,
+                )
+                break
 
-            frame = {"type": "entry", "name": "entry"}
+        dataframe = pd.DataFrame(self._profiles_data).set_index(["node", "profile"])
 
-            node = self._store_cct_node(ctxId, frame)
+        if self._parallel_profiles_mode:
+            metadata = self._profiles_metadata.loc[
+                dataframe.index.get_level_values(1).unique().tolist()
+            ]
 
+        else:
             try:
-                self._total_execution_time = self._summary_profile[ctxId][
-                    self._time_metric
-                ]
+                nodes = int(self._dir_path.split("/")[-1].split("_")[-1])
             except Exception:
-                self._total_execution_time = None
+                nodes = 0
+            metadata = {
+                "date": datetime.utcfromtimestamp(
+                    os.path.getmtime(self._dir_path)
+                ).strftime("%Y-%m-%d %H:%M:%S"),
+                "file_path": self._dir_path,
+                "nodes": nodes,
+            }
+            dataframe = dataframe.droplevel(level=1)
 
-            self._parse_context(
-                pChildren, szChildren, node, meta_db, self._total_execution_time
-            )
+        inc_metrics = list(
+            filter(lambda x: x.endswith("(inc)"), dataframe.columns.tolist())
+        )
 
-            table = pd.DataFrame(self._metrics_table).set_index("node")
+        exc_metrics = list(
+            filter(lambda x: not x.endswith("(inc)"), dataframe.columns.tolist())
+        )
 
-            inclusive_metrics = []
-            exclusive_metrics = []
+        return GraphFrame(
+            Graph(self._graph_roots),
+            dataframe,
+            inc_metrics=inc_metrics,
+            exc_metrics=exc_metrics,
+            default_metric=self._time_metric,
+            metadata=metadata,
+        )
 
-            for im in list(self._inclusive_metrics.values()):
-                if im in table.columns.tolist():
-                    inclusive_metrics.append(im)
+    def _read_summary_profile(
+        self,
+    ) -> None:
 
-            for em in (list(self._exclusive_metrics.values()),):
-                if em in table.columns.tolist():
-                    exclusive_metrics.append(em)
+        with open(self._profile_file, "rb") as file:
+            file.seek(FILE_HEADER_OFFSET)
+            formatProfileInfos = "<QQ"
+            profile_db = file.read(struct.calcsize(formatProfileInfos))
+            (szProfileInfos, pProfileInfos) = safe_unpack(
+                formatProfileInfos, profile_db, 0
+            )
 
-            graphframe = GraphFrame(
-                Graph(self._cct_roots),
-                table,
-                inc_metrics=inclusive_metrics,
-                exc_metrics=exclusive_metrics,
-                default_metric=self._time_metric,
+            file.seek(pProfileInfos)
+            profile_db = file.read(szProfileInfos)
+            (pProfiles,) = safe_unpack("<Q", profile_db, 0)
+
+            (nValues, pValues, nCtxs, _, pCtxIndices) = safe_unpack(
+                "<QQLLQ", profile_db, pProfiles - pProfileInfos
             )
 
-            print("DATA IMPORTED")
-            return graphframe
+            file.seek(pCtxIndices)
+            formatCtxs = "<LQ"
+            cct_sub_db = file.read(nCtxs * struct.calcsize(formatCtxs))
+
+            file.seek(pValues)
+            formatValues = "<Hd"
+            values_sub_db = file.read(nValues * struct.calcsize(formatValues))
+
+            for i in range(nCtxs):
+                (ctxId, startIndex) = safe_unpack("<LQ", cct_sub_db, 0, i)
+                cct_id = ctxId
+
+                if i == nCtxs - 1:
+                    end_index = nValues
+                else:
+                    (_, end_index) = safe_unpack(formatCtxs, cct_sub_db, 0, i + 1)
+
+                self._summary_profile[cct_id] = {}
+
+                for j in range(startIndex, end_index):
+                    (metricId, value) = safe_unpack("<Hd", values_sub_db, 0, j)
+
+                    if metricId in self._metric_descriptions:
+                        self._summary_profile[cct_id][
+                            self._metric_descriptions[metricId]
+                        ] = value
 
     def read(self) -> GraphFrame:
         self._read_metric_descriptions()
-        self._read_summary_profile()
+        if (
+            not self._parallel_profiles_mode
+            or self._min_application_percentage_time is not None
+        ):
+            self._read_summary_profile()
+
+        if self._parallel_profiles_mode:
+            self._read_profiles_metadata()
+
         return self._read_cct()
diff --git a/hatchet/tests/hpctoolkit_latest.py b/hatchet/tests/hpctoolkit_latest.py
index 75f74eb7..3eaaa28d 100644
--- a/hatchet/tests/hpctoolkit_latest.py
+++ b/hatchet/tests/hpctoolkit_latest.py
@@ -8,7 +8,11 @@
 
 
 def test_import_entire_db(data_dir: str) -> None:
-    graphframe = GraphFrame.from_hpctoolkit_latest(f"{data_dir}/hpctoolkit-gamess")
+    graphframe = GraphFrame.from_hpctoolkit_latest(
+        f"{data_dir}/hpctoolkit-gamess",
+        metric_names=["time", "gpuop", "gker", "gxcopy", "gxcopy:count"],
+        label_function_nodes=False,
+    )
 
     assert len(graphframe.graph.roots) == 1
     assert graphframe.graph.roots[0]._hatchet_nid == 1195
@@ -16,7 +20,7 @@ def test_import_entire_db(data_dir: str) -> None:
     assert graphframe.graph.roots[0].frame["name"] == "entry"
     assert graphframe.graph.roots[0].frame["type"] == "entry"
 
-    assert len(graphframe.dataframe) == 10824
+    assert len(graphframe.dataframe) == 11292
     assert "name" in graphframe.dataframe.columns
     assert "time (inc)" in graphframe.dataframe.columns
     assert "time" in graphframe.dataframe.columns
@@ -42,19 +46,22 @@ def test_import_entire_db(data_dir: str) -> None:
     assert measurements["gxcopy:count (inc)"] == 9688
 
     measurements = graphframe.dataframe.loc[Node(None, hnid=1004)]
-    assert measurements["name"] == "[libsci_cray.so.5.0]:0"
+    assert measurements["name"] == "loop [libsci_cray.so.5.0]:0"
     assert round(measurements["time (inc)"], 2) == 0.08
     assert round(measurements["time"], 2) == 0.08
 
     measurements = graphframe.dataframe.loc[Node(None, hnid=1003)]
-    assert measurements["name"] == "[libsci_cray.so.5.0]:0"
+    assert measurements["name"] == "line [libsci_cray.so.5.0]:0"
     assert round(measurements["time (inc)"], 2) == 0.08
     assert round(measurements["time"], 2) == 0.08
 
 
 def test_filter_by_max_depth(data_dir: str) -> None:
     graphframe = GraphFrame.from_hpctoolkit_latest(
-        f"{data_dir}/hpctoolkit-gamess", max_depth=10
+        f"{data_dir}/hpctoolkit-gamess",
+        max_depth=10,
+        metric_names=["time", "gpuop", "gker", "gxcopy", "gxcopy:count"],
+        label_function_nodes=False,
     )
 
     assert len(graphframe.graph.roots) == 1
@@ -97,7 +104,7 @@ def test_filter_by_max_depth(data_dir: str) -> None:
     assert measurements["gxcopy:count (inc)"] == 9688
 
     measurements = graphframe.dataframe.loc[Node(None, hnid=9845)]
-    assert measurements["name"] == "[gamess.00.x]:0"
+    assert measurements["name"] == "loop [gamess.00.x]:0"
     assert round(measurements["time (inc)"], 2) == 786.09
     assert round(measurements["gpuop (inc)"], 2) == 608.09
     assert round(measurements["gker (inc)"], 2) == 608.00
@@ -110,7 +117,10 @@ def test_filter_by_max_depth(data_dir: str) -> None:
 
 def test_filter_by_min_percentage_of_application_time(data_dir: str) -> None:
     graphframe = GraphFrame.from_hpctoolkit_latest(
-        f"{data_dir}/hpctoolkit-gamess", min_percentage_of_application_time=1
+        f"{data_dir}/hpctoolkit-gamess",
+        min_percentage_of_application_time=1,
+        metric_names=["time", "gpuop", "gker", "gxcopy", "gxcopy:count"],
+        label_function_nodes=False,
     )
 
     assert len(graphframe.graph.roots) == 1
@@ -151,63 +161,10 @@ def test_filter_by_min_percentage_of_application_time(data_dir: str) -> None:
     assert round(measurements["time"], 3) == 159.238
 
     measurements = graphframe.dataframe.loc[Node(None, hnid=251)]
-    assert measurements["name"] == "[libc-2.31.so]:0"
+    assert measurements["name"] == "line [libc-2.31.so]:0"
     assert round(measurements["time (inc)"], 3) == 159.238
     assert round(measurements["time"], 3) == 159.238
 
     for node in graphframe.graph.traverse():
         node_time = graphframe.dataframe.loc[node]["time (inc)"]
         assert node_time / application_time >= 0.01
-
-
-def test_filter_by_min_percentage_of_parent_time(data_dir: str) -> None:
-    graphframe = GraphFrame.from_hpctoolkit_latest(
-        f"{data_dir}/hpctoolkit-gamess", min_percentage_of_parent_time=1
-    )
-
-    assert len(graphframe.graph.roots) == 1
-    assert graphframe.graph.roots[0]._hatchet_nid == 1195
-    assert graphframe.graph.roots[0]._depth == 0
-    assert graphframe.graph.roots[0].frame["name"] == "entry"
-    assert graphframe.graph.roots[0].frame["type"] == "entry"
-
-    assert len(graphframe.dataframe) == 4576
-    assert "name" in graphframe.dataframe.columns
-    assert "time (inc)" in graphframe.dataframe.columns
-    assert "time" in graphframe.dataframe.columns
-    assert "gpuop (inc)" in graphframe.dataframe.columns
-    assert "gker (inc)" in graphframe.dataframe.columns
-    assert "gxcopy (inc)" in graphframe.dataframe.columns
-    assert "gxcopy:count (inc)" in graphframe.dataframe.columns
-
-    measurements = graphframe.dataframe.loc[Node(None, hnid=1195)]
-    assert measurements["name"] == "entry"
-    assert round(measurements["time (inc)"], 2) == 1608.49
-    assert round(measurements["gpuop (inc)"], 2) == 608.09
-    assert round(measurements["gker (inc)"], 2) == 608.00
-    assert round(measurements["gxcopy (inc)"], 2) == 0.09
-    assert measurements["gxcopy:count (inc)"] == 9688
-
-    measurements = graphframe.dataframe.loc[Node(None, hnid=1197)]
-    assert measurements["name"] == "gamess_"
-    assert round(measurements["time (inc)"], 2) == 1608.49
-    assert round(measurements["gpuop (inc)"], 2) == 608.09
-    assert round(measurements["gker (inc)"], 2) == 608.00
-    assert round(measurements["gxcopy (inc)"], 2) == 0.09
-    assert measurements["gxcopy:count (inc)"] == 9688
-
-    measurements = graphframe.dataframe.loc[Node(None, hnid=2856)]
-    assert measurements["name"] == "__GI___sched_yield"
-    assert round(measurements["time (inc)"], 3) == 159.238
-    assert round(measurements["time"], 3) == 159.238
-
-    measurements = graphframe.dataframe.loc[Node(None, hnid=251)]
-    assert measurements["name"] == "[libc-2.31.so]:0"
-    assert round(measurements["time (inc)"], 3) == 159.238
-    assert round(measurements["time"], 3) == 159.238
-
-    for node in graphframe.graph.traverse():
-        node_time = graphframe.dataframe.loc[node]["time (inc)"]
-        if node.frame["type"] != "entry":
-            parent_time = graphframe.dataframe.loc[node.parents[0]]["time (inc)"]
-            assert node_time / parent_time >= 0.01