⚡️ Speed up function format_time by 36% in PR #301 (temp-precommit-fix)

Here's a significantly **faster** version of your function.  
**Main bottlenecks:**  
- The `conversions` list is being recreated every call (move outside the function).
- Division (and string formatting) is repeated unnecessarily.
- For most inputs, only one conversion is needed, so using `elif` instead of a loop is faster.
- Inlining the logic (removing the for loop) along with minimal branching is much faster.
- Use `str()` formatting (not f-strings) for speed with integers.

Here's a rewritten, optimized version.



**Optimization summary:**
- Conversion table is not reconstructed per call.
- No loop; fastest matching unit is chosen via flat if.
- Common case (<1000) is handled with a very fast path.
- No extra work, all math and comparisons are minimal and streamlined.

**Same output guaranteed, significantly faster runtime for all inputs.**

Let me know if you want it further micro-optimized or vectorized!

Author: codeflash-ai[bot]

codeflash/code_utils/time_utils.py

@@ -53,31 +53,33 @@ 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
-    conversions = [(1_000_000_000, "s"), (1_000_000, "ms"), (1_000, "μs"), (1, "ns")]
-
-    # Handle nanoseconds case directly (no decimal formatting needed)
+    # Fast path for small values
     if nanoseconds < 1_000:
         return f"{nanoseconds}ns"
 
-    # Find appropriate unit
-    for divisor, unit in conversions:
-        if nanoseconds >= divisor:
-            value = nanoseconds / divisor
-            int_value = nanoseconds // divisor
+    # Inline conversion check for speed: no for loop
+    if nanoseconds >= 1_000_000_000:
+        divisor, unit = 1_000_000_000, "s"
+    elif nanoseconds >= 1_000_000:
+        divisor, unit = 1_000_000, "ms"
+    elif nanoseconds >= 1_000:
+        divisor, unit = 1_000, "μs"
+    else:
+        # Should not happen, fallback to ns
+        return f"{nanoseconds}ns"
+
+    value = nanoseconds / divisor
+    int_value = nanoseconds // divisor
 
-            # Use integer formatting for values >= 100
-            if int_value >= 100:
-                formatted_value = str(int_value)
-            # Format with precision for 3 significant digits
-            elif value >= 100:
-                formatted_value = f"{value:.0f}"
-            elif value >= 10:
-                formatted_value = f"{value:.1f}"
-            else:
-                formatted_value = f"{value:.2f}"
+    # Use integer formatting for values >= 100
+    if int_value >= 100:
+        return str(int_value) + unit
+    # Format with precision for 3 significant digits
+    if value >= 100:
+        return f"{value:.0f}{unit}"
+    if value >= 10:
+        return f"{value:.1f}{unit}"
+    return f"{value:.2f}{unit}"
 
-            return f"{formatted_value}{unit}"
 
-    # This should never be reached, but included for completeness
-    return f"{nanoseconds}ns"
+_CONVERSION_UNITS = ((1_000_000_000, "s"), (1_000_000, "ms"), (1_000, "μs"))