⚡️ Speed up function humanize_runtime by 22% in PR #1318 (fix/js-jest30-loop-runner)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1318

If you approve this dependent PR, these changes will be merged into the original PR branch fix/js-jest30-loop-runner.

This PR will be automatically closed if the original PR is merged.

---

📄 22% (0.22x) speedup for humanize_runtime in codeflash/code_utils/time_utils.py

⏱️ Runtime : 324 microseconds → 266 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 21% runtime improvement (324μs → 266μs) through three key optimizations:

Primary Optimizations

1. Integer threshold comparisons instead of floating-point division: The original code performed time_in_ns / 1000 >= 1 (floating-point division) to check if conversion was needed. The optimized version uses time_in_ns >= 1_000 (integer comparison), which is significantly faster. This eliminates one unnecessary float conversion and division operation per function call.

2. Direct nanosecond-based unit selection: Instead of converting to microseconds first (time_micro = float(time_in_ns) / 1000) and then checking thresholds in microseconds, the optimized code compares directly against nanosecond thresholds (e.g., time_in_ns < 1_000_000 for microseconds). This reduces the number of division operations from 2 per unit check to just 1, performed only after the correct unit is determined.

3. String partition instead of split: Replacing str(runtime_human).split(".") with runtime_human.partition(".") avoids list allocation. The partition method returns a 3-tuple directly without scanning the entire string or creating intermediate list objects, reducing memory allocations.

4. Deferred string conversion: The original code initialized runtime_human: str = str(time_in_ns) immediately, even though this value would be overwritten in most cases (when time_in_ns >= 1000). The optimized version only performs this conversion in the else branch where it's actually needed, eliminating redundant string conversions in ~85% of test cases.

Performance Impact by Use Case

Based on the annotated tests, the optimization is particularly effective for:

• Large time values (minutes/hours/days): 22-49% faster due to reduced division operations
• Boundary conditions: 14-31% faster, especially at unit transitions where the simpler logic shines
• Microsecond/millisecond ranges: 10-27% faster across the most common use cases

Given the function_references, this function is used in test assertions and likely in performance reporting contexts. The 21% speedup means performance metrics can be formatted more efficiently, which is valuable when humanize_runtime is called frequently in profiling or benchmark reporting scenarios where thousands of time values need formatting.

The optimization preserves exact output behavior while reducing computational overhead through smarter type usage (integer vs. float operations) and more efficient string handling (partition vs. split).

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 154 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 3 Passed
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

from __future__ import annotations

import re  # used for pattern matching in large-scale validation

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.time_utils import humanize_runtime

def test_nanoseconds_zero_one_two():
    # 0 ns should be formatted as "0.00 nanoseconds" (zero handled specially by padding)
    codeflash_output = humanize_runtime(0) # 1.87μs -> 1.51μs (23.9% faster)
    # 1 ns should be singular "nanosecond" and formatted to two decimal places
    codeflash_output = humanize_runtime(1) # 1.30μs -> 1.03μs (26.2% faster)
    # 2 ns should be plural "nanoseconds" and formatted to two decimal places
    codeflash_output = humanize_runtime(2) # 822ns -> 681ns (20.7% faster)

@pytest.mark.parametrize(
    "input_ns, expected",
    [
        # 1.5 microseconds -> 1500 ns -> becomes "1.50 microseconds" (singular micro -> then 's' added by code)
        (1500, "1.50 microseconds"),
        # 2.0 microseconds -> 2000 ns -> "2.00 microseconds"
        (2000, "2.00 microseconds"),
        # 2 milliseconds -> 2_000_000 ns -> "2.00 milliseconds"
        (2_000_000, "2.00 milliseconds"),
        # 3 seconds -> 3_000_000_000 ns -> "3.00 seconds"
        (3_000_000_000, "3.00 seconds"),
    ],
)
def test_micro_milli_second_transitions(input_ns, expected):
    # Validate micro -> milli -> second transitions and expected formatting exactly
    codeflash_output = humanize_runtime(input_ns) # 16.0μs -> 13.7μs (17.1% faster)

def test_minute_hour_day_boundaries():
    # 5 minutes -> compute ns such that function falls into 'minutes' branch and shows "5.00 minutes"
    five_minutes_ns = 5 * 60 * 1_000_000_000  # 5 minutes in nanoseconds
    # The function divides differently (via micro), but this ns value should map to 5 minutes.
    codeflash_output = humanize_runtime(five_minutes_ns) # 4.02μs -> 3.24μs (24.1% faster)

    # 2 hours -> should format as "2.00 hours"
    two_hours_ns = 2 * 60 * 60 * 1_000_000_000
    codeflash_output = humanize_runtime(two_hours_ns) # 2.04μs -> 1.40μs (45.8% faster)

    # 2 days -> should format as "2.00 days"
    two_days_ns = 2 * 24 * 60 * 60 * 1_000_000_000
    codeflash_output = humanize_runtime(two_days_ns) # 1.47μs -> 991ns (48.6% faster)

def test_formatting_length_branches_and_truncation():
    # When the integer-part length is 2 and there is a decimal, we expect one decimal digit only.
    # 12.345 microseconds -> corresponds to 12.345 * 1000 ns = 12345 ns
    codeflash_output = humanize_runtime(12345) # 3.77μs -> 3.38μs (11.6% faster)

    # When the integer part becomes 3 digits (e.g., 999 microseconds), function should return integer only.
    # 999 microseconds = 999000 ns
    codeflash_output = humanize_runtime(999000) # 1.77μs -> 1.40μs (26.4% faster)

    # Small nanosecond value with two-digit integer part -> "10.0 nanoseconds"
    codeflash_output = humanize_runtime(10) # 991ns -> 841ns (17.8% faster)

def test_negative_and_unexpected_values():
    # The function does not explicitly guard against negative numbers;
    # ensure negative inputs produce deterministic, documented-like output.
    # For -1 ns, expect "-1.0 nanoseconds" according to current implementation branches.
    codeflash_output = humanize_runtime(-1) # 1.82μs -> 1.49μs (22.1% faster)

def test_large_scale_outputs_are_valid_and_unit_consistent():
    # Construct a diverse but deterministic set of inputs across many orders of magnitude.
    # Keep the total number < 1000 as requested.
    powers = [0, 1, 2, 5, 10]  # small values
    # add many powers of ten to exercise unit transitions up to very large values
    powers += [10 ** e for e in range(3, 18, 2)]  # 10^3, 10^5, ... up to 10^17
    # add boundary-ish values around unit thresholds
    boundaries = [
        999, 1000, 1001, 999_000, 1_000_000, 1_000_001,
        60 * 1_000_000_000,  # ~60 seconds in ns boundary
        3600 * 1_000_000_000,  # ~1 hour in ns boundary
    ]
    test_values = []
    # combine deterministic patterns, limit overall length well below 1000
    for v in powers + boundaries:
        test_values.append(int(v))
        test_values.append(int(v * 1.5))  # scaled variant to ensure fractional behavior
        test_values.append(int(v + 123))  # offset variant

    # Remove duplicates and limit to first 200 entries for performance safety
    seen = []
    for v in test_values:
        if v not in seen:
            seen.append(v)
    test_values = seen[:200]

    # Allowed unit tokens produced by the function (both singular and plural)
    allowed_units = {
        "nanosecond", "nanoseconds",
        "microsecond", "microseconds",
        "millisecond", "milliseconds",
        "second", "seconds",
        "minute", "minutes",
        "hour", "hours",
        "day", "days",
    }

    # Regex to capture "<number> <unit>" with optional negative sign and decimals
    pattern = re.compile(r"^-?\d+(?:\.\d+)?\s+([a-z]+)$")

    # Validate each produced string:
    outputs = [humanize_runtime(v) for v in test_values]

    for inp, out in zip(test_values, outputs):
        m = pattern.match(out)
        unit = m.group(1)

def test_exact_behavior_for_one_with_fraction_adds_plural():
    # When the humanized number starts with '1' and has a fractional part,
    # the implementation appends an 's' to the unit (e.g., "1.50 microseconds").
    # 1500 ns -> 1.5 microseconds initially -> should become "1.50 microseconds"
    codeflash_output = humanize_runtime(1500) # 3.97μs -> 3.50μs (13.5% faster)

def test_small_integer_two_digit_integer_branch():
    # Confirm two-digit integer branch returns exactly one decimal when decimal exists.
    # 12345 ns -> previously asserted as "12.3 microseconds"
    codeflash_output = humanize_runtime(12345); out = codeflash_output # 3.57μs -> 3.04μs (17.5% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from codeflash.code_utils.time_utils import humanize_runtime

def test_single_nanosecond():
    """Test that a single nanosecond is properly formatted with singular unit."""
    codeflash_output = humanize_runtime(1); result = codeflash_output # 2.00μs -> 1.53μs (30.7% faster)

def test_few_nanoseconds():
    """Test that multiple nanoseconds use plural form."""
    codeflash_output = humanize_runtime(2); result = codeflash_output # 1.77μs -> 1.42μs (24.7% faster)

def test_many_nanoseconds():
    """Test that larger nanosecond values are formatted correctly."""
    codeflash_output = humanize_runtime(999); result = codeflash_output # 1.53μs -> 1.21μs (26.5% faster)

def test_single_microsecond():
    """Test conversion to microseconds for values >= 1000 ns."""
    codeflash_output = humanize_runtime(1000); result = codeflash_output # 3.53μs -> 2.98μs (18.5% faster)

def test_few_microseconds():
    """Test that multiple microseconds use plural form."""
    codeflash_output = humanize_runtime(2000); result = codeflash_output # 3.27μs -> 2.86μs (14.4% faster)

def test_microseconds_with_decimal():
    """Test microseconds with decimal precision."""
    codeflash_output = humanize_runtime(1500); result = codeflash_output # 3.99μs -> 3.60μs (10.9% faster)

def test_single_millisecond():
    """Test conversion to milliseconds at 1 million nanoseconds."""
    codeflash_output = humanize_runtime(1000000); result = codeflash_output # 3.50μs -> 2.90μs (20.4% faster)

def test_few_milliseconds():
    """Test that multiple milliseconds use plural form."""
    codeflash_output = humanize_runtime(2000000); result = codeflash_output # 3.39μs -> 2.87μs (18.2% faster)

def test_milliseconds_with_decimal():
    """Test milliseconds with decimal precision."""
    codeflash_output = humanize_runtime(1500000); result = codeflash_output # 4.17μs -> 3.50μs (19.2% faster)

def test_single_second():
    """Test conversion to seconds at 1 billion nanoseconds."""
    codeflash_output = humanize_runtime(1000000000); result = codeflash_output # 3.60μs -> 2.94μs (22.1% faster)

def test_few_seconds():
    """Test that multiple seconds use plural form."""
    codeflash_output = humanize_runtime(2000000000); result = codeflash_output # 3.93μs -> 3.32μs (18.4% faster)

def test_seconds_with_decimal():
    """Test seconds with decimal precision."""
    codeflash_output = humanize_runtime(1500000000); result = codeflash_output # 4.57μs -> 3.98μs (14.9% faster)

def test_single_minute():
    """Test conversion to minutes."""
    codeflash_output = humanize_runtime(60000000000); result = codeflash_output # 3.90μs -> 3.35μs (16.5% faster)

def test_few_minutes():
    """Test that multiple minutes use plural form."""
    codeflash_output = humanize_runtime(120000000000); result = codeflash_output # 3.91μs -> 3.28μs (19.3% faster)

def test_single_hour():
    """Test conversion to hours."""
    codeflash_output = humanize_runtime(3600000000000); result = codeflash_output # 4.09μs -> 3.33μs (22.9% faster)

def test_few_hours():
    """Test that multiple hours use plural form."""
    codeflash_output = humanize_runtime(7200000000000); result = codeflash_output # 3.93μs -> 3.34μs (17.7% faster)

def test_single_day():
    """Test conversion to days."""
    codeflash_output = humanize_runtime(86400000000000); result = codeflash_output # 4.06μs -> 3.31μs (22.7% faster)

def test_few_days():
    """Test that multiple days use plural form."""
    codeflash_output = humanize_runtime(172800000000000); result = codeflash_output # 3.90μs -> 3.27μs (19.3% faster)

def test_zero_nanoseconds():
    """Test handling of zero nanoseconds (edge case at lower bound)."""
    codeflash_output = humanize_runtime(0); result = codeflash_output # 1.83μs -> 1.45μs (26.2% faster)

def test_boundary_microsecond_999():
    """Test boundary value just below microsecond conversion (999 ns)."""
    codeflash_output = humanize_runtime(999); result = codeflash_output # 1.69μs -> 1.29μs (31.0% faster)

def test_boundary_microsecond_1000():
    """Test boundary value at microsecond conversion (1000 ns)."""
    codeflash_output = humanize_runtime(1000); result = codeflash_output # 3.45μs -> 2.96μs (16.2% faster)

def test_boundary_millisecond_999999():
    """Test boundary value just below millisecond conversion (999,999 ns)."""
    codeflash_output = humanize_runtime(999999); result = codeflash_output # 4.37μs -> 3.82μs (14.4% faster)

def test_boundary_millisecond_1000000():
    """Test boundary value at millisecond conversion (1,000,000 ns)."""
    codeflash_output = humanize_runtime(1000000); result = codeflash_output # 3.46μs -> 2.85μs (21.5% faster)

def test_boundary_second_59999999():
    """Test boundary value just below second conversion (59,999,999 µs)."""
    codeflash_output = humanize_runtime(59999999000); result = codeflash_output # 4.20μs -> 3.59μs (17.1% faster)

def test_boundary_second_60000000():
    """Test boundary value at second conversion (60,000,000 µs)."""
    codeflash_output = humanize_runtime(60000000000); result = codeflash_output # 3.93μs -> 3.37μs (16.7% faster)

def test_boundary_minute_3599999999():
    """Test boundary value just below minute conversion."""
    codeflash_output = humanize_runtime(3599999999000); result = codeflash_output # 4.04μs -> 3.53μs (14.5% faster)

def test_boundary_minute_3600000000():
    """Test boundary value at minute conversion (60 minutes in µs)."""
    codeflash_output = humanize_runtime(3600000000000); result = codeflash_output # 4.08μs -> 3.37μs (21.2% faster)

def test_large_nanosecond_value_with_precision():
    """Test large nanosecond values that require specific formatting."""
    codeflash_output = humanize_runtime(500); result = codeflash_output # 1.61μs -> 1.31μs (22.8% faster)

def test_microsecond_formatting_precision():
    """Test that microsecond formatting respects .3g format."""
    codeflash_output = humanize_runtime(1234000); result = codeflash_output # 4.38μs -> 3.75μs (16.8% faster)

def test_millisecond_formatting_precision():
    """Test that millisecond formatting respects .3g format."""
    codeflash_output = humanize_runtime(1234000000); result = codeflash_output # 4.51μs -> 3.97μs (13.6% faster)

def test_second_formatting_precision():
    """Test that second formatting respects .3g format."""
    codeflash_output = humanize_runtime(1234000000000); result = codeflash_output # 4.25μs -> 3.70μs (14.9% faster)

def test_near_day_boundary():
    """Test values near the day boundary."""
    codeflash_output = humanize_runtime(86399000000000); result = codeflash_output # 4.19μs -> 3.50μs (19.8% faster)

def test_exactly_one_unit_boundary():
    """Test exact unit boundary transitions."""
    # 2 microseconds should use plural
    codeflash_output = humanize_runtime(2000); result = codeflash_output # 3.47μs -> 3.00μs (15.3% faster)

def test_very_small_fractional_microsecond():
    """Test microseconds with very small fractional parts."""
    codeflash_output = humanize_runtime(1100); result = codeflash_output # 4.01μs -> 3.56μs (12.7% faster)

def test_exactly_two_unit_threshold():
    """Test the exact threshold where singular changes to plural (>= 2)."""
    # 1.99 microseconds should still be singular
    codeflash_output = humanize_runtime(1990); result = codeflash_output # 3.95μs -> 3.42μs (15.5% faster)

def test_slightly_above_two_unit_threshold():
    """Test slightly above the plural threshold."""
    codeflash_output = humanize_runtime(2010); result = codeflash_output # 3.75μs -> 3.24μs (15.8% faster)

def test_very_large_nanosecond_value():
    """Test handling of very large nanosecond values (months in ns)."""
    # 30 days in nanoseconds
    thirty_days_ns = 30 * 86400000000000
    codeflash_output = humanize_runtime(thirty_days_ns); result = codeflash_output # 4.39μs -> 3.59μs (22.4% faster)
    # Verify it's formatted as a number followed by a unit
    parts = result.split(" ")

def test_large_minute_value():
    """Test large minute values (e.g., 1000 minutes)."""
    thousand_minutes_ns = 1000 * 60000000000
    codeflash_output = humanize_runtime(thousand_minutes_ns); result = codeflash_output # 4.45μs -> 3.79μs (17.5% faster)
    parts = result.split(" ")

def test_large_hour_value():
    """Test large hour values (e.g., 1000 hours)."""
    thousand_hours_ns = 1000 * 3600000000000
    codeflash_output = humanize_runtime(thousand_hours_ns); result = codeflash_output # 4.19μs -> 3.61μs (16.1% faster)
    parts = result.split(" ")

def test_maximum_reasonable_nanosecond_value():
    """Test with a very large but reasonable nanosecond value (1 year)."""
    # Approximately 365 days in nanoseconds
    year_ns = 365 * 86400000000000
    codeflash_output = humanize_runtime(year_ns); result = codeflash_output # 4.19μs -> 3.26μs (28.6% faster)
    parts = result.split(" ")
    # First part should be numeric
    numeric_part = parts[0]

def test_decimal_precision_consistency():
    """Test that decimal precision is consistent across unit conversions."""
    # Test a range of values to ensure formatting is consistent
    test_values = [
        1500000,        # 1.5 ms
        15000000,       # 15 ms
        150000000,      # 150 ms
        1500000000,     # 1.5 s
        15000000000,    # 15 s
        150000000000,   # 2.5 min
    ]
    for value in test_values:
        codeflash_output = humanize_runtime(value); result = codeflash_output # 13.4μs -> 10.8μs (24.5% faster)
        # Each result should have format "X.XX unit" or "XXX unit"
        parts = result.split(" ")
        # First part should be numeric (can contain dots)
        numeric_part = parts[0]

def test_sequence_of_increasing_values():
    """Test a sequence of increasing nanosecond values to verify unit transitions."""
    # Test values across different unit boundaries
    test_cases = [
        (1, "nanosecond"),
        (999, "nanoseconds"),
        (1000, "microsecond"),
        (999999, "microsecond"),
        (1000000, "millisecond"),
        (999999999, "millisecond"),
        (1000000000, "second"),
        (59999999999, "second"),
        (60000000000, "minute"),
        (3599999999999, "hour"),
        (3600000000000, "hour"),
        (86399999999999, "hour"),
        (86400000000000, "day"),
    ]
    
    for value, expected_unit in test_cases:
        codeflash_output = humanize_runtime(value); result = codeflash_output # 20.1μs -> 16.2μs (24.0% faster)

def test_many_microsecond_values():
    """Test a range of microsecond values to ensure consistent formatting."""
    # Generate 50 evenly spaced microsecond values
    for i in range(1, 50):
        ns_value = i * 1000  # Convert to microseconds
        codeflash_output = humanize_runtime(ns_value); result = codeflash_output # 47.1μs -> 36.9μs (27.6% faster)
        # Should have format like "X microsecond(s)" or "X.X microsecond(s)"
        parts = result.split(" ")

def test_formatting_with_various_significant_figures():
    """Test that .3g formatting is applied correctly across ranges."""
    test_values = [
        1230000,      # Should show 1.23 ms
        12300000,     # Should show 12.3 ms  
        123000000,    # Should show 123 ms
        1230000000,   # Should show 1.23 s
        12300000000,  # Should show 12.3 s
        123000000000, # Should show 123 s or 2 min
    ]
    
    for value in test_values:
        codeflash_output = humanize_runtime(value); result = codeflash_output # 13.2μs -> 10.7μs (22.9% faster)
        parts = result.split(" ")
        # Verify the numeric part is present and properly formatted
        numeric = parts[0]

def test_response_structure_consistency():
    """Test that all responses follow the format 'number unit'."""
    # Test 100 values spanning all unit types
    test_values = [
        1, 100, 999,
        1000, 10000, 100000, 999999,
        1000000, 10000000, 100000000, 999999999,
        1000000000, 10000000000, 100000000000, 999999999999,
        1000000000000, 10000000000000, 100000000000000,
        1000000000000000, 10000000000000000, 100000000000000000,
        1000000000000000000, 10000000000000000000,
    ]
    
    for value in test_values:
        codeflash_output = humanize_runtime(value); result = codeflash_output # 34.9μs -> 26.9μs (29.6% faster)
        # All results should have exactly one space separating number and unit
        parts = result.split(" ")
        # Unit part should be non-empty and not numeric
        unit_part = parts[1]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.code_utils.time_utils import humanize_runtime

def test_humanize_runtime():
    humanize_runtime(1000)

def test_humanize_runtime_2():
    humanize_runtime(10)

def test_humanize_runtime_3():
    humanize_runtime(-10)

🔎 Click to see Concolic Coverage Tests

To edit these changes git checkout codeflash/optimize-pr1318-2026-02-04T19.44.17 and push.