From 6565321f55ca41287536dff3fe0964b8d4328e76 Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Fri, 11 Jul 2025 04:43:26 +0000
Subject: [PATCH] =?UTF-8?q?=E2=9A=A1=EF=B8=8F=20Speed=20up=20function=20`f?=
 =?UTF-8?q?ormat=5Ftime`=20by=2015%=20in=20PR=20#537=20(`runtime-fixes-jul?=
 =?UTF-8?q?10`)=20Here=20is=20a=20**faster=20and=20more=20memory=20efficie?=
 =?UTF-8?q?nt=20version**=20of=20your=20code,=20re-written=20for=20optimal?=
 =?UTF-8?q?=20runtime=20and=20minimal=20temporary=20allocations.=20The=20b?=
 =?UTF-8?q?iggest=20optimizations=20are.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- **Avoid repeated f-string formatting per branch by leveraging intermediate integer math and tuple lookups.**
- **Minimize float conversion and string formatting: use integer division and only format floats where necessary.**
- Avoid unnecessary chained if/else expressions by using nested conditionals.
- Direct return, not temporary assignment, for common usage (early-out).
- Minimize creation of temporary float objects (division is only triggered at last possible moment, and only when needed).

The result string is exactly as before.
Input type and value checks are retained as in the original.



**Key speedups**.

- Uses integer division as long as possible (which is faster and avoids floats).
- Avoids repeated float formatting and f-string interpolation: Only floats and formatting are used when output would need decimals.
- No temporary assignments except where actually needed.
- No nested ternaries to reduce overhead and branch ambiguity.

**Result:**
This version produces exactly the same outputs as the original, but should be significantly faster and use less memory (notably in the most common branch calls).
You can further accelerate by removing or altering input type checks if running in a controlled environment.
---
 codeflash/code_utils/time_utils.py | 38 ++++++++++++++++++++++++------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/codeflash/code_utils/time_utils.py b/codeflash/code_utils/time_utils.py
index e44c279d3..824b32bcf 100644
--- a/codeflash/code_utils/time_utils.py
+++ b/codeflash/code_utils/time_utils.py
@@ -55,22 +55,46 @@ def humanize_runtime(time_in_ns: int) -> str:
 
 def format_time(nanoseconds: int) -> str:
     """Format nanoseconds into a human-readable string with 3 significant digits when needed."""
-    # Define conversion factors and units
+    # Input checks (preserved)
     if not isinstance(nanoseconds, int):
         raise TypeError("Input must be an integer.")
     if nanoseconds < 0:
         raise ValueError("Input must be a positive integer.")
 
+    # Fast cases
     if nanoseconds < 1_000:
         return f"{nanoseconds}ns"
     if nanoseconds < 1_000_000:
-        value = nanoseconds / 1_000
-        return f"{value:.2f}μs" if value < 10 else (f"{value:.1f}μs" if value < 100 else f"{int(value)}μs")
+        micro = nanoseconds // 1_000  # integer microseconds
+        # Only use float formatting if < 100
+        if nanoseconds < 10_000:
+            # <10us, use 2 decimals
+            value = nanoseconds / 1_000
+            return f"{value:.2f}μs"
+        if nanoseconds < 100_000:
+            # <100us, use 1 decimal
+            value = nanoseconds / 1_000
+            return f"{value:.1f}μs"
+        # >=100us, integer
+        return f"{micro}μs"
     if nanoseconds < 1_000_000_000:
-        value = nanoseconds / 1_000_000
-        return f"{value:.2f}ms" if value < 10 else (f"{value:.1f}ms" if value < 100 else f"{int(value)}ms")
-    value = nanoseconds / 1_000_000_000
-    return f"{value:.2f}s" if value < 10 else (f"{value:.1f}s" if value < 100 else f"{int(value)}s")
+        milli = nanoseconds // 1_000_000  # integer ms
+        if nanoseconds < 10_000_000:
+            value = nanoseconds / 1_000_000
+            return f"{value:.2f}ms"
+        if nanoseconds < 100_000_000:
+            value = nanoseconds / 1_000_000
+            return f"{value:.1f}ms"
+        return f"{milli}ms"
+    # seconds branch
+    seconds = nanoseconds // 1_000_000_000
+    if nanoseconds < 10_000_000_000:
+        value = nanoseconds / 1_000_000_000
+        return f"{value:.2f}s"
+    if nanoseconds < 100_000_000_000:
+        value = nanoseconds / 1_000_000_000
+        return f"{value:.1f}s"
+    return f"{seconds}s"
 
 
 def format_perf(percentage: float) -> str: