content: Release all free discardable memory when idle.

content/common/discardable_shared_memory_heap.h

 // Copyright 2014 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.
 
 #ifndef CONTENT_COMMON_DISCARDABLE_SHARED_MEMORY_HEAP_H_
 #define CONTENT_COMMON_DISCARDABLE_SHARED_MEMORY_HEAP_H_
 
-#include <bitset>
+#include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/linked_list.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
 #include "content/common/content_export.h"
 
 namespace base {
 class DiscardableSharedMemory;
 }
 
 namespace content {
 
 // Implements a heap of discardable shared memory. A free list is used to keep
 // track of free blocks.
@@ skipping 18 matching lines @@
     size_t start_;
     size_t length_;
 
     DISALLOW_COPY_AND_ASSIGN(Span);
   };
 
   explicit DiscardableSharedMemoryHeap(size_t block_size);
   ~DiscardableSharedMemoryHeap();
 
   // Grow heap using |shared_memory| and return a span for this new memory.
-  // |shared_memory| must be aligned to the block size and |size| must be a
+  // |shared_memory| must be aligned to the block size and size must be a

[Avi (use Gerrit), 2015/03/09 16:03:37]

What size?

[reveman, 2015/03/09 18:08:26]

DiscardableSharedMemory::mapped_size(), but I reintroduced the |size| argument
in the latest patch as I think using mapped_size was a bad idea. It should be
possible for mapped_size() to be larger than the size used by heap.

   // multiple of the block size.
-  scoped_ptr<Span> Grow(scoped_ptr<base::DiscardableSharedMemory> shared_memory,
-                        size_t size);
+  scoped_ptr<Span> Grow(
+      scoped_ptr<base::DiscardableSharedMemory> shared_memory);
 
   // Merge |span| into the free list. This will coalesce |span| with
   // neighboring spans in free list when possible.
   void MergeIntoFreeList(scoped_ptr<Span> span);
 
   // Split an allocated span into two spans, one of length |blocks| followed
   // by another span of length "span->length - blocks" blocks. Modifies |span|
   // to point to the first span of length |blocks|. Return second span.
   scoped_ptr<Span> Split(Span* span, size_t blocks);
 
   // Search free list for span that satisfies the request for |blocks| of
   // memory. If found, the span is removed from the free list and returned.
   scoped_ptr<Span> SearchFreeList(size_t blocks);
 
-  // Release shared memory segments that have been purged. Returns bytes of
-  // memory that were released.
-  size_t ReleaseFreeMemory();
+  // Release free shared memory segments.
+  void ReleaseFreeMemory();
+
+  // Release shared memory segments that have been purged.
+  void ReleasePurgedMemory();
+
+  // Returns total bytes of memory in heap.
+  size_t GetSize() const;
+
+  // Returns bytes of memory currently in the free list.
+  size_t GetFreeListSize() const;
 
  private:
+  class ScopedMemorySegment {
+   public:
+    ScopedMemorySegment(scoped_ptr<base::DiscardableSharedMemory> shared_memory,
+                        DiscardableSharedMemoryHeap* heap);
+    ~ScopedMemorySegment();
+
+    bool IsUsed() const;
+    bool IsResident() const;
+
+   private:
+    scoped_ptr<base::DiscardableSharedMemory> shared_memory_;
+    DiscardableSharedMemoryHeap* heap_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedMemorySegment);
+  };
+
   scoped_ptr<Span> RemoveFromFreeList(Span* span);
   scoped_ptr<Span> Carve(Span* span, size_t blocks);
   void RegisterSpan(Span* span);
   void UnregisterSpan(Span* span);
-  void ReleaseMemory(base::DiscardableSharedMemory* shared_memory);
+  bool IsMemoryUsed(const base::DiscardableSharedMemory* shared_memory);
+  bool IsMemoryResident(const base::DiscardableSharedMemory* shared_memory);
+  void ReleaseMemory(const base::DiscardableSharedMemory* shared_memory);
 
   size_t block_size_;
+  size_t num_blocks_;
+  size_t num_free_blocks_;
 
-  // Discardable shared memory instances.
-  ScopedVector<base::DiscardableSharedMemory> shared_memory_segments_;
+  // Vector of memory segments.
+  std::vector<linked_ptr<ScopedMemorySegment>> memory_segments_;

[Avi (use Gerrit), 2015/03/09 16:03:37]

Why are you switching to linked_ptr? ScopedVector is preferred.

https://groups.google.com/a/chromium.org/d/msg/chromium-dev/cDHsauJfP5c/U2fHW...

[Avi (use Gerrit), 2015/03/09 17:21:25]

http://crbug.com/137767

[reveman, 2015/03/09 18:08:26]

I used linked_ptr as it's not spec compliant to use std::remove_if with
ScopedVector. Changed back to ScopedVector and used std::partition instead of
remove_if in latest patch.

 
   // Mapping from first/last block of span to Span instance.
   typedef base::hash_map<size_t, Span*> SpanMap;
   SpanMap spans_;
 
   // Linked-list of free discardable memory regions.
   base::LinkedList<Span> free_spans_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemoryHeap);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_DISCARDABLE_SHARED_MEMORY_HEAP_H_