Add SPM support to rocprofv3 tool and CLI

Author: SrirakshaNag

projects/rocprofiler-sdk/source/bin/rocprofv3-avail.py

@@ -82,6 +82,9 @@ def add_list_options(subparsers):
             "list", help="List options for hw counters, agents and pc-sampling support"
         )
         add_parser_bool_argument(list_command, "--pmc", help="List counters")
+        add_parser_bool_argument(
+            list_command, "--spm", help="List counters supporting SPM"
+        )
         add_parser_bool_argument(
             list_command, "--agent", help="List basic info of agents"
         )
@@ -97,6 +100,7 @@ def add_info_options(subparsers):
         )
 
         info_command.add_argument("--pmc", nargs="*", help="PMC info")
+        info_command.add_argument("--spm", nargs="*", help="SPM info")
         info_command.add_argument(
             "--pc-sampling", nargs="*", help="Detailed PC Sampling info"
         )
@@ -198,6 +202,10 @@ def list_basic_agent(args, list_counters):
     from rocprofv3 import avail
 
     def print_agent_counter(counters):
+        if len(counters) == 0:
+            msg = "No PMC counters supported"
+            print("{:30}\n".format(msg))
+            return
         names_len = [len(counter.name) for counter in counters]
         names = [
             "{name:{width}}".format(name=counter.name, width=max(names_len))
@@ -271,10 +279,57 @@ def info_pc_sampling(args):
         print("\n")
 
 
-def listing(args):
+def listing_spm(args):
+    from rocprofv3 import avail
+
+    def print_agent_counter(counters):
+        if len(counters) == 0:
+            print("{:30}\n".format("No SPM counters supported"))
+            return
+        names_len = [len(counter.name) for counter in counters]
+        names = [
+            "{name:{width}}".format(name=counter.name, width=max(names_len))
+            for counter in counters
+        ]
+        columns = get_number_columns(max(names_len))
+        print("{:30}:\n".format("SPM"))
+        for idx in range(0, len(names), columns):
+            print("{:30}".format(" ".join(names[idx : (idx + columns)])))
+
+    agent_spm_counters = avail.get_spm_counters()
+    agent_info_map = avail.get_agent_info_map()
+
+    for agent, info in dict(sorted(agent_info_map.items())).items():
+        if (
+            info["type"] == 2
+            and args.device is not None
+            and info["logical_node_type_id"] == args.device
+        ):
+            print(
+                "{:30}:\t{}\n{:30}:\t{}".format(
+                    "GPU", info["logical_node_type_id"], "Name", info["name"]
+                )
+            )
+            print_agent_counter(agent_spm_counters[agent])
+            print("\n")
+            break
+        elif info["type"] == 2 and args.device is None:
+            print(
+                "{:30}:\t{}\n{:30}:\t{}".format(
+                    "GPU", info["logical_node_type_id"], "Name", info["name"]
+                )
+            )
+            print_agent_counter(agent_spm_counters[agent])
+            print("\n")
+
+
+def listing_pmc(args):
     from rocprofv3 import avail
 
     def print_agent_counter(counters):
+        if len(counters) == 0:
+            print("{:30}\n".format("No PMC counters supported"))
+            return
         names_len = [len(counter.name) for counter in counters]
         names = [
             "{name:{width}}".format(name=counter.name, width=max(names_len))
@@ -312,24 +367,65 @@ def print_agent_counter(counters):
             print("\n")
 
 
+def info_spm(args):
+    from rocprofv3 import avail
+
+    agent_info_map = avail.get_agent_info_map()
+
+    def print_spm_info(_args, agent):
+
+        if not _args.spm:
+            spm_counters = avail.get_spm_counters()[agent]
+            for counter in spm_counters:
+                print(counter)
+                print("\n")
+        else:
+            spm_counters = avail.get_spm_counters()[agent]
+            for spm in _args.spm:
+                for counter in spm_counters:
+                    if spm == counter.get_as_dict()["Counter_Name"]:
+                        print(counter)
+
+    for agent, info in dict(sorted(agent_info_map.items())).items():
+        if (
+            info["type"] == 2
+            and args.device is not None
+            and info["logical_node_type_id"] == args.device
+        ):
+            print(
+                "{}:{}\n{}:{}".format(
+                    "GPU", info["logical_node_type_id"], "Name", info["name"]
+                )
+            )
+            print_spm_info(args, agent)
+            break
+        elif info["type"] == 2 and args.device is None:
+            print(
+                "{}:{}\n{}:{}".format(
+                    "GPU", info["logical_node_type_id"], "Name", info["name"]
+                )
+            )
+            print_spm_info(args, agent)
+
+
 def info_pmc(args):
     from rocprofv3 import avail
 
-    agent_counters = avail.get_counters()
     agent_info_map = avail.get_agent_info_map()
 
-    def print_pmc_info(args, pmc_counters):
+    def print_pmc_info(_args, agent):
 
-        if not args.pmc:
+        if not _args.pmc:
+            pmc_counters = avail.get_counters()[agent]
             for counter in pmc_counters:
                 print(counter)
                 print("\n")
         else:
-            for pmc in args.pmc:
+            pmc_counters = avail.get_counters()[agent]
+            for pmc in _args.pmc:
                 for counter in pmc_counters:
                     if pmc == counter.get_as_dict()["Counter_Name"]:
                         print(counter)
-                        print("\n")
 
     for agent, info in dict(sorted(agent_info_map.items())).items():
         if (
@@ -342,34 +438,44 @@ def print_pmc_info(args, pmc_counters):
                     "GPU", info["logical_node_type_id"], "Name", info["name"]
                 )
             )
-            print_pmc_info(args, agent_counters[agent])
+            print_pmc_info(args, agent)
             break
         elif info["type"] == 2 and args.device is None:
             print(
                 "{}:{}\n{}:{}".format(
                     "GPU", info["logical_node_type_id"], "Name", info["name"]
                 )
             )
-            print_pmc_info(args, agent_counters[agent])
+            print_pmc_info(args, agent)
 
 
 def process_info(args):
-    if args.pmc is None and args.pc_sampling is None:
+
+    if args.pmc is None and args.pc_sampling is None and args.spm is None:
         list_basic_agent(args, True)
     if args.pmc is not None:
         info_pmc(args)
+    if args.spm is not None:
+        info_spm(args)
     if args.pc_sampling is not None:
         os.environ["ROCPROFILER_PC_SAMPLING_BETA_ENABLED"] = "on"
         info_pc_sampling(args)
 
 
 def process_list(args):
-    if args.agent is None and args.pc_sampling is None and args.pmc is None:
-        listing(args)
+    if (
+        args.agent is None
+        and args.pc_sampling is None
+        and args.pmc is None
+        and args.spm is None
+    ):
+        listing_pmc(args)
     if args.agent:
         list_basic_agent(args, False)
     if args.pmc:
-        listing(args)
+        listing_pmc(args)
+    if args.spm:
+        listing_spm(args)
     if args.pc_sampling:
         os.environ["ROCPROFILER_PC_SAMPLING_BETA_ENABLED"] = "on"
         list_pc_sampling(args)

projects/rocprofiler-sdk/source/bin/rocprofv3.py

@@ -470,6 +470,44 @@ def add_parser_bool_argument(gparser, *args, **kwargs):
         action="append",
     )
 
+    spm_options = parser.add_argument_group("Streaming Performance Monitor(SPM) options")
+
+    add_parser_bool_argument(
+        spm_options,
+        "--spm-beta-enabled",
+        help="enable SPM; beta version",
+    )
+
+    spm_options.add_argument(
+        "--spm",
+        help=(
+            "Specify SPM events to collect(comma OR space separated in case of more than 1 counters). "
+            "Note: job will fail if entire set of counters cannot be collected in single pass"
+        ),
+        default=None,
+        nargs="*",
+    )
+
+    spm_options.add_argument(
+        "--spm-buffer-size",
+        help="SPM Buffer size in kilobytes. Default value is set to 32768 KB in tool",
+        default=None,
+        type=str,
+    )
+
+    spm_options.add_argument(
+        "--spm-timeout",
+        help="Timeout for SPM, in ms. Default value is set to 0 ms in tool",
+        default=None,
+        type=int,
+    )
+
+    spm_options.add_argument(
+        "--spm-frequency",
+        help="Frequency in Ghz. This is estimated to shader clock count. Default is set to 0.5GHz in tool.",
+        default=None,
+        type=str,
+    )
     pc_sampling_options = parser.add_argument_group("PC sampling options")
 
     add_parser_bool_argument(
@@ -1143,6 +1181,20 @@ def is_filtered(key):
     return patch_args(dotdict(data))
 
 
+def int_auto(num_str):
+    if isinstance(num_str, str):
+        if "0x" in num_str:
+            return int(num_str, 16)
+        else:
+            return int(num_str, 10)
+    elif isinstance(num_str, int):
+        return num_str
+    else:
+        raise ValueError(
+            f"{type(num_str)} is not supported. {num_str} should be of type integer or string."
+        )
+
+
 def run(app_args, args, **kwargs):
 
     app_env = dict(os.environ)
@@ -1740,6 +1792,48 @@ def log_config(_env):
         update_env("ROCPROF_PC_SAMPLING_METHOD", args.pc_sampling_method)
         update_env("ROCPROF_PC_SAMPLING_INTERVAL", args.pc_sampling_interval)
 
+    if args.spm or args.spm_buffer_size or args.spm_timeout or args.spm_frequency:
+
+        if (
+            not args.spm_beta_enabled
+            and os.environ.get("ROCPROFILER_SPM_BETA_ENABLED", None) is None
+        ):
+            fatal_error(
+                "SPM unavailable. The feature is implicitly disabled. To enable it, use --spm-beta-enabled option"
+            )
+
+        update_env("ROCPROFILER_SPM_BETA_ENABLED", True, overwrite=True)
+        update_env("ROCPROF_SPM_COUNTER_COLLECTION", True, overwrite=True)
+
+        if (
+            args.pmc
+            or args.pc_sampling_beta_enabled
+            or os.environ.get("ROCPROFILER_PC_SAMPLING_BETA_ENABLED", None) is not None
+        ):
+            fatal_error(
+                "SPM feature cannot be enabled along with pc sampling or pmc counter collection"
+            )
+
+        if args.spm is None:
+            fatal_error("Please input list of counters to be sampled")
+
+        update_env(
+            "ROCPROF_SPM_COUNTERS",
+            "spm: {}".format(" ".join(args.spm)),
+            overwrite=True,
+        )
+
+        if args.spm_buffer_size:
+            update_env(
+                "ROCPROF_SPM_BUFFER_SIZE", int_auto(args.spm_buffer_size), overwrite=True
+            )
+
+        if args.spm_timeout:
+            update_env("ROCPROF_SPM_TIMEOUT_MS", args.spm_timeout, overwrite=True)
+
+        if args.spm_frequency:
+            update_env("ROCPROF_SPM_FREQUENCY", float(args.spm_frequency), overwrite=True)
+
     if args.disable_signal_handlers is not None:
         update_env("ROCPROF_SIGNAL_HANDLERS", not args.disable_signal_handlers)
 
@@ -1751,19 +1845,6 @@ def log_config(_env):
 
     if args.advanced_thread_trace:
 
-        def int_auto(num_str):
-            if isinstance(num_str, str):
-                if "0x" in num_str:
-                    return int(num_str, 16)
-                else:
-                    return int(num_str, 10)
-            elif isinstance(num_str, int):
-                return num_str
-            else:
-                raise ValueError(
-                    f"{type(num_str)} is not supported. {num_str} should be of type integer or string."
-                )
-
         update_env("ROCPROF_ADVANCED_THREAD_TRACE", True, overwrite=True)
 
         if args.att_target_cu is not None: