⚡️ Speed up function compare_test_results by 37% in PR #687 (granular-async-instrumentation)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #687

If you approve this dependent PR, these changes will be merged into the original PR branch granular-async-instrumentation.

This PR will be automatically closed if the original PR is merged.

---

📄 37% (0.37x) speedup for compare_test_results in codeflash/verification/equivalence.py

⏱️ Runtime : 742 microseconds → 540 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 37% speedup through several key micro-optimizations in the comparator function, which is the performance bottleneck (consuming 80% of runtime):

Primary Optimization - Identity Check: Added if orig is new: return True at the start of comparator. This short-circuits expensive recursive comparisons when objects are identical in memory, which happens frequently when comparing the same data structures.

Loop Optimizations: Replaced all() generator expressions with explicit for loops in multiple places:

• List/tuple comparisons: Changed from all(comparator(elem1, elem2, superset_obj) for elem1, elem2 in zip(orig, new)) to a loop with early return on first mismatch
• Dictionary comparisons: Converted all(k in new and comparator(v, new[k], superset_obj) for k, v in orig.items()) to explicit iteration
• Similar changes for numpy arrays and class object comparisons

This eliminates the overhead of generator creation and the all() function call, while enabling faster short-circuit evaluation.

Why This Works: The all() function with generators creates additional Python objects and function call overhead. Direct loops with early returns are more efficient, especially when mismatches occur early in the comparison (which triggers the short-circuit behavior).

Test Case Performance: The optimizations are particularly effective for test cases with:

• Identical objects (benefits from identity check)
• Large nested data structures where early mismatches occur
• Complex recursive comparisons where avoiding generator overhead accumulates significant savings

The optimizations maintain identical behavior while reducing function call overhead and memory allocations during the comparison process.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_codeflash_capture.py::test_codeflash_capture_basic	43.7μs	41.2μs	5.90%✅
test_codeflash_capture.py::test_codeflash_capture_multiple_helpers	51.1μs	43.5μs	17.6%✅
test_codeflash_capture.py::test_codeflash_capture_recursive	44.2μs	36.8μs	20.1%✅
test_codeflash_capture.py::test_codeflash_capture_super_init	45.4μs	41.6μs	9.30%✅
test_codeflash_capture.py::test_instrument_codeflash_capture_and_run_tests	55.9μs	47.6μs	17.5%✅
test_comparator.py::test_compare_results_fn	60.6μs	57.8μs	4.87%✅
test_instrument_all_and_run.py::test_bubble_sort_behavior_results	44.3μs	39.7μs	11.6%✅
test_instrument_all_and_run.py::test_class_method_full_instrumentation	57.2μs	28.5μs	100%✅
test_instrumentation_run_results_aiservice.py::test_class_method_full_instrumentation	44.6μs	36.5μs	22.2%✅
test_instrumentation_run_results_aiservice.py::test_class_method_test_instrumentation_only	36.1μs	29.1μs	24.1%✅
test_pickle_patcher.py::test_run_and_parse_picklepatch	259μs	138μs	87.4%✅

To edit these changes git checkout codeflash/optimize-pr687-2025-09-13T01.22.10 and push.

[misrasaurabh1]

wow, this is an important function to optimize!