Add "markingMode": "none" to the android key in the app/package.json to switch the memory management to one, that will not traverse the JS heap graph

PanayotCankov · PanayotCankov · commit 70928832841b · 2017-08-24T13:44:11.000+03:00
diff --git a/.gitignore b/.gitignore
@@ -15,4 +15,8 @@ obj/
 bin/
 .svn/
 
-**/.vscode/
+**/.vscode/
+
+.project
+.DS_Store
+.settings
diff --git a/runtime/src/main/java/com/tns/AppConfig.java b/runtime/src/main/java/com/tns/AppConfig.java
@@ -17,7 +17,8 @@ private enum KnownKeys {
         GcThrottleTime("gcThrottleTime", 0),
         MemoryCheckInterval("memoryCheckInterval", 0),
         FreeMemoryRatio("freeMemoryRatio", 0.0),
-        Profiling("profiling", "");
+        Profiling("profiling", ""),
+        MarkingMode("markingMode", "Full");
 
         public static final KnownKeys[] asArray = {
             V8FlagsKey,
@@ -28,7 +29,8 @@ private enum KnownKeys {
             GcThrottleTime,
             MemoryCheckInterval,
             FreeMemoryRatio,
-            Profiling
+            Profiling,
+            MarkingMode
         };
 
         private final String name;
@@ -111,6 +113,9 @@ public AppConfig(File appDir) {
                     if (androidObject.has(KnownKeys.FreeMemoryRatio.getName())) {
                         values[KnownKeys.FreeMemoryRatio.getIndex()] = androidObject.getDouble(KnownKeys.FreeMemoryRatio.getName());
                     }
+                    if (androidObject.has(KnownKeys.MarkingMode.getName())) {
+                        values[KnownKeys.MarkingMode.getIndex()] = androidObject.getString(KnownKeys.MarkingMode.getName());
+                    }
                 }
             }
         } catch (Exception e) {
@@ -146,4 +151,5 @@ public double getFreeMemoryRatio() {
     public String getProfilingMode() {
         return (String)values[KnownKeys.Profiling.getIndex()];
     }
+    public String getMarkingMode() { return (String)values[KnownKeys.MarkingMode.getIndex()]; }
 }
diff --git a/runtime/src/main/java/com/tns/Runtime.java b/runtime/src/main/java/com/tns/Runtime.java
@@ -202,6 +202,14 @@ public DynamicConfiguration getDynamicConfig() {
         return dynamicConfig;
     }
 
+    public int getMarkingMode() {
+        String mode = staticConfiguration == null || staticConfiguration.appConfig == null ? "full" : staticConfiguration.appConfig.getMarkingMode();
+        if ("none".equals(mode)) {
+            return 1;
+        }
+        return 0;
+    }
+
     public static boolean isInitialized() {
         Runtime runtime = Runtime.getCurrentRuntime();
 
@@ -806,6 +814,38 @@ private void makeInstanceWeak(ByteBuffer buff, int length, boolean keepAsWeak) {
         }
     }
 
+    @RuntimeCallable
+    private boolean makeInstanceWeakAndCheckIfAlive(int javaObjectID) {
+        if (logger.isEnabled()) {
+            logger.write("makeInstanceWeakAndCheckIfAlive instance " + javaObjectID);
+        }
+        Object instance = strongInstances.get(javaObjectID);
+        if (instance == null) {
+            WeakReference<Object> ref = weakInstances.get(javaObjectID);
+            if (ref == null) {
+                return false;
+            } else {
+                instance = ref.get();
+                if (instance == null) {
+                    // The Java was moved from strong to weak, and then the Java instance was collected.
+                    weakInstances.remove(javaObjectID);
+                    weakJavaObjectToID.remove(Integer.valueOf(javaObjectID));
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+        } else {
+            strongInstances.delete(javaObjectID);
+            strongJavaObjectToID.remove(instance);
+
+            weakJavaObjectToID.put(instance, Integer.valueOf(javaObjectID));
+            weakInstances.put(javaObjectID, new WeakReference<Object>(instance));
+
+            return true;
+        }
+    }
+
     @RuntimeCallable
     private void checkWeakObjectAreAlive(ByteBuffer input, ByteBuffer output, int length) {
         input.position(0);
diff --git a/runtime/src/main/jni/ObjectManager.cpp b/runtime/src/main/jni/ObjectManager.cpp
@@ -17,8 +17,14 @@ using namespace v8;
 using namespace std;
 using namespace tns;
 
-ObjectManager::ObjectManager(jobject javaRuntimeObject)
-    : m_javaRuntimeObject(javaRuntimeObject), m_env(JEnv()), m_numberOfGC(0), m_currentObjectId(0), m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this) {
+ObjectManager::ObjectManager(jobject javaRuntimeObject) :
+        m_javaRuntimeObject(javaRuntimeObject),
+        m_env(JEnv()),
+        m_numberOfGC(0),
+        m_currentObjectId(0),
+        m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this),
+        m_markingMode(JavaScriptMarkingMode::Full) {
+
     auto runtimeClass = m_env.FindClass("com/tns/Runtime");
     assert(runtimeClass != nullptr);
 
@@ -31,6 +37,9 @@ ObjectManager::ObjectManager(jobject javaRuntimeObject)
     MAKE_INSTANCE_WEAK_BATCH_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeak", "(Ljava/nio/ByteBuffer;IZ)V");
     assert(MAKE_INSTANCE_WEAK_BATCH_METHOD_ID != nullptr);
 
+    MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeakAndCheckIfAlive", "(I)Z");
+    assert(MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID != nullptr);
+
     CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "checkWeakObjectAreAlive", "(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;I)V");
     assert(CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID != nullptr);
 
@@ -45,6 +54,14 @@ ObjectManager::ObjectManager(jobject javaRuntimeObject)
 
     auto useGlobalRefs = m_env.CallStaticBooleanMethod(runtimeClass, useGlobalRefsMethodID);
     m_useGlobalRefs = useGlobalRefs == JNI_TRUE;
+
+    auto getMarkingModeMethodID = m_env.GetMethodID(runtimeClass, "getMarkingMode", "()I");
+    jint markingMode = m_env.CallIntMethod(m_javaRuntimeObject, getMarkingModeMethodID);
+    switch(markingMode) {
+        case 1:
+            m_markingMode = JavaScriptMarkingMode::None;
+            break;
+    }
 }
 
 void ObjectManager::SetInstanceIsolate(Isolate* isolate) {
@@ -57,8 +74,10 @@ void ObjectManager::Init(Isolate* isolate) {
     auto jsWrapperFunc = jsWrapperFuncTemplate->GetFunction();
     m_poJsWrapperFunc = new Persistent<Function>(isolate, jsWrapperFunc);
 
-    isolate->AddGCPrologueCallback(ObjectManager::OnGcStartedStatic, kGCTypeAll);
-    isolate->AddGCEpilogueCallback(ObjectManager::OnGcFinishedStatic, kGCTypeAll);
+    if (m_markingMode != JavaScriptMarkingMode::None) {
+        isolate->AddGCPrologueCallback(ObjectManager::OnGcStartedStatic, kGCTypeAll);
+        isolate->AddGCEpilogueCallback(ObjectManager::OnGcFinishedStatic, kGCTypeAll);
+    }
 }
 
 
@@ -211,7 +230,11 @@ void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jcl
     auto state = new ObjectWeakCallbackState(this, jsInstanceInfo, objectHandle);
 
     // subscribe for JS GC event
-    objectHandle->SetWeak(state, JSObjectWeakCallbackStatic, WeakCallbackType::kFinalizer);
+    if (m_markingMode == JavaScriptMarkingMode::None) {
+        objectHandle->SetWeak(state, JSObjectFinalizerStatic, WeakCallbackType::kFinalizer);
+    } else {
+        objectHandle->SetWeak(state, JSObjectWeakCallbackStatic, WeakCallbackType::kFinalizer);
+    }
 
     auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
 
@@ -263,6 +286,56 @@ void ObjectManager::JSObjectWeakCallbackStatic(const WeakCallbackInfo<ObjectWeak
     thisPtr->JSObjectWeakCallback(isolate, callbackState);
 }
 
+void ObjectManager::JSObjectFinalizerStatic(const WeakCallbackInfo<ObjectWeakCallbackState>& data) {
+    ObjectWeakCallbackState* callbackState = data.GetParameter();
+
+    ObjectManager* thisPtr = callbackState->thisPtr;
+
+    auto isolate = data.GetIsolate();
+
+    thisPtr->JSObjectFinalizer(isolate, callbackState);
+}
+
+void ObjectManager::JSObjectFinalizer(Isolate* isolate, ObjectWeakCallbackState* callbackState) {
+    Persistent<Object>* po = callbackState->target;
+
+    auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
+    auto jsInstance = po->Get(m_isolate);
+    auto jsInfo = jsInstance->GetInternalField(jsInfoIdx);
+    if (jsInfo->IsUndefined()) {
+        // Typescript object layout has an object instance as child of the actual registered instance. checking for that
+        auto prototypeObject = jsInstance->GetPrototype().As<Object>();
+        if (!prototypeObject.IsEmpty() && prototypeObject->IsObject()) {
+            DEBUG_WRITE("GetJSInstanceInfo: need to check prototype :%d", prototypeObject->GetIdentityHash());
+            if (IsJsRuntimeObject(prototypeObject)) {
+                jsInfo = prototypeObject->GetInternalField(jsInfoIdx);
+            }
+        }
+    }
+
+    if (jsInfo.IsEmpty() || !jsInfo->IsExternal()) {
+        // The JavaScript instance has been forcefully disconnected from the Java instance.
+        po->Reset();
+        return;
+    }
+
+    auto external = jsInfo.As<External>();
+    auto jsInstanceInfo = static_cast<JSInstanceInfo *>(external->Value());
+    auto javaObjectID = jsInstanceInfo->JavaObjectID;
+
+    jboolean isJavaInstanceAlive = m_env.CallBooleanMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID, javaObjectID);
+    if (isJavaInstanceAlive) {
+        // If the Java instance is alive, keep the JavaScript instance alive.
+        // TODO: Check should we really register the finalizer again?
+        po->SetWeak(callbackState, JSObjectFinalizerStatic, WeakCallbackType::kFinalizer);
+    } else {
+        // If the Java instance is dead, this JavaScript instance can be let die.
+        delete jsInstanceInfo;
+        jsInstance->SetInternalField(jsInfoIdx, Undefined(m_isolate));
+        po->Reset();
+    }
+}
+
 /*
  * When JS GC happens change state of the java counterpart to mirror state of JS object and REVIVE the JS object unconditionally
  * "Regular" js objects are pushed into the "regular objects" array
diff --git a/runtime/src/main/jni/ObjectManager.h b/runtime/src/main/jni/ObjectManager.h
@@ -57,6 +57,18 @@ class ObjectManager {
             END
         };
 
+        enum class JavaScriptMarkingMode {
+            /**
+             * For JavaScript instances with implementation objects that were marked for collection,
+             * MarkReachableObjects will scann the whole graph of reachable objects and keep strong reference to
+             * the Java instances of implementation objects.
+             */
+            Full,
+            /**
+             * Fully suppress the MarkReachableObjects.
+             */
+            None
+        };
 
     private:
 
@@ -142,8 +154,12 @@ class ObjectManager {
 
         static void JSObjectWeakCallbackStatic(const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);
 
+        static void JSObjectFinalizerStatic(const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);
+
         void JSObjectWeakCallback(v8::Isolate* isolate, ObjectWeakCallbackState* callbackState);
 
+        void JSObjectFinalizer(v8::Isolate* isolate, ObjectWeakCallbackState* callbackState);
+
         bool HasImplObject(v8::Isolate* isolate, const v8::Local<v8::Object>& obj);
 
         void MarkReachableObjects(v8::Isolate* isolate, const v8::Local<v8::Object>& obj);
@@ -196,6 +212,8 @@ class ObjectManager {
 
         bool m_useGlobalRefs;
 
+        JavaScriptMarkingMode m_markingMode;
+
         jclass JAVA_LANG_CLASS;
 
         jmethodID GET_NAME_METHOD_ID;
@@ -206,6 +224,8 @@ class ObjectManager {
 
         jmethodID MAKE_INSTANCE_WEAK_BATCH_METHOD_ID;
 
+        jmethodID MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID;
+
         jmethodID CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID;
 
         v8::Persistent<v8::Function>* m_poJsWrapperFunc;
diff --git a/test-app/app/src/main/assets/app/package.json b/test-app/app/src/main/assets/app/package.json
@@ -5,6 +5,7 @@
 		"profilerOutputDir": "",
 		"gcThrottleTime": 500,
 		"memoryCheckInterval": 10,
-		"freeMemoryRatio": 0.50
+		"freeMemoryRatio": 0.50,
+		"markingMode": "full"
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`"profilerOutputDir": "",`
`6`	`6`	`"gcThrottleTime": 500,`
`7`	`7`	`"memoryCheckInterval": 10,`
`8`		`- "freeMemoryRatio": 0.50`
	`8`	`+ "freeMemoryRatio": 0.50,`
	`9`	`+ "markingMode": "full"`
`9`	`10`	`}`
`10`	`11`	`}`