perf: cheaper object construction; drop markingMode full (#2093)

* test: benchmark the object lifecycle phases and many live wrappers

Splits a wrapped object's cost into allocation (kept alive), release through
a V8 GC and the Java GC that follows, for JS-constructed, JS-extended and
Java-returned objects; and times an object return with 50k live wrappers.

* perf: trim per-construction work in RegisterInstance

- EncodeSignature formatted the argument count through a std::stringstream
  on every constructor and dynamic method resolution; it now appends
  std::to_string into a reserved buffer.
- The instance's class is the global ref ResolveClass already returned from
  the class cache, so the second FindClass(fullClassName) lookup is gone.
- JsArgConverter skips parsing the signature of a zero-argument constructor.
- makeInstanceStrong skips storeClass, which takes two locks, when the
  previous registration stored the same class.

* refactor: remove the markingMode "full" machinery

Only markingMode "none" is supported. "full" was already non-functional:
its weak callback queued wrappers for processing that no longer existed, so
they were revived forever.

- ObjectManager always arms the finalizer path; the full-mode weak callback,
  its GC bookkeeping, the batch DirectBuffer plumbing and the unused
  declarations behind it are gone, as are DirectBuffer itself and the Java
  makeInstanceWeak(ByteBuffer)/checkWeakObjectAreAlive/getMarkingModeOrdinal.
- AppConfig drops the key (native config indices shift accordingly) and logs
  a warning when an app still sets markingMode to anything but "none".
- The __markingMode global is gone; testGC.js no longer gates on it, so its
  specs now run (they pass under the finalizer path).

* refactor: pass the native startup options by name

initNativeScript received AppConfig's whole value array and the native side
read five entries by KnownKeys ordinal, so removing or reordering a key
silently shifted them (and read past the end under CheckJNI). The five
values are now explicit initNativeScript parameters, gathered into a
Runtime::StartupOptions on the native side.

* test: keep the 50k wrappers pinned while their benchmark is timed

Author: edusperoni

test-app/app/src/main/assets/app/package.json

@@ -6,7 +6,6 @@
 		"gcThrottleTime": 500,
 		"memoryCheckInterval": 10,
 		"freeMemoryRatio": 0.50,
-		"markingMode": "none",
 		"maxLogcatObjectSize": 1024,
 		"forceLog": false,
 		"suppressCallJSMethodExceptions": false,

test-app/app/src/main/assets/app/tests/benchmarks/jniBenchmarks.js

@@ -53,6 +53,41 @@ function measureCallback(name, cb, kind, iterations) {
     return report(name, samples);
 }
 
+
+// Splits an object's lifecycle into allocation (objects kept alive), release through a
+// V8 GC (wrapper finalization and the Java-side strong -> weak bookkeeping), and the
+// Java GC that follows. Each phase is reported per object.
+function measureLifecycle(name, count, create) {
+    if (FILTER && name.indexOf(FILTER) < 0) return null;
+    count *= SCALE;
+    var javaRuntime = java.lang.Runtime.getRuntime();
+    var alloc = [], release = [], javaGc = [];
+    var warm = [];
+    for (var w = 0; w < Math.max(1000, count >> 2); w++) warm.push(create());
+    warm = null;
+    gc();
+    javaRuntime.gc();
+    for (var r = 0; r < ROUNDS; r++) {
+        var kept = new Array(count);
+        var start = performance.now();
+        for (var i = 0; i < count; i++) kept[i] = create();
+        alloc.push((performance.now() - start) * 1e6 / count);
+
+        kept = null;
+        start = performance.now();
+        gc();
+        release.push((performance.now() - start) * 1e6 / count);
+
+        start = performance.now();
+        javaRuntime.gc();
+        javaGc.push((performance.now() - start) * 1e6 / count);
+    }
+    report(name + " [alloc, kept alive]", alloc);
+    report(name + " [release: V8 gc]", release);
+    return report(name + " [release: Java gc]", javaGc);
+}
+
+
 function buildBenchmarks() {
     var bench = new JniBench();
     var other = bench.getOther();
@@ -244,6 +279,35 @@ function buildBenchmarks() {
                 return s;
             });
         },
+        function () {
+            return measureLifecycle("lifecycle new java.lang.Object()", 20000, function () {
+                return new java.lang.Object();
+            });
+        },
+        function () {
+            return measureLifecycle("lifecycle new Object.extend({})()", 20000, function () {
+                return new Extended();
+            });
+        },
+        function () {
+            return measureLifecycle("lifecycle JniBench.newObjectInJava()", 20000, function () {
+                return JniBench.newObjectInJava();
+            });
+        },
+        function () {
+            if (FILTER && "instance.self() [50k live wrappers]".indexOf(FILTER) < 0) return null;
+            var live = new Array(50000);
+            for (var i = 0; i < live.length; i++) live[i] = new java.lang.Object();
+            // Pinned from a global: an optimized frame may drop a local after its last use.
+            globalThis.__jniBenchLive = live;
+            var result = measureJs("instance.self() [50k live wrappers]", 50000, function (n) {
+                var s;
+                for (var i = 0; i < n; i++) s = bench.self();
+                return s;
+            });
+            globalThis.__jniBenchLive = null;
+            return result;
+        },
         function () {
             return measureCallback("callback.noArgs()", callback, 0, 20000);
         },

test-app/app/src/main/assets/app/tests/testGC.js

@@ -1,7 +1,4 @@
-// Run GC tests only in Full marking mode
-let describeFunc = __markingMode == 0 ? describe : xdescribe;
-
-describeFunc("Tests garbage collection", function () {
+describe("Tests garbage collection", function () {
 	var myCustomEquality = function(first, second) {
 		return first == second;
 	};

test-app/runtime/CMakeLists.txt

@@ -182,7 +182,6 @@ add_library(
         src/main/cpp/ConcurrentQueue.cpp
         src/main/cpp/Constants.cpp
         src/main/cpp/CrashBreadcrumbs.cpp
-        src/main/cpp/DirectBuffer.cpp
         src/main/cpp/ErrorEvents.cpp
         src/main/cpp/EventLoop.cpp
         src/main/cpp/Events.cpp

test-app/runtime/src/main/cpp/CallbackHandlers.cpp

@@ -154,8 +154,8 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local<Object> &j
     success = !localInstance.IsNull();
 
     if (success) {
-        jclass instanceClass = env.FindClass(fullClassName);
-        objectManager->SetJavaClass(jsObject, instanceClass);
+        // ResolveClass returned the class cache's global ref for fullClassName.
+        objectManager->SetJavaClass(jsObject, generatedJavaClass);
     } else {
         DEBUG_WRITE_FORCE("RegisterInstance failed with null new instance class: %s",
                           fullClassName.c_str());

test-app/runtime/src/main/cpp/DirectBuffer.cpp

@@ -85,8 +85,10 @@ JsArgConverter::JsArgConverter(const v8::FunctionCallbackInfo<Value> &args,
           m_error(Error()) {
     m_argsLen = args.Length();
 
-    JniSignatureParser parser(methodSignature);
-    m_ownedTokens = parser.Parse();
+    if (m_argsLen > 0) {
+        JniSignatureParser parser(methodSignature);
+        m_ownedTokens = parser.Parse();
+    }
 
     for (int i = 0; i < m_argsLen; i++) {
         m_isValid = ConvertArg(args[i], i);

test-app/runtime/src/main/cpp/DirectBuffer.h

@@ -13,7 +13,6 @@
 #include "NativeScriptException.h"
 #include "Runtime.h"
 #include "ObjectManager.h"
-#include <sstream>
 
 using namespace v8;
 
@@ -111,19 +110,14 @@ MethodCache::CacheMethodInfo MethodCache::ResolveConstructorSignature(const Args
 
 // Encoded signature <className>.S/I.<methodName>.<argsCount>.<arg1class>.<...>
 string MethodCache::EncodeSignature(const string& className, const string& methodName, const FunctionCallbackInfo<Value>& args, bool isStatic) {
-    string sig(className);
-    sig.append(".");
-    if (isStatic) {
-        sig.append("S.");
-    } else {
-        sig.append("I.");
-    }
+    int len = args.Length();
+    string sig;
+    sig.reserve(className.size() + methodName.size() + 8 + len * 12);
+    sig.append(className);
+    sig.append(isStatic ? ".S." : ".I.");
     sig.append(methodName);
     sig.append(".");
-    int len = args.Length();
-    stringstream s;
-    s << len;
-    sig.append(s.str());
+    sig.append(std::to_string(len));
 
     for (int i = 0; i < len; i++) {
         sig.append(".");