Move Partition Allocator into Chromium base.

base/allocator/partition_allocator/partition_alloc_unittest.cc

-/*
- * 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
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
 
-#include "wtf/allocator/PartitionAlloc.h"
+#include "base/allocator/partition_allocator/partition_alloc.h"
 
-#include "testing/gtest/include/gtest/gtest.h"
-#include "wtf/BitwiseOperations.h"
-#include "wtf/CPU.h"
-#include "wtf/PtrUtil.h"
-#include "wtf/Vector.h"
-#include <memory>
 #include <stdlib.h>
 #include <string.h>
 
-#if OS(POSIX)
+#include <memory>
+#include <vector>
+
+#include "base/bits.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(OS_POSIX)
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
-#endif  // OS(POSIX)
+#endif  // defined(OS_POSIX)
+
+namespace {
+template <typename T>
+std::unique_ptr<T[]> WrapArrayUnique(T* ptr) {
+  return std::unique_ptr<T[]>(ptr);
+}
+}  // namespace
 
 #if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 
-namespace WTF {
+namespace base {
 
 namespace {
 
 const size_t kTestMaxAllocation = 4096;
 SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
 PartitionAllocatorGeneric genericAllocator;
 
 const size_t kTestAllocSize = 16;
-#if !ENABLE(ASSERT)
+#if !DCHECK_IS_ON()
 const size_t kPointerOffset = 0;
 const size_t kExtraAllocSize = 0;
 #else
-const size_t kPointerOffset = WTF::kCookieSize;
-const size_t kExtraAllocSize = WTF::kCookieSize * 2;
+const size_t kPointerOffset = kCookieSize;
+const size_t kExtraAllocSize = kCookieSize * 2;
 #endif
 const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
-const size_t kTestBucketIndex = kRealAllocSize >> WTF::kBucketShift;
+const size_t kTestBucketIndex = kRealAllocSize >> kBucketShift;
 
 const char* typeName = nullptr;
 
 void TestSetup() {
   allocator.init();
   genericAllocator.init();
 }
 
 void TestShutdown() {
   // We expect no leaks in the general case. We have a test for leak
   // detection.
   EXPECT_TRUE(allocator.shutdown());
   EXPECT_TRUE(genericAllocator.shutdown());
 }
 
-#if !CPU(64BIT) || OS(POSIX)
+#if !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 bool SetAddressSpaceLimit() {
-#if !CPU(64BIT)
+#if !defined(ARCH_CPU_64_BITS)
   // 32 bits => address space is limited already.
   return true;
-#elif OS(POSIX) && !OS(MACOSX)
+#elif defined(OS_POSIX) && !defined(OS_MACOSX)
   // Mac will accept RLIMIT_AS changes but it is not enforced.
   // See https://crbug.com/435269 and rdar://17576114.
   const size_t kAddressSpaceLimit = static_cast<size_t>(4096) * 1024 * 1024;
   struct rlimit limit;
   if (getrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > kAddressSpaceLimit) {
     limit.rlim_cur = kAddressSpaceLimit;
     if (setrlimit(RLIMIT_AS, &limit) != 0)
       return false;
   }
   return true;
 #else
   return false;
 #endif
 }
 
 bool ClearAddressSpaceLimit() {
-#if !CPU(64BIT)
+#if !defined(ARCH_CPU_64_BITS)
   return true;
-#elif OS(POSIX)
+#elif defined(OS_POSIX)
   struct rlimit limit;
   if (getrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   limit.rlim_cur = limit.rlim_max;
   if (setrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   return true;
 #else
   return false;
 #endif
@@ skipping 39 matching lines @@
   for (i = 0; i < numSlots; ++i) {
     partitionFree(ptr + kPointerOffset);
     ptr += size;
   }
 }
 
 void CycleFreeCache(size_t size) {
   size_t realSize = size + kExtraAllocSize;
   size_t bucketIdx = realSize >> kBucketShift;
   PartitionBucket* bucket = &allocator.root()->buckets()[bucketIdx];
-  ASSERT(!bucket->activePagesHead->numAllocatedSlots);
+  DCHECK(!bucket->activePagesHead->numAllocatedSlots);
 
   for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
     void* ptr = partitionAlloc(allocator.root(), size, typeName);
     EXPECT_EQ(1, bucket->activePagesHead->numAllocatedSlots);
     partitionFree(ptr);
     EXPECT_EQ(0, bucket->activePagesHead->numAllocatedSlots);
     EXPECT_NE(-1, bucket->activePagesHead->emptyCacheIndex);
   }
 }
 
 void CycleGenericFreeCache(size_t size) {
   for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
     void* ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
     PartitionPage* page =
         partitionPointerToPage(partitionCookieFreePointerAdjust(ptr));
     PartitionBucket* bucket = page->bucket;
     EXPECT_EQ(1, bucket->activePagesHead->numAllocatedSlots);
     partitionFreeGeneric(genericAllocator.root(), ptr);
     EXPECT_EQ(0, bucket->activePagesHead->numAllocatedSlots);
     EXPECT_NE(-1, bucket->activePagesHead->emptyCacheIndex);
   }
 }
 
 void CheckPageInCore(void* ptr, bool inCore) {
-#if OS(LINUX)
+#if defined(OS_LINUX)
   unsigned char ret;
   EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
   EXPECT_EQ(inCore, ret);
 #endif
 }
 
 class MockPartitionStatsDumper : public PartitionStatsDumper {
  public:
   MockPartitionStatsDumper()
       : m_totalResidentBytes(0),
         m_totalActiveBytes(0),
         m_totalDecommittableBytes(0),
         m_totalDiscardableBytes(0) {}
 
   void partitionDumpTotals(const char* partitionName,
                            const PartitionMemoryStats* memoryStats) override {
     EXPECT_GE(memoryStats->totalMmappedBytes, memoryStats->totalResidentBytes);
     EXPECT_EQ(m_totalResidentBytes, memoryStats->totalResidentBytes);
     EXPECT_EQ(m_totalActiveBytes, memoryStats->totalActiveBytes);
     EXPECT_EQ(m_totalDecommittableBytes, memoryStats->totalDecommittableBytes);
     EXPECT_EQ(m_totalDiscardableBytes, memoryStats->totalDiscardableBytes);
   }
 
   void partitionsDumpBucketStats(
       const char* partitionName,
       const PartitionBucketMemoryStats* memoryStats) override {
     (void)partitionName;
     EXPECT_TRUE(memoryStats->isValid);
     EXPECT_EQ(0u, memoryStats->bucketSlotSize & kAllocationGranularityMask);
-    m_bucketStats.append(*memoryStats);
+    m_bucketStats.push_back(*memoryStats);
     m_totalResidentBytes += memoryStats->residentBytes;
     m_totalActiveBytes += memoryStats->activeBytes;
     m_totalDecommittableBytes += memoryStats->decommittableBytes;
     m_totalDiscardableBytes += memoryStats->discardableBytes;
   }
 
   bool IsMemoryAllocationRecorded() {
     return m_totalResidentBytes != 0 && m_totalActiveBytes != 0;
   }
 
   const PartitionBucketMemoryStats* GetBucketStats(size_t bucketSize) {
     for (size_t i = 0; i < m_bucketStats.size(); ++i) {
       if (m_bucketStats[i].bucketSlotSize == bucketSize)
         return &m_bucketStats[i];
     }
     return 0;
   }
 
  private:
   size_t m_totalResidentBytes;
   size_t m_totalActiveBytes;
   size_t m_totalDecommittableBytes;
   size_t m_totalDiscardableBytes;
 
-  Vector<PartitionBucketMemoryStats> m_bucketStats;
+  std::vector<PartitionBucketMemoryStats> m_bucketStats;
 };
 
 }  // anonymous namespace
 
 // Check that the most basic of allocate / free pairs work.
 TEST(PartitionAllocTest, Basic) {
   TestSetup();
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
   PartitionPage* seedPage = &PartitionRootGeneric::gSeedPage;
 
@@ skipping 182 matching lines @@
 TEST(PartitionAllocTest, FreePageListPageTransitions) {
   TestSetup();
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
   size_t numToFillFreeListPage =
       kPartitionPageSize / (sizeof(PartitionPage) + kExtraAllocSize);
   // The +1 is because we need to account for the fact that the current page
   // never gets thrown on the freelist.
   ++numToFillFreeListPage;
   std::unique_ptr<PartitionPage* []> pages =
-      wrapArrayUnique(new PartitionPage*[numToFillFreeListPage]);
+      WrapArrayUnique(new PartitionPage*[numToFillFreeListPage]);
 
   size_t i;
   for (i = 0; i < numToFillFreeListPage; ++i) {
     pages[i] = GetFullPage(kTestAllocSize);
   }
   EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->activePagesHead);
   for (i = 0; i < numToFillFreeListPage; ++i)
     FreeFullPage(pages[i]);
   EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
   EXPECT_TRUE(bucket->emptyPagesHead);
@@ skipping 25 matching lines @@
   TestSetup();
   // This is guaranteed to cross a super page boundary because the first
   // partition page "slot" will be taken up by a guard page.
   size_t numPagesNeeded = kNumPartitionPagesPerSuperPage;
   // The super page should begin and end in a guard so we one less page in
   // order to allocate a single page in the new super page.
   --numPagesNeeded;
 
   EXPECT_GT(numPagesNeeded, 1u);
   std::unique_ptr<PartitionPage* []> pages;
-  pages = wrapArrayUnique(new PartitionPage*[numPagesNeeded]);
+  pages = WrapArrayUnique(new PartitionPage*[numPagesNeeded]);
   uintptr_t firstSuperPageBase = 0;
   size_t i;
   for (i = 0; i < numPagesNeeded; ++i) {
     pages[i] = GetFullPage(kTestAllocSize);
     void* storagePtr = partitionPageToPointer(pages[i]);
     if (!i)
       firstSuperPageBase =
           reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
     if (i == numPagesNeeded - 1) {
       uintptr_t secondSuperPageBase =
@@ skipping 40 matching lines @@
                                    kGenericSmallestBucket, typeName);
   EXPECT_EQ(ptr, newPtr);
 
   // Change the size of the realloc, switching buckets.
   newPtr = partitionReallocGeneric(genericAllocator.root(), ptr,
                                    kGenericSmallestBucket + 1, typeName);
   EXPECT_NE(newPtr, ptr);
   // Check that the realloc copied correctly.
   char* newCharPtr = static_cast<char*>(newPtr);
   EXPECT_EQ(*newCharPtr, 'A');
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Subtle: this checks for an old bug where we copied too much from the
   // source of the realloc. The condition can be detected by a trashing of
   // the uninitialized value in the space of the upsized allocation.
   EXPECT_EQ(kUninitializedByte,
             static_cast<unsigned char>(*(newCharPtr + kGenericSmallestBucket)));
 #endif
   *newCharPtr = 'B';
   // The realloc moved. To check that the old allocation was freed, we can
   // do an alloc of the old allocation size and check that the old allocation
   // address is at the head of the freelist and reused.
@@ skipping 90 matching lines @@
   partitionFreeGeneric(genericAllocator.root(), ptr3);
   partitionFreeGeneric(genericAllocator.root(), ptr2);
   // Should be freeable at this point.
   EXPECT_NE(-1, page->emptyCacheIndex);
   EXPECT_EQ(0, page->numAllocatedSlots);
   EXPECT_EQ(0, page->numUnprovisionedSlots);
   void* newPtr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
   EXPECT_EQ(ptr3, newPtr);
   newPtr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
   EXPECT_EQ(ptr2, newPtr);
-#if OS(LINUX) && !ENABLE(ASSERT)
+#if defined(OS_LINUX) && !DCHECK_IS_ON()
   // On Linux, we have a guarantee that freelisting a page should cause its
   // contents to be nulled out. We check for null here to detect an bug we
   // had where a large slot size was causing us to not properly free all
   // resources back to the system.
   // We only run the check when asserts are disabled because when they are
   // enabled, the allocated area is overwritten with an "uninitialized"
   // byte pattern.
   EXPECT_EQ(0, *(reinterpret_cast<char*>(newPtr) + (size - 1)));
 #endif
   partitionFreeGeneric(genericAllocator.root(), newPtr);
@@ skipping 115 matching lines @@
   size_t size = kSystemPageSize - kExtraAllocSize;
   EXPECT_EQ(size, partitionAllocActualSize(genericAllocator.root(), size));
   ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
   memset(ptr, 'A', size);
   ptr2 =
       partitionReallocGeneric(genericAllocator.root(), ptr, size + 1, typeName);
   EXPECT_NE(ptr, ptr2);
   char* charPtr2 = static_cast<char*>(ptr2);
   EXPECT_EQ('A', charPtr2[0]);
   EXPECT_EQ('A', charPtr2[size - 1]);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr2[size]));
 #endif
 
   // Test that shrinking an allocation with realloc() also copies everything
   // from the old allocation.
   ptr = partitionReallocGeneric(genericAllocator.root(), ptr2, size - 1,
                                 typeName);
   EXPECT_NE(ptr2, ptr);
   char* charPtr = static_cast<char*>(ptr);
   EXPECT_EQ('A', charPtr[0]);
   EXPECT_EQ('A', charPtr[size - 2]);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));
 #endif
 
   partitionFreeGeneric(genericAllocator.root(), ptr);
 
   // Test that shrinking a direct mapped allocation happens in-place.
   size = kGenericMaxBucketed + 16 * kSystemPageSize;
   ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
   size_t actualSize = partitionAllocGetSize(ptr);
   ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr,
@@ skipping 233 matching lines @@
   TestShutdown();
 }
 
 // Test correct handling if our mapping collides with another.
 TEST(PartitionAllocTest, MappingCollision) {
   TestSetup();
   // The -2 is because the first and last partition pages in a super page are
   // guard pages.
   size_t numPartitionPagesNeeded = kNumPartitionPagesPerSuperPage - 2;
   std::unique_ptr<PartitionPage* []> firstSuperPagePages =
-      wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
+      WrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
   std::unique_ptr<PartitionPage* []> secondSuperPagePages =
-      wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
+      WrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
 
   size_t i;
   for (i = 0; i < numPartitionPagesNeeded; ++i)
     firstSuperPagePages[i] = GetFullPage(kTestAllocSize);
 
   char* pageBase =
       reinterpret_cast<char*>(partitionPageToPointer(firstSuperPagePages[0]));
   EXPECT_EQ(kPartitionPageSize,
             reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
   pageBase -= kPartitionPageSize;
@@ skipping 170 matching lines @@
   EXPECT_TRUE(ptr);
   partitionFreeGeneric(genericAllocator.root(), ptr);
 
   EXPECT_TRUE(bucket->activePagesHead);
   EXPECT_TRUE(bucket->emptyPagesHead);
   EXPECT_TRUE(bucket->decommittedPagesHead);
 
   TestShutdown();
 }
 
-#if !CPU(64BIT) || OS(POSIX)
+#if !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
 static void DoReturnNullTest(size_t allocSize) {
   TestSetup();
 
   EXPECT_TRUE(SetAddressSpaceLimit());
 
   // Work out the number of allocations for 6 GB of memory.
   const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
 
   void** ptrs = reinterpret_cast<void**>(partitionAllocGeneric(
@@ skipping 32 matching lines @@
 
   EXPECT_TRUE(ClearAddressSpaceLimit());
 
   TestShutdown();
 }
 
 // Tests that if an allocation fails in "return null" mode, repeating it doesn't
 // crash, and still returns null. The test tries to allocate 6 GB of memory in
 // 512 kB blocks. On 64-bit POSIX systems, the address space is limited to 4 GB
 // using setrlimit() first.
-#if OS(MACOSX)
+#if defined(OS_MACOSX)
 #define MAYBE_RepeatedReturnNull DISABLED_RepeatedReturnNull
 #else
 #define MAYBE_RepeatedReturnNull RepeatedReturnNull
 #endif
 TEST(PartitionAllocTest, MAYBE_RepeatedReturnNull) {
   // A single-slot but non-direct-mapped allocation size.
   DoReturnNullTest(512 * 1024);
 }
 
 // Another "return null" test but for larger, direct-mapped allocations.
-#if OS(MACOSX)
+#if defined(OS_MACOSX)
 #define MAYBE_RepeatedReturnNullDirect DISABLED_RepeatedReturnNullDirect
 #else
 #define MAYBE_RepeatedReturnNullDirect RepeatedReturnNullDirect
 #endif
 TEST(PartitionAllocTest, MAYBE_RepeatedReturnNullDirect) {
   // A direct-mapped allocation size.
   DoReturnNullTest(256 * 1024 * 1024);
 }
 
-#endif  // !CPU(64BIT) || OS(POSIX)
+#endif  // !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
-#if !OS(ANDROID)
+// Death tests misbehave on Android, http://crbug.com/643760.
+#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 
 // Make sure that malloc(-1) dies.
 // In the past, we had an integer overflow that would alias malloc(-1) to
 // malloc(0), which is not good.
 TEST(PartitionAllocDeathTest, LargeAllocs) {
   TestSetup();
   // Largest alloc.
   EXPECT_DEATH(partitionAllocGeneric(genericAllocator.root(),
                                      static_cast<size_t>(-1), typeName),
                "");
@@ skipping 89 matching lines @@
   EXPECT_TRUE(ptr);
   char* badPtr = reinterpret_cast<char*>(ptr) + kPartitionPageSize;
 
   EXPECT_DEATH(partitionFreeGeneric(genericAllocator.root(), badPtr), "");
 
   partitionFreeGeneric(genericAllocator.root(), ptr);
 
   TestShutdown();
 }
 
-#endif  // !OS(ANDROID)
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 // Tests that partitionDumpStatsGeneric and partitionDumpStats runs without
 // crashing and returns non zero values when memory is allocated.
 TEST(PartitionAllocTest, DumpMemoryStats) {
   TestSetup();
   {
     void* ptr = partitionAlloc(allocator.root(), kTestAllocSize, typeName);
     MockPartitionStatsDumper mockStatsDumper;
     partitionDumpStats(allocator.root(), "mock_allocator",
                        false /* detailed dump */, &mockStatsDumper);
@@ skipping 640 matching lines @@
 
     EXPECT_FALSE(page->freelistHead);
 
     partitionFreeGeneric(genericAllocator.root(), ptr1);
     partitionFreeGeneric(genericAllocator.root(), ptr2);
   }
 
   TestShutdown();
 }
 
-}  // namespace WTF
+TEST(PartitionAllocTest, CLZWorks) {
+  EXPECT_EQ(32u, bits::CountLeadingZeroBits32(0u));
+  EXPECT_EQ(31u, bits::CountLeadingZeroBits32(1u));
+  EXPECT_EQ(1u, bits::CountLeadingZeroBits32(1u << 30));
+  EXPECT_EQ(0u, bits::CountLeadingZeroBits32(1u << 31));
+
+#if defined(ARCH_CPU_64_BITS)
+  EXPECT_EQ(64u, bits::CountLeadingZeroBitsSizeT(0ull));
+  EXPECT_EQ(63u, bits::CountLeadingZeroBitsSizeT(1ull));
+  EXPECT_EQ(32u, bits::CountLeadingZeroBitsSizeT(1ull << 31));
+  EXPECT_EQ(1u, bits::CountLeadingZeroBitsSizeT(1ull << 62));
+  EXPECT_EQ(0u, bits::CountLeadingZeroBitsSizeT(1ull << 63));
+#else
+  EXPECT_EQ(32u, bits::CountLeadingZeroBitsSizeT(0u));
+  EXPECT_EQ(31u, bits::CountLeadingZeroBitsSizeT(1u));
+  EXPECT_EQ(1u, bits::CountLeadingZeroBitsSizeT(1u << 30));
+  EXPECT_EQ(0u, bits::CountLeadingZeroBitsSizeT(1u << 31));
+#endif
+}
+
+}  // namespace base
 
 #endif  // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)