Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/tests/system-alloc_unittest.cc

 // Copyright (c) 2007, 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 22 matching lines @@
 #include "config_for_unittests.h"
 #include "system-alloc.h"
 #include <stdio.h>
 #if defined HAVE_STDINT_H
 #include <stdint.h>             // to get uintptr_t
 #elif defined HAVE_INTTYPES_H
 #include <inttypes.h>           // another place uintptr_t might be defined
 #endif
 #include <sys/types.h>
 #include <algorithm>
+#include <limits>
 #include "base/logging.h"               // for Check_GEImpl, Check_LTImpl, etc
-#include <google/malloc_extension.h>    // for MallocExtension::instance
+#include <gperftools/malloc_extension.h>    // for MallocExtension::instance
 #include "common.h"                     // for kAddressBits
 
 class ArraySysAllocator : public SysAllocator {
 public:
   // Was this allocator invoked at least once?
   bool invoked_;
 
   ArraySysAllocator() : SysAllocator() {
     ptr_ = 0;
     invoked_ = false;
@@ skipping 21 matching lines @@
     if ((ptr & (alignment-1)) != 0) {
       ptr += alignment - (ptr & (alignment-1));
     }
 
     ptr_ += size;
     return reinterpret_cast<void *>(ptr);
   }
 
   void DumpStats() {
   }
-  void FlagsInitialized() {}
 
 private:
   static const int kArraySize = 8 * 1024 * 1024;
   char array_[kArraySize];
   // We allocate the next chunk from here
   int ptr_;
 
 };
 const int ArraySysAllocator::kArraySize;
 ArraySysAllocator a;
@@ skipping 11 matching lines @@
 }
 
 #if 0  // could port this to various OSs, but won't bother for now
 TEST(AddressBits, CpuVirtualBits) {
   // Check that kAddressBits is as least as large as either the number of bits
   // in a pointer or as the number of virtual bits handled by the processor.
   // To be effective this test must be run on each processor model.
   const int kPointerBits = 8 * sizeof(void*);
   const int kImplementedVirtualBits = NumImplementedVirtualBits();
 
-  CHECK_GE(kAddressBits, min(kImplementedVirtualBits, kPointerBits));
+  CHECK_GE(kAddressBits, std::min(kImplementedVirtualBits, kPointerBits));
 }
 #endif
 
 static void TestBasicRetryFailTest() {
   // Check with the allocator still works after a failed allocation.
-  void* p = malloc(1ULL << 50);  // Asking for 1P ram
-  CHECK(p == NULL);
+  //
+  // There is no way to call malloc and guarantee it will fail.  malloc takes a
+  // size_t parameter and the C++ standard does not constrain the size of
+  // size_t.  For example, consider an implementation where size_t is 32 bits
+  // and pointers are 64 bits.
+  //
+  // It is likely, though, that sizeof(size_t) == sizeof(void*).  In that case,
+  // the first allocation here might succeed but the second allocation must
+  // fail.
+  //
+  // If the second allocation succeeds, you will have to rewrite or
+  // disable this test.
+  // The weird parens are to avoid macro-expansion of 'max' on windows.
+  const size_t kHugeSize = (std::numeric_limits<size_t>::max)() / 2;
+  void* p1 = malloc(kHugeSize);
+  void* p2 = malloc(kHugeSize);
+  CHECK(p2 == NULL);
+  if (p1 != NULL) free(p1);
 
   char* q = new char[1024];
   CHECK(q != NULL);
   delete [] q;
 }
 
 int main(int argc, char** argv) {
   TestBasicInvoked();
   TestBasicRetryFailTest();
 
   printf("PASS\n");
   return 0;
 }