Separate out profiler CLI tooling into OSS and fb specific components.

Summary:
This diff does two things:
- Moves the profiler scuba logging functionality to a fb specific folder.
- Some of the functionality such as parsing the program and showing the stacktraces in the profiler results cannot be supported in OSS yet, so until they can be supported in OSS we move this functionality to the fb specific internal only version.

Reviewed By: dbort

Differential Revision:
D47851149

Privacy Context Container: L1124100

fbshipit-source-id: 15e04e1cc17b16c2cd1bffff308b19ea2df93bc2

Author: tarun292

build/env_interface.bzl

@@ -124,6 +124,10 @@ _EXTERNAL_DEPS_MAP = {
         _FBCODE: "fbcode//caffe2:libtorch",
         _XPLAT: "fbsource//xplat/caffe2:torch_mobile_all_ops",
     },
+    "prettytable": {
+        _FBCODE: "fbsource//third-party/pypi/prettytable:prettytable",
+        _XPLAT: "fbsource//third-party/pypi/prettytable:prettytable",
+    },
     "pybind11": {
         _FBCODE: _EXTERNAL_DEP_FALLTHROUGH,
         _XPLAT: "fbsource//arvr/third-party/pybind11:pybind11",

profiler/TARGETS

@@ -9,39 +9,19 @@ runtime.python_library(
         "parse_profiler_results.py",
         "profiler_results_cli.py",
     ],
+    base_module = "executorch.profiler",
     visibility = ["@EXECUTORCH_CLIENTS"],
-    deps = [
-        "fbsource//third-party/pypi/prettytable:prettytable",
-        "//executorch/exir:schema",
-        "//executorch/exir/serialize:lib",
-    ],
-)
-
-runtime.python_library(
-    name = "profiler_results_scuba",
-    srcs = [
-        "profiler_results_scuba.py",
-    ],
-    visibility = ["@EXECUTORCH_CLIENTS"],
-    deps = [
-        ":parse_profiler_library",
-        "//executorch/exir:schema",
-        "//executorch/exir/serialize:lib",
-        "//libfb/py:fburl",
-        "//libfb/py:scuba_url",
-        "//rfe/scubadata:scubadata_py3",
-    ],
+    external_deps = ["prettytable"],
 )
 
 runtime.python_library(
     name = "profiler_results_cli_lib",
     srcs = [
         "profiler_results_cli.py",
     ],
+    base_module = "executorch.profiler",
     deps = [
         ":parse_profiler_library",
-        ":profiler_results_scuba",
-        "//executorch/exir/serialize:lib",
     ],
 )
 

profiler/parse_profiler_results.py

@@ -12,8 +12,6 @@
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-from executorch.exir.schema import Frame, FrameList, Program
-from executorch.exir.serialize import deserialize_from_flatbuffer
 from prettytable import PrettyTable
 
 # This version number should match the one defined in profiler.h
@@ -109,76 +107,6 @@ class MemEvent:
     total_allocations_done: int
 
 
-def frame_short_repr(frame: Frame) -> str:
-    return f"{Path(frame.filename).name}:{frame.lineno}:{frame.name}"
-
-
-def frame_list_short_repr(frame_list: FrameList) -> Optional[str]:
-    if frame_list is None:
-        return None
-
-    return frame_short_repr(frame_list.items[-1])
-
-
-def _stacktraces(program: Program, execution_plan_idx: int, chain_idx: int):
-    # The step api executes one instruction more than exists to determine if it has reached the end of the program
-    if chain_idx == len(program.execution_plan[execution_plan_idx].chains):
-        return None
-    chain = program.execution_plan[execution_plan_idx].chains[chain_idx]
-    stacktraces = chain.stacktrace
-
-    if stacktraces is None:
-        return None
-
-    result = []
-    for stacktrace in stacktraces:
-        result.append(stacktrace)
-    return result
-
-
-def fetch_frame_list_short_repr(
-    program: Program,
-    execution_plan_idx: int,
-    chain_idx: int,
-    instruction_idx: int,
-) -> Optional[str]:
-    if chain_idx == CHAIN_IDX_NO_CHAIN:
-        return None
-
-    assert chain_idx >= 0
-
-    frame_lists = _stacktraces(program, execution_plan_idx, chain_idx)
-    if frame_lists is None:
-        return None
-
-    assert instruction_idx < len(frame_lists)
-    frame_list = frame_lists[instruction_idx]
-    return frame_list_short_repr(frame_list)
-
-
-def get_frame_list(program, execution_plan_idx, chain_idx, instruction_idx):
-    if program is None:
-        return None
-
-    if chain_idx == CHAIN_IDX_NO_CHAIN:
-        return None
-
-    frame_lists = _stacktraces(program, execution_plan_idx, chain_idx)
-
-    if frame_lists is None:
-        return None
-
-    assert instruction_idx < len(frame_lists)
-
-    return frame_lists[instruction_idx]
-
-
-def frame_list_normal_vector_short(frame_list: FrameList) -> Optional[List[str]]:
-    if frame_list is None:
-        return None
-    return [frame_short_repr(frame) for frame in frame_list.items]
-
-
 def adjust_time_scale(event: ProfileData, time_scale: TimeScale):
     time_div_factor = {
         TimeScale.CPU_CYCLES: 1,
@@ -400,11 +328,7 @@ def profile_table(
 ) -> List[PrettyTable]:
 
     results = []
-    execution_plan_idx = 0
     max_len = 0
-    program = None
-    if model_buffer is not None:
-        program = deserialize_from_flatbuffer(model_buffer)
 
     for name, prof_entries_list in profile_data.items():
         table = PrettyTable()
@@ -415,14 +339,7 @@ def profile_table(
                     entry.name,
                     entry.chain_idx,
                     entry.instruction_idx,
-                    None
-                    if program is None
-                    else fetch_frame_list_short_repr(
-                        program,
-                        execution_plan_idx,
-                        entry.chain_idx,
-                        entry.instruction_idx,
-                    ),
+                    None,
                 )
                 + tuple(val for val in entry.duration)
                 for entry in prof_entries_list

profiler/profiler_results_cli.py

@@ -5,107 +5,29 @@
 # LICENSE file in the root directory of this source tree.
 
 import argparse
-import json
 import sys
 
-from executorch.exir.serialize import deserialize_from_flatbuffer
-
 from executorch.profiler.parse_profiler_results import (
     deserialize_profile_results,
-    fetch_frame_list_short_repr,
     mem_profile_table,
     profile_aggregate_framework_tax,
     profile_framework_tax_table,
     profile_table,
-    ProfileData,
 )
 
-from executorch.profiler.profiler_results_scuba import upload_to_scuba
-
-
-def gen_chrome_traceevents_json(
-    profile_results_path: str, model_ff_path: str, json_out_path: str
-):
-    with open(profile_results_path, "rb") as prof_res_file:
-        prof_res_buf = prof_res_file.read()
-        model_ff_buf = None
-        if model_ff_path is not None:
-            with open(model_ff_path, "rb") as model_ff_file:
-                model_ff_buf = model_ff_file.read()
-
-    prof_data, _ = deserialize_profile_results(prof_res_buf)
-    prof_table = profile_table(prof_data, model_ff_buf)
-
-    print(prof_table)
-
-    root = {}
-    trace_events = []
-    root["traceEvents"] = trace_events
-
-    for block_name, prof_data_list in prof_data.items():
-        for d in prof_data_list:
-            stacktrace_short = None
-            if model_ff_buf is not None:
-                stacktrace_short = fetch_frame_list_short_repr(
-                    deserialize_from_flatbuffer(model_ff_buf),
-                    0,
-                    d.chain_idx,
-                    d.instruction_idx,
-                )
-            name = d.name
-            if stacktrace_short is not None:
-                name += " [" + stacktrace_short + "]"
-            for ts_ms, duration_ms in zip(d.ts, d.duration):
-                e = {}
-
-                MS_TO_US_SCALE = 1000
-                ts_us = ts_ms * MS_TO_US_SCALE
-                duration_us = duration_ms * MS_TO_US_SCALE
-                e["name"] = block_name + ":" + name
-                e["cat"] = "cpu_op"
-                e["ph"] = "X"
-                e["ts"] = int(ts_us)
-                e["dur"] = int(duration_us)
-                e["pid"] = 0
-                e["tid"] = 0
-                trace_events.append(e)
-
-    json_content: str = json.dumps(root, indent=2)
-
-    with open(json_out_path, "wb") as json_file:
-        json_file.write(json_content.encode("ascii"))
-
 
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--prof_results_bin", help="profiling results binary file")
-    parser.add_argument(
-        "--model_path",
-        type=str,
-        default=None,
-        help="path to executorch flatbuffer model",
-    )
-    parser.add_argument("--chrome_json_path", type=str, default=None)
     args = parser.parse_args()
 
-    if args.chrome_json_path is not None:
-        gen_chrome_traceevents_json(
-            args.prof_results_bin, args.model_path, args.chrome_json_path
-        )
-        return 0
-
     with open(args.prof_results_bin, "rb") as prof_results_file:
         out_bytes = prof_results_file.read()
 
-    model_bytes = None
-    if args.model_path is not None:
-        with open(args.model_path, "rb") as model_file:
-            model_bytes = model_file.read()
-
     prof_data, mem_allocations = deserialize_profile_results(out_bytes)
     framework_tax_data = profile_aggregate_framework_tax(prof_data)
 
-    prof_tables = profile_table(prof_data, model_bytes)
+    prof_tables = profile_table(prof_data)
     for table in prof_tables:
         print(table)