Revert "Add --timing flag, phase timing to @dynamo_timed (pytorch#92637)"

This reverts commit 773b513.

Reverted pytorch#92637 on behalf of https://github.com/malfet due to Broke lint

Author: pytorchmergebot

benchmarks/dynamo/common.py

@@ -1425,10 +1425,6 @@ def run_one_model(
                 name, model, example_inputs, optimize_ctx, experiment
             )
             print(status)
-        if self.args.timing:
-            from torch._dynamo.utils import print_time_report
-            print_time_report()
-
         end_calls_captured = torch._dynamo.utils.counters["stats"]["calls_captured"]
         end_unique_graphs = torch._dynamo.utils.counters["stats"]["unique_graphs"]
         if explain:
@@ -1687,9 +1683,6 @@ def get_example_inputs(self):
         want to verify the numerical correctness of graidents. But that may
         cause time measurement not accurate""",
     )
-    parser.add_argument(
-        "--timing", action="store_true", help="Emits phase timing"
-    )
 
     group_fuser = parser.add_mutually_exclusive_group()
     # --nvfuser is now the default, keep the option to not break scripts

benchmarks/dynamo/run_all.sh

@@ -26,7 +26,7 @@ if getent hosts fwdproxy; then
 fi
 
 # Feel free to edit these, but we expect most users not to need to modify this
-BASE_FLAGS=( --accuracy --explain --timing)
+BASE_FLAGS=( --accuracy --explain )
 DATE="$(date)"
 WORK="$PWD"
 

torch/_dynamo/__init__.py

@@ -13,7 +13,7 @@
     skip,
 )
 from .external_utils import is_compiling
-from .utils import compilation_metrics, guard_failures, orig_code_map, reset_frame_count
+from .utils import compilation_metrics, guard_failures, orig_code_map
 
 __all__ = [
     "allow_in_graph",
@@ -48,7 +48,6 @@ def reset():
     resume_execution.ContinueExecutionCache.cache.clear()
     eval_frame.most_recent_backend = None
     compilation_metrics.clear()
-    reset_frame_count()
 
 
 def list_backends():

torch/_dynamo/convert_frame.py

@@ -35,7 +35,6 @@
     format_bytecode,
     gen_record_file_name,
     guard_failures,
-    increment_frame,
     init_logging,
     is_namedtuple,
     istype,
@@ -195,8 +194,8 @@ def convert_frame_assert(
     """Fully convert a frame into an FX graph"""
     init_logging()
 
+    @dynamo_timed
     def _convert_frame_assert(frame: types.FrameType, cache_size: int, hooks: Hooks):
-        increment_frame()
         code = frame.f_code
         input_codes.add(code)
         if code in output_codes:
@@ -274,7 +273,6 @@ def format_guard_failures(code):
     return wrap_convert_context(_convert_frame_assert)
 
 
-@dynamo_timed(phase_name="entire_frame_compile")
 def _compile(
     code: types.CodeType,
     globals: Dict[str, object],

torch/_dynamo/eval_frame.py

@@ -41,7 +41,7 @@
 from .mutation_guard import install_generation_tagging_init
 from .output_graph import CompilerFn
 from .types import DynamoCallback
-from .utils import compile_times, dynamo_timed
+from .utils import compile_times
 
 log = logging.getLogger(__name__)
 

torch/_dynamo/output_graph.py

@@ -48,7 +48,6 @@
     clone_inputs,
     count_calls,
     counters,
-    dynamo_timed,
     format_graph_tabular,
     same,
 )
@@ -625,7 +624,6 @@ def compile_and_call_fx_graph(self, tx, rv, root):
         cg.make_call_generated_code(name)
         return cg.get_instructions()
 
-    @dynamo_timed(phase_name="backend_compile")
     def call_user_compiler(self, gm: fx.GraphModule) -> CompiledFn:
         try:
             name = (

torch/_dynamo/symbolic_convert.py

@@ -50,7 +50,7 @@
     GlobalWeakRefSource,
     LocalSource,
 )
-from .utils import counters, graph_break_dup_warning_checker, istype, proxy_args_kwargs, dynamo_timed
+from .utils import counters, graph_break_dup_warning_checker, istype, proxy_args_kwargs
 from .variables.base import MutableLocal, typestr, VariableTracker
 from .variables.builder import VariableBuilder, wrap_fx_proxy
 from .variables.builtin import BuiltinVariable

torch/_dynamo/utils.py

@@ -86,90 +86,20 @@ def profile_wrapper(*args, **kwargs):
     return profile_wrapper
 
 
-frame_phase_timing = collections.OrderedDict()
-
-curr_frame = 0
-
-# Note: Called for you by dynamo - you almost never ever want to invoke this yourself.
-def increment_frame():
-    global curr_frame
-    curr_frame = curr_frame + 1
-
-
-# Note: Called for you by dynamo - you almost never ever want to invoke this yourself.
-def reset_frame_count():
-    global curr_frame
-    frame_phase_timing.clear()
-    curr_frame = 0
-
-
-# Print a report of time spent so far
-# Ex:
-# TIMING:
-# entire_frame_compile:8.574629999999999
-# backend_compile:5.26806
-def print_time_report():
-    total = 0
-    total_by_key = {}
-    print("TIMING:")
-    for frame, timings in frame_phase_timing.items():
-        for key, timing in timings.items():
-            total += timing
-            if key not in total_by_key:
-                total_by_key[key] = timing
-            else:
-                total_by_key[key] += timing
-
-    out = ""
-    for key, value in total_by_key.items():
-        out = f"{out} {key}:{round(value, 5)}"
-
-    print(out)
-
-
-# dynamo_timed API works as a function decorator
-# By wrapping a function in dynamo_timed, we can store a record in compilation_metrics
-# where the key is the functions name.
-# For example:
-#
-#  @dynamo_timed
-#  def _foo(...):
-#
-# Would show up as an entry in our timing dict:
-# OrderedDict([('bar.<locals>._foo', [0.083690, 0.23949, 3.1425e-05])])
-# This is extremely useful for granular debugging.
-#
-# For a higher-level mode, pass a phase_name into dynamo_timed
-# phase_names record an extra record into a separate compilation timing structure,
-# one keyed on frame+name rather than function.
-# The frame is incremented outside of this function, in def increment_frame() above.
-def dynamo_timed(original_function=None, phase_name=None):
-    def dynamo_timed_inner(func):
-        @wraps(func)
-        def time_wrapper(*args, **kwargs):
-            key = func.__qualname__
-            if key not in compilation_metrics:
-                compilation_metrics[key] = []
-            t0 = time.time()
-            r = func(*args, **kwargs)
-            time_spent = time.time() - t0
-            # print(f"Dynamo timer: key={key}, latency={latency:.2f} sec")
-            compilation_metrics[key].append(time_spent)
-            if phase_name:
-                frame_key = str(curr_frame)
-                if frame_key not in frame_phase_timing:
-                    frame_phase_timing[frame_key] = {}
-                assert (
-                    phase_name not in frame_phase_timing[frame_key]
-                ), f"Duplicate phase name {phase_name} for frame {frame_key}"
-                frame_phase_timing[frame_key][phase_name] = time_spent
-            return r
-
-        return time_wrapper
-
-    if original_function:
-        return dynamo_timed_inner(original_function)
-    return dynamo_timed_inner
+def dynamo_timed(func):
+    @wraps(func)
+    def time_wrapper(*args, **kwargs):
+        key = func.__qualname__
+        if key not in compilation_metrics:
+            compilation_metrics[key] = []
+        t0 = time.time()
+        r = func(*args, **kwargs)
+        latency = time.time() - t0
+        # print(f"Dynamo timer: key={key}, latency={latency:.2f} sec")
+        compilation_metrics[key].append(latency)
+        return r
+
+    return time_wrapper
 
 
 def compile_times(repr="str", aggregate=False):