Add some support for promptly purging pages.

third_party/WebKit/Source/platform/heap/HeapPage.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #ifndef HeapPage_h
 #define HeapPage_h
 
 #include <stdint.h>
 #include "base/trace_event/memory_allocator_dump.h"
 #include "platform/PlatformExport.h"
 #include "platform/heap/BlinkGC.h"
 #include "platform/heap/GCInfo.h"
+#include "platform/heap/PagePool.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "platform/wtf/AddressSanitizer.h"
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/ContainerAnnotations.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/allocator/Partitions.h"
 
 namespace blink {
@@ skipping 335 matching lines @@
     *previous_next = next_;
     next_ = nullptr;
   }
   BasePage* Next() const { return next_; }
 
   // Virtual methods are slow. So performance-sensitive methods should be
   // defined as non-virtual methods on |NormalPage| and |LargeObjectPage|. The
   // following methods are not performance-sensitive.
   virtual size_t ObjectPayloadSizeForTesting() = 0;
   virtual bool IsEmpty() = 0;
-  virtual void RemoveFromHeap() = 0;
+  virtual void RemoveFromHeap(
+      DecommitMemoryTiming = DecommitMemoryTiming::DecommitAsAppropriate) = 0;
   virtual void Sweep() = 0;
   virtual void MakeConsistentForMutator() = 0;
   virtual void InvalidateObjectStartBitmap() = 0;
 
 #if defined(ADDRESS_SANITIZER)
   virtual void PoisonUnmarkedObjects() = 0;
 #endif
 
   // Check if the given address points to an object in this heap page. If so,
   // find the start of that object and mark it using the given |Visitor|.
@@ skipping 62 matching lines @@
   size_t PayloadSize() {
     return (BlinkPagePayloadSize() - PageHeaderSize()) & ~kAllocationMask;
   }
   Address PayloadEnd() { return Payload() + PayloadSize(); }
   bool ContainedInObjectPayload(Address address) {
     return Payload() <= address && address < PayloadEnd();
   }
 
   size_t ObjectPayloadSizeForTesting() override;
   bool IsEmpty() override;
-  void RemoveFromHeap() override;
+  void RemoveFromHeap(DecommitMemoryTiming =
+                          DecommitMemoryTiming::DecommitAsAppropriate) override;
   void Sweep() override;
   void MakeConsistentForMutator() override;
   void InvalidateObjectStartBitmap() override {
     object_start_bit_map_computed_ = false;
   }
 #if defined(ADDRESS_SANITIZER)
   void PoisonUnmarkedObjects() override;
 #endif
   void CheckAndMarkPointer(Visitor*, Address) override;
 #if DCHECK_IS_ON()
@@ skipping 27 matching lines @@
   // Context object holding the state of the arena page compaction pass, passed
   // in when compacting individual pages.
   class CompactionContext {
     STACK_ALLOCATED();
 
    public:
     // Page compacting into.
     NormalPage* current_page_ = nullptr;
     // Offset into |m_currentPage| to the next free address.
     size_t allocation_point_ = 0;
+
+    void AddAvailable(BasePage*);
+    BasePage* TakeAvailable();
     // Chain of available pages to use for compaction. Page compaction picks the
     // next one when the current one is exhausted.
     BasePage* available_pages_ = nullptr;
+    BasePage* last_available_ = nullptr;
+
     // Chain of pages that have been compacted. Page compaction will add
     // compacted pages once the current one becomes exhausted.
     BasePage** compacted_pages_ = nullptr;
   };
 
   void SweepAndCompact(CompactionContext&);
 
  private:
   HeapObjectHeader* FindHeaderFromAddress(Address);
   void PopulateObjectStartBitMap();
@@ skipping 20 matching lines @@
   // ObjectPayload.
   Address Payload() { return GetHeapObjectHeader()->Payload(); }
   size_t PayloadSize() { return payload_size_; }
   Address PayloadEnd() { return Payload() + PayloadSize(); }
   bool ContainedInObjectPayload(Address address) {
     return Payload() <= address && address < PayloadEnd();
   }
 
   size_t ObjectPayloadSizeForTesting() override;
   bool IsEmpty() override;
-  void RemoveFromHeap() override;
+  void RemoveFromHeap(DecommitMemoryTiming =
+                          DecommitMemoryTiming::DecommitAsAppropriate) override;
   void Sweep() override;
   void MakeConsistentForMutator() override;
   void InvalidateObjectStartBitmap() override {}
 #if defined(ADDRESS_SANITIZER)
   void PoisonUnmarkedObjects() override;
 #endif
   void CheckAndMarkPointer(Visitor*, Address) override;
 #if DCHECK_IS_ON()
   void CheckAndMarkPointer(Visitor*,
                            Address,
@@ skipping 194 matching lines @@
   }
   void ClearFreeLists() override;
 #if DCHECK_IS_ON()
   bool IsConsistentForGC() override;
   bool PagesToBeSweptContains(Address);
 #endif
   void TakeFreelistSnapshot(const String& dump_base_name) override;
 
   Address AllocateObject(size_t allocation_size, size_t gc_info_index);
 
-  void FreePage(NormalPage*);
+  void FreePage(NormalPage*, DecommitMemoryTiming);
 
   bool Coalesce();
   void PromptlyFreeObject(HeapObjectHeader*);
   bool ExpandObject(HeapObjectHeader*, size_t);
   bool ShrinkObject(HeapObjectHeader*, size_t);
   void DecreasePromptlyFreedSize(size_t size) { promptly_freed_size_ -= size; }
 
   bool IsObjectAllocatedAtAllocationPoint(HeapObjectHeader* header) {
     return header->PayloadEnd() == current_allocation_point_;
   }
@@ skipping 228 matching lines @@
   return OutOfLineAllocate(allocation_size, gc_info_index);
 }
 
 inline NormalPageArena* NormalPage::ArenaForNormalPage() const {
   return static_cast<NormalPageArena*>(Arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h