content/common/host_discardable_shared_memory_manager.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_HOST_DISCARDABLE_SHARED_MEMORY_MANAGER_H_
   6 #define CONTENT_COMMON_HOST_DISCARDABLE_SHARED_MEMORY_MANAGER_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/discardable_memory_shmem_allocator.h"
  11 #include "base/memory/discardable_shared_memory.h"
  12 #include "base/memory/linked_ptr.h"
  13 #include "base/memory/memory_pressure_listener.h"
  14 #include "base/memory/shared_memory.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/process/process_handle.h"
  17 #include "base/synchronization/lock.h"
  18 #include "content/common/content_export.h"
  19
  20 namespace content {
  21
  22 // Implementation of DiscardableMemoryShmemAllocator that allocates and
  23 // manages discardable memory segments for the browser process and child
  24 // processes. This class is thread-safe and instances can safely be used
  25 // on any thread.
  26 class CONTENT_EXPORT HostDiscardableSharedMemoryManager
  27     : public base::DiscardableMemoryShmemAllocator {
  28  public:
  29   HostDiscardableSharedMemoryManager();
  30   ~HostDiscardableSharedMemoryManager() override;
  31
  32   // Returns a singleton instance.
  33   static HostDiscardableSharedMemoryManager* current();
  34
  35   // Overridden from base::DiscardableMemoryShmemAllocator:
  36   scoped_ptr<base::DiscardableMemoryShmemChunk> AllocateLockedDiscardableMemory(
  37       size_t size) override;
  38
  39   // This allocates a discardable memory segment for |process_handle|.
  40   // A valid shared memory handle is returned on success.
  41   void AllocateLockedDiscardableSharedMemoryForChild(
  42       base::ProcessHandle process_handle,
  43       size_t size,
  44       base::SharedMemoryHandle* shared_memory_handle);
  45
  46   // Call this to notify the manager that child process associated with
  47   // |process_handle| has been removed. The manager will use this to release
  48   // memory segments allocated for child process to the OS.
  49   void ProcessRemoved(base::ProcessHandle process_handle);
  50
  51   // The maximum number of bytes of memory that may be allocated. This will
  52   // cause memory usage to be reduced if currently above |limit|.
  53   void SetMemoryLimit(size_t limit);
  54
  55   // Reduce memory usage if above current memory limit.
  56   void EnforceMemoryPolicy();
  57
  58  private:
  59   struct MemorySegment {
  60     MemorySegment(linked_ptr<base::DiscardableSharedMemory> memory,
  61                   base::ProcessHandle process_handle);
  62     ~MemorySegment();
  63
  64     linked_ptr<base::DiscardableSharedMemory> memory;
  65     base::ProcessHandle process_handle;
  66   };
  67
  68   static bool CompareMemoryUsageTime(const MemorySegment& a,
  69                                      const MemorySegment& b) {
  70     // In this system, LRU memory segment is evicted first.
  71     return a.memory->last_known_usage() > b.memory->last_known_usage();
  72   }
  73
  74   void OnMemoryPressure(
  75       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
  76   void ReduceMemoryUsageUntilWithinMemoryLimit();
  77   void ReduceMemoryUsageUntilWithinLimit(size_t limit);
  78   void BytesAllocatedChanged(size_t new_bytes_allocated) const;
  79
  80   // Virtual for tests.
  81   virtual base::Time Now() const;
  82   virtual void ScheduleEnforceMemoryPolicy();
  83
  84   base::Lock lock_;
  85   // Note: The elements in |segments_| are arranged in such a way that they form
  86   // a heap. The LRU memory segment always first.
  87   typedef std::vector<MemorySegment> MemorySegmentVector;
  88   MemorySegmentVector segments_;
  89   size_t memory_limit_;
  90   size_t bytes_allocated_;
  91   scoped_ptr<base::MemoryPressureListener> memory_pressure_listener_;
  92   bool enforce_memory_policy_pending_;
  93   base::WeakPtrFactory<HostDiscardableSharedMemoryManager> weak_ptr_factory_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(HostDiscardableSharedMemoryManager);
  96 };
  97
  98 }  // namespace content
  99
 100 #endif  // CONTENT_COMMON_HOST_DISCARDABLE_SHARED_MEMORY_MANAGER_H_