PartitionAlloc: minor cleanups.

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 188 matching lines @@
             partitionBucketInitBase(bucket, root);
             // Disable psuedo buckets so that touching them faults.
             if (currentSize % kGenericSmallestBucket)
                 bucket->activePagesHead = 0;
             currentSize += currentIncrement;
             ++bucket;
         }
         currentIncrement <<= 1;
     }
     ASSERT(currentSize == 1 << kGenericMaxBucketedOrder);
-    ASSERT(bucket == &root->buckets[0] + (kGenericNumBucketedOrders * kGenericNumBucketsPerOrder));
+    ASSERT(bucket == &root->buckets[0] + kGenericNumBuckets);
 
     // Then set up the fast size -> bucket lookup table.
     bucket = &root->buckets[0];
     PartitionBucket** bucketPtr = &root->bucketLookups[0];
     for (order = 0; order <= kBitsPerSizet; ++order) {
         for (j = 0; j < kGenericNumBucketsPerOrder; ++j) {
             if (order < kGenericMinBucketedOrder) {
                 // Use the bucket of the finest granularity for malloc(0) etc.
                 *bucketPtr++ = &root->buckets[0];
             } else if (order > kGenericMaxBucketedOrder) {
                 *bucketPtr++ = &PartitionRootGeneric::gPagedBucket;
             } else {
                 PartitionBucket* validBucket = bucket;
                 // Skip over invalid buckets.
                 while (validBucket->slotSize % kGenericSmallestBucket)
                     validBucket++;
                 *bucketPtr++ = validBucket;
                 bucket++;
             }
         }
     }
-    ASSERT(bucket == &root->buckets[0] + (kGenericNumBucketedOrders * kGenericNumBucketsPerOrder));
+    ASSERT(bucket == &root->buckets[0] + kGenericNumBuckets);
     ASSERT(bucketPtr == &root->bucketLookups[0] + ((kBitsPerSizet + 1) * kGenericNumBucketsPerOrder));
     // And there's one last bucket lookup that will be hit for e.g. malloc(-1),
     // which tries to overflow to a non-existant order.
     *bucketPtr = &PartitionRootGeneric::gPagedBucket;
 }
 
 static bool partitionAllocShutdownBucket(PartitionBucket* bucket)
 {
     // Failure here indicates a memory leak.
     bool foundLeak = bucket->numFullPages;
@@ skipping 34 matching lines @@
         foundLeak |= partitionAllocShutdownBucket(bucket);
     }
     foundLeak |= partitionAllocBaseShutdown(root);
     return !foundLeak;
 }
 
 bool partitionAllocGenericShutdown(PartitionRootGeneric* root)
 {
     bool foundLeak = false;
     size_t i;
-    for (i = 0; i < kGenericNumBucketedOrders * kGenericNumBucketsPerOrder; ++i) {
+    for (i = 0; i < kGenericNumBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets[i];
         foundLeak |= partitionAllocShutdownBucket(bucket);
     }
     foundLeak |= partitionAllocBaseShutdown(root);
     return !foundLeak;
 }
 
 #if !CPU(64BIT)
 static NEVER_INLINE void partitionOutOfMemoryWithLotsOfUncommitedPages()
 {
@@ skipping 847 matching lines @@
     if (bucket->activePagesHead != &PartitionRootGeneric::gSeedPage) {
         for (const PartitionPage* page = bucket->activePagesHead; page; page = page->nextPage) {
             ASSERT(page != &PartitionRootGeneric::gSeedPage);
             partitionDumpPageStats(statsOut, page);
         }
     }
 }
 
 void partitionDumpStatsGeneric(PartitionRootGeneric* partition, const char* partitionName, PartitionStatsDumper* partitionStatsDumper)
 {
-    const size_t partitionNumBuckets = kGenericNumBucketedOrders * kGenericNumBucketsPerOrder;
+    PartitionBucketMemoryStats bucketStats[kGenericNumBuckets];
     spinLockLock(&partition->lock);
-    PartitionBucketMemoryStats bucketStats[partitionNumBuckets];
-    for (size_t i = 0; i < partitionNumBuckets; ++i) {
+    for (size_t i = 0; i < kGenericNumBuckets; ++i) {
         const PartitionBucket* bucket = &partition->buckets[i];
         // Don't report the pseudo buckets that the generic allocator sets up in
         // order to preserve a fast size->bucket map (see
         // partitionAllocGenericInit for details).
         if (!bucket->activePagesHead)
             bucketStats[i].isValid = false;
         else
             partitionDumpBucketStats(&bucketStats[i], bucket);
     }
 
     static const size_t kMaxReportableDirectMaps = 4096;
     uint32_t directMapLengths[kMaxReportableDirectMaps];
     size_t numDirectMappedAllocations = 0;
     for (PartitionDirectMapExtent* extent = partition->directMapList; extent; extent = extent->nextExtent) {
         ASSERT(!extent->nextExtent || extent->nextExtent->prevExtent == extent);
         directMapLengths[numDirectMappedAllocations] = extent->bucket->slotSize;
         ++numDirectMappedAllocations;
         if (numDirectMappedAllocations == kMaxReportableDirectMaps)
             break;
     }
 
     spinLockUnlock(&partition->lock);
 
     // partitionsDumpBucketStats is called after collecting stats because it
     // can try to allocate using PartitionAllocGeneric and it can't obtain the
     // lock.
-    for (size_t i = 0; i < partitionNumBuckets; ++i) {
+    for (size_t i = 0; i < kGenericNumBuckets; ++i) {
         if (bucketStats[i].isValid)
             partitionStatsDumper->partitionsDumpBucketStats(partitionName, &bucketStats[i]);
     }
     for (size_t i = 0; i < numDirectMappedAllocations; ++i) {
         PartitionBucketMemoryStats stats;
         memset(&stats, '\0', sizeof(stats));
         stats.isValid = true;
         stats.isDirectMap = true;
         stats.numFullPages = 1;
         uint32_t size = directMapLengths[i];
@@ skipping 18 matching lines @@
     // partitionsDumpBucketStats is called after collecting stats because it
     // can use PartitionAlloc to allocate and this can affect the statistics.
     for (size_t i = 0; i < partitionNumBuckets; ++i) {
         if (memoryStats[i].isValid)
             partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
     }
 }
 
 } // namespace WTF