Switch wtf/SpinLock to std::atomic

third_party/WebKit/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 37 matching lines @@
 static_assert(sizeof(WTF::PartitionPage) <= WTF::kPageMetadataSize, "PartitionPage should not be too big");
 static_assert(sizeof(WTF::PartitionBucket) <= WTF::kPageMetadataSize, "PartitionBucket should not be too big");
 static_assert(sizeof(WTF::PartitionSuperPageExtentEntry) <= WTF::kPageMetadataSize, "PartitionSuperPageExtentEntry should not be too big");
 static_assert(WTF::kPageMetadataSize * WTF::kNumPartitionPagesPerSuperPage <= WTF::kSystemPageSize, "page metadata fits in hole");
 // Check that some of our zanier calculations worked out as expected.
 static_assert(WTF::kGenericSmallestBucket == 8, "generic smallest bucket");
 static_assert(WTF::kGenericMaxBucketed == 983040, "generic max bucketed");
 
 namespace WTF {
 
-int PartitionRootBase::gInitializedLock = 0;
+SpinLock PartitionRootBase::gInitializedLock;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
 void (*PartitionRootBase::gOomHandlingFunction)() = nullptr;
 PartitionAllocHooks::AllocationHook* PartitionAllocHooks::m_allocationHook = nullptr;
 PartitionAllocHooks::FreeHook* PartitionAllocHooks::m_freeHook = nullptr;
 
 static uint16_t partitionBucketNumSystemPages(size_t size)
 {
     // This works out reasonably for the current bucket sizes of the generic
@@ skipping 28 matching lines @@
             bestPages = i;
         }
     }
     ASSERT(bestPages > 0);
     return bestPages;
 }
 
 static void partitionAllocBaseInit(PartitionRootBase* root)
 {
     ASSERT(!root->initialized);
-
-    spinLockLock(&PartitionRootBase::gInitializedLock);
-    if (!PartitionRootBase::gInitialized) {
-        PartitionRootBase::gInitialized = true;
-        // We mark the seed page as free to make sure it is skipped by our
-        // logic to find a new active page.
-        PartitionRootBase::gPagedBucket.activePagesHead = &PartitionRootGeneric::gSeedPage;
+    {
+        SpinLock::Guard guard(PartitionRootBase::gInitializedLock);
+        if (!PartitionRootBase::gInitialized) {
+            PartitionRootBase::gInitialized = true;
+            // We mark the seed page as free to make sure it is skipped by our
+            // logic to find a new active page.
+            PartitionRootBase::gPagedBucket.activePagesHead = &PartitionRootGeneric::gSeedPage;
+        }
     }
-    spinLockUnlock(&PartitionRootBase::gInitializedLock);
 
     root->initialized = true;
     root->totalSizeOfCommittedPages = 0;
     root->totalSizeOfSuperPages = 0;
     root->totalSizeOfDirectMappedPages = 0;
     root->nextSuperPage = 0;
     root->nextPartitionPage = 0;
     root->nextPartitionPageEnd = 0;
     root->firstExtent = 0;
     root->currentExtent = 0;
@@ skipping 33 matching lines @@
         if (!i)
             bucket->slotSize = kAllocationGranularity;
         else
             bucket->slotSize = i << kBucketShift;
         partitionBucketInitBase(bucket, root);
     }
 }
 
 void partitionAllocGenericInit(PartitionRootGeneric* root)
 {
-    spinLockLock(&root->lock);
+    SpinLock::Guard guard(root->lock);
 
     partitionAllocBaseInit(root);
 
     // Precalculate some shift and mask constants used in the hot path.
     // Example: malloc(41) == 101001 binary.
     // Order is 6 (1 << 6-1)==32 is highest bit set.
     // orderIndex is the next three MSB == 010 == 2.
     // subOrderIndexMask is a mask for the remaining bits == 11 (masking to 01 for the subOrderIndex).
     size_t order;
     for (order = 0; order <= kBitsPerSizet; ++order) {
@@ skipping 56 matching lines @@
                 *bucketPtr++ = validBucket;
                 bucket++;
             }
         }
     }
     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;
-
-    spinLockUnlock(&root->lock);
 }
 
 static bool partitionAllocShutdownBucket(PartitionBucket* bucket)
 {
     // Failure here indicates a memory leak.
     bool foundLeak = bucket->numFullPages;
     for (PartitionPage* page = bucket->activePagesHead; page; page = page->nextPage)
         foundLeak |= (page->numAllocatedSlots > 0);
     return foundLeak;
 }
@@ skipping 28 matching lines @@
     for (i = 0; i < root->numBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets()[i];
         foundLeak |= partitionAllocShutdownBucket(bucket);
     }
     foundLeak |= partitionAllocBaseShutdown(root);
     return !foundLeak;
 }
 
 bool partitionAllocGenericShutdown(PartitionRootGeneric* root)
 {
-    spinLockLock(&root->lock);
+    SpinLock::Guard guard(root->lock);
     bool foundLeak = false;
     size_t i;
     for (i = 0; i < kGenericNumBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets[i];
         foundLeak |= partitionAllocShutdownBucket(bucket);
     }
     foundLeak |= partitionAllocBaseShutdown(root);
-    spinLockUnlock(&root->lock);
     return !foundLeak;
 }
 
 #if !CPU(64BIT)
 static NEVER_INLINE void partitionOutOfMemoryWithLotsOfUncommitedPages()
 {
     IMMEDIATE_CRASH();
 }
 #endif
 
@@ skipping 919 matching lines @@
     if (flags & PartitionPurgeDecommitEmptyPages)
         partitionDecommitEmptyPages(root);
     // We don't currently do anything for PartitionPurgeDiscardUnusedSystemPages
     // here because that flag is only useful for allocations >= system page
     // size. We only have allocations that large inside generic partitions
     // at the moment.
 }
 
 void partitionPurgeMemoryGeneric(PartitionRootGeneric* root, int flags)
 {
-    spinLockLock(&root->lock);
+    SpinLock::Guard guard(root->lock);
     if (flags & PartitionPurgeDecommitEmptyPages)
         partitionDecommitEmptyPages(root);
     if (flags & PartitionPurgeDiscardUnusedSystemPages) {
         for (size_t i = 0; i < kGenericNumBuckets; ++i) {
             PartitionBucket* bucket = &root->buckets[i];
             if (bucket->slotSize >= kSystemPageSize)
                 partitionPurgeBucket(bucket);
         }
     }
-    spinLockUnlock(&root->lock);
 }
 
 static void partitionDumpPageStats(PartitionBucketMemoryStats* statsOut, const PartitionPage* page)
 {
     uint16_t bucketNumSlots = partitionBucketSlots(page->bucket);
 
     if (partitionPageStateIsDecommitted(page)) {
         ++statsOut->numDecommittedPages;
         return;
     }
@@ skipping 57 matching lines @@
     }
 }
 
 void partitionDumpStatsGeneric(PartitionRootGeneric* partition, const char* partitionName, bool isLightDump, PartitionStatsDumper* partitionStatsDumper)
 {
     PartitionBucketMemoryStats bucketStats[kGenericNumBuckets];
     static const size_t kMaxReportableDirectMaps = 4096;
     uint32_t directMapLengths[kMaxReportableDirectMaps];
     size_t numDirectMappedAllocations = 0;
 
-    spinLockLock(&partition->lock);
+    {
+        SpinLock::Guard guard(partition->lock);
 
-    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);
+        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);
+        }
+
+        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;
+        }
     }
 
-    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.
     PartitionMemoryStats partitionStats = { 0 };
     partitionStats.totalMmappedBytes = partition->totalSizeOfSuperPages + partition->totalSizeOfDirectMappedPages;
     partitionStats.totalCommittedBytes = partition->totalSizeOfCommittedPages;
     for (size_t i = 0; i < kGenericNumBuckets; ++i) {
         if (bucketStats[i].isValid) {
             partitionStats.totalResidentBytes += bucketStats[i].residentBytes;
             partitionStats.totalActiveBytes += bucketStats[i].activeBytes;
@@ skipping 48 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF