⚡️ Speed up function format_time by 15% in PR #537 (runtime-fixes-jul10)

Here is a **faster and more memory efficient version** of your code, re-written for optimal runtime and minimal temporary allocations.  
The biggest optimizations are.

- **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.

Author: codeflash-ai[bot]

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: