Simple BlinkGC heap compaction.

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 290 matching lines @@
   NO_SANITIZE_ADDRESS
   void link(FreeListEntry** prevNext) {
     m_next = *prevNext;
     *prevNext = this;
   }
 
   NO_SANITIZE_ADDRESS
   FreeListEntry* next() const { return m_next; }
 
   NO_SANITIZE_ADDRESS
+  FreeListEntry** prevNext() { return &m_next; }
+
+  NO_SANITIZE_ADDRESS
   void append(FreeListEntry* next) {
     ASSERT(!m_next);
     m_next = next;
   }
 
  private:
   FreeListEntry* m_next;
 };
 
 // Blink heap pages are set up with a guard page before and after the payload.
@@ skipping 184 matching lines @@
     // Compute the amount of padding we have to add to a header to make
     // the size of the header plus the padding a multiple of 8 bytes.
     size_t paddingSize = (sizeof(NormalPage) + allocationGranularity -
                           (sizeof(HeapObjectHeader) % allocationGranularity)) %
                          allocationGranularity;
     return sizeof(NormalPage) + paddingSize;
   }
 
   inline NormalPageArena* arenaForNormalPage() const;
 
+  size_t sweepCompact(NormalPage*&, BasePage**, size_t);

[haraken, 2016/12/02 12:43:20]

sweepAndCompact ?

+
  private:
   HeapObjectHeader* findHeaderFromAddress(Address);
   void populateObjectStartBitMap();
 
   bool m_objectStartBitMapComputed;
   uint8_t m_objectStartBitMap[reservedForObjectBitMap];
 };
 
 // Large allocations are allocated as separate objects and linked in a list.
 //
@@ skipping 133 matching lines @@
   static void zapFreedMemory(Address, size_t);
   static void checkFreedMemoryIsZapped(Address, size_t);
 #endif
 
  private:
   int m_biggestFreeListIndex;
 
   // All FreeListEntries in the nth list have size >= 2^n.
   FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
+  size_t size() const;

[haraken, 2016/12/02 12:43:20]

size => freeListSize ? (since size() is used in various meanings in Oilpan.)

[sof, 2016/12/04 14:55:38]

That's better, done.

+
   friend class NormalPageArena;
 };
 
 // Each thread has a number of thread arenas (e.g., Generic arenas,
 // typed arenas for Node, arenas for collection backings etc)
 // and BaseArena represents each thread arena.
 //
 // BaseArena is a parent class of NormalPageArena and LargeObjectArena.
 // NormalPageArena represents a part of a heap that contains NormalPages
 // and LargeObjectArena represents a part of a heap that contains
@@ skipping 76 matching lines @@
   bool shrinkObject(HeapObjectHeader*, size_t);
   void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
   bool isObjectAllocatedAtAllocationPoint(HeapObjectHeader* header) {
     return header->payloadEnd() == m_currentAllocationPoint;
   }
 
   bool isLazySweeping() const { return m_isLazySweeping; }
   void setIsLazySweeping(bool flag) { m_isLazySweeping = flag; }
 
+  size_t arenaSize();
+  size_t freeListSize();
+
+  void sweepCompact();

[haraken, 2016/12/02 12:43:20]

sweepAndCompact ?

[sof, 2016/12/04 14:55:38]

Done.

+
  private:
-  void allocatePage();
+  NormalPage* allocatePage();
+  void allocateAndAddPage();
+
   Address outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex);
   Address allocateFromFreeList(size_t, size_t gcInfoIndex);
 
   Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 
   Address currentAllocationPoint() const { return m_currentAllocationPoint; }
   bool hasCurrentAllocationArea() const {
     return currentAllocationPoint() && remainingAllocationSize();
   }
   void setAllocationPoint(Address, size_t);
@@ skipping 144 matching lines @@
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h