⚡️ Speed up method PortManager.get_port by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for PortManager.get_port in nvflare/lighter/tree_prov.py

⏱️ Runtime : 24.0 microseconds → 22.5 microseconds (best of 787 runs)

📝 Explanation and details

The optimized code achieves a 6% speedup by implementing two key changes:

1. Added class variable initialization: The original code assumed last_port_number existed as a class variable but never defined it, which would cause an AttributeError. The optimized version explicitly initializes last_port_number = 9000 as a class variable.

2. Reduced attribute access overhead: Instead of the original pattern of incrementing and then returning the class variable (2 attribute accesses), the optimized version:

   • Calculates the new value in a local variable: num = cls.last_port_number + 1
   • Updates the class variable once: cls.last_port_number = num
   • Returns the local variable: return num

This optimization reduces class attribute lookups from 2 to 1 per method call. Since Python attribute access involves dictionary lookups on the class object, eliminating one lookup per call provides measurable performance gains.

The test results show this optimization is particularly effective for:

• Sequential calls (16-34% faster on subsequent calls within the same test)
• Large-scale operations (8-18% faster when called hundreds of times)
• Edge cases with non-standard starting values (consistently 10-20% faster)

The performance gain comes from Python's attribute access mechanics - local variable access is significantly faster than repeated class attribute lookups, especially when the method is called frequently.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from nvflare.lighter.tree_prov import PortManager

# unit tests

# ----------- Basic Test Cases -----------

def test_get_port_increments_once():
    # Reset state for deterministic test
    PortManager.last_port_number = 9000
    # First call should return 9001
    codeflash_output = PortManager.get_port() # 512ns -> 462ns (10.8% faster)

def test_get_port_increments_twice():
    # Reset state
    PortManager.last_port_number = 9000
    # Two consecutive calls should increment by 1 each time
    codeflash_output = PortManager.get_port() # 473ns -> 449ns (5.35% faster)
    codeflash_output = PortManager.get_port() # 257ns -> 221ns (16.3% faster)

def test_get_port_multiple_calls():
    # Reset state
    PortManager.last_port_number = 9000
    # Call get_port 5 times and check the returned values
    expected_ports = [9001, 9002, 9003, 9004, 9005]
    actual_ports = [PortManager.get_port() for _ in range(5)] # 500ns -> 427ns (17.1% faster)

# ----------- Edge Test Cases -----------

def test_get_port_large_start_value():
    # Start at a high port number near the upper valid range
    PortManager.last_port_number = 65534
    # Next call should be 65535 (max valid port)
    codeflash_output = PortManager.get_port() # 476ns -> 431ns (10.4% faster)
    # Next call should be 65536 (invalid port, but function does not check)
    codeflash_output = PortManager.get_port() # 275ns -> 215ns (27.9% faster)

def test_get_port_negative_start_value():
    # Start at a negative port number (unusual, but should increment)
    PortManager.last_port_number = -2
    codeflash_output = PortManager.get_port() # 485ns -> 443ns (9.48% faster)
    codeflash_output = PortManager.get_port() # 290ns -> 225ns (28.9% faster)
    codeflash_output = PortManager.get_port() # 220ns -> 219ns (0.457% faster)

def test_get_port_zero_start_value():
    # Start at zero
    PortManager.last_port_number = 0
    codeflash_output = PortManager.get_port() # 477ns -> 388ns (22.9% faster)
    codeflash_output = PortManager.get_port() # 279ns -> 261ns (6.90% faster)

def test_get_port_max_int_start_value():
    # Start at a very large integer (simulate overflow)
    import sys
    PortManager.last_port_number = sys.maxsize - 1
    codeflash_output = PortManager.get_port() # 586ns -> 543ns (7.92% faster)
    # Python ints are unbounded, so next value is sys.maxsize + 1
    codeflash_output = PortManager.get_port() # 329ns -> 280ns (17.5% faster)

def test_get_port_multiple_instances_share_state():
    # The port number should be shared across all instances (class variable)
    PortManager.last_port_number = 9000
    class SubPortManager(PortManager):
        pass
    codeflash_output = PortManager.get_port() # 566ns -> 494ns (14.6% faster)
    codeflash_output = SubPortManager.get_port() # 384ns -> 364ns (5.49% faster)
    codeflash_output = PortManager.get_port() # 307ns -> 249ns (23.3% faster)
    codeflash_output = SubPortManager.get_port() # 309ns -> 298ns (3.69% faster)

def test_get_port_state_persistence():
    # The state should persist across calls and not reset
    PortManager.last_port_number = 9000
    codeflash_output = PortManager.get_port() # 499ns -> 430ns (16.0% faster)
    # Simulate program "pause" and call again
    codeflash_output = PortManager.get_port() # 276ns -> 206ns (34.0% faster)

# ----------- Large Scale Test Cases -----------

def test_get_port_large_number_of_calls():
    # Test that the function can handle a large number of calls efficiently
    PortManager.last_port_number = 10000
    n = 1000  # As per instructions, keep under 1000
    start = PortManager.last_port_number
    ports = [PortManager.get_port() for _ in range(n)] # 455ns -> 407ns (11.8% faster)

def test_get_port_large_number_of_calls_edge():
    # Start at a high value and call get_port many times
    PortManager.last_port_number = 65000
    n = 500
    ports = [PortManager.get_port() for _ in range(n)] # 460ns -> 389ns (18.3% faster)

def test_get_port_no_shared_state_between_tests():
    # Ensure that tests do not leak state (pytest runs tests in isolation)
    PortManager.last_port_number = 9000
    codeflash_output = PortManager.get_port() # 472ns -> 403ns (17.1% faster)
    PortManager.last_port_number = 9000
    codeflash_output = PortManager.get_port() # 280ns -> 239ns (17.2% faster)

# ----------- Additional Edge/Robustness Cases -----------

def test_get_port_non_integer_start_value():
    # If last_port_number is not an int, should raise TypeError
    PortManager.last_port_number = "not_an_int"
    with pytest.raises(TypeError):
        PortManager.get_port() # 1.36μs -> 1.48μs (8.10% slower)

def test_get_port_float_start_value():
    # If last_port_number is a float, should increment as float (unusual)
    PortManager.last_port_number = 9000.5
    # Should return 9001.5
    codeflash_output = PortManager.get_port() # 616ns -> 576ns (6.94% faster)
    # Next call should return 9002.5
    codeflash_output = PortManager.get_port() # 351ns -> 272ns (29.0% faster)

def test_get_port_bool_start_value():
    # If last_port_number is a boolean, True == 1, so should increment to 2
    PortManager.last_port_number = True
    codeflash_output = PortManager.get_port() # 514ns -> 446ns (15.2% faster)
    PortManager.last_port_number = False
    codeflash_output = PortManager.get_port() # 331ns -> 289ns (14.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 nvflare.lighter.tree_prov import PortManager

# ------------------
# Basic Test Cases
# ------------------

def test_port_increments_from_default():
    """Test that get_port returns 9001 as the first value after reset."""
    codeflash_output = PortManager.get_port() # 559ns -> 634ns (11.8% slower)

def test_port_increments_multiple_times():
    """Test that get_port increments sequentially for multiple calls."""
    codeflash_output = PortManager.get_port() # 500ns -> 591ns (15.4% slower)
    codeflash_output = PortManager.get_port() # 268ns -> 255ns (5.10% faster)
    codeflash_output = PortManager.get_port() # 183ns -> 179ns (2.23% faster)

def test_port_increments_within_single_test():
    """Test that multiple calls within a single test increment as expected."""
    ports = [PortManager.get_port() for _ in range(5)] # 495ns -> 531ns (6.78% slower)

# ------------------
# Edge Test Cases
# ------------------

def test_port_manager_large_start_value():
    """Test behavior when last_port_number is set to a large value."""
    PortManager.last_port_number = 65535  # Common max port number
    codeflash_output = PortManager.get_port() # 529ns -> 465ns (13.8% faster)
    codeflash_output = PortManager.get_port() # 239ns -> 211ns (13.3% faster)

def test_port_manager_negative_start_value():
    """Test behavior when last_port_number is set to a negative value."""
    PortManager.last_port_number = -1
    codeflash_output = PortManager.get_port() # 520ns -> 432ns (20.4% faster)
    codeflash_output = PortManager.get_port() # 281ns -> 250ns (12.4% faster)

def test_port_manager_zero_start_value():
    """Test behavior when last_port_number is set to zero."""
    PortManager.last_port_number = 0
    codeflash_output = PortManager.get_port() # 489ns -> 413ns (18.4% faster)

def test_port_manager_max_int_value():
    """Test behavior when last_port_number is set to a very large integer (simulate overflow)."""
    import sys
    PortManager.last_port_number = sys.maxsize - 1
    codeflash_output = PortManager.get_port() # 604ns -> 543ns (11.2% faster)
    codeflash_output = PortManager.get_port() # 308ns -> 279ns (10.4% faster)

def test_port_manager_multiple_instances_share_state():
    """Test that PortManager's state is shared across different references (class variable)."""
    class AnotherPortManager(PortManager):
        pass
    PortManager.get_port() # 598ns -> 663ns (9.80% slower)
    AnotherPortManager.get_port() # 405ns -> 389ns (4.11% faster)

def test_port_manager_manual_set_between_calls():
    """Test that manually setting last_port_number between calls affects the next port."""
    codeflash_output = PortManager.get_port() # 629ns -> 615ns (2.28% faster)
    PortManager.last_port_number = 9999
    codeflash_output = PortManager.get_port() # 315ns -> 338ns (6.80% slower)

# ------------------
# Large Scale Test Cases
# ------------------

def test_port_manager_many_increments():
    """Test that get_port can handle many sequential increments."""
    num_calls = 500
    start = PortManager.last_port_number
    results = [PortManager.get_port() for _ in range(num_calls)] # 523ns -> 480ns (8.96% faster)

def test_port_manager_large_gap():
    """Test behavior when last_port_number is set to a large value and incremented many times."""
    PortManager.last_port_number = 100000
    ports = [PortManager.get_port() for _ in range(100)] # 507ns -> 459ns (10.5% faster)

def test_port_manager_consecutive_resets():
    """Test that resetting last_port_number repeatedly works as expected."""
    PortManager.last_port_number = 5000
    codeflash_output = PortManager.get_port() # 488ns -> 428ns (14.0% faster)
    PortManager.last_port_number = 8000
    codeflash_output = PortManager.get_port() # 270ns -> 255ns (5.88% faster)
    PortManager.last_port_number = 42
    codeflash_output = PortManager.get_port() # 226ns -> 205ns (10.2% faster)

# Additional edge: test that the class variable is not instance variable
def test_port_manager_instance_variable_does_not_affect_class():
    """Test that setting an instance variable does not affect the class variable."""
    instance = PortManager()
    instance.last_port_number = 12345  # This creates an instance variable, not affecting the class
    codeflash_output = PortManager.get_port() # 484ns -> 509ns (4.91% slower)

# Additional edge: test that get_port does not accept arguments
def test_port_manager_get_port_no_arguments():
    """Test that get_port does not accept any arguments."""
    with pytest.raises(TypeError):
        PortManager.get_port(1) # 2.27μs -> 2.25μs (1.16% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-PortManager.get_port-mhcbriju and push.