⚡️ Speed up method StatisticConfigDecomposer.decompose by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for StatisticConfigDecomposer.decompose in nvflare/app_common/statistics/statisitcs_objects_decomposer.py

⏱️ Runtime : 15.3 microseconds → 14.4 microseconds (best of 579 runs)

📝 Explanation and details

The optimization changes the return type from a list [statistic_config.name, statistic_config.config] to a tuple (statistic_config.name, statistic_config.config). This micro-optimization provides a 6% speedup by eliminating the overhead of list creation.

Key optimization:

• Tuple vs List: Tuples are immutable and have lower allocation overhead than lists in Python. Since the decomposed data is read-only (just returning two values that won't be modified), a tuple is the more efficient choice.

Why this works:

• Lists require additional memory allocation for their dynamic resizing capability and internal structure
• Tuples are optimized for fixed-size, immutable data and have faster creation time
• The returned data structure is purely for data transport and doesn't need list's mutability features

Performance characteristics from tests:

• Most effective on simple data types (12-18% improvement for boolean/None configs)
• Consistent gains across different data sizes and types (1-18% improvement range)
• Particularly good for high-frequency decomposition operations where the allocation overhead compounds
• Works well for both small configs and large nested structures (up to 1000 elements)

This optimization is ideal for serialization/deserialization pipelines where the decompose method is called frequently and the returned structure is immediately consumed rather than modified.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from nvflare.app_common.statistics.statisitcs_objects_decomposer import \
    StatisticConfigDecomposer

# Mocks for dependencies, since we cannot import nvflare in this test environment.
# These are minimal stand-ins to support the tested behavior.

class StatisticConfig:
    """Mock class to simulate nvflare.app_common.abstract.statistics_spec.StatisticConfig"""
    def __init__(self, name, config):
        self.name = name
        self.config = config

class DatumManager:
    """Mock class to simulate nvflare.fuel.utils.fobs.datum.DatumManager"""
    pass

class Decomposer:
    """Mock class to simulate nvflare.fuel.utils.fobs.Decomposer"""
    pass
from nvflare.app_common.statistics.statisitcs_objects_decomposer import \
    StatisticConfigDecomposer

# =========================
# Unit Tests for decompose
# =========================

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

def test_decompose_basic_string_name_dict_config():
    """Test with typical string name and dictionary config."""
    sc = StatisticConfig(name="mean", config={"window": 5, "type": "rolling"})
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 505ns -> 450ns (12.2% faster)

def test_decompose_basic_int_name_list_config():
    """Test with integer name and list config."""
    sc = StatisticConfig(name=123, config=[1, 2, 3])
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 459ns -> 433ns (6.00% faster)

def test_decompose_basic_float_name_tuple_config():
    """Test with float name and tuple config."""
    sc = StatisticConfig(name=3.14, config=(1, 2))
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 416ns -> 408ns (1.96% faster)

def test_decompose_basic_bool_name_none_config():
    """Test with boolean name and None config."""
    sc = StatisticConfig(name=True, config=None)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 455ns -> 393ns (15.8% faster)

def test_decompose_basic_empty_string_name_empty_dict_config():
    """Test with empty string name and empty dict config."""
    sc = StatisticConfig(name="", config={})
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 452ns -> 426ns (6.10% faster)

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

def test_decompose_edge_none_name_none_config():
    """Test with None name and None config."""
    sc = StatisticConfig(name=None, config=None)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 455ns -> 405ns (12.3% faster)

def test_decompose_edge_empty_list_name_empty_list_config():
    """Test with empty list name and empty list config."""
    sc = StatisticConfig(name=[], config=[])
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 423ns -> 372ns (13.7% faster)

def test_decompose_edge_complex_object_config():
    """Test with complex object in config."""
    complex_config = {"nested": {"a": [1, 2, {"b": "c"}]}, "set": set([1, 2])}
    sc = StatisticConfig(name="complex", config=complex_config)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 466ns -> 420ns (11.0% faster)

def test_decompose_edge_manager_argument():
    """Test that manager argument is accepted and ignored."""
    sc = StatisticConfig(name="with_manager", config={"a": 1})
    decomposer = StatisticConfigDecomposer()
    manager = DatumManager()
    codeflash_output = decomposer.decompose(sc, manager=manager); result = codeflash_output # 749ns -> 749ns (0.000% faster)

def test_decompose_edge_unusual_types():
    """Test with unusual types for name and config."""
    class Dummy:
        pass
    dummy = Dummy()
    sc = StatisticConfig(name=dummy, config=dummy)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 447ns -> 440ns (1.59% faster)

def test_decompose_edge_mutable_config():
    """Test with mutable config and ensure reference is preserved."""
    config = {"x": [1, 2]}
    sc = StatisticConfig(name="mutable", config=config)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 451ns -> 451ns (0.000% faster)
    # Mutate config after decompose and check result reflects change
    config["x"].append(3)

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

def test_decompose_large_dict_config():
    """Test with large dictionary config."""
    large_dict = {str(i): i for i in range(1000)}
    sc = StatisticConfig(name="large", config=large_dict)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 468ns -> 412ns (13.6% faster)

def test_decompose_large_list_config():
    """Test with large list config."""
    large_list = [i for i in range(1000)]
    sc = StatisticConfig(name="large_list", config=large_list)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 456ns -> 433ns (5.31% faster)

def test_decompose_large_nested_config():
    """Test with deeply nested config."""
    nested = {"level1": {"level2": {"level3": [i for i in range(1000)]}}}
    sc = StatisticConfig(name="nested", config=nested)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 418ns -> 439ns (4.78% slower)

def test_decompose_large_object_name():
    """Test with large string as name."""
    large_name = "x" * 1000
    sc = StatisticConfig(name=large_name, config={"test": "value"})
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 436ns -> 418ns (4.31% faster)

def test_decompose_large_mixed_types():
    """Test with large config containing mixed types."""
    mixed_config = {
        "ints": [i for i in range(500)],
        "strs": [str(i) for i in range(500)],
        "dicts": [{str(i): i} for i in range(10)],
        "bool": True,
        "none": None,
    }
    sc = StatisticConfig(name="mixed", config=mixed_config)
    decomposer = StatisticConfigDecomposer()
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 475ns -> 401ns (18.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.app_common.statistics.statisitcs_objects_decomposer import \
    StatisticConfigDecomposer


# Mocking minimal dependencies for isolated testing
class StatisticConfig:
    """Mock of nvflare.app_common.abstract.statistics_spec.StatisticConfig"""
    def __init__(self, name, config):
        self.name = name
        self.config = config

class DatumManager:
    """Mock of nvflare.fuel.utils.fobs.datum.DatumManager"""
    pass
from nvflare.app_common.statistics.statisitcs_objects_decomposer import \
    StatisticConfigDecomposer


# Fixtures for reuse
@pytest.fixture
def decomposer():
    return StatisticConfigDecomposer()

@pytest.fixture
def datum_manager():
    return DatumManager()

# 1. Basic Test Cases

def test_decompose_basic_string_name_dict_config(decomposer):
    # Basic: name is a string, config is a dict
    sc = StatisticConfig("accuracy", {"threshold": 0.9, "method": "mean"})
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 470ns -> 459ns (2.40% faster)

def test_decompose_basic_int_name_list_config(decomposer):
    # Basic: name is an int, config is a list
    sc = StatisticConfig(42, [1, 2, 3])
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 455ns -> 421ns (8.08% faster)

def test_decompose_basic_float_name_tuple_config(decomposer):
    # Basic: name is a float, config is a tuple
    sc = StatisticConfig(3.14, (1, 2))
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 474ns -> 415ns (14.2% faster)

def test_decompose_basic_bool_name_none_config(decomposer):
    # Basic: name is a bool, config is None
    sc = StatisticConfig(True, None)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 465ns -> 411ns (13.1% faster)

def test_decompose_basic_empty_string_name_empty_dict_config(decomposer):
    # Basic: name is empty string, config is empty dict
    sc = StatisticConfig("", {})
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 455ns -> 432ns (5.32% faster)

# 2. Edge Test Cases

def test_decompose_edge_none_name_none_config(decomposer):
    # Edge: name is None, config is None
    sc = StatisticConfig(None, None)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 440ns -> 425ns (3.53% faster)

def test_decompose_edge_empty_list_name_empty_list_config(decomposer):
    # Edge: name and config are empty lists
    sc = StatisticConfig([], [])
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 398ns -> 405ns (1.73% slower)

def test_decompose_edge_nested_config(decomposer):
    # Edge: config is a deeply nested dict/list structure
    sc = StatisticConfig("nested", {"a": [1, {"b": (2, 3)}, []], "c": {"d": "e"}})
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 445ns -> 439ns (1.37% faster)

def test_decompose_edge_object_name_object_config(decomposer):
    # Edge: name and config are objects (not typical types)
    class Dummy:
        def __eq__(self, other):
            return isinstance(other, Dummy)
    dummy1 = Dummy()
    dummy2 = Dummy()
    sc = StatisticConfig(dummy1, dummy2)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 453ns -> 415ns (9.16% faster)

def test_decompose_edge_manager_argument_ignored(decomposer, datum_manager):
    # Edge: manager argument is passed but ignored
    sc = StatisticConfig("name", "config")
    codeflash_output = decomposer.decompose(sc, manager=datum_manager); result = codeflash_output # 791ns -> 692ns (14.3% faster)

def test_decompose_edge_config_with_special_types(decomposer):
    # Edge: config contains unusual types
    sc = StatisticConfig("special", {frozenset([1, 2]): "val", "bytes": b"bytes"})
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 483ns -> 461ns (4.77% faster)

# 3. Large Scale Test Cases

def test_decompose_large_name_and_config_list(decomposer):
    # Large: name is a long string, config is a large list
    long_name = "n" * 1000
    large_list = list(range(1000))
    sc = StatisticConfig(long_name, large_list)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 509ns -> 464ns (9.70% faster)

def test_decompose_large_config_dict(decomposer):
    # Large: config is a large dict
    large_dict = {str(i): i for i in range(1000)}
    sc = StatisticConfig("large_dict", large_dict)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 516ns -> 506ns (1.98% faster)

def test_decompose_large_nested_structure(decomposer):
    # Large: config is a large nested structure
    nested = {"outer": [{"inner": [i for i in range(100)]} for _ in range(10)]}
    sc = StatisticConfig("nested_large", nested)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 475ns -> 463ns (2.59% faster)

def test_decompose_large_multiple_types(decomposer):
    # Large: config contains many different types
    config = {
        "ints": list(range(500)),
        "floats": [float(i) for i in range(500)],
        "strings": ["s" + str(i) for i in range(500)],
        "dicts": [{str(i): i} for i in range(10)],
        "tuples": [(i, i + 1) for i in range(10)],
    }
    sc = StatisticConfig("multi_type", config)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 488ns -> 481ns (1.46% faster)

def test_decompose_large_config_with_repeated_values(decomposer):
    # Large: config is a list with many repeated values
    repeated = ["repeat"] * 1000
    sc = StatisticConfig("repeated", repeated)
    codeflash_output = decomposer.decompose(sc); result = codeflash_output # 464ns -> 433ns (7.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-StatisticConfigDecomposer.decompose-mhe7ak7g and push.