PartitionAlloc: Remove the 2 GB per-partition address space limit

Source/wtf/PartitionAlloc.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 235 matching lines @@
 
     return noLeaks;
 }
 
 static void partitionAllocBaseShutdown(PartitionRootBase* root)
 {
     ASSERT(root->initialized);
     root->initialized = false;
 
     // Now that we've examined all partition pages in all buckets, it's safe
-    // to free all our super pages. We first collect the super page pointers
-    // on the stack because some of them are themselves store in super pages.
-    char* superPages[kMaxPartitionSize / kSuperPageSize];
-    size_t numSuperPages = 0;
+    // to free all our super pages. Since the super page extent entries are
+    // stored in the super pages, we need to be careful not to access them
+    // after we've released the corresponding super page.
     PartitionSuperPageExtentEntry* entry = root->firstExtent;
     while (entry) {
+        PartitionSuperPageExtentEntry* nextEntry = entry->next;
         char* superPage = entry->superPageBase;
-        while (superPage != entry->superPagesEnd) {
-            superPages[numSuperPages] = superPage;
-            numSuperPages++;
+        char* superPagesEnd = entry->superPagesEnd;
+        while (superPage < superPagesEnd) {
+            freePages(superPage, kSuperPageSize);
             superPage += kSuperPageSize;
         }
-        entry = entry->next;
+        entry = nextEntry;
     }
-    ASSERT(numSuperPages == root->totalSizeOfSuperPages / kSuperPageSize);
-    for (size_t i = 0; i < numSuperPages; ++i)
-        freePages(superPages[i], kSuperPageSize);
 }
 
 bool partitionAllocShutdown(PartitionRoot* root)
 {
     bool noLeaks = true;
     size_t i;
     for (i = 0; i < root->numBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets()[i];
         if (!partitionAllocShutdownBucket(bucket))
             noLeaks = false;
@@ skipping 14 matching lines @@
     }
     partitionAllocBaseShutdown(root);
     return noLeaks;
 }
 
 static NEVER_INLINE void partitionOutOfMemory()
 {
     IMMEDIATE_CRASH();
 }
 
-static NEVER_INLINE void partitionFull()
-{
-    IMMEDIATE_CRASH();
-}
-
 static ALWAYS_INLINE void partitionDecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
 {
     decommitSystemPages(addr, len);
     ASSERT(root->totalSizeOfCommittedPages > len);
     root->totalSizeOfCommittedPages -= len;
 }
 
 static ALWAYS_INLINE void partitionRecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
 {
     recommitSystemPages(addr, len);
@@ skipping 11 matching lines @@
     if (LIKELY(numPartitionPagesLeft >= numPartitionPages)) {
         // In this case, we can still hand out pages from the current super page
         // allocation.
         char* ret = root->nextPartitionPage;
         root->nextPartitionPage += totalSize;
         return ret;
     }
 
     // Need a new super page.
     root->totalSizeOfSuperPages += kSuperPageSize;
-    if (root->totalSizeOfSuperPages > kMaxPartitionSize)
-        partitionFull();
     char* requestedAddress = root->nextSuperPage;
     char* superPage = reinterpret_cast<char*>(allocPages(requestedAddress, kSuperPageSize, kSuperPageSize));
     if (UNLIKELY(!superPage)) {
         if (flags & PartitionAllocReturnNull)
             return 0;
         partitionOutOfMemory();
     }
     root->nextSuperPage = superPage + kSuperPageSize;
     char* ret = superPage + kPartitionPageSize;
     root->nextPartitionPage = ret + totalSize;
@@ skipping 620 matching lines @@
     printf("total live: %zu bytes\n", totalLive);
     printf("total resident: %zu bytes\n", totalResident);
     printf("total freeable: %zu bytes\n", totalFreeable);
     fflush(stdout);
 }
 
 #endif // !NDEBUG
 
 } // namespace WTF