Align ashmem region sizes to page size after ashmem creation failed.

base/memory/discardable_memory_allocator_android.cc

 // Copyright 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_allocator_android.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <utility>
@@ skipping 28 matching lines @@
 // currently the maximum allowed). If the client requests 4096 bytes and a free
 // chunk of 8192 bytes is available then the free chunk gets splitted into two
 // pieces to minimize fragmentation (since 8192 - 4096 = 4096 which is greater
 // than 4095).
 // TODO(pliard): tune this if splitting chunks too often leads to performance
 // issues.
 const size_t kMaxChunkFragmentationBytes = 4096 - 1;
 
 const size_t kMinAshmemRegionSize = 32 * 1024 * 1024;
 
+// Returns 0 if the provided size is too high to be aligned.
+size_t AlignToNextPage(size_t size) {
+  const size_t kPageSize = 4096;
+  DCHECK_EQ(static_cast<int>(kPageSize), getpagesize());
+  if (size > std::numeric_limits<size_t>::max() - kPageSize + 1)
+    return 0;
+  const size_t mask = ~(kPageSize - 1);
+  return (size + kPageSize - 1) & mask;
+}
+
 }  // namespace
 
 namespace internal {
 
 class DiscardableMemoryAllocator::DiscardableAshmemChunk
     : public DiscardableMemory {
  public:
   // Note that |ashmem_region| must outlive |this|.
   DiscardableAshmemChunk(AshmemRegion* ashmem_region,
                          int fd,
@@ skipping 40 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DiscardableAshmemChunk);
 };
 
 class DiscardableMemoryAllocator::AshmemRegion {
  public:
   // Note that |allocator| must outlive |this|.
   static scoped_ptr<AshmemRegion> Create(
       size_t size,
       const std::string& name,
       DiscardableMemoryAllocator* allocator) {
-    DCHECK_EQ(size, internal::AlignToNextPage(size));
+    DCHECK_EQ(size, AlignToNextPage(size));
     int fd;
     void* base;
     if (!internal::CreateAshmemRegion(name.c_str(), size, &fd, &base))
       return scoped_ptr<AshmemRegion>();
     return make_scoped_ptr(new AshmemRegion(fd, size, base, allocator));
   }
 
   virtual ~AshmemRegion() {
     const bool result = internal::CloseAshmemRegion(fd_, size_, base_);
     DCHECK(result);
@@ skipping 244 matching lines @@
 DiscardableMemoryAllocator::DiscardableAshmemChunk::~DiscardableAshmemChunk() {
   if (locked_)
     internal::UnlockAshmemRegion(fd_, offset_, size_, address_);
   ashmem_region_->OnChunkDeletion(address_, size_);
 }
 
 DiscardableMemoryAllocator::DiscardableMemoryAllocator(
     const std::string& name,
     size_t ashmem_region_size)
     : name_(name),
-      ashmem_region_size_(std::max(kMinAshmemRegionSize, ashmem_region_size)) {
+      ashmem_region_size_(
+          std::max(kMinAshmemRegionSize, AlignToNextPage(ashmem_region_size))),
+      last_ashmem_region_size_(0) {
   DCHECK_GE(ashmem_region_size_, kMinAshmemRegionSize);
 }
 
 DiscardableMemoryAllocator::~DiscardableMemoryAllocator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(ashmem_regions_.empty());
 }
 
 scoped_ptr<DiscardableMemory> DiscardableMemoryAllocator::Allocate(
     size_t size) {
-  const size_t aligned_size = internal::AlignToNextPage(size);
+  const size_t aligned_size = AlignToNextPage(size);
   if (!aligned_size)
     return scoped_ptr<DiscardableMemory>();
   // TODO(pliard): make this function less naive by e.g. moving the free chunks
   // multiset to the allocator itself in order to decrease even more
   // fragmentation/speedup allocation. Note that there should not be more than a
   // couple (=5) of AshmemRegion instances in practice though.
   AutoLock auto_lock(lock_);
   DCHECK_LE(ashmem_regions_.size(), 5U);
   for (ScopedVector<AshmemRegion>::iterator it = ashmem_regions_.begin();
        it != ashmem_regions_.end(); ++it) {
     scoped_ptr<DiscardableMemory> memory(
         (*it)->Allocate_Locked(size, aligned_size));
     if (memory)
       return memory.Pass();
   }
   // The creation of the (large) ashmem region might fail if the address space
   // is too fragmented. In case creation fails the allocator retries by
   // repetitively dividing the size by 2.
   const size_t min_region_size = std::max(kMinAshmemRegionSize, aligned_size);
   for (size_t region_size = std::max(ashmem_region_size_, aligned_size);
-       region_size >= min_region_size; region_size /= 2) {
+       region_size >= min_region_size;
+       region_size = AlignToNextPage(region_size / 2)) {
     scoped_ptr<AshmemRegion> new_region(
         AshmemRegion::Create(region_size, name_.c_str(), this));
     if (!new_region)
       continue;
+    last_ashmem_region_size_ = region_size;
     ashmem_regions_.push_back(new_region.release());
     return ashmem_regions_.back()->Allocate_Locked(size, aligned_size);
   }
   // TODO(pliard): consider adding an histogram to see how often this happens.
   return scoped_ptr<DiscardableMemory>();
 }
 
+size_t DiscardableMemoryAllocator::last_ashmem_region_size() const {
+  AutoLock auto_lock(lock_);
+  return last_ashmem_region_size_;
+}
+
 void DiscardableMemoryAllocator::DeleteAshmemRegion_Locked(
     AshmemRegion* region) {
   lock_.AssertAcquired();
   // Note that there should not be more than a couple of ashmem region instances
   // in |ashmem_regions_|.
   DCHECK_LE(ashmem_regions_.size(), 5U);
   const ScopedVector<AshmemRegion>::iterator it = std::find(
       ashmem_regions_.begin(), ashmem_regions_.end(), region);
   DCHECK_NE(ashmem_regions_.end(), it);
   std::swap(*it, ashmem_regions_.back());
   ashmem_regions_.pop_back();
 }
 
 }  // namespace internal
 }  // namespace base