Bug 1669306 - Allow JSAPI tests to opt-in to reuse a global and cx instead of tearing everything down and starting up every time. r=nbp

Cons: (1) messy, (2) may be unnecessary once Stencil allows better caching of self-hosted code.

Pros: 322x faster for testJitABIcalls.

Differential Revision: https://phabricator.services.mozilla.com/D92475

Author: hotsphink

js/src/jsapi-tests/testGCOutOfMemory.cpp

@@ -73,6 +73,4 @@ virtual JSContext* createContext() override {
   return cx;
 }
 
-virtual void destroyContext() override { JS_DestroyContext(cx); }
-
 END_TEST(testGCOutOfMemory)

js/src/jsapi-tests/testOOM.cpp

@@ -101,10 +101,14 @@ BEGIN_TEST(testHelperThreadOOM) {
 }
 
 bool init() override {
-  js::DestroyHelperThreadsState();
+  JSAPITest::uninit();              // Discard the just-created JSContext.
+  js::DestroyHelperThreadsState();  // The test creates this state.
   return true;
 }
-void uninit() override { js::CreateHelperThreadsState(); }
+void uninit() override {
+  // Leave things initialized after this test finishes.
+  js::CreateHelperThreadsState();
+}
 
 END_TEST(testHelperThreadOOM)
 

js/src/jsapi-tests/tests.cpp

@@ -17,7 +17,15 @@
 
 JSAPITest* JSAPITest::list;
 
-bool JSAPITest::init() {
+bool JSAPITest::init(JSContext* maybeReusableContext) {
+  if (maybeReusableContext && reuseGlobal) {
+    cx = maybeReusableContext;
+    global.init(cx, cx->global());
+    return init();
+  }
+
+  MaybeFreeContext(maybeReusableContext);
+
   cx = createContext();
   if (!cx) {
     return false;
@@ -32,18 +40,32 @@ bool JSAPITest::init() {
     return false;
   }
   JS::EnterRealm(cx, global);
-  return true;
+  return init();
 }
 
-void JSAPITest::uninit() {
-  if (global) {
-    JS::LeaveRealm(cx, nullptr);
-    global = nullptr;
+JSContext* JSAPITest::maybeForgetContext() {
+  if (!reuseGlobal) {
+    return nullptr;
   }
-  if (cx) {
-    destroyContext();
-    cx = nullptr;
+
+  JSContext* reusableCx = cx;
+  global.reset();
+  cx = nullptr;
+  return reusableCx;
+}
+
+/* static */
+void JSAPITest::MaybeFreeContext(JSContext* maybeCx) {
+  if (maybeCx) {
+    JS::LeaveRealm(maybeCx, nullptr);
+    JS_DestroyContext(maybeCx);
   }
+}
+
+void JSAPITest::uninit() {
+  global.reset();
+  MaybeFreeContext(cx);
+  cx = nullptr;
   msgs.clear();
 }
 
@@ -112,6 +134,17 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
+  if (filter && strcmp(filter, "--list") == 0) {
+    for (JSAPITest* test = JSAPITest::list; test; test = test->next) {
+      printf("%s\n", test->name());
+    }
+    return 0;
+  }
+
+  // Reinitializing the global for every test is quite slow, due to having to
+  // recompile all self-hosted builtins. Allow tests to opt-in to reusing the
+  // global.
+  JSContext* maybeReusedContext = nullptr;
   for (JSAPITest* test = JSAPITest::list; test; test = test->next) {
     const char* name = test->name();
     if (filter && strstr(name, filter) == nullptr) {
@@ -121,7 +154,7 @@ int main(int argc, char* argv[]) {
     total += 1;
 
     printf("%s\n", name);
-    if (!test->init()) {
+    if (!test->init(maybeReusedContext)) {
       printf("TEST-UNEXPECTED-FAIL | %s | Failed to initialize.\n", name);
       failures++;
       test->uninit();
@@ -139,8 +172,13 @@ int main(int argc, char* argv[]) {
         failures++;
       }
     }
+
+    // Return a non-nullptr pointer if the context & global can safely be
+    // reused for the next test.
+    maybeReusedContext = test->maybeForgetContext();
     test->uninit();
   }
+  JSAPITest::MaybeFreeContext(maybeReusedContext);
 
   MOZ_RELEASE_ASSERT(!JSRuntime::hasLiveRuntimes());
   JS_ShutDown();

js/src/jsapi-tests/tests.h

@@ -77,7 +77,13 @@ class JSAPITest {
   bool knownFail;
   JSAPITestString msgs;
 
-  JSAPITest() : cx(nullptr), knownFail(false) {
+  // Whether this test is willing to skip its init() and reuse a global (and
+  // JSContext etc.) from a previous test that also has reuseGlobal=true. It
+  // also means this test is willing to skip its uninit() if it is followed by
+  // another reuseGlobal test.
+  bool reuseGlobal;
+
+  JSAPITest() : cx(nullptr), knownFail(false), reuseGlobal(false) {
     next = list;
     list = this;
   }
@@ -87,7 +93,19 @@ class JSAPITest {
     MOZ_RELEASE_ASSERT(!global);
   }
 
-  virtual bool init();
+  // Initialize this test, possibly with the cx from a previously run test.
+  bool init(JSContext* maybeReusedContext);
+
+  // If this test is ok with its cx and global being reused, release this
+  // test's cx to be reused by another test.
+  JSContext* maybeForgetContext();
+
+  static void MaybeFreeContext(JSContext* maybeCx);
+
+  // The real initialization happens in init(JSContext*), above, but this
+  // method may be overridden to perform additional initialization after the
+  // JSContext and global have been created.
+  virtual bool init() { return true; }
   virtual void uninit();
 
   virtual const char* name() = 0;
@@ -353,12 +371,6 @@ class JSAPITest {
     return cx;
   }
 
-  virtual void destroyContext() {
-    MOZ_RELEASE_ASSERT(cx);
-    JS_DestroyContext(cx);
-    cx = nullptr;
-  }
-
   static void reportWarning(JSContext* cx, JSErrorReport* report) {
     MOZ_RELEASE_ASSERT(report->isWarning());