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

third_party/tcmalloc/chromium/src/tests/tcmalloc_unittest.cc

 // Copyright (c) 2005, 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 70 matching lines @@
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>        // defines pvalloc/etc on cygwin
 #endif
 #include <assert.h>
 #include <vector>
 #include <algorithm>
 #include <string>
 #include <new>
 #include "base/logging.h"
 #include "base/simple_mutex.h"
-#include "google/malloc_hook.h"
-#include "google/malloc_extension.h"
-#include "google/tcmalloc.h"
+#include "gperftools/malloc_hook.h"
+#include "gperftools/malloc_extension.h"
+#include "gperftools/tcmalloc.h"
 #include "thread_cache.h"
 #include "tests/testutil.h"
 
 // Windows doesn't define pvalloc and a few other obsolete unix
 // functions; nor does it define posix_memalign (which is not obsolete).
-#if defined(_MSC_VER) || defined(__MINGW32__)
+#if defined(_WIN32)
 # define cfree free         // don't bother to try to test these obsolete fns
 # define valloc malloc
 # define pvalloc malloc
 // I'd like to map posix_memalign to _aligned_malloc, but _aligned_malloc
 // must be paired with _aligned_free (not normal free), which is too
 // invasive a change to how we allocate memory here.  So just bail
-# include <errno.h>
-# define memalign(alignment, size)         malloc(size)
-# define posix_memalign(pptr, align, size) ((*(pptr)=malloc(size)) ? 0 : ENOMEM)
+static bool kOSSupportsMemalign = false;
+static inline void* Memalign(size_t align, size_t size) {
+  //LOG(FATAL) << "memalign not supported on windows";
+  exit(1);
+  return NULL;
+}
+static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
+  //LOG(FATAL) << "posix_memalign not supported on windows";
+  exit(1);
+  return -1;
+}
+
+// OS X defines posix_memalign in some OS versions but not others;
+// it's confusing enough to check that it's easiest to just not to test.
+#elif defined(__APPLE__)
+static bool kOSSupportsMemalign = false;
+static inline void* Memalign(size_t align, size_t size) {
+  //LOG(FATAL) << "memalign not supported on OS X";
+  exit(1);
+  return NULL;
+}
+static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
+  //LOG(FATAL) << "posix_memalign not supported on OS X";
+  exit(1);
+  return -1;
+}
+
+#else
+static bool kOSSupportsMemalign = true;
+static inline void* Memalign(size_t align, size_t size) {
+  return memalign(align, size);
+}
+static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
+  return posix_memalign(ptr, align, size);
+}
+
 #endif
 
 // On systems (like freebsd) that don't define MAP_ANONYMOUS, use the old
 // form of the name instead.
 #ifndef MAP_ANONYMOUS
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
 #define LOGSTREAM   stdout
 
@@ skipping 23 matching lines @@
 static const int FLAGS_allocweight = 50;    // Weight for picking allocation
 static const int FLAGS_freeweight = 50;     // Weight for picking free
 static const int FLAGS_updateweight = 10;   // Weight for picking update
 static const int FLAGS_passweight = 1;      // Weight for passing object
 
 static const int kSizeBits = 8 * sizeof(size_t);
 static const size_t kMaxSize = ~static_cast<size_t>(0);
 static const size_t kMaxSignedSize = ((size_t(1) << (kSizeBits-1)) - 1);
 
 static const size_t kNotTooBig = 100000;
-static const size_t kTooBig = kMaxSize;
+// We want an allocation that is definitely more than main memory.  OS
+// X has special logic to discard very big allocs before even passing
+// the request along to the user-defined memory allocator; we're not
+// interested in testing their logic, so we have to make sure we're
+// not *too* big.
+static const size_t kTooBig = kMaxSize - 100000;
 
 static int news_handled = 0;
 
 // Global array of threads
 class TesterThread;
 static TesterThread** threads;
 
 // To help with generating random numbers
 class TestHarness {
  private:
@@ skipping 76 matching lines @@
   assert(i < types_->size());
   if ((num_tests_ % FLAGS_log_every_n_tests) == 0) {
     fprintf(LOGSTREAM, "  Test %d out of %d: %s\n",
             num_tests_, FLAGS_numtests, (*types_)[i].name.c_str());
   }
   return (*types_)[i].type;
 }
 
 class AllocatorState : public TestHarness {
  public:
-  explicit AllocatorState(int seed) : TestHarness(seed) {
-    CHECK_GE(FLAGS_memalign_max_fraction, 0);
-    CHECK_LE(FLAGS_memalign_max_fraction, 1);
-    CHECK_GE(FLAGS_memalign_min_fraction, 0);
-    CHECK_LE(FLAGS_memalign_min_fraction, 1);
-    double delta = FLAGS_memalign_max_fraction - FLAGS_memalign_min_fraction;
-    CHECK_GE(delta, 0);
-    memalign_fraction_ = (Uniform(10000)/10000.0 * delta +
-                          FLAGS_memalign_min_fraction);
-    //fprintf(LOGSTREAM, "memalign fraction: %f\n", memalign_fraction_);
+  explicit AllocatorState(int seed) : TestHarness(seed), memalign_fraction_(0) {
+    if (kOSSupportsMemalign) {
+      CHECK_GE(FLAGS_memalign_max_fraction, 0);
+      CHECK_LE(FLAGS_memalign_max_fraction, 1);
+      CHECK_GE(FLAGS_memalign_min_fraction, 0);
+      CHECK_LE(FLAGS_memalign_min_fraction, 1);
+      double delta = FLAGS_memalign_max_fraction - FLAGS_memalign_min_fraction;
+      CHECK_GE(delta, 0);
+      memalign_fraction_ = (Uniform(10000)/10000.0 * delta +
+                            FLAGS_memalign_min_fraction);
+      //fprintf(LOGSTREAM, "memalign fraction: %f\n", memalign_fraction_);
+    }
   }
   virtual ~AllocatorState() {}
 
   // Allocate memory.  Randomly choose between malloc() or posix_memalign().
   void* alloc(size_t size) {
     if (Uniform(100) < memalign_fraction_ * 100) {
       // Try a few times to find a reasonable alignment, or fall back on malloc.
       for (int i = 0; i < 5; i++) {
         size_t alignment = 1 << Uniform(FLAGS_lg_max_memalign);
         if (alignment >= sizeof(intptr_t) &&
             (size < sizeof(intptr_t) ||
              alignment < FLAGS_memalign_max_alignment_ratio * size)) {
           void *result = reinterpret_cast<void*>(static_cast<intptr_t>(0x1234));
-          int err = posix_memalign(&result, alignment, size);
+          int err = PosixMemalign(&result, alignment, size);
           if (err != 0) {
             CHECK_EQ(err, ENOMEM);
           }
           return err == 0 ? result : NULL;
         }
       }
     }
     return malloc(size);
   }
 
@@ skipping 601 matching lines @@
 volatile bool g_no_memory = false;
 std::new_handler g_old_handler = NULL;
 static void OnNoMemory() {
   g_no_memory = true;
   std::set_new_handler(g_old_handler);
 }
 
 static void TestSetNewMode() {
   int old_mode = tc_set_new_mode(1);
 
-  // DebugAllocation will try to catch huge allocations.  We need to avoid this
-  // by requesting a smaller malloc block, that still can't be satisfied.
-  const size_t kHugeRequest = kTooBig - 1024;
-
   g_old_handler = std::set_new_handler(&OnNoMemory);
   g_no_memory = false;
-  void* ret = malloc(kHugeRequest);
+  void* ret = malloc(kTooBig);
   EXPECT_EQ(NULL, ret);
   EXPECT_TRUE(g_no_memory);
 
   g_old_handler = std::set_new_handler(&OnNoMemory);
   g_no_memory = false;
-  ret = calloc(1, kHugeRequest);
+  ret = calloc(1, kTooBig);
   EXPECT_EQ(NULL, ret);
   EXPECT_TRUE(g_no_memory);
 
   g_old_handler = std::set_new_handler(&OnNoMemory);
   g_no_memory = false;
-  ret = realloc(NULL, kHugeRequest);
+  ret = realloc(NULL, kTooBig);
   EXPECT_EQ(NULL, ret);
   EXPECT_TRUE(g_no_memory);
 
-  // Not really important, but must be small enough such that kAlignment +
-  // kHugeRequest does not overflow.
-  const int kAlignment = 1 << 5;
+  if (kOSSupportsMemalign) {
+    // Not really important, but must be small enough such that
+    // kAlignment + kTooBig does not overflow.
+    const int kAlignment = 1 << 5;
 
-  g_old_handler = std::set_new_handler(&OnNoMemory);
-  g_no_memory = false;
-  ret = memalign(kAlignment, kHugeRequest);
-  EXPECT_EQ(NULL, ret);
-  EXPECT_TRUE(g_no_memory);
+    g_old_handler = std::set_new_handler(&OnNoMemory);
+    g_no_memory = false;
+    ret = Memalign(kAlignment, kTooBig);
+    EXPECT_EQ(NULL, ret);
+    EXPECT_TRUE(g_no_memory);
 
-  g_old_handler = std::set_new_handler(&OnNoMemory);
-  g_no_memory = false;
-  EXPECT_EQ(ENOMEM,
-            posix_memalign(&ret, kAlignment, kHugeRequest));
-  EXPECT_EQ(NULL, ret);
-  EXPECT_TRUE(g_no_memory);
+    g_old_handler = std::set_new_handler(&OnNoMemory);
+    g_no_memory = false;
+    EXPECT_EQ(ENOMEM,
+              PosixMemalign(&ret, kAlignment, kTooBig));
+    EXPECT_EQ(NULL, ret);
+    EXPECT_TRUE(g_no_memory);
+  }
 
   tc_set_new_mode(old_mode);
 }
 
 static int RunAllTests(int argc, char** argv) {
   // Optional argv[1] is the seed
   AllocatorState rnd(argc > 1 ? atoi(argv[1]) : 100);
 
   SetTestResourceLimit();
 
@@ skipping 83 matching lines @@
     // We make sure we realloc to a big size, since some systems (OS
     // X) will notice if the realloced size continues to fit into the
     // malloc-block and make this a noop if so.
     p1 = realloc(p1, 30000);
     CHECK(p1 != NULL);
     VerifyNewHookWasCalled();
     VerifyDeleteHookWasCalled();
     cfree(p1);  // synonym for free
     VerifyDeleteHookWasCalled();
 
-    CHECK_EQ(posix_memalign(&p1, sizeof(p1), 40), 0);
-    CHECK(p1 != NULL);
-    VerifyNewHookWasCalled();
-    free(p1);
-    VerifyDeleteHookWasCalled();
+    if (kOSSupportsMemalign) {
+      CHECK_EQ(PosixMemalign(&p1, sizeof(p1), 40), 0);
+      CHECK(p1 != NULL);
+      VerifyNewHookWasCalled();
+      free(p1);
+      VerifyDeleteHookWasCalled();
 
-    p1 = memalign(sizeof(p1) * 2, 50);
-    CHECK(p1 != NULL);
-    VerifyNewHookWasCalled();
-    free(p1);
-    VerifyDeleteHookWasCalled();
+      p1 = Memalign(sizeof(p1) * 2, 50);
+      CHECK(p1 != NULL);
+      VerifyNewHookWasCalled();
+      free(p1);
+      VerifyDeleteHookWasCalled();
+    }
 
     // Windows has _aligned_malloc.  Let's test that that's captured too.
 #if (defined(_MSC_VER) || defined(__MINGW32__)) && !defined(PERFTOOLS_NO_ALIGNED_MALLOC)
     p1 = _aligned_malloc(sizeof(p1) * 2, 64);
+    CHECK(p1 != NULL);
     VerifyNewHookWasCalled();
     _aligned_free(p1);
     VerifyDeleteHookWasCalled();
 #endif
 
     p1 = valloc(60);
     CHECK(p1 != NULL);
     VerifyNewHookWasCalled();
     free(p1);
     VerifyDeleteHookWasCalled();
@@ skipping 217 matching lines @@
   int minor;
   const char* patch;
   char mmp[64];
   const char* human_version = tc_version(&major, &minor, &patch);
   snprintf(mmp, sizeof(mmp), "%d.%d%s", major, minor, patch);
   CHECK(!strcmp(PACKAGE_STRING, human_version));
   CHECK(!strcmp(PACKAGE_VERSION, mmp));
 
   fprintf(LOGSTREAM, "PASS\n");
 }