Have functions own their deopt patchers

Summary:
Currently deopt patchers are all owned by the Runtime singleton.  They are
stored in a single vector structure.  They're technically all TypeDeoptPatchers
underneath today.  The way they get accessed is that when a type is modified,
the Runtime singleton checks a Map[Type, Vector[TypeDeoptPatcher*]] structure
and then patches the respective patchers depending on the type.

This means that all deopt patchers live as long as the Runtime does.  There is
no deallocation path for individual patchers today.

Move the deopt patchers onto CompiledFunction objects, keeping them on the HIR
function during compilation.  This will allow them to be destroyed when
individual functions are destroyed, and it gives us a way to traverse all
patchers for an individual function.  It also allows us to prune unreachable /
unused patchers after codegen is complete.

Reviewed By: mpage

Differential Revision: D83502081

fbshipit-source-id: 68dece60649241c26f2ea48035d7b3a4f7568c6f

Author: alexmalyshev

cinderx/Jit/codegen/gen_asm.cpp

@@ -1429,6 +1429,14 @@ void NativeGenerator::linkDeoptPatchers(const asmjit::CodeHolder& code) {
       env_.rt->watchType(typed_patcher->type(), typed_patcher);
     }
   }
+
+  // Any patchers that aren't linked at this point are pointing to patch points
+  // that were optimized out.  It's safe to delete them.
+  std::erase_if(
+      const_cast<hir::Function*>(func_)->deopt_patchers,
+      [](std::unique_ptr<DeoptPatcher>& patcher) {
+        return !patcher->isLinked();
+      });
 }
 
 void NativeGenerator::generateResumeEntry(const FrameInfo& frame_info) {

cinderx/Jit/compiled_function.cpp

@@ -58,6 +58,11 @@ void CompiledFunction::setCompileTime(std::chrono::nanoseconds time) {
   compile_time_ = time;
 }
 
+void CompiledFunction::setDeoptPatchers(
+    std::vector<std::unique_ptr<DeoptPatcher>>&& deopt_patchers) {
+  deopt_patchers_ = std::move(deopt_patchers);
+}
+
 void CompiledFunction::setHirFunc(std::unique_ptr<hir::Function>&& irfunc) {
   irfunc_ = std::move(irfunc);
 }

cinderx/Jit/compiled_function.h

@@ -55,6 +55,7 @@ bool isJitCompiled(const PyFunctionObject* func);
 
 #include "cinderx/Common/util.h"
 #include "cinderx/Jit/code_runtime.h"
+#include "cinderx/Jit/deopt_patcher.h"
 #include "cinderx/Jit/hir/hir.h"
 
 #include <chrono>
@@ -129,6 +130,9 @@ class CompiledFunction {
   std::chrono::nanoseconds compileTime() const;
   void setCompileTime(std::chrono::nanoseconds time);
 
+  void setDeoptPatchers(
+      std::vector<std::unique_ptr<DeoptPatcher>>&& deopt_patchers);
+
   void setHirFunc(std::unique_ptr<hir::Function>&& irfunc);
 
   const hir::Function::InlineFunctionStats& inlinedFunctionsStats() const {
@@ -150,6 +154,8 @@ class CompiledFunction {
   std::chrono::nanoseconds compile_time_;
   hir::Function::InlineFunctionStats inline_function_stats_;
   hir::OpcodeCounts hir_opcode_counts_;
+  // All the deopt patchers pointing to patch points in this function.
+  std::vector<std::unique_ptr<DeoptPatcher>> deopt_patchers_;
   std::unique_ptr<hir::Function> irfunc_;
   CodeRuntime* runtime_;
 };

cinderx/Jit/compiler.cpp

@@ -184,7 +184,7 @@ std::unique_ptr<CompiledFunction> Compiler::Compile(
   }
 
   Timer timer;
-  std::unique_ptr<jit::hir::Function> irfunc(jit::hir::buildHIR(preloader));
+  std::unique_ptr<hir::Function> irfunc(hir::buildHIR(preloader));
   if (nullptr != compilation_phase_timer) {
     compilation_phase_timer->end();
   }
@@ -253,6 +253,7 @@ std::unique_ptr<CompiledFunction> Compiler::Compile(
       hir_opcode_counts,
       code_runtime);
   compiled_func->setCompileTime(compile_time);
+  compiled_func->setDeoptPatchers(std::move(irfunc->deopt_patchers));
   if (getConfig().log.debug) {
     irfunc->setCompilationPhaseTimer(nullptr);
     compiled_func->setHirFunc(std::move(irfunc));

cinderx/Jit/hir/hir.h

@@ -4408,9 +4408,16 @@ class Function {
 
   Environment env;
 
-  // optional property used to track time taken for individual compilation
+  // All the deopt patchers pointing to patch points in this function.
+  //
+  // These will be moved over to the CompiledFunction after compilation is
+  // complete.
+  std::vector<std::unique_ptr<DeoptPatcher>> deopt_patchers;
+
+  // Optional property used to track time taken for individual compilation
   // phases
-  std::unique_ptr<CompilationPhaseTimer> compilation_phase_timer{nullptr};
+  std::unique_ptr<CompilationPhaseTimer> compilation_phase_timer;
+
   // Return the total number of arguments (positional + kwonly + varargs +
   // varkeywords)
   int numArgs() const;
@@ -4440,6 +4447,13 @@ class Function {
 
   bool canDeopt() const;
 
+  template <typename T, typename... Args>
+  T* allocateDeoptPatcher(Args&&... args) {
+    deopt_patchers.emplace_back(
+        std::make_unique<T>(std::forward<Args>(args)...));
+    return static_cast<T*>(deopt_patchers.back().get());
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Function);
 };

cinderx/Jit/hir/simplify.cpp

@@ -978,8 +978,7 @@ Register* simplifyLoadAttrSplitDict(
 
   Register* receiver = load_attr->GetOperand(0);
   auto patchpoint = env.emitInstr<DeoptPatchpoint>(
-      Runtime::get()->allocateDeoptPatcher<SplitDictDeoptPatcher>(
-          type, name, keys));
+      env.func.allocateDeoptPatcher<SplitDictDeoptPatcher>(type, name, keys));
   patchpoint->setGuiltyReg(receiver);
   patchpoint->setDescr("SplitDictDeoptPatcher");
   env.emit<UseType>(receiver, receiver->type());
@@ -1053,7 +1052,7 @@ void emitTypeAttrDeoptPatcher(
   // notifies subtypes of the modified type, so we only have to watch the
   // object's type.
   auto patchpoint = env.emitInstr<DeoptPatchpoint>(
-      Runtime::get()->allocateDeoptPatcher<TypeAttrDeoptPatcher>(
+      env.func.allocateDeoptPatcher<TypeAttrDeoptPatcher>(
           info.py_type, info.attr_name, info.descr));
   patchpoint->setGuiltyReg(info.receiver);
   patchpoint->setDescr(description);
@@ -1139,7 +1138,7 @@ Register* simplifyLoadAttrGenericDescriptor(Env& env, const DescrInfo& info) {
     // patches on any changes to the type, since type_setattro() calls
     // PyType_Modified() before updating tp_descr_{get,set}.
     auto patchpoint = env.emitInstr<DeoptPatchpoint>(
-        Runtime::get()->allocateDeoptPatcher<TypeDeoptPatcher>(descr_type));
+        env.func.allocateDeoptPatcher<TypeDeoptPatcher>(descr_type));
     patchpoint->setGuiltyReg(info.receiver);
     patchpoint->setDescr("tp_descr_get/tp_descr_set");
   }

cinderx/Jit/runtime.h

@@ -172,13 +172,6 @@ class Runtime : public IRuntime {
   // Release any references this Runtime holds to Python objects.
   void releaseReferences();
 
-  template <typename T, typename... Args>
-  T* allocateDeoptPatcher(Args&&... args) {
-    deopt_patchers_.emplace_back(
-        std::make_unique<T>(std::forward<Args>(args)...));
-    return static_cast<T*>(deopt_patchers_.back().get());
-  }
-
   LoadAttrCache* allocateLoadAttrCache() {
     return load_attr_caches_.allocate();
   }
@@ -312,7 +305,6 @@ class Runtime : public IRuntime {
 
   // References to Python objects held by this Runtime
   std::unordered_set<ThreadedRef<PyObject>> references_;
-  std::vector<std::unique_ptr<DeoptPatcher>> deopt_patchers_;
   Builtins builtins_;
 
   std::unordered_map<BorrowedRef<PyTypeObject>, std::vector<TypeDeoptPatcher*>>

cinderx/RuntimeTests/deopt_patcher_test.cpp

@@ -91,8 +91,7 @@ def func():
   ASSERT_TRUE(term->IsReturn()) << *term;
 
   // Insert a patchpoint immediately before the return
-  jit::Runtime* jit_rt = jit::Runtime::get();
-  auto patcher = jit_rt->allocateDeoptPatcher<MyDeoptPatcher>(123);
+  auto patcher = irfunc->allocateDeoptPatcher<MyDeoptPatcher>(123);
   EXPECT_EQ(patcher->id(), 123);
   auto patchpoint = jit::hir::DeoptPatchpoint::create(patcher);
   patchpoint->InsertBefore(*term);
@@ -107,6 +106,7 @@ def func():
 
   size_t deopts = 0;
   auto callback = [&deopts](const jit::DeoptMetadata&) { deopts += 1; };
+  jit::Runtime* jit_rt = jit::Runtime::get();
   jit_rt->setGuardFailureCallback(callback);
 
   // Make sure things work in the nominal case.