PartitionAlloc: make PartitionPurgeDiscardUnusedSystemPages discard more.

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 1666 matching lines @@
     partitionFreeGeneric(genericAllocator.root(), ptr7);
 
     TestShutdown();
 }
 
 // Tests the API to purge discardable memory.
 TEST(PartitionAllocTest, PurgeDiscardable)
 {
     TestSetup();
 
+    // Free the second of two 4096 byte allocations and then purge.
     {
         void* ptr1 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
         char* ptr2 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize));
         partitionFreeGeneric(genericAllocator.root(), ptr2);
+        PartitionPage* page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
+        EXPECT_EQ(2u, page->numUnprovisionedSlots);
         {
             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);
+        EXPECT_EQ(3u, page->numUnprovisionedSlots);
 
         partitionFreeGeneric(genericAllocator.root(), ptr1);
     }
+    // Free the first of two 4096 byte allocations and then purge.
+    {
+        char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize));
+        void* ptr2 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        {
+            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(ptr1 - kPointerOffset, true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        CheckPageInCore(ptr1 - kPointerOffset, false);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+    }
     {
         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);
         {
@@ skipping 47 matching lines @@
         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);
     }
+    // This sub-test tests truncation of the provisioned slots in a trickier
+    // case where the freelist is rewritten.
+    partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDecommitEmptyPages);
+    {
+        char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize));
+        void* ptr2 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        void* ptr3 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        void* ptr4 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        ptr1[0] = 'A';
+        ptr1[kSystemPageSize] = 'A';
+        ptr1[kSystemPageSize * 2] = 'A';
+        ptr1[kSystemPageSize * 3] = 'A';
+        PartitionPage* page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+        partitionFreeGeneric(genericAllocator.root(), ptr4);
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        EXPECT_EQ(0u, page->numUnprovisionedSlots);
+
+        {
+            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(2 * kSystemPageSize, stats->discardableBytes);
+            EXPECT_EQ(kSystemPageSize, stats->activeBytes);
+            EXPECT_EQ(4 * kSystemPageSize, stats->residentBytes);
+        }
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        EXPECT_EQ(1u, page->numUnprovisionedSlots);
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
+
+        // Let's check we didn't brick the freelist.
+        void* ptr1b = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        EXPECT_EQ(ptr1, ptr1b);
+        void* ptr2b = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        EXPECT_EQ(ptr2, ptr2b);
+        EXPECT_FALSE(page->freelistHead);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+        partitionFreeGeneric(genericAllocator.root(), ptr3);
+    }
+    // This sub-test is similar, but tests a double-truncation.
+    partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDecommitEmptyPages);
+    {
+        char* ptr1 = reinterpret_cast<char*>(partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize));
+        void* ptr2 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        void* ptr3 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        void* ptr4 = partitionAllocGeneric(genericAllocator.root(), kSystemPageSize - kExtraAllocSize);
+        ptr1[0] = 'A';
+        ptr1[kSystemPageSize] = 'A';
+        ptr1[kSystemPageSize * 2] = 'A';
+        ptr1[kSystemPageSize * 3] = 'A';
+        PartitionPage* page = partitionPointerToPage(partitionCookieFreePointerAdjust(ptr1));
+        partitionFreeGeneric(genericAllocator.root(), ptr4);
+        partitionFreeGeneric(genericAllocator.root(), ptr3);
+        EXPECT_EQ(0u, page->numUnprovisionedSlots);
+
+        {
+            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(2 * kSystemPageSize, stats->discardableBytes);
+            EXPECT_EQ(2 * kSystemPageSize, stats->activeBytes);
+            EXPECT_EQ(4 * kSystemPageSize, stats->residentBytes);
+        }
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
+        partitionPurgeMemoryGeneric(genericAllocator.root(), PartitionPurgeDiscardUnusedSystemPages);
+        EXPECT_EQ(2u, page->numUnprovisionedSlots);
+        CheckPageInCore(ptr1 - kPointerOffset, true);
+        CheckPageInCore(ptr1 - kPointerOffset + kSystemPageSize, true);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), false);
+        CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
+
+        EXPECT_FALSE(page->freelistHead);
+
+        partitionFreeGeneric(genericAllocator.root(), ptr1);
+        partitionFreeGeneric(genericAllocator.root(), ptr2);
+    }
 
     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)
 {
@@ skipping 12 matching lines @@
     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)