PartitionAlloc: implement discarding for partitionPurgeMemoryGeneric().

Source/wtf/PartitionAllocTest.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 176 matching lines @@
         void* ptr = partitionAllocGeneric(genericAllocator.root(), size);
         PartitionPage* page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
         PartitionBucket* bucket = page->bucket;
         EXPECT_EQ(1, bucket->activePagesHead->numAllocatedSlots);
         partitionFreeGeneric(genericAllocator.root(), ptr);
         EXPECT_EQ(0, bucket->activePagesHead->numAllocatedSlots);
         EXPECT_NE(-1, bucket->activePagesHead->emptyCacheIndex);
     }
 }
 
+void CheckPageInCore(void* ptr, bool inCore)
+{
+#if OS(LINUX)
+    unsigned char ret;
+    EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
+    EXPECT_EQ(inCore, ret);
+#endif
+}
+
 class MockPartitionStatsDumper : public PartitionStatsDumper {
 public:
     MockPartitionStatsDumper()
         : m_totalResidentBytes(0)
         , m_totalActiveBytes(0) { }
 
     void partitionsDumpBucketStats(const char* partitionName, const PartitionBucketMemoryStats* memoryStats) override
     {
         (void) partitionName;
         EXPECT_TRUE(memoryStats->isValid);
@@ skipping 1133 matching lines @@
             partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
             EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(2048);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_EQ(2048u, stats->bucketSlotSize);
             EXPECT_EQ(2048u, stats->activeBytes);
             EXPECT_EQ(kSystemPageSize, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(0u, stats->numFullPages);
             EXPECT_EQ(1u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
         }
 
         partitionFreeGeneric(genericAllocator.root(), genericPtr);
 
         {
             MockPartitionStatsDumper mockStatsDumperGeneric;
             partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
             EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(2048);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_EQ(2048u, stats->bucketSlotSize);
             EXPECT_EQ(0u, stats->activeBytes);
             EXPECT_EQ(kSystemPageSize, stats->residentBytes);
             EXPECT_EQ(kSystemPageSize, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(0u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(1u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
         }
 
         CycleGenericFreeCache(kTestAllocSize);
 
         {
             MockPartitionStatsDumper mockStatsDumperGeneric;
             partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
             EXPECT_FALSE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(2048);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_EQ(2048u, stats->bucketSlotSize);
             EXPECT_EQ(0u, stats->activeBytes);
             EXPECT_EQ(0u, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(0u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(1u, stats->numDecommittedPages);
         }
     }
 
     // This test checks for correct empty page list accounting.
     {
         size_t size = kPartitionPageSize - kExtraAllocSize;
@@ skipping 11 matching lines @@
             partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
             EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(kPartitionPageSize);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_EQ(kPartitionPageSize, stats->bucketSlotSize);
             EXPECT_EQ(kPartitionPageSize, stats->activeBytes);
             EXPECT_EQ(kPartitionPageSize, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(1u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(1u, stats->numDecommittedPages);
         }
         partitionFreeGeneric(genericAllocator.root(), ptr1);
     }
 
     // This test checks for correct direct mapped accounting.
     {
@@ skipping 10 matching lines @@
             EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(realSizeSmaller);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_TRUE(stats->isDirectMap);
             EXPECT_EQ(realSizeSmaller, stats->bucketSlotSize);
             EXPECT_EQ(realSizeSmaller, stats->activeBytes);
             EXPECT_EQ(realSizeSmaller, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(1u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
 
             stats = mockStatsDumperGeneric.GetBucketStats(realSizeBigger);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_TRUE(stats->isDirectMap);
             EXPECT_EQ(realSizeBigger, stats->bucketSlotSize);
             EXPECT_EQ(realSizeBigger, stats->activeBytes);
             EXPECT_EQ(realSizeBigger, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(1u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
         }
 
         partitionFreeGeneric(genericAllocator.root(), ptr2);
         partitionFreeGeneric(genericAllocator.root(), ptr);
 
         // Whilst we're here, allocate again and free with different ordering
@@ skipping 15 matching lines @@
 
             size_t slotSize = 65536 + (65536 / kGenericNumBucketsPerOrder);
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(slotSize);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_FALSE(stats->isDirectMap);
             EXPECT_EQ(slotSize, stats->bucketSlotSize);
             EXPECT_EQ(65536 + kSystemPageSize, stats->activeBytes);
             EXPECT_EQ(slotSize, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(kSystemPageSize, stats->discardableBytes);
             EXPECT_EQ(1u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
         }
 
         partitionFreeGeneric(genericAllocator.root(), ptr);
 
         void* ptr2 = partitionAllocGeneric(genericAllocator.root(), 65536 + kSystemPageSize + 1);
         EXPECT_EQ(ptr, ptr2);
 
         {
             MockPartitionStatsDumper mockStatsDumperGeneric;
             partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
             EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
 
             size_t slotSize = 65536 + (65536 / kGenericNumBucketsPerOrder);
             const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(slotSize);
             EXPECT_TRUE(stats);
             EXPECT_TRUE(stats->isValid);
             EXPECT_FALSE(stats->isDirectMap);
             EXPECT_EQ(slotSize, stats->bucketSlotSize);
             EXPECT_EQ(slotSize, stats->activeBytes);
             EXPECT_EQ(slotSize, stats->residentBytes);
             EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(0u, stats->discardableBytes);
             EXPECT_EQ(1u, stats->numFullPages);
             EXPECT_EQ(0u, stats->numActivePages);
             EXPECT_EQ(0u, stats->numEmptyPages);
             EXPECT_EQ(0u, stats->numDecommittedPages);
         }
 
         partitionFreeGeneric(genericAllocator.root(), ptr2);
     }
 
     TestShutdown();
@@ skipping 28 matching lines @@
         EXPECT_TRUE(stats->isValid);
         EXPECT_EQ(0u, stats->decommittableBytes);
         EXPECT_EQ(0u, stats->residentBytes);
     }
     // Calling purge again here is a good way of testing we didn't mess up the
     // state of the free cache ring.
     partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDecommitEmptyPages);
     TestShutdown();
 }
 
+// Tests the API to purge discardable memory.
+TEST(PartitionAllocTest, PurgeDiscardable)
+{
+    TestSetup();
+
+    {
+        void* ptr1 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        char* ptr2 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize));
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+        {
+            MockPartitionStatsDumper mockStatsDumperGeneric;
+            partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
+            EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
+
+            const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(kSystemPageSize);
+            EXPECT_TRUE(stats);
+            EXPECT_TRUE(stats->isValid);
+            EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(kSystemPageSize, stats->discardableBytes);
+            EXPECT_EQ(kSystemPageSize, stats->activeBytes);
+            EXPECT_EQ(2 * kSystemPageSize, stats->residentBytes);
+        }
+        CheckPageInCore(ptr2 - kPointerOffset, true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        CheckPageInCore(ptr2 - kPointerOffset, false);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+    }
+    {
+        char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), 9216 - kExtraAllocSize));
+        void* ptr2 = partitionAllocGeneric(genericAllocator.root(), 9216 - kExtraAllocSize);
+        void* ptr3 = partitionAllocGeneric(genericAllocator.root(), 9216 - kExtraAllocSize);
+        void* ptr4 = partitionAllocGeneric(genericAllocator.root(), 9216 - kExtraAllocSize);
+        memset(ptr1, 'A', 9216 - kExtraAllocSize);
+        memset(ptr2, 'A', 9216 - kExtraAllocSize);
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        {
+            MockPartitionStatsDumper mockStatsDumperGeneric;
+            partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
+            EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
+
+            const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(9216);
+            EXPECT_TRUE(stats);
+            EXPECT_TRUE(stats->isValid);
+            EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(2 * kSystemPageSize, stats->discardableBytes);
+            EXPECT_EQ(9216u * 2, stats->activeBytes);
+            EXPECT_EQ(9 * kSystemPageSize, stats->residentBytes);
+        }
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr3);
+        partitionFreeGeneric(genericAllocator.root(), ptr4);
+    }
+    {
+        char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), (64 * kSystemPageSize) - kExtraAllocSize));
+        memset(ptr1, 'A', (64 * kSystemPageSize) - kExtraAllocSize);
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), (61 * kSystemPageSize) - kExtraAllocSize));
+        {
+            MockPartitionStatsDumper mockStatsDumperGeneric;
+            partitionDumpStatsGeneric(genericAllocator.root(), "mock_generic_allocator", &mockStatsDumperGeneric);
+            EXPECT_TRUE(mockStatsDumperGeneric.IsMemoryAllocationRecorded());
+
+            const PartitionBucketMemoryStats* stats = mockStatsDumperGeneric.GetBucketStats(64 * kSystemPageSize);
+            EXPECT_TRUE(stats);
+            EXPECT_TRUE(stats->isValid);
+            EXPECT_EQ(0u, stats->decommittableBytes);
+            EXPECT_EQ(3 * kSystemPageSize, stats->discardableBytes);
+            EXPECT_EQ(61 * kSystemPageSize, stats->activeBytes);
+            EXPECT_EQ(64 * kSystemPageSize, stats->residentBytes);
+        }
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 61), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 62), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 63), true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 61), false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 62), false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 63), false);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+    }
+
+    TestShutdown();
+}
+
 // Tests that the countLeadingZeros() functions work to our satisfaction.
 // It doesn't seem worth the overhead of a whole new file for these tests, so
 // we'll put them here since partitionAllocGeneric will depend heavily on these
 // functions working correctly.
 TEST(PartitionAllocTest, CLZWorks)
 {
     EXPECT_EQ(32u, countLeadingZeros32(0u));
     EXPECT_EQ(31u, countLeadingZeros32(1u));
     EXPECT_EQ(1u, countLeadingZeros32(1u << 30));
     EXPECT_EQ(0u, countLeadingZeros32(1u << 31));
 
 #if CPU(64BIT)
     EXPECT_EQ(64u, countLeadingZerosSizet(0ull));
     EXPECT_EQ(63u, countLeadingZerosSizet(1ull));
     EXPECT_EQ(32u, countLeadingZerosSizet(1ull << 31));
     EXPECT_EQ(1u, countLeadingZerosSizet(1ull << 62));
     EXPECT_EQ(0u, countLeadingZerosSizet(1ull << 63));
 #else
     EXPECT_EQ(32u, countLeadingZerosSizet(0u));
     EXPECT_EQ(31u, countLeadingZerosSizet(1u));
     EXPECT_EQ(1u, countLeadingZerosSizet(1u << 30));
     EXPECT_EQ(0u, countLeadingZerosSizet(1u << 31));
 #endif
 }
 
 } // namespace WTF
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)