Set Android/V8 memory limits from dalvik.vm.heapsize.

webkit/glue/webkitplatformsupport_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/glue/webkitplatformsupport_impl.h"
 
 #if defined(OS_LINUX)
 #include <malloc.h>
 #endif
 
 #include <math.h>
 
 #include <vector>
 
+#if defined(OS_ANDROID)
+#include <sys/system_properties.h>
+#endif
+
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/platform_file.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "grit/webkit_chromium_resources.h"
 #include "grit/webkit_resources.h"
 #include "grit/webkit_strings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCookie.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrameClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginListBuilder.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
+#if defined(OS_ANDROID)
+#include "webkit/glue/dalvik_heap_size_android.h"
+#endif
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/websocketstreamhandle_impl.h"
 #include "webkit/glue/webthread_impl.h"
 #include "webkit/glue/weburlloader_impl.h"
 #include "webkit/glue/worker_task_runner.h"
 #include "webkit/media/audio_decoder.h"
 #include "webkit/plugins/npapi/plugin_instance.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_LINUX)
@@ skipping 563 matching lines @@
   return 0;
 }
 
 WebKit::WebString WebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
     const WebKit::WebString& challenge,
     const WebKit::WebURL& url) {
   return WebKit::WebString("");
 }
 
-#if defined(OS_LINUX)
-static size_t memoryUsageMBLinux() {
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+static size_t memoryUsageMB() {
   struct mallinfo minfo = mallinfo();
   uint64_t mem_usage =
 #if defined(USE_TCMALLOC)
       minfo.uordblks
 #else
       (minfo.hblkhd + minfo.arena)
 #endif
       >> 20;
 
   v8::HeapStatistics stat;
   v8::V8::GetHeapStatistics(&stat);
   return mem_usage + (static_cast<uint64_t>(stat.total_heap_size()) >> 20);
 }
-#endif
-
-#if defined(OS_MACOSX)
-static size_t memoryUsageMBMac() {
+#elif defined(OS_MACOSX)
+static size_t memoryUsageMB() {
   using base::ProcessMetrics;
   static ProcessMetrics* process_metrics =
       // The default port provider is sufficient to get data for the current
       // process.
       ProcessMetrics::CreateProcessMetrics(base::GetCurrentProcessHandle(),
                                            NULL);
   DCHECK(process_metrics);
   return process_metrics->GetWorkingSetSize() >> 20;
 }
-#endif
-
-#if !defined(OS_LINUX) && !defined(OS_MACOSX)
-static size_t memoryUsageMBGeneric() {
+#else
+static size_t memoryUsageMB() {
   using base::ProcessMetrics;
   static ProcessMetrics* process_metrics =
       ProcessMetrics::CreateProcessMetrics(base::GetCurrentProcessHandle());
   DCHECK(process_metrics);
   return process_metrics->GetPagefileUsage() >> 20;
 }
 #endif
 
 static size_t getMemoryUsageMB(bool bypass_cache) {
   size_t current_mem_usage = 0;
   MemoryUsageCache* mem_usage_cache_singleton = MemoryUsageCache::GetInstance();
   if (!bypass_cache &&
       mem_usage_cache_singleton->IsCachedValueValid(&current_mem_usage))
     return current_mem_usage;
 
-  current_mem_usage =
-#if defined(OS_LINUX)
-      memoryUsageMBLinux();
-#elif defined(OS_MACOSX)
-      memoryUsageMBMac();
-#else
-      memoryUsageMBGeneric();
-#endif
+  current_mem_usage = memoryUsageMB();
   mem_usage_cache_singleton->SetMemoryValue(current_mem_usage);
   return current_mem_usage;
 }
 
 size_t WebKitPlatformSupportImpl::memoryUsageMB() {
   return getMemoryUsageMB(false);
 }
 
 size_t WebKitPlatformSupportImpl::actualMemoryUsageMB() {
   return getMemoryUsageMB(true);
 }
 
+#if defined(OS_ANDROID)
+size_t WebKitPlatformSupportImpl::lowMemoryUsageMB() {
+  // If memory usage is below this threshold, do not bother forcing GC.

[darin (slow to review), 2012/05/14 16:23:49]

Are you expecting this function to be called on multiple threads?

I'm pretty sure that using the Singleton pattern to allocate a DalvikHeapSize
object is overkill.  You just have an integer value that could be held as a
static.  If you need it to be a thread-safe static, then perhaps you should use
LazyInstance.  But, I'd expect that a simple global function to query the dalvik
heapsize would do.

  size_t QueryDalvikVMHeapSize();

I'm also curious if this should be part of base/sys_info.h instead.

[ulan, 2012/05/15 12:44:03]

Thanks, converted DalvikHeapSize to LazyInstance since it can be called from
multiple threads.

Moved it to base/android and made it accessible via a static method of SysInfo.

+  // Allow us to use up to our memory class value before V8's GC kicks in.
+  // These values have been determined by experimentation.
+  DalvikHeapSize* heap_size_singleton = DalvikHeapSize::GetInstance();
+  return heap_size_singleton->HeapSizeMB() / 4;
+}
+
+size_t WebKitPlatformSupportImpl::highMemoryUsageMB() {
+  // If memory usage is above this threshold, force GC more aggressively.
+  return lowMemoryUsageMB() * 2;
+}
+
+size_t WebKitPlatformSupportImpl::highUsageDeltaMB() {
+  // Threshold of delta of memory usage growth (vs. last working set estimate)
+  // to force GC when memory usage is high.
+  // Avoid constant V8 GC when memory usage equals to working set estimate.
+  return lowMemoryUsageMB() / 2;
+}
+#endif
+
 void WebKitPlatformSupportImpl::SuspendSharedTimer() {
   ++shared_timer_suspended_;
 }
 
 void WebKitPlatformSupportImpl::ResumeSharedTimer() {
   // The shared timer may have fired or been adjusted while we were suspended.
   if (--shared_timer_suspended_ == 0 && !shared_timer_.IsRunning()) {
     setSharedTimerFireInterval(
         shared_timer_fire_time_ - monotonicallyIncreasingTime());
   }
@@ skipping 12 matching lines @@
   worker_task_runner->OnWorkerRunLoopStarted(runLoop);
 }
 
 void WebKitPlatformSupportImpl::didStopWorkerRunLoop(
     const WebKit::WebWorkerRunLoop& runLoop) {
   WorkerTaskRunner* worker_task_runner = WorkerTaskRunner::Instance();
   worker_task_runner->OnWorkerRunLoopStopped(runLoop);
 }
 
 }  // namespace webkit_glue