Unregister TimeLimit in Runtime destructor

Summary:
Provide a mechanism to register a list of callbacks to call during runtime destruction.
`TimeLimitMonitor` leverages this mechanism to unregister the monitoring.

Reviewed By: davedets

Differential Revision: D16677617

fbshipit-source-id: f2bc1d4fca1507a6a3f4e112fd2490d50045fe2e

include/hermes/VM/Runtime.h

@@ -96,6 +96,8 @@ using VMExperimentFlags = uint32_t;
 /// Type used to assign object unique integer identifiers.
 using ObjectID = uint32_t;
 
+using DestructionCallback = std::function<void(Runtime *)>;
+
 #define PROP_CACHE_IDS(V) V(RegExpLastIndex, Predefined::lastIndex)
 
 /// Fixed set of ids used by the property cache in Runtime.
@@ -474,6 +476,12 @@ class Runtime : public HandleRootOwner,
   }
 #endif
 
+  /// Register \p callback which will be called
+  /// during runtime destruction.
+  void registerDestructionCallback(DestructionCallback callback) {
+    destructionCallbacks_.emplace_back(callback);
+  }
+
 #ifdef HERMES_ENABLE_DEBUGGER
   /// Encapsulates useful information about a stack frame, needed by the
   /// debugger. It requres extra context and cannot be extracted from a
@@ -978,6 +986,9 @@ class Runtime : public HandleRootOwner,
   /// we are sure it's safe to unregisterRuntime in destructor.
   std::shared_ptr<SamplingProfiler> samplingProfiler_;
 
+  /// A list of callbacks to call before runtime destruction.
+  std::vector<DestructionCallback> destructionCallbacks_;
+
 #if defined(HERMES_ENABLE_DEBUGGER) || defined(HERMESVM_TIMELIMIT)
   /// An atomic boolean set when an async pause is requested.
   /// This may be manipulated from multiple threads.

lib/VM/Runtime.cpp

@@ -367,6 +367,10 @@ Runtime::~Runtime() {
     // Calling delete will automatically remove it from the list.
     delete &runtimeModuleList_.back();
   }
+
+  for (auto callback : destructionCallbacks_) {
+    callback(this);
+  }
 }
 
 /// A helper class used to measure the duration of GC marking different roots.

lib/VM/TimeLimitMonitor.cpp

@@ -89,13 +89,20 @@ void TimeLimitMonitor::watchRuntime(Runtime *runtime, int timeoutInMs) {
         std::chrono::milliseconds(timeoutInMs);
     timeoutMap_[runtime] = deadline;
   }
+
+  runtime->registerDestructionCallback(
+      [this](Runtime *runtime) { this->unwatchRuntime(runtime); });
+
   // There is only one thread anyway.
   newRequestCond_.notify_one();
 }
 
 void TimeLimitMonitor::unwatchRuntime(Runtime *runtime) {
   std::lock_guard<std::mutex> lock(timeoutMapMtx_);
-  timeoutMap_.erase(runtime);
+  // unwatchRuntime() may be called multiple times for the same runtime.
+  if (timeoutMap_.find(runtime) != timeoutMap_.end()) {
+    timeoutMap_.erase(runtime);
+  }
 }
 
 } // namespace vm