Add torch.cuda.Event section timing to infer()

Replaces time.time() with perf_counter() and torch.cuda.Event-based
timing so GPU-timeline durations (preprocess, inference, vae_decode)
are measured accurately via elapsed_time() rather than wall-clock.
Prints a per-section table after each run.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -161,29 +161,73 @@ def update_dimensions_on_upload(image):
 @spaces.GPU
 def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps, progress=gr.Progress(track_tqdm=True)):
     import time, traceback
-    t0 = time.time()
+    _cuda_ok = torch.cuda.is_available()
+    _marks: dict = {}  # name -> (cuda_event | None, perf_counter_float)
+
+    def _mark(name: str) -> None:
+        ev = None
+        if _cuda_ok:
+            ev = torch.cuda.Event(enable_timing=True)
+            ev.record()
+        _marks[name] = (ev, time.perf_counter())
+
+    def _elapsed_ms(a: str, b: str) -> float:
+        ev_a, t_a = _marks[a]
+        ev_b, t_b = _marks[b]
+        if ev_a and ev_b:
+            return ev_a.elapsed_time(ev_b)  # true GPU-timeline ms
+        return (t_b - t_a) * 1000.0
+
+    def _print_timings() -> None:
+        if _cuda_ok:
+            try:
+                torch.cuda.synchronize()
+            except Exception:
+                pass
+        rows = [
+            ("image_load",  "load_start",  "load_end"),
+            ("preprocess",  "pipe_start",  "first_step"),
+            ("inference",   "first_step",  "last_step"),
+            ("vae_decode",  "last_step",   "pipe_end"),
+        ]
+        total_ms = 0.0
+        lines = []
+        for label, a, b in rows:
+            if a in _marks and b in _marks:
+                ms = _elapsed_ms(a, b)
+                total_ms += ms
+                lines.append(f"[timing]   {label:<14} {ms:8.1f} ms")
+        if "load_start" in _marks and "pipe_end" in _marks:
+            overall_ms = _elapsed_ms("load_start", "pipe_end")
+            lines.append(f"[timing]   {'overhead':<14} {overall_ms - total_ms:8.1f} ms")
+            lines.append(f"[timing]   {'── total ──':<14} {overall_ms:8.1f} ms")
+        print("[timing] ─────────────────────────────────────")
+        print("\n".join(lines))
+        print("[timing] ─────────────────────────────────────")
+
+    t0 = time.perf_counter()
 
     def _t():
-        return f"t={time.time()-t0:.1f}s"
+        return f"t={time.perf_counter()-t0:.1f}s"
 
     def _mem(sync=False):
-        if not torch.cuda.is_available():
+        if not _cuda_ok:
             return "CUDA not available"
         if sync:
             try:
                 torch.cuda.synchronize()
             except Exception as se:
                 return f"CUDA sync failed: {se}"
-        alloc   = torch.cuda.memory_allocated()  / 1024**3
-        reserved= torch.cuda.memory_reserved()   / 1024**3
-        peak    = torch.cuda.max_memory_allocated()/ 1024**3
+        alloc    = torch.cuda.memory_allocated()   / 1024**3
+        reserved = torch.cuda.memory_reserved()    / 1024**3
+        peak     = torch.cuda.max_memory_allocated()/ 1024**3
         return f"alloc={alloc:.2f}GB reserved={reserved:.2f}GB peak={peak:.2f}GB"
 
     print(f"[infer] ===== START =====")
     print(f"[infer] steps={steps}, guidance={guidance_scale}, seed={seed}, randomize={randomize_seed}")
     print(f"[infer] prompt={repr(prompt[:120])}")
 
-    if torch.cuda.is_available():
+    if _cuda_ok:
         p = torch.cuda.get_device_properties(0)
         print(f"[infer] GPU: {p.name}, total={p.total_memory/1024**3:.1f}GB, cap={p.major}.{p.minor}")
         torch.cuda.reset_peak_memory_stats()
@@ -194,8 +238,10 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
     torch.cuda.empty_cache()
     print(f"[infer] cache cleared — {_mem()}")
 
+    _mark("load_start")
     pil_images = b64_to_pil_list(images_b64_json)
-    print(f"[infer] decoded {len(pil_images)} image(s)")
+    _mark("load_end")
+    print(f"[infer] decoded {len(pil_images)} image(s) — {_elapsed_ms('load_start', 'load_end'):.0f}ms")
     if not pil_images:
         raise gr.Error("Please upload at least one image to edit.")
     if not prompt or prompt.strip() == "":
@@ -207,20 +253,23 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
     width, height = update_dimensions_on_upload(pil_images[0])
     print(f"[infer] input={pil_images[0].size}, output={width}x{height}, seed={seed}")
 
-    # Per-step callback: logs wall-clock time per denoising step after a GPU sync.
-    # Step 1 time includes any torch.compile Triton kernel compilation — if it is
-    # much longer than later steps, compilation overhead is the bottleneck.
+    # Per-step callback: syncs the GPU then records a CUDA event so elapsed_time()
+    # gives true GPU-timeline durations for preprocess / inference / vae_decode.
+    # Step 1 time includes any torch.compile Triton kernel compilation.
     _step_t = []
     def _step_cb(pipeline, step_idx, timestep, cb_kwargs):
         torch.cuda.synchronize()
-        now = time.time()
+        now = time.perf_counter()
         _step_t.append(now)
-        delta = now - (_step_t[-2] if len(_step_t) > 1 else t0)
+        if step_idx == 0:
+            _mark("first_step")
+        _mark("last_step")  # overwritten each iteration; final value = end of last step
+        delta_ms = (now - (_step_t[-2] if len(_step_t) > 1 else t0)) * 1000
         tag = " ← includes compile" if step_idx == 0 else ""
-        print(f"[infer] step {step_idx+1}/{steps} done — {delta:.1f}s{tag} | {_mem()} | {_t()}")
+        print(f"[infer] step {step_idx+1}/{steps} done — {delta_ms:.0f}ms{tag} | {_mem()} | {_t()}")
         return cb_kwargs
 
-    t_pipe_start = time.time()
+    _mark("pipe_start")
     print(f"[infer] calling pipe... {_t()}")
     try:
         result_image = pipe(
@@ -230,8 +279,10 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
             callback_on_step_end=_step_cb,
             callback_on_step_end_tensor_inputs=["latents"],
         ).images[0]
+        _mark("pipe_end")
         print(f"[infer] VAE decode + postprocess done — {_mem(sync=True)} | {_t()}")
-        duration = time.time() - t_pipe_start
+        _print_timings()
+        duration = _elapsed_ms("pipe_start", "pipe_end") / 1000.0
         threading.Thread(
             target=log_inference,
             args=(pil_images, result_image, prompt, seed, steps, guidance_scale,
@@ -246,7 +297,8 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
             torch.cuda.synchronize()
         except Exception as cuda_err:
             print(f"[infer] CUDA synchronize after error: {cuda_err}")
-        duration = time.time() - t_pipe_start
+        _print_timings()
+        duration = time.perf_counter() - _marks["pipe_start"][1]
         threading.Thread(
             target=log_inference,
             args=(pil_images, None, prompt, seed, steps, guidance_scale,