Fix native allocation tracking on Dalvik.

Fixed issue where we had inverted logic when checking for
pending exceptions.

Changed the logic to not update the native allocation watermarks
after concurrent GC since the finalizers may not have been run at
this point.

Copied over the test from ART for ensuring that it is working.

Bug: 10444866

Change-Id: Ie26170f9c4703f11e993233cdc9c5f46396fca84

2 files changed, 22 insertions, 6 deletions

diff --git a/vm/alloc/Alloc.cpp b/vm/alloc/Alloc.cpp
index 8edbbf685..3d40d1165 100644
--- a/vm/alloc/Alloc.cpp
+++ b/vm/alloc/Alloc.cpp
@@ -315,6 +315,7 @@ void dvmRunFinalization() {
   Thread *self = dvmThreadSelf();
   assert(self != NULL);
   JValue unusedResult;
+  assert(gDvm.methJavaLangSystem_runFinalization != NULL);
   dvmCallMethod(self, gDvm.methJavaLangSystem_runFinalization, NULL, &unusedResult);
 }
 
diff --git a/vm/alloc/HeapSource.cpp b/vm/alloc/HeapSource.cpp
index 2c0a47489..82c2b9e95 100644
--- a/vm/alloc/HeapSource.cpp
+++ b/vm/alloc/HeapSource.cpp
@@ -29,6 +29,7 @@
 #include "alloc/HeapBitmap.h"
 #include "alloc/HeapBitmapInlines.h"
 
+static void dvmHeapSourceUpdateMaxNativeFootprint();
 static void snapIdealFootprint();
 static void setIdealFootprint(size_t max);
 static size_t getMaximumSize(const HeapSource *hs);
@@ -183,6 +184,7 @@ struct HeapSource {
     int32_t nativeBytesAllocated;
     size_t nativeFootprintGCWatermark;
     size_t nativeFootprintLimit;
+    bool nativeNeedToRunFinalization;
 
     /*
      * State for the GC daemon.
@@ -648,6 +650,7 @@ GcHeap* dvmHeapSourceStartup(size_t startSize, size_t maximumSize,
     hs->nativeBytesAllocated = 0;
     hs->nativeFootprintGCWatermark = startSize;
     hs->nativeFootprintLimit = startSize * 2;
+    hs->nativeNeedToRunFinalization = false;
     hs->hasGcThread = false;
     hs->heapBase = (char *)base;
     hs->heapLength = length;
@@ -1408,6 +1411,11 @@ void dvmHeapSourceGrowForUtilization()
     } else {
         heap->concurrentStartBytes = freeBytes - CONCURRENT_START;
     }
+
+    /* Mark that we need to run finalizers and update the native watermarks
+     * next time we attempt to register a native allocation.
+     */
+    gHs->nativeNeedToRunFinalization = true;
 }
 
 /*
@@ -1523,6 +1531,15 @@ static void dvmHeapSourceUpdateMaxNativeFootprint()
 
 void dvmHeapSourceRegisterNativeAllocation(int bytes)
 {
+    /* If we have just done a GC, ensure that the finalizers are done and update
+     * the native watermarks.
+     */
+    if (gHs->nativeNeedToRunFinalization) {
+        dvmRunFinalization();
+        dvmHeapSourceUpdateMaxNativeFootprint();
+        gHs->nativeNeedToRunFinalization = false;
+    }
+
     android_atomic_add(bytes, &gHs->nativeBytesAllocated);
 
     if ((size_t)gHs->nativeBytesAllocated > gHs->nativeFootprintGCWatermark) {
@@ -1532,19 +1549,17 @@ void dvmHeapSourceRegisterNativeAllocation(int bytes)
          */
         if ((size_t)gHs->nativeBytesAllocated > gHs->nativeFootprintLimit) {
             Thread* self = dvmThreadSelf();
-
             dvmRunFinalization();
-            if (!dvmCheckException(self)) {
+            if (dvmCheckException(self)) {
                 return;
             }
-
             dvmLockHeap();
             bool waited = dvmWaitForConcurrentGcToComplete();
             dvmUnlockHeap();
             if (waited) {
                 // Just finished a GC, attempt to run finalizers.
                 dvmRunFinalization();
-                if (!dvmCheckException(self)) {
+                if (dvmCheckException(self)) {
                     return;
                 }
             }
@@ -1556,8 +1571,8 @@ void dvmHeapSourceRegisterNativeAllocation(int bytes)
                 dvmCollectGarbageInternal(GC_FOR_MALLOC);
                 dvmUnlockHeap();
                 dvmRunFinalization();
-
-                if (!dvmCheckException(self)) {
+                gHs->nativeNeedToRunFinalization = false;
+                if (dvmCheckException(self)) {
                     return;
                 }
             }