Oilpan: Discard unused system pages when sweeping NormalPageHeaps

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

 /*
  * 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 1086 matching lines @@
 {
     HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(payload());
     return header->isFree() && header->size() == payloadSize();
 }
 
 void NormalPage::removeFromHeap()
 {
     heapForNormalPage()->freePage(this);
 }
 
+static void discardPages(Address begin, Address end)
+{
+    uintptr_t beginAddress = WTF::roundUpToSystemPage(reinterpret_cast<uintptr_t>(begin));
+    uintptr_t endAddress = WTF::roundDownToSystemPage(reinterpret_cast<uintptr_t>(end));
+    if (beginAddress < endAddress)

[sof, 2016/02/04 10:20:04]

I understand the concern; for other live objects on that page, their next access
will be potentially costly.

[Yuta Kitamura, 2016/02/04 10:50:11]

We could make the condition a little bit tighter, i.e. discard memory
only when the unused interval is more than e.g. 32KB.

According to my experiment, the major contributor is large-sized
buckets, so I suspect there's enough memory that can be collected
by just discarding longer contiguous unused regions.

But that's kind of trade-offs; on low mem devices we probably should
return every unused 4K page, while on desktops we have some more
freedom on delaying the disposal. Just large contiguous memory should
be more prioritized than shorter regions.

+        WTF::discardSystemPages(reinterpret_cast<void*>(beginAddress), endAddress - beginAddress);
+}
+
 void NormalPage::sweep()
 {
     size_t markedObjectSize = 0;
     Address startOfGap = payload();
     for (Address headerAddress = startOfGap; headerAddress < payloadEnd(); ) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() > 0);
         ASSERT(header->size() < blinkPagePayloadSize());
 
         if (header->isPromptlyFreed())
@@ skipping 22 matching lines @@
             // an error if the finalizer touches any other on-heap object that
             // die at the same GC cycle.
             ASAN_UNPOISON_MEMORY_REGION(payload, payloadSize);
             header->finalize(payload, payloadSize);
             // This memory will be added to the freelist. Maintain the invariant
             // that memory on the freelist is zero filled.
             SET_MEMORY_INACCESSIBLE(headerAddress, size);
             headerAddress += size;
             continue;
         }
-        if (startOfGap != headerAddress)
+        if (startOfGap != headerAddress) {
             heapForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
+#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+            discardPages(startOfGap, headerAddress);
+#endif
+        }
         header->unmark();
         headerAddress += header->size();
         markedObjectSize += header->size();
         startOfGap = headerAddress;
     }
-    if (startOfGap != payloadEnd())
+    if (startOfGap != payloadEnd()) {
         heapForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
+#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+        discardPages(startOfGap, payloadEnd());
+#endif
+    }
 
     if (markedObjectSize)
         Heap::increaseMarkedObjectSize(markedObjectSize);
 }
 
 void NormalPage::makeConsistentForGC()
 {
     size_t markedObjectSize = 0;
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
@@ skipping 406 matching lines @@
 
     m_hasEntries = true;
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     m_entries[index + 1] = m_entries[index];
     m_entries[index] = cachePage;
 }
 
 } // namespace blink