⚡️ Speed up function parse_flags by 38%

[codeflash-ai]

📄 38% (0.38x) speedup for parse_flags in bench_runner/flags.py

⏱️ Runtime : 35.1 microseconds → 25.4 microseconds (best of 30 runs)

📝 Explanation and details

To optimize the parse_flags function for better runtime performance and possibly reduce memory consumption, we can make the following improvements.

1. Split and strip flags in one go using a generator.
2. Validate flag existence and construct the internal_flags list in one loop.

Here's the optimized version of the parse_flags function.

Explanation.

1. Local flag_mapping Reference: Assigning FLAG_MAPPING to a local variable flag_mapping saves time in accessing the global namespace repeatedly.
2. Single Loop for Processing: By merging the stripping, checking, and appending operations into a single loop, the function reduces unnecessary list creations and iterations, leading to more efficient processing.

These optimizations should result in slight improvements in both runtime performance and memory usage, while still maintaining the original functionality and return values.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from bench_runner.flags import parse_flags


# Mocking FLAGS and FLAG_MAPPING for testing purposes
class MockFlag:
    def __init__(self, gha_variable, name):
        self.gha_variable = gha_variable
        self.name = name

FLAGS = [
    MockFlag("valid_flag1", "internal_name1"),
    MockFlag("valid_flag2", "internal_name2"),
    MockFlag("valid_flag_with_special_chars!@#", "internal_name_with_special_chars"),
    MockFlag("valid_flag_ñ", "internal_name_ñ"),
    MockFlag("valid_flag_你好", "internal_name_你好")
]

FLAG_MAPPING = {flag.gha_variable: flag.name for flag in FLAGS}
from bench_runner.flags import parse_flags

# unit tests

# Basic functionality tests


def test_none_input():
    codeflash_output = parse_flags(None)

# Handling empty strings
def test_empty_string():
    codeflash_output = parse_flags("")

def test_whitespace_string():
    codeflash_output = parse_flags("   ")

def test_commas_only():
    codeflash_output = parse_flags(",,,")

# Handling whitespace


def test_single_invalid_flag():
    with pytest.raises(ValueError, match="Invalid flag invalid_flag"):
        parse_flags("invalid_flag")





def test_case_sensitivity():
    with pytest.raises(ValueError, match="Invalid flag VALID_FLAG1"):
        parse_flags("VALID_FLAG1,valid_flag2")

# Performance and scalability

def test_flags_with_embedded_commas():
    with pytest.raises(ValueError, match="Invalid flag valid"):
        parse_flags("valid_flag1,valid,flag2")

def test_flags_with_only_whitespace_characters():
    codeflash_output = parse_flags(" , , ")






def test_flags_with_newline_characters():
    with pytest.raises(ValueError, match="Invalid flag valid_flag1\nvalid_flag2"):
        parse_flags("valid_flag1\nvalid_flag2")

def test_flags_with_tab_characters():
    with pytest.raises(ValueError, match="Invalid flag valid_flag1\tvalid_flag2"):
        parse_flags("valid_flag1\tvalid_flag2")





def test_flags_with_embedded_semicolons():
    with pytest.raises(ValueError, match="Invalid flag valid_flag1;valid_flag2"):
        parse_flags("valid_flag1;valid_flag2")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from bench_runner.flags import parse_flags


# Mocking the FLAGS and FLAG_MAPPING for the purpose of testing
class Flag:
    def __init__(self, gha_variable, name):
        self.gha_variable = gha_variable
        self.name = name

FLAGS = [
    Flag("flag1", "internal_flag1"),
    Flag("flag2", "internal_flag2"),
    Flag("flag3", "internal_flag3"),
]

FLAG_MAPPING = {flag.gha_variable: flag.name for flag in FLAGS}
from bench_runner.flags import parse_flags

# unit tests

# Basic Functionality


def test_none_input():
    codeflash_output = parse_flags(None)

# Handling Empty Strings
def test_empty_string():
    codeflash_output = parse_flags("")

def test_string_with_only_commas():
    codeflash_output = parse_flags(",,,")

# Handling Whitespace


def test_single_invalid_flag():
    with pytest.raises(ValueError, match="Invalid flag invalid_flag"):
        parse_flags("invalid_flag")








def test_case_sensitivity_check():
    with pytest.raises(ValueError, match="Invalid flag FLAG1"):
        parse_flags("FLAG1,Flag2,flag3")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from bench_runner.flags import parse_flags
import pytest

def test_parse_flags():
    with pytest.raises(ValueError, match='Invalid\\ flag\\ \x00'):
        parse_flags('jit,\x00')

def test_parse_flags_2():
    assert parse_flags(None) == []

def test_parse_flags_3():
    assert parse_flags('') == []

📢 Feedback on this optimization?

[mdboom]

The "copy a global to a local reference" optimization is no longer necessary.

Complicates for very little reason.