Always initialize the CinderX JIT

Summary:
Remove the need for having one of `PYTHONJIT{,ALL,AUTO,LISTFILE}` defined to use
the JIT.  It is now unconditionally initialized.  As long as the application has
`cinderx` as a dependency, it can call `cinderx.jit.force_compile()` to
JIT-compile functions.

Having `cinderx` automatically compile code still requires applying one of
`PYTHONJIT{AUTO,ALL,LISTFILE}` to the environment before running the binary, or
calling `cinderx.jit.{append,read}_jit_list()` at runtime.

`cinderx.jit.enable()` does not yet allow the user to specify the JitAuto
threshold or to enable JitAll mode, that will come later.

Reviewed By: DinoV

Differential Revision: D80621511

fbshipit-source-id: b64d17cecee7855369fbe3528a6194644de21a1f

Author: alexmalyshev

cinderx/Jit/pyjit.cpp

@@ -141,9 +141,6 @@ std::atomic<int> g_compile_workers_retries;
 
 int jit_help = 0;
 
-// Temporary boolean for when `-X jit` or `PYTHONJIT=1` are used.
-bool bare_jit = false;
-
 uint64_t countCalls(PyCodeObject* code) {
 #if SHADOWCODE_SUPPORTED
   return code->co_mutable->ncalls;
@@ -343,18 +340,11 @@ size_t parse_sized_argument(const std::string& val) {
 
 FlagProcessor initFlagProcessor() {
   jit_help = 0;
-  bare_jit = false;
 
   FlagProcessor flag_processor;
 
   // Flags are inspected in order of definition below.
 
-  flag_processor.addOption(
-      "jit",
-      "PYTHONJIT",
-      bare_jit,
-      "Initialize the JIT but don't automatically compile any functions");
-
   flag_processor.addOption(
       "jit-all",
       "PYTHONJITALL",
@@ -1322,7 +1312,7 @@ PyObject* enable_jit(PyObject* /* self */, PyObject* /* arg */) {
   if (jitCtx() == nullptr) {
     PyErr_SetString(
         PyExc_RuntimeError,
-        "Trying to re-enable the JIT but it was never initialized");
+        "Trying to re-enable the JIT but the JIT context is missing");
     return nullptr;
   }
   if (isJitUsable()) {
@@ -2231,10 +2221,9 @@ PyObject* disable_specialized_opcodes(PyObject* /* self */, PyObject*) {
 // and return 1. Otherwise, return 0.
 int deopt_gen_impl(PyGenObject* gen) {
 #if PY_VERSION_HEX >= 0x030C0000
-  if (deopt_jit_gen(gen)) {
-    return 1;
-  }
-  return 0;
+  // deopt_jit_gen optimistically succeeds when the generator isn't a JIT
+  // generator.
+  return JitGenObject::cast(gen) != nullptr && deopt_jit_gen(gen);
 #else
   GenDataFooter* footer = genDataFooter(gen);
   if (footer == nullptr || Ci_GenIsCompleted(gen)) {
@@ -2915,33 +2904,18 @@ int initialize() {
       jit_list = jit::JITList::create();
     }
     if (jit_list == nullptr) {
-      JIT_LOG("Failed to allocate JIT list");
+      PyErr_SetString(PyExc_RuntimeError, "Failed to allocate JIT list");
       return -1;
     }
 
     try {
       jit_list->parseFile(getConfig().jit_list.filename.c_str());
     } catch (const std::exception& exn) {
-      if (getConfig().jit_list.error_on_parse) {
-        PyErr_SetString(PyExc_RuntimeError, exn.what());
-        return -1;
-      }
-
-      JIT_LOG("{}", exn.what());
-      JIT_LOG("Continuing on with the JIT disabled");
-      return 0;
+      PyErr_SetString(PyExc_RuntimeError, exn.what());
+      return -1;
     }
   }
 
-  auto const& config = getConfig();
-  bool use_jit = bare_jit || config.compile_all ||
-      config.jit_list.filename != "" || config.auto_jit_threshold > 0;
-  if (use_jit || config.force_init.value_or(false)) {
-    JIT_DLOG("Initializing the JIT");
-  } else {
-    return 0;
-  }
-
 #if PY_VERSION_HEX >= 0x030C0000
   jit::init_jit_genobject_type();
 #endif
@@ -2963,12 +2937,10 @@ int initialize() {
     return -1;
   }
 
-  getMutableConfig().state = use_jit ? State::kRunning : State::kPaused;
+  getMutableConfig().state = State::kRunning;
 
   g_jit_list = jit_list.release();
 
-  JIT_DLOG("JIT is {}", isJitUsable() ? "enabled" : "disabled");
-
   return 0;
 }
 

cinderx/PythonLib/test_cinderx/test_jitlist.py

@@ -151,13 +151,10 @@ def func():
                 return 24
 
             assert not cinderx.jit.is_jit_compiled(func)
-
             cinderx.jit.lazy_compile(func)
+            assert not cinderx.jit.is_jit_compiled(func)
 
-            # This has to use multiple threads otherwise this will take many minutes to run.
-            # It'll be compiling all functions that were loaded and not-yet-run in JitAll
-            # mode.
-            assert cinderx.jit.precompile_all(workers=10)
+            assert cinderx.jit.precompile_all(workers=2)
             assert cinderx.jit.is_jit_compiled(func)
 
             print(func())
@@ -169,7 +166,7 @@ def func():
             codepath = dirpath / "mod.py"
             codepath.write_text(code)
             proc = subprocess.run(
-                [sys.executable, "-X", "jit", "mod.py"],
+                [sys.executable, "mod.py"],
                 stdout=subprocess.PIPE,
                 cwd=tmp,
                 encoding=ENCODING,
@@ -218,32 +215,6 @@ def test_precompile_all_bad_args(self) -> None:
         with self.assertRaises(ValueError):
             cinderx.jit.precompile_all(workers=200000)
 
-    def test_default_parse_error_behavior_startup(self) -> None:
-        code = 'print("Hello world!")'
-        jitlist = "OH NO"
-        with tempfile.TemporaryDirectory() as tmp:
-            dirpath = Path(tmp)
-            codepath = dirpath / "mod.py"
-            jitlistpath = dirpath / "jitlist.txt"
-            codepath.write_text(code)
-            jitlistpath.write_text(jitlist)
-            proc = subprocess.run(
-                [
-                    sys.executable,
-                    "-X",
-                    "jit-list-file=jitlist.txt",
-                    "mod.py",
-                ],
-                capture_output=True,
-                cwd=tmp,
-                encoding=ENCODING,
-                env={"PYTHONPATH": CINDERX_PATH},
-            )
-        self.assertEqual(proc.returncode, 0, proc)
-        self.assertIn(
-            "Error while parsing line 1 in JIT list file jitlist.txt", proc.stderr
-        )
-
     def test_fail_on_parse_error_startup(self) -> None:
         code = 'print("Hello world!")'
         jitlist = "OH NO"

cinderx/RuntimeTests/cmdline_test.cpp

@@ -285,29 +285,21 @@ TEST_F(CmdLineTest, JITEnable) {
           []() {},
           []() {
             ASSERT_TRUE(isJitUsable());
+            ASSERT_TRUE(getConfig().compile_all);
             ASSERT_EQ(is_intel_syntax(), 0); // default to AT&T syntax
           }),
       0);
 
-  ASSERT_EQ(
-      try_flag_and_envvar_effect(
-          L"jit", "PYTHONJIT=1", []() {}, []() { ASSERT_TRUE(isJitUsable()); }),
-      0);
-
   ASSERT_EQ(
       try_flag_and_envvar_effect(
           L"jit-all=0",
           "PYTHONJITALL=0",
           []() {},
-          []() { ASSERT_FALSE(isJitUsable()); }),
-      0);
-
-  ASSERT_EQ(
-      try_flag_and_envvar_effect(
-          L"jit=0",
-          "PYTHONJIT=0",
-          []() {},
-          []() { ASSERT_FALSE(isJitUsable()); }),
+          []() {
+            // JIT still usable when JitAll is not enabled.
+            ASSERT_TRUE(isJitUsable());
+            ASSERT_FALSE(getConfig().compile_all);
+          }),
       0);
 }
 

cinderx/TestScripts/3.14-opt-failures.txt

@@ -81,10 +81,16 @@ test_cinderx.test_compiler_sbs_stdlib_7
 test_cinderx.test_compiler_sbs_stdlib_8
 test_cinderx.test_compiler_sbs_stdlib_9
 test_cinderx.test_cpython_overrides.test_dis
-test_cinderx.test_cpython_overrides.test_inspect
 test_cinderx.test_immortalize
 test_cinderx.test_jit_attr_cache
 test_cinderx.test_jit_coroutines
+test_cinderx.test_jit_disable
+test_cinderx.test_jit_exception
+test_cinderx.test_jit_frame
+test_cinderx.test_jit_generators
 test_cinderx.test_jit_global_cache
+test_cinderx.test_jit_perf_map
 test_cinderx.test_jit_preload
+test_cinderx.test_jit_specialization
+test_cinderx.test_jit_type_annotations
 test_cinderx.test_parallel_gc