base: Discardable memory types.

base/memory/discardable_memory_android.cc

 // Copyright (c) 2013 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 "base/memory/discardable_memory_android.h"
 
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <limits>
 
 #include "base/android/sys_utils.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/discardable_memory.h"
 #include "base/memory/discardable_memory_allocator_android.h"
+#include "base/memory/discardable_memory_emulated.h"
 #include "base/synchronization/lock.h"
 #include "third_party/ashmem/ashmem.h"
 
 namespace base {
 namespace {
 
 const size_t kPageSize = 4096;
 
 const char kAshmemAllocatorName[] = "DiscardableMemoryAllocator";
 
@@ skipping 58 matching lines @@
         size_(size) {
     DCHECK_GE(fd_, 0);
     DCHECK(memory_);
   }
 
   virtual ~DiscardableMemoryAndroidSimple() {
     internal::CloseAshmemRegion(fd_, size_, memory_);
   }
 
   // DiscardableMemory:
-  virtual LockDiscardableMemoryStatus Lock() OVERRIDE {
+  virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
     return internal::LockAshmemRegion(fd_, 0, size_, memory_);
   }
 
   virtual void Unlock() OVERRIDE {
     internal::UnlockAshmemRegion(fd_, 0, size_, memory_);
   }
 
   virtual void* Memory() const OVERRIDE {
     return memory_;
   }
@@ skipping 69 matching lines @@
   AutoLock lock(g_context.Get().lock);
   g_context.Get().decrement_ashmem_fd_count();
   if (munmap(address, size) == -1) {
     DPLOG(ERROR) << "Failed to unmap memory.";
     close(fd);
     return false;
   }
   return close(fd) == 0;
 }
 
-LockDiscardableMemoryStatus LockAshmemRegion(int fd,
+DiscardableMemoryLockStatus LockAshmemRegion(int fd,
                                              size_t off,
                                              size_t size,
                                              const void* address) {
   const int result = ashmem_pin_region(fd, off, size);
   DCHECK_EQ(0, mprotect(address, size, PROT_READ | PROT_WRITE));
-  return result == ASHMEM_WAS_PURGED ?
-      DISCARDABLE_MEMORY_PURGED : DISCARDABLE_MEMORY_SUCCESS;
+  return result == ASHMEM_WAS_PURGED ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
+                                     : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
 }
 
 bool UnlockAshmemRegion(int fd, size_t off, size_t size, const void* address) {
   const int failed = ashmem_unpin_region(fd, off, size);
   if (failed)
     DLOG(ERROR) << "Failed to unpin memory.";
   // This allows us to catch accesses to unlocked memory.
   DCHECK_EQ(0, mprotect(address, size, PROT_NONE));
   return !failed;
 }
 
 }  // namespace internal
 
 // static
-bool DiscardableMemory::SupportedNatively() {
-  return true;
+void DiscardableMemory::GetSupportedTypes(
+    std::vector<DiscardableMemoryType>* types) {
+  const DiscardableMemoryType supported_types[] = {
+    DISCARDABLE_MEMORY_TYPE_ANDROID,
+    DISCARDABLE_MEMORY_TYPE_EMULATED
+  };
+  types->assign(supported_types, supported_types + arraysize(supported_types));
 }
 
 // Allocation can happen in two ways:
 // - Each client-requested allocation is backed by an individual ashmem region.
 // This allows deleting ashmem regions individually by closing the ashmem file
 // descriptor. This is the default path that is taken when file descriptor usage
 // allows us to do so or when the allocation size would require and entire
 // ashmem region.
 // - Allocations are performed by the global allocator when file descriptor
 // usage gets too high. This still allows unpinning but does not allow deleting
 // (i.e. releasing the physical pages backing) individual regions.
 //
 // TODO(pliard): consider tuning the size threshold used below. For instance we
 // might want to make it a fraction of kMinAshmemRegionSize and also
 // systematically have small allocations go through the allocator to let big
 // allocations systematically go through individual ashmem regions.
 //
 // static
 scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemory(
-    size_t size) {
-  if (!CheckSizeCanBeAlignedToNextPage(size))
-    return scoped_ptr<DiscardableMemory>();
-  // Pinning & unpinning works with page granularity therefore align the size
-  // upfront.
-  const size_t aligned_size = internal::AlignToNextPage(size);
-  // Note that the following code is slightly racy. The worst that can happen in
-  // practice though is taking the wrong decision (e.g. using the allocator
-  // rather than DiscardableMemoryAndroidSimple). Moreover keeping the lock
-  // acquired for the whole allocation would cause a deadlock when the allocator
-  // tries to create an ashmem region.
-  GlobalContext* const global_context = g_context.Pointer();
-  if (GetCurrentNumberOfAshmemFDs() < 0.9 * global_context->ashmem_fd_limit) {
-    int fd;
-    void* address;
-    if (internal::CreateAshmemRegion("", aligned_size, &fd, &address)) {
-      return scoped_ptr<DiscardableMemory>(
-          new DiscardableMemoryAndroidSimple(fd, address, aligned_size));
+    DiscardableMemoryType type, size_t size) {
+  switch (type) {
+    case DISCARDABLE_MEMORY_TYPE_NONE:
+    case DISCARDABLE_MEMORY_TYPE_MAC:
+      return scoped_ptr<DiscardableMemory>();
+    case DISCARDABLE_MEMORY_TYPE_ANDROID: {
+      if (!CheckSizeCanBeAlignedToNextPage(size))
+        return scoped_ptr<DiscardableMemory>();
+      // Pinning & unpinning works with page granularity therefore align the
+      // size upfront.
+      const size_t aligned_size = internal::AlignToNextPage(size);
+      // Note that the following code is slightly racy. The worst that can
+      // happen in practice though is taking the wrong decision (e.g. using
+      // the allocator rather than DiscardableMemoryAndroidSimple). Moreover
+      // keeping the lock acquired for the whole allocation would cause a
+      // deadlock when the allocator tries to create an ashmem region.
+      GlobalContext* const global_context = g_context.Pointer();
+      if (GetCurrentNumberOfAshmemFDs() <
+          0.9 * global_context->ashmem_fd_limit) {
+        int fd;
+        void* address;
+        if (internal::CreateAshmemRegion("", aligned_size, &fd, &address)) {
+          return scoped_ptr<DiscardableMemory>(
+              new DiscardableMemoryAndroidSimple(fd, address, aligned_size));
+        }
+      }
+      return global_context->allocator.Allocate(size);
+    }
+    case DISCARDABLE_MEMORY_TYPE_EMULATED: {
+      scoped_ptr<internal::DiscardableMemoryEmulated> memory(
+          new internal::DiscardableMemoryEmulated(size));
+      if (!memory->Initialize())
+        return scoped_ptr<DiscardableMemory>();
+
+      return memory.PassAs<DiscardableMemory>();
     }
   }
-  return global_context->allocator.Allocate(size);
+
+  NOTREACHED();
+  return scoped_ptr<DiscardableMemory>();
 }
 
 // static
 bool DiscardableMemory::PurgeForTestingSupported() {
   return false;
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace base