⚡️ Speed up function get_dumpable by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for get_dumpable in electrum/harden_memory_linux.py

⏱️ Runtime : 943 microseconds → 890 microseconds (best of 210 runs)

📝 Explanation and details

The optimized version achieves a 5% speedup by eliminating redundant function call overhead in the critical path. Here are the key optimizations:

Primary Optimization: Inlined Global Check

• Original: Always calls _load_libc() which checks if _libc is not None: and returns
• Optimized: Directly checks if _libc is None: in get_dumpable(), avoiding the function call overhead after initialization

Secondary Optimization: Reduced Global Variable Access

• Original: Accesses the global _libc multiple times during initialization
• Optimized: Uses a local variable libc during setup, then assigns to _libc only once

Performance Impact Analysis:
From the line profiler data, the optimization eliminates the most expensive operation:

• Original: _load_libc() call takes 3953.7ns per hit (71.7% of total time)
• Optimized: Direct if _libc is None: check takes only 211.1ns per hit (6.3% of total time)

Test Results Show Consistent Gains:

• Single calls: 7-13% improvement (6.72μs → 6.25μs)
• Repeated calls: Up to 19% improvement (1.26μs → 1.06μs)
• Bulk operations: 5.8% improvement on 1000 iterations

This optimization is particularly effective for workloads that call get_dumpable() multiple times, as it eliminates the function call overhead after the first initialization while maintaining identical behavior and error handling.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import ctypes
import ctypes.util
import os
import sys

# imports
import pytest  # used for our unit tests
from electrum.harden_memory_linux import get_dumpable

PR_GET_DUMPABLE = 3

_libc = None  # type: Optional[ctypes.CDLL]
from electrum.harden_memory_linux import \
    get_dumpable  # --- end electrum/harden_memory_linux.py ---

# unit tests

# Basic Test Cases

def test_get_dumpable_returns_bool():
    """Test that get_dumpable always returns a boolean value."""
    codeflash_output = get_dumpable(); result = codeflash_output # 6.72μs -> 6.25μs (7.52% faster)

def test_get_dumpable_consistency():
    """
    Test that multiple calls to get_dumpable return the same value
    (unless the dumpable state is changed externally between calls).
    """
    codeflash_output = get_dumpable(); result1 = codeflash_output # 3.39μs -> 3.26μs (4.02% faster)
    codeflash_output = get_dumpable(); result2 = codeflash_output # 1.21μs -> 1.06μs (14.2% faster)

def test_get_dumpable_true_or_false():
    """
    Test that get_dumpable returns either True or False, never other values.
    """
    codeflash_output = get_dumpable(); result = codeflash_output # 2.97μs -> 2.66μs (11.6% faster)

# Edge Test Cases




def test_get_dumpable_idempotency():
    """
    Test that get_dumpable does not change the dumpable state.
    """
    codeflash_output = get_dumpable(); before = codeflash_output # 6.60μs -> 6.16μs (7.21% faster)
    codeflash_output = get_dumpable(); after = codeflash_output # 1.25μs -> 1.09μs (14.0% faster)

# Large Scale Test Cases

def test_get_dumpable_many_calls():
    """
    Test calling get_dumpable repeatedly to check for memory leaks or instability.
    """
    results = []
    for _ in range(1000):  # Reasonable upper bound
        results.append(get_dumpable()) # 902μs -> 852μs (5.80% faster)



#------------------------------------------------
import ctypes
import ctypes.util
import os
import sys
import types

# imports
import pytest  # used for our unit tests
from electrum.harden_memory_linux import get_dumpable

PR_GET_DUMPABLE = 3

_libc = None  # type: None
from electrum.harden_memory_linux import get_dumpable

# unit tests

# --- Basic Test Cases ---

def test_get_dumpable_returns_bool():
    """Test that get_dumpable returns a boolean value."""
    codeflash_output = get_dumpable(); result = codeflash_output # 6.78μs -> 6.01μs (12.8% faster)

def test_get_dumpable_consistency():
    """Test that repeated calls to get_dumpable return the same value (dumpable status shouldn't change spontaneously)."""
    codeflash_output = get_dumpable(); first = codeflash_output # 3.83μs -> 3.37μs (13.8% faster)
    codeflash_output = get_dumpable(); second = codeflash_output # 1.26μs -> 1.06μs (19.2% faster)

# --- Edge Test Cases ---




def test_get_dumpable_stress_multiple_calls():
    """Test calling get_dumpable many times to check for resource leaks or errors."""
    # 1000 calls, should always return same value and not leak resources
    results = [get_dumpable() for _ in range(1000)] # 6.61μs -> 6.21μs (6.34% faster)





#------------------------------------------------
from electrum.harden_memory_linux import get_dumpable
import pytest

def test_get_dumpable():
    with pytest.raises(SideEffectDetected, match='A\\ "subprocess\\.Popen\\(\'/sbin/ldconfig\',\\ \\[\'/sbin/ldconfig\',\\ \'\\-p\'\\],\\ None,\\ \\{\'LC_ALL\':\\ \'C\',\\ \'LANG\':\\ \'C\'\\}\\)"\\ operation\\ was\\ detected\\.\\ CrossHair\\ should\\ not\\ be\\ run\\ on\\ code\\ with\\ side\\ effects'):
        get_dumpable()

To edit these changes git checkout codeflash/optimize-get_dumpable-mhl85hr5 and push.