From adde14fc8cac4d632d22a519b6bcc77dc06ec59a Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Sat, 21 Feb 2026 00:26:38 +0000
Subject: [PATCH] Optimize _ensure_languages_registered
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The optimized code achieves a **124% speedup (482μs → 214μs)** by eliminating redundant module imports through two key optimizations:

**Primary Optimization: Hoisting Imports to Module Scope**
Moving `contextlib`, `importlib`, and `sys` imports from inside the function to module-level eliminates ~61μs of repeated import overhead. The line profiler shows the original code spent time importing these modules on every cold call (35μs + 26μs), which adds up across multiple invocations.

**Secondary Optimization: sys.modules Cache Check**
The most impactful change is checking `if name in sys.modules` before calling `importlib.import_module(name)`. The profiler reveals that subsequent calls were still invoking `importlib.import_module()` even for already-loaded modules. By checking the cache first, the optimized version:
- Avoids 228 out of 231 redundant import_module calls (see optimized profiler: 228 continues vs 3 actual imports)
- Reduces from 462 total contextlib.suppress operations to just 6
- Trades expensive import_module calls (~82-256ms each) for fast dictionary lookups (~320ns each)

**Loop Refactoring**
Replacing three separate `with contextlib.suppress` blocks with a loop over a tuple makes the code more maintainable while enabling the cache check optimization. The loop itself adds negligible overhead (68μs total).

**Test Results Validation**
The annotated tests show consistent 400-600% speedups in cold-path scenarios (when modules need registration), with the optimization being most effective when:
- Functions are called multiple times after initial registration (e.g., `test_ensure_languages_registered_large_scale_repeated_calls`)
- Multiple sequential resets occur (e.g., `test_ensure_languages_registered_multiple_sequential_resets` shows 548% improvement)
- The function is in a hot path with repeated calls (several tests show sub-microsecond improvement after first call)

The optimization maintains correctness by preserving the ImportError suppression behavior and idempotency guarantees, while dramatically reducing runtime for the common case where language modules are already loaded in sys.modules.
---
 codeflash/languages/registry.py | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/codeflash/languages/registry.py b/codeflash/languages/registry.py
index 28d547c1b..53debd074 100644
--- a/codeflash/languages/registry.py
+++ b/codeflash/languages/registry.py
@@ -7,7 +7,10 @@
 
 from __future__ import annotations
 
+import contextlib
+import importlib
 import logging
+import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -47,17 +50,18 @@ def _ensure_languages_registered() -> None:
 
     # Import support modules to trigger registration
     # These imports are deferred to avoid circular imports
-    import contextlib
-    import importlib
-
-    with contextlib.suppress(ImportError):
-        importlib.import_module("codeflash.languages.python.support")
-
-    with contextlib.suppress(ImportError):
-        importlib.import_module("codeflash.languages.javascript.support")
-
-    with contextlib.suppress(ImportError):
-        importlib.import_module("codeflash.languages.java.support")
+    module_names = (
+        "codeflash.languages.python.support",
+        "codeflash.languages.javascript.support",
+        "codeflash.languages.java.support",
+    )
+
+    for name in module_names:
+        # Avoid the cost of importlib.import_module when the module is already loaded.
+        if name in sys.modules:
+            continue
+        with contextlib.suppress(ImportError):
+            importlib.import_module(name)
 
     _languages_registered = True