Revert D73401869

Summary:
This diff reverts D73401869
Failures with 3.14 and 3.12 refleak tests.  The refleak tests are taking a while to debug and they're hitting brand new issues, I need more time to address them.

Depends on D73401869

Reviewed By: jbower-fb, yoney

Differential Revision: D79649298

fbshipit-source-id: 26722a14cb9b44b9e6a71aa7a412ca95bad10027

Author: alexmalyshev

cinderx/Jit/pyjit.cpp

@@ -33,22 +33,6 @@ int initialize();
  */
 void finalize();
 
-/*
- * Check if a function should be scheduled for compilation.
- *
- * This doesn't guarantee that the function can or will be compiled, it just
- * checks if the JIT has been configured in such a way that compilation is
- * possible.
- */
-bool shouldScheduleCompile(BorrowedRef<PyFunctionObject> func);
-
-/*
- * Variant of shouldScheduleCompile() for nested code objects.
- */
-bool shouldScheduleCompile(
-    BorrowedRef<> module_name,
-    BorrowedRef<PyCodeObject> code);
-
 /*
  * Overwrite the entry point of a function so that it tries to JIT-compile
  * itself in the future.

cinderx/Jit/pyjit.h

@@ -73,13 +73,6 @@ def verify_stack(
         )
 
 
-def compiles_after_one_call() -> bool:
-    """
-    Check if CinderX will automatically compile functions after they are called once.
-    """
-    return cinderx.jit.auto_jit_threshold() == 1 or cinderx.jit.is_compile_all()
-
-
 def _identity(obj: object) -> object:
     return obj
 

cinderx/PythonLib/cinderx/test_support.py

@@ -23,9 +23,6 @@
 if not AT_LEAST_312:
     import _testcindercapi
 
-import cinderx
-
-cinderx.init()
 import cinderx.jit
 
 import cinderx.test_support as cinder_support
@@ -37,11 +34,7 @@
     jit_suppress,
     jit_unsuppress,
 )
-from cinderx.test_support import (
-    compiles_after_one_call,
-    run_in_subprocess,
-    skip_unless_jit,
-)
+from cinderx.test_support import run_in_subprocess, skip_unless_jit
 
 from .common import failUnlessHasOpcodes, with_globals
 
@@ -55,9 +48,6 @@
 
 ENCODING: str = sys.stdout.encoding or sys.getdefaultencoding()
 
-# Hack to allow subprocesses to find where cinderx is.
-MOD_PATH: str = os.path.dirname(os.path.dirname(cinderx.__file__))
-
 
 class TestException(Exception):
     pass
@@ -182,9 +172,7 @@ def test_error_preloading_inlined(self):
                 if lazy_imports:
                     cmd.append("-L")
                 cmd.append(str(root / "main.py"))
-                proc = subprocess.run(
-                    cmd, cwd=root, capture_output=True, env={"PYTHONPATH": MOD_PATH}
-                )
+                proc = subprocess.run(cmd, cwd=root, capture_output=True)
                 # We expect an exception, but not a crash!
                 self.assertEqual(proc.returncode, 1, proc.stderr)
                 self.assertEqual(
@@ -728,11 +716,9 @@ def test_cellvar_unbound(self):
 
         self.assertEqual(
             str(ctx.exception),
-            (
-                "cannot access local variable 'a' where it is not associated with a value"
-                if AT_LEAST_312
-                else "local variable 'a' referenced before assignment"
-            ),
+            "cannot access local variable 'a' where it is not associated with a value"
+            if AT_LEAST_312
+            else "local variable 'a' referenced before assignment",
         )
 
     def test_freevars(self):
@@ -986,7 +972,7 @@ async def main():
         with self.assertRaises(asyncio.CancelledError):
             asyncio.run(main())
 
-        if compiles_after_one_call():
+        if cinderx.jit.is_enabled() and cinderx.jit.auto_jit_threshold() <= 1:
             self.assertTrue(is_jit_compiled(a))
             self.assertTrue(is_jit_compiled(b))
             self.assertTrue(is_jit_compiled(c.__wrapped__))
@@ -1547,7 +1533,7 @@ def testfunc():
             testfunc = mod.testfunc
             self.assertTrue(testfunc())
 
-            if compiles_after_one_call():
+            if cinderx.jit.is_enabled() and cinderx.jit.auto_jit_threshold() <= 1:
                 self.assertTrue(is_jit_compiled(testfunc))
 
 
@@ -1583,7 +1569,7 @@ def g():
 
             self.assertFalse(is_jit_compiled(f))
 
-            if compiles_after_one_call():
+            if cinderx.jit.auto_jit_threshold() <= 1:
                 self.assertTrue(is_jit_compiled(g))
 
     @unittest.skipIf(
@@ -1608,19 +1594,11 @@ def g():
 
             self.assertFalse(is_jit_compiled(f))
 
-            if compiles_after_one_call():
+            if cinderx.jit.auto_jit_threshold() <= 1:
                 self.assertTrue(is_jit_compiled(g))
 
             self.assertEqual(cinderx.jit.get_num_inlined_functions(g), 1)
 
-    @unittest.skipIf(
-        (
-            cinderx.jit.auto_jit_threshold() == 0
-            or cinderx.jit.auto_jit_threshold() > 10000
-        )
-        and not cinderx.jit.is_compile_all(),
-        "Expecting the JIT to be compiling a bunch of code automatically",
-    )
     def test_max_code_size_slow(self):
         code = textwrap.dedent(
             """
@@ -1649,15 +1627,11 @@ def junk{i}(j):
             codepath.write_text(code)
 
             def run_test(asserts_func, params):
-                args = [sys.executable, "-X", "jit-all"]
+                args = [sys.executable, "-X", "jit"]
                 args.extend(params)
                 args.append("mod.py")
                 proc = subprocess.run(
-                    args,
-                    cwd=tmp,
-                    stdout=subprocess.PIPE,
-                    encoding=ENCODING,
-                    env={"PYTHONPATH": MOD_PATH},
+                    args, cwd=tmp, stdout=subprocess.PIPE, encoding=ENCODING
                 )
                 self.assertEqual(proc.returncode, 0, proc)
                 actual_stdout = [x.strip() for x in proc.stdout.split("\n")]
@@ -1732,106 +1706,49 @@ def test_max_code_size_fast(self):
 
             def run_proc():
                 proc = subprocess.run(
-                    args,
-                    cwd=tmp,
-                    stdout=subprocess.PIPE,
-                    encoding=ENCODING,
-                    env={"PYTHONPATH": MOD_PATH},
+                    args, cwd=tmp, stdout=subprocess.PIPE, encoding=ENCODING
                 )
                 self.assertEqual(proc.returncode, 0, proc)
                 actual_stdout = [x.strip() for x in proc.stdout.split("\n")]
                 return actual_stdout[0]
 
-            args = [sys.executable, "-X", "jit-all", "mod.py"]
+            args = [sys.executable, "-X", "jit", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 0")
             args = [
                 sys.executable,
                 "-X",
-                "jit-all",
+                "jit",
                 "-X",
                 "jit-max-code-size=1234567",
                 "mod.py",
             ]
             self.assertEqual(run_proc(), "max_size: 1234567")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1k",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1k", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1024")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1K",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1K", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1024")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1m",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1m", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1048576")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1M",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1M", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1048576")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1g",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1g", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1073741824")
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=1G",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=1G", "mod.py"]
             self.assertEqual(run_proc(), "max_size: 1073741824")
 
             def run_proc():
                 proc = subprocess.run(
-                    args,
-                    cwd=tmp,
-                    stderr=subprocess.PIPE,
-                    encoding=ENCODING,
-                    env={"PYTHONPATH": MOD_PATH},
+                    args, cwd=tmp, stderr=subprocess.PIPE, encoding=ENCODING
                 )
                 self.assertEqual(proc.returncode, -6, proc)
                 return proc.stderr
 
-            args = [
-                sys.executable,
-                "-X",
-                "jit-all",
-                "-X",
-                "jit-max-code-size=-1",
-                "mod.py",
-            ]
+            args = [sys.executable, "-X", "jit", "-X", "jit-max-code-size=-1", "mod.py"]
             self.assertIn("Invalid unsigned integer in input string: '-1'", run_proc())
             args = [
                 sys.executable,
                 "-X",
-                "jit-all",
+                "jit",
                 "-X",
                 "jit-max-code-size=1.1",
                 "mod.py",
@@ -1840,7 +1757,7 @@ def run_proc():
             args = [
                 sys.executable,
                 "-X",
-                "jit-all",
+                "jit",
                 "-X",
                 "jit-max-code-size=dogs",
                 "mod.py",
@@ -1849,7 +1766,7 @@ def run_proc():
             args = [
                 sys.executable,
                 "-X",
-                "jit-all",
+                "jit",
                 "-X",
                 "jit-max-code-size=1152921504606846976g",
                 "mod.py",
@@ -2567,10 +2484,9 @@ class PerfMapTests(unittest.TestCase):
     @skip_unless_jit("Runs a subprocess with the JIT enabled")
     def test_forked_pid_map(self):
         proc = subprocess.run(
-            [sys.executable, "-X", "jit-all", "-X", "jit-perfmap", self.HELPER_FILE],
+            [sys.executable, "-X", "jit", "-X", "jit-perfmap", self.HELPER_FILE],
             stdout=subprocess.PIPE,
             encoding=ENCODING,
-            env={"PYTHONPATH": MOD_PATH},
         )
         self.assertEqual(proc.returncode, 0)
 
@@ -2609,12 +2525,7 @@ def test_batch_compile_nested_func(self):
             "jit-batch-compile-workers=2",
             str(root / "main.py"),
         ]
-        proc = subprocess.run(
-            cmd,
-            cwd=root,
-            capture_output=True,
-            env={"PYTHONPATH": MOD_PATH},
-        )
+        proc = subprocess.run(cmd, cwd=root, capture_output=True)
         self.assertEqual(proc.returncode, 0, proc.stderr)
         self.assertEqual(b"42\n", proc.stdout, proc.stdout)
 
@@ -2628,7 +2539,7 @@ def test_func_destroyed_during_preload(self):
             [
                 sys.executable,
                 "-X",
-                "jit-all",
+                "jit",
                 "-X",
                 "jit-batch-compile-workers=4",
                 # Enable lazy imports
@@ -2640,7 +2551,6 @@ def test_func_destroyed_during_preload(self):
             cwd=os.path.dirname(__file__),
             stdout=subprocess.PIPE,
             encoding=ENCODING,
-            env={"PYTHONPATH": MOD_PATH},
         )
         self.assertEqual(proc.returncode, 0)
         expected_stdout = """resolving a_func
@@ -2693,7 +2603,6 @@ def test_preload_error(self):
                     cmd,
                     cwd=root,
                     capture_output=True,
-                    env={"PYTHONPATH": MOD_PATH},
                 )
                 self.assertEqual(proc.returncode, 1, proc.stderr)
                 self.assertIn(b"RuntimeError: boom\n", proc.stderr)
@@ -2709,7 +2618,7 @@ def lme_test_func(self, flag=False):
     def test_multiple_call_method_same_load_method(self):
         self.assertEqual(self.lme_test_func(), "1")
         self.assertEqual(self.lme_test_func(True), "1 flag")
-        if compiles_after_one_call():
+        if cinderx.jit.is_enabled() and cinderx.jit.auto_jit_threshold() <= 1:
             self.assertTrue(is_jit_compiled(LoadMethodEliminationTests.lme_test_func))
 
 

cinderx/PythonLib/test_cinderx/test_cinderjit.py

@@ -51,7 +51,6 @@
     TYPED_UINT64,
     TYPED_UINT8,
 )
-from cinderx.test_support import compiles_after_one_call
 
 from ..common import CompilerTest
 
@@ -614,7 +613,7 @@ def assert_jitted(self, func: Callable[..., object]) -> None:
             return
 
         # Can't guarantee that functions will be called with arbitrary JitAuto settings.
-        if not compiles_after_one_call():
+        if cinderx.jit.auto_jit_threshold() != 0:
             return
 
         self.assertTrue(cinderx.jit.is_jit_compiled(func), func.__name__)