Move immortalize functions to pre-fork model build

Summary: This takes our existing immortal code object support and moves it into the pre-fork build configuration.

Reviewed By: alexmalyshev

Differential Revision: D109072395

fbshipit-source-id: aa8d62f8bba91676f6e18f7e1d4fc00f8d7f8b29

Author: DinoV

cinderx/Common/define.h

@@ -31,3 +31,18 @@ constexpr bool kFreeThreadedBuild =
 #else
     false;
 #endif
+
+// True when CinderX is built for the prefork (fork-and-exec) process model,
+// i.e. with the ENABLE_PREFORK_MODEL build flag.  In this mode some behaviors
+// that would otherwise be runtime options are forced on at compile time -- e.g.
+// JIT-compiled functions are always immortalized, avoiding refcount churn that
+// would otherwise be copied-on-write across forked worker processes.
+//
+// Prefer branching on this constexpr over #ifdef ENABLE_PREFORK_MODEL so the
+// guarded code still gets type-checked in every build configuration.
+constexpr bool kPreforkModel =
+#ifdef ENABLE_PREFORK_MODEL
+    true;
+#else
+    false;
+#endif

cinderx/Jit/config.h

@@ -212,13 +212,6 @@ struct Config {
   // List of function name patterns for which to capture compilation times.
   std::vector<std::string> capture_compilation_times_for;
 
-  // Option to force compiled functions to be immortalized. By default a
-  // CompiledFunction's timetime will be tied to a function via a reference put
-  // in the function's __dict__. When we force CompiledFunction's to always be
-  // immortalized no such reference will be created and the CompiledFunction
-  // will be set to be immortal and never collected.
-  bool immortalize_compiled_functions{false};
-
   // Use stable sentinel pointers in output (for deterministic test output).
   bool use_stable_pointers{false};
 

cinderx/Jit/context.cpp

@@ -718,8 +718,9 @@ Ref<CompiledFunction> Context::makeCompiledFunction(
   if (outer_it != code_outer_funcs_.end() && outer_it->second != func) {
     outer = outer_it->second;
   }
-  bool immortal = getConfig().immortalize_compiled_functions ||
-      (func != nullptr && _Py_IsImmortal(func)) ||
+  // In the prefork model JIT-compiled functions are always immortalized (see
+  // kPreforkModel); otherwise they're only immortal if the owning function is.
+  bool immortal = kPreforkModel || (func != nullptr && _Py_IsImmortal(func)) ||
       (outer != nullptr && _Py_IsImmortal(outer));
   auto compiled = CompiledFunction::create(std::move(compiled_func), immortal);
   if (compiled == nullptr) {

cinderx/Jit/pyjit.cpp

@@ -703,12 +703,6 @@ FlagProcessor initFlagProcessor() {
       getMutableConfig().compile_perf_trampoline_prefork,
       "Compile perf trampoline pre-fork");
 
-  flag_processor.addOption(
-      "cinderx-jit-immortalize-compiled-functions",
-      "CINDERX_JIT_IMMORTALIZE_COMPILED_FUNCTIONS",
-      getMutableConfig().immortalize_compiled_functions,
-      "Always immortalize CompiledFunction objects");
-
   flag_processor.addOption(
       "cinderx-jit-max-code-size",
       "CINDERX_JIT_MAX_CODE_SIZE",

cinderx/PythonLib/cinderx/__init__.py

@@ -74,6 +74,7 @@ def is_supported_runtime() -> bool:
         install_frame_evaluator,
         is_frame_evaluator_installed,
         is_immortal,
+        is_prefork_build,
         remove_frame_evaluator,
         set_adaptive_delay,
         strict_module_patch,
@@ -485,6 +486,9 @@ def is_immortal(obj: object) -> bool:
             "Can't answer whether an object is mortal or immortal from Python code"
         )
 
+    def is_prefork_build() -> bool:
+        return False
+
     def remove_frame_evaluator() -> None:
         pass
 

cinderx/PythonLib/cinderx/test_support.py

@@ -135,6 +135,12 @@ def skip_if_jit(reason: str) -> Callable[[Callable[..., None]], Callable[..., No
     return passIf(cinderx.jit.is_enabled(), reason)
 
 
+def skip_if_prefork(
+    reason: str = "Behavior intentionally differs in prefork builds (e.g. compiled functions are always immortalized)",
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    return passIf(cinderx.is_prefork_build(), reason)
+
+
 def skip_if_ft(reason: str) -> Callable[[Callable[..., None]], Callable[..., None]]:
     return passIf(FREE_THREADING_BUILD, reason)
 

cinderx/PythonLib/test_cinderx/test_cinderjit.py

@@ -32,6 +32,7 @@
     passUnless,
     run_in_subprocess,
     skip_if_ft,
+    skip_if_prefork,
     skip_test_if_oss,
     skip_unless_jit,
     subprocess_env,
@@ -2541,6 +2542,10 @@ def test_jit_unsuppress(self) -> None:
             jit_unsuppress(is_jit_compiled)
 
     @passIf(not cinderx.jit.is_enabled(), "only relevant when the JIT is enabled")
+    @skip_if_prefork(
+        "Prefork builds immortalize compiled functions and do not publish "
+        "__cinderx_compiled_func__, so the function never deopts"
+    )
     def test_compiled_code_ref(self):
         self.assertNotIn("__cinderx_compiled_func__", compiled_code_func.__dict__)
         cinder_support.failUnlessJITCompiled(compiled_code_func)
@@ -2553,6 +2558,10 @@ def test_compiled_code_ref(self):
         self.assertFalse(cinderx.jit.is_jit_compiled(compiled_code_func))
 
     @passIf(not cinderx.jit.is_enabled(), "only relevant when the JIT is enabled")
+    @skip_if_prefork(
+        "Prefork builds immortalize compiled functions and do not publish "
+        "__cinderx_compiled_func__, so the function never deopts"
+    )
     def test_nested_compiled_code_ref(self):
         # CompiledCode should be re-used for nested functions, even if the outer
         # function is never compiled.
@@ -2573,6 +2582,10 @@ def test_nested_compiled_code_ref(self):
         )
 
     @passIf(not cinderx.jit.is_enabled(), "only relevant when the JIT is enabled")
+    @skip_if_prefork(
+        "Prefork builds immortalize compiled functions and do not publish "
+        "__cinderx_compiled_func__, so the function never deopts"
+    )
     def test_nested_compiled_code_ref_outer_destroyed(self):
         d = {}
         exec(

cinderx/PythonLib/test_cinderx/test_deferred_cleanup.py

@@ -9,7 +9,12 @@
 import unittest
 from pathlib import Path
 
-from cinderx.test_support import ENCODING, skip_unless_jit, subprocess_env
+from cinderx.test_support import (
+    ENCODING,
+    skip_if_prefork,
+    skip_unless_jit,
+    subprocess_env,
+)
 
 
 # Each subprocess must use the allocator that actually unmaps freed code
@@ -24,6 +29,10 @@
 
 
 @skip_unless_jit("Exercises JIT-compiled code lifetime")
+@skip_if_prefork(
+    "Prefork builds always immortalize compiled functions, so the mortal "
+    "deferred-cleanup/deopt lifecycle these tests exercise does not apply"
+)
 class DeferredCleanupTest(unittest.TestCase):
     """
     Tests for the deferred freeing of JIT-compiled code (the

cinderx/RuntimeTests/main.cpp

@@ -210,6 +210,16 @@ void registerCinderX() {
 #endif
 }
 
+// In the prefork-model build CinderX intentionally immortalizes JIT-compiled
+// objects, so they are never freed and LeakSanitizer reports them as leaks at
+// exit, failing the test binary even though every gtest passes. Turn leak
+// checking off for that build only; non-prefork builds keep leak detection.
+// kPreforkModel is a constexpr, so this folds to a constant return as required
+// by __lsan_is_turned_off().
+extern "C" __attribute__((used)) int __lsan_is_turned_off() {
+  return int{kPreforkModel};
+}
+
 int main(int argc, char* argv[]) {
 #ifdef CINDERX_RUNTIME_TESTS_PYTHONPATH_PACKAGE
   // OSS path: point PYTHONPATH at the in-tree cinderx package so

cinderx/TestScripts/cinder_test_runner.py

@@ -274,7 +274,9 @@ def manage_worker(
     worker.wait()
 
 
-def _computeSkipTests(huntrleaks, use_rr=False) -> Tuple[Set[str], Set[str]]:
+def _computeSkipTests(
+    huntrleaks, use_rr=False, extra_skip_files=None
+) -> Tuple[Set[str], Set[str]]:
     skip_list_files = ["devserver_skip_tests.txt", "cinder_skip_test.txt"]
 
     version = "".join(str(v) for v in sys.version_info[:2])
@@ -288,6 +290,9 @@ def _computeSkipTests(huntrleaks, use_rr=False) -> Tuple[Set[str], Set[str]]:
     if use_rr:
         skip_list_files.append("rr_skip_tests.txt")
 
+    if extra_skip_files:
+        skip_list_files.extend(extra_skip_files)
+
     try:
         import cinderjit  # noqa: F401
 
@@ -354,8 +359,10 @@ def _select_tests(exclude: Set[str]) -> List[str]:
     return tests
 
 
-def list_tests(huntrleaks, use_rr):
-    skip_modules, skip_patterns = _computeSkipTests(huntrleaks, use_rr)
+def list_tests(huntrleaks, use_rr, extra_skip_files=None):
+    skip_modules, skip_patterns = _computeSkipTests(
+        huntrleaks, use_rr, extra_skip_files
+    )
 
     return _select_tests(skip_modules)
 
@@ -376,6 +383,7 @@ def __init__(
         json_summary_file: str | None,
         failfast: bool,
         expected_failures: list[str],
+        skip_lists: list[str] | None = None,
     ):
         self._cinder_regr_runner_logfile = logfile
         self._success_on_test_errors = success_on_test_errors
@@ -403,7 +411,9 @@ def __init__(
         # False, False => quiet, pgo
         self._logger = libregrtest_logger.Logger(self._results, False, False)
 
-        skip_modules, skip_patterns = _computeSkipTests(self._huntrleaks, self._use_rr)
+        skip_modules, skip_patterns = _computeSkipTests(
+            self._huntrleaks, self._use_rr, skip_lists
+        )
 
         if tests is None:
             tests = _select_tests(skip_modules)
@@ -866,7 +876,7 @@ def worker_main(args):
 
 def dispatcher_main(args):
     if args.list:
-        tests = list_tests(args.huntrleaks, args.use_rr)
+        tests = list_tests(args.huntrleaks, args.use_rr, args.skip_list)
         tests.sort()
         print(json.dumps(tests, indent=0))
         sys.exit(0)
@@ -901,6 +911,7 @@ def dispatcher_main(args):
                 args.json_summary_file,
                 args.failfast,
                 args.expected_failures,
+                args.skip_list,
             )
             print(f"Spawning {num_workers} workers")
             test_runner.run()
@@ -1033,6 +1044,14 @@ def main():
         action="append",
         help="A file which specifies expected failures for this test run.",
     )
+    dispatcher_parser.add_argument(
+        "--skip-list",
+        action="append",
+        help="A file listing extra tests to skip for this run, in the same "
+        "format as the checked-in *_skip_tests.txt files. Use to skip tests "
+        "for a specific build configuration (e.g. prefork-model) without "
+        "affecting other builds. Can be supplied multiple times.",
+    )
     dispatcher_parser.add_argument("rest", nargs=argparse.REMAINDER)
     dispatcher_parser.set_defaults(func=dispatcher_main)