⚡️ Speed up function get_processor by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for get_processor in python/sglang/srt/utils/hf_transformers_utils.py

⏱️ Runtime : 2.45 seconds → 2.03 seconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 20% speedup through several key micro-optimizations that reduce Python's runtime overhead:

Key Optimizations:

1. Argument Dictionary Consolidation: The original code passed the same arguments (trust_remote_code, revision, **kwargs) to multiple from_pretrained() calls. The optimized version builds pretrained_args once and reuses it, eliminating redundant dictionary creation and argument unpacking operations.

2. Reduced Branch Complexity: The nested condition for Qwen2-VL/Sarashina2Vision models was simplified from separate if checks to a single combined condition (if config.model_type in {...} and "size" not in kwargs:), reducing branch prediction overhead.

3. Exception Handling Optimization: When catching ValueError and setting use_fast=True, the optimized version modifies the pre-built pretrained_args dictionary instead of rebuilding arguments, avoiding duplicate keyword argument processing.

Performance Impact:
The test results show consistent improvements across different scenarios:

• Basic processor creation: 16.9% faster (291ms → 249ms)
• With trust_remote_code: 19.2% faster (283ms → 237ms)
• Edge cases with special tokens: ~30% faster (25.4ms → 19.6ms)
• Large-scale kwargs handling: 14.7% faster with 500 arguments

Why This Works:
Python's dictionary operations and keyword argument unpacking (**kwargs) have significant overhead. By pre-building the arguments dictionary once and reusing it, the optimization reduces:

• Dictionary creation/copying operations
• Keyword argument splatting overhead
• Redundant function call setup costs

This optimization is particularly effective for functions called frequently in model loading pipelines, where even small per-call improvements compound significantly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from unittest.mock import MagicMock, patch

# imports
import pytest  # used for our unit tests
from sglang.srt.utils.hf_transformers_utils import get_processor

# function to test
# (The get_processor function and its dependencies are assumed to be defined above as per the user's code block.)

# =============================
# Unit tests for get_processor
# =============================

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








def test_value_error_other(monkeypatch):
    # Test ValueError not related to slow version is re-raised
    mock_config = MagicMock()
    mock_config.model_type = "bert"
    def processor_patch(tokenizer_name, **kwargs):
        raise ValueError("other error")
    monkeypatch.setattr("transformers.AutoConfig.from_pretrained", lambda *a, **k: mock_config)
    monkeypatch.setattr("transformers.AutoProcessor.from_pretrained", processor_patch)
    monkeypatch.setattr("sglang.srt.utils.hf_transformers_utils.get_tokenizer_from_processor", lambda proc: MagicMock())
    monkeypatch.setattr("sglang.srt.utils.hf_transformers_utils.attach_additional_stop_token_ids", lambda t: None)
    with pytest.raises(ValueError) as excinfo:
        get_processor("bert-base-uncased") # 4.58μs -> 5.26μs (12.9% slower)



def test_processor_is_tokenizer(monkeypatch):
    # Test get_tokenizer_from_processor returns processor if it's a PreTrainedTokenizerBase
    mock_config = MagicMock()
    mock_config.model_type = "bert"
    class MockTokenizerBase:
        def get_added_vocab(self):
            return {}
    mock_processor = MockTokenizerBase()
    monkeypatch.setattr("transformers.AutoConfig.from_pretrained", lambda *a, **k: mock_config)
    monkeypatch.setattr("transformers.AutoProcessor.from_pretrained", lambda *a, **k: mock_processor)
    monkeypatch.setattr("sglang.srt.utils.hf_transformers_utils.get_tokenizer_from_processor", lambda proc: proc)
    monkeypatch.setattr("sglang.srt.utils.hf_transformers_utils.attach_additional_stop_token_ids", lambda t: None)
    codeflash_output = get_processor("bert-base-uncased"); result = codeflash_output # 3.78μs -> 4.13μs (8.66% slower)

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





#------------------------------------------------
from unittest.mock import MagicMock, patch

# imports
import pytest  # used for our unit tests
from sglang.srt.utils.hf_transformers_utils import get_processor

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

def test_basic_default_processor():
    # Test with a normal model name, should return a processor with a tokenizer
    codeflash_output = get_processor("bert-base-uncased"); processor = codeflash_output # 291ms -> 249ms (16.9% faster)





def test_basic_tokenizer_mode_and_trust_remote_code():
    # Should pass tokenizer_mode and trust_remote_code through
    codeflash_output = get_processor("bert-base-uncased", tokenizer_mode="auto", trust_remote_code=True); processor = codeflash_output # 283ms -> 237ms (19.2% faster)

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




def test_edge_eom_id_in_added_vocab():
    # Should attach additional_stop_token_ids if <|eom_id|> present
    vocab = {"<|eom_id|>": 42}
    with patch("transformers.AutoProcessor.from_pretrained", lambda *a, **kw: type("Proc", (), {"tokenizer": type("Tok", (), {"get_added_vocab": lambda self: vocab, "additional_stop_token_ids": None})()})()):
        codeflash_output = get_processor("bert-base-uncased"); processor = codeflash_output # 25.4ms -> 19.6ms (29.8% faster)

def test_edge_eom_id_not_in_added_vocab():
    # Should set additional_stop_token_ids to None if <|eom_id|> not present
    vocab = {"something_else": 99}
    with patch("transformers.AutoProcessor.from_pretrained", lambda *a, **kw: type("Proc", (), {"tokenizer": type("Tok", (), {"get_added_vocab": lambda self: vocab, "additional_stop_token_ids": None})()})()):
        codeflash_output = get_processor("bert-base-uncased"); processor = codeflash_output # 24.1ms -> 18.7ms (29.4% faster)


def test_edge_use_fast_false():
    # Should respect use_fast=False for models not in llava/clip
    codeflash_output = get_processor("bert-base-uncased", use_fast=False); processor = codeflash_output # 290ms -> 237ms (22.2% faster)




def test_large_scale_kwargs():
    # Test with many kwargs
    kwargs = {f"key{i}": i for i in range(500)}
    codeflash_output = get_processor("bert-base-uncased", **kwargs); processor = codeflash_output # 291ms -> 254ms (14.7% faster)


def test_large_scale_eom_id_in_vocab_many():
    # Test with many processors having <|eom_id|> in vocab
    for i in range(50):
        vocab = {"<|eom_id|>": i}
        with patch("transformers.AutoProcessor.from_pretrained", lambda *a, **kw: type("Proc", (), {"tokenizer": type("Tok", (), {"get_added_vocab": lambda self: vocab, "additional_stop_token_ids": None})()})()):
            codeflash_output = get_processor("bert-base-uncased"); processor = codeflash_output
# 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-get_processor-mhorpkmc and push.