Revert of 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 {
 
-SpinLock PartitionRootBase::gInitializedLock;
+int PartitionRootBase::gInitializedLock = 0;
 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);
-    {
-        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;
-        }
+
+    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;
     }
+    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)
 {
-    SpinLock::Guard guard(root->lock);
+    spinLockLock(&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)
 {
-    SpinLock::Guard guard(root->lock);
+    spinLockLock(&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)
 {
-    SpinLock::Guard guard(root->lock);
+    spinLockLock(&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;
 
-    {
-        SpinLock::Guard guard(partition->lock);
+    spinLockLock(&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