Handle missing fork in run_in_subprocess

Summary: Centralize fork availability handling in run_in_subprocess and remove redundant test decorators.

Reviewed By: alexmalyshev

Differential Revision: D115912872

fbshipit-source-id: 92220ed28404ca364a344cdfac26cd1b5f4964e6

Author: yoney

cinderx/PythonLib/cinderx/test_support.py

@@ -338,12 +338,16 @@ def __init__(self, exc: Exception) -> None:
         self.exc = exc
 
 
-def run_in_subprocess(func: Callable[..., TRet]) -> Callable[..., TRet]:
+def run_in_subprocess(func: Callable[..., None]) -> Callable[..., None]:
     """
-    Run a function in a subprocess.  This enables modifying process state in a
-    test without affecting other test functions.
+    Run a test function in a subprocess.  This enables modifying process state
+    without affecting other test functions.  Pass the test without running it
+    when fork is unavailable.
     """
 
+    if "fork" not in multiprocessing.get_all_start_methods():
+        return passAlways(f"fork is unavailable on {platform.system()}")(func)
+
     queue: multiprocessing.Queue = multiprocessing.Queue()
 
     def wrapper(queue: multiprocessing.Queue, *args: object) -> None:
@@ -353,15 +357,14 @@ def wrapper(queue: multiprocessing.Queue, *args: object) -> None:
         except Exception as e:
             queue.put(_ExceptionResult(e), timeout=SUBPROCESS_TIMEOUT_SEC)
 
-    def wrapped(*args: object) -> TRet:
+    def wrapped(*args: object) -> None:
         fork = multiprocessing.get_context("fork")
         p = fork.Process(target=wrapper, args=(queue, *args))
         p.start()
         value = queue.get(timeout=SUBPROCESS_TIMEOUT_SEC)
         p.join(timeout=SUBPROCESS_TIMEOUT_SEC)
         if isinstance(value, _ExceptionResult):
             raise value.exc
-        return value
 
     return wrapped
 

cinderx/PythonLib/test_cinderx/test_free_threading/test_free_threading.py

@@ -2,7 +2,6 @@
 
 # pyre-strict
 
-import os
 import threading
 import unittest
 from concurrent.futures import ThreadPoolExecutor
@@ -18,7 +17,6 @@ def fibonacci(n: int) -> int:
 
 
 class FunctionWatcherTest(unittest.TestCase):
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_qualname_updates(self) -> None:
         worker_count = 10
@@ -53,7 +51,6 @@ def setUp(self):
     def tearDown(self):
         cinderx.jit.background_compile(self.bg_compile)
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_force_compile(self) -> None:
         worker_count = 10
@@ -87,7 +84,6 @@ def recompile_and_call(_: int) -> list[int]:
         )
         self.assertTrue(cinderx.jit.is_jit_compiled(fibonacci))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_calls_trigger_jit_compilation(self) -> None:
         cinderx.jit.compile_after_n_calls(3)

cinderx/PythonLib/test_cinderx/test_free_threading/test_jit_cells.py

@@ -5,7 +5,6 @@
 """Free-threaded JIT regression tests for closure cell access."""
 
 import gc
-import os
 import queue
 import threading
 import unittest
@@ -18,7 +17,6 @@
 class JITCellTest(unittest.TestCase):
     """Exercises closure cells shared by concurrently executing JIT code."""
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_load_deref(self) -> None:
         """A loaded cell value must remain alive while writers replace it."""
@@ -63,7 +61,6 @@ def writer(prefix: str) -> None:
 
         self.assertTrue(value.startswith("w"))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_store_deref_releases_each_value_once(self) -> None:
         """Concurrent cell stores must transfer ownership exactly once."""

cinderx/PythonLib/test_cinderx/test_free_threading/test_jit_lists.py

@@ -5,7 +5,6 @@
 """Free-threaded JIT regression tests for list subscripts."""
 
 import dis
-import os
 import threading
 import unittest
 from collections.abc import Callable
@@ -71,7 +70,6 @@ def writer(prefix: str) -> None:
 
         self.assertTrue(values[0].startswith("w"))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_subscript_without_specialized_opcodes(self) -> None:
         """Keep generic HIR when compiling an adaptive list opcode."""
@@ -92,7 +90,6 @@ def read_item(values: list[str]) -> str:
 
         self.exercise_concurrent_access(read_item)
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @unittest.skipUnless(FREE_THREADING_BUILD, "requires free-threaded build")
     @run_in_subprocess
     def test_concurrent_subscript_with_simplify(self) -> None:

cinderx/PythonLib/test_cinderx/test_free_threading/test_jit_tuples.py

@@ -5,7 +5,6 @@
 """Free-threaded JIT regression tests for tuple subscripts."""
 
 import dis
-import os
 import threading
 import unittest
 from collections.abc import Callable, Sequence
@@ -57,7 +56,6 @@ def reader(_: int) -> bool:
         self.assertEqual(results, [True] * worker_count)
         return worker_count * iterations
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_subscript_without_specialized_opcodes(self) -> None:
         """Keep generic HIR when compiling an adaptive tuple opcode."""
@@ -78,7 +76,6 @@ def read_item(values: Sequence[object]) -> object:
         values = (object(),)
         self.exercise_concurrent_reads(read_item, values)
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_subscript_with_simplify(self) -> None:
         """Keep the direct LoadArrayItem path for exact tuples.
@@ -104,7 +101,6 @@ def read_item(values: Sequence[object]) -> object:
         values = (object(),)
         self.exercise_concurrent_reads(read_item, values)
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_concurrent_deopt_on_guard_failure(self) -> None:
         """Concurrent list calls deopt at the exact-tuple guard."""

cinderx/PythonLib/test_cinderx/test_immortalize.py

@@ -2,7 +2,6 @@
 # pyre-unsafe
 
 import gc
-import os
 import sys
 import unittest
 
@@ -24,14 +23,12 @@ def test_default_not_immortal(self) -> None:
         obj = []
         self.assertFalse(cinderx.is_immortal(obj))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_is_immortal(self) -> None:
         obj = []
         cinderx.immortalize_heap()
         self.assertTrue(cinderx.is_immortal(obj))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_post_immortalize(self) -> None:
         cinderx.immortalize_heap()
@@ -42,7 +39,6 @@ def test_post_immortalize(self) -> None:
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_exact_dict_unicode_keys(self) -> None:
         key = "".join(("qe2_", "param"))
@@ -61,7 +57,6 @@ def test_immortalize_exact_dict_unicode_keys(self) -> None:
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_gc_collected_exact_dict_entries(self) -> None:
         key = "".join(("gc_collected_", "param"))
@@ -83,7 +78,6 @@ def test_immortalize_gc_collected_exact_dict_entries(self) -> None:
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_nested_exact_dict_entries(self) -> None:
         outer_key = "".join(("outer_", "param"))
@@ -106,7 +100,6 @@ def test_immortalize_nested_exact_dict_entries(self) -> None:
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_self_referential_exact_dict_entries(self) -> None:
         key = "".join(("self_", "param"))
@@ -125,7 +118,6 @@ def test_immortalize_self_referential_exact_dict_entries(self) -> None:
         self.assertTrue(cinderx.is_immortal(self_key))
         self.assertIs(mapping[self_key], mapping)
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_consts_entries(self) -> None:
         def target() -> None:
@@ -143,7 +135,6 @@ def target() -> None:
         self.assertTrue(cinderx.is_immortal(consts))
         self.assertTrue(cinderx.is_immortal(const))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_consts_tuple_entry(self) -> None:
         def target() -> None:
@@ -162,7 +153,6 @@ def target() -> None:
         self.assertTrue(cinderx.is_immortal(consts))
         self.assertTrue(cinderx.is_immortal(tuple_const))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_consts_nested_exact_dict_entries(self) -> None:
         def target() -> None:
@@ -184,7 +174,6 @@ def target() -> None:
         self.assertTrue(cinderx.is_immortal(key))
         self.assertTrue(cinderx.is_immortal(value))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_nested_code_object_consts(self) -> None:
         def inner() -> None:
@@ -210,7 +199,6 @@ def outer() -> None:
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_name_tuple_entries(self) -> None:
         def target() -> None:
@@ -233,7 +221,6 @@ def target() -> None:
         self.assertTrue(cinderx.is_immortal(name))
         self.assertTrue(cinderx.is_immortal(local_name))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_exceptiontable(self) -> None:
         def target() -> None:
@@ -251,7 +238,6 @@ def target() -> None:
         self.assertTrue(cinderx.is_immortal(target.__code__))
         self.assertTrue(cinderx.is_immortal(exceptiontable))
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_refcount(self) -> None:
         from cinderx import jit
@@ -274,7 +260,6 @@ def f():
         _PY_DEBUG_BUILD,
         "Python 3.12 debug builds only allow interned immortal unicode",
     )
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_immortalize_code_qualname(self) -> None:
         def target() -> None:

cinderx/PythonLib/test_cinderx/test_jit_global_cache.py

@@ -5,7 +5,6 @@
 # pyre-unsafe
 
 import builtins
-import os
 import unittest
 from textwrap import dedent
 
@@ -142,7 +141,6 @@ def _test_unwatch_builtins(self):
         # pyrefly: ignore [unsupported-operation]
         builtins.__dict__[42] = 42
 
-    @unittest.skipUnless(hasattr(os, "fork"), "fork not available on Windows")
     @run_in_subprocess
     def test_unwatch_builtins(self):
         try:
@@ -152,8 +150,8 @@ def test_unwatch_builtins(self):
             del builtins.__dict__[42]
 
     @skip_unless_lazy_imports()
-    @failUnlessHasOpcodes("LOAD_GLOBAL")
     @run_in_subprocess
+    @failUnlessHasOpcodes("LOAD_GLOBAL")
     def test_preload_side_effect_modifies_globals(self):
         with cinder_support.temp_sys_path() as tmp:
             (tmp / "tmp_a.py").write_text(
@@ -226,8 +224,8 @@ def get_a():
                 self.assertEqual(relevant_deopts, [])
 
     @skip_unless_lazy_imports()
-    @failUnlessHasOpcodes("LOAD_GLOBAL")
     @run_in_subprocess
+    @failUnlessHasOpcodes("LOAD_GLOBAL")
     def test_preload_side_effect_makes_globals_unwatchable(self):
         with cinder_support.temp_sys_path() as tmp:
             (tmp / "tmp_a.py").write_text(
@@ -274,8 +272,8 @@ def get_a():
             )
 
     @skip_unless_lazy_imports()
-    @failUnlessHasOpcodes("LOAD_GLOBAL")
     @run_in_subprocess
+    @failUnlessHasOpcodes("LOAD_GLOBAL")
     def test_preload_side_effect_makes_builtins_unwatchable(self):
         with cinder_support.temp_sys_path() as tmp:
             (tmp / "tmp_a.py").write_text(