Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/base/low_level_alloc.cc

 /* Copyright (c) 2006, 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 41 matching lines @@
 // form of the name instead.
 #ifndef MAP_ANONYMOUS
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
 // A first-fit allocator with amortized logarithmic free() time.
 
 // ---------------------------------------------------------------------------
 static const int kMaxLevel = 30;
 
-namespace {
+// We put this class-only struct in a namespace to avoid polluting the
+// global namespace with this struct name (thus risking an ODR violation).
+namespace low_level_alloc_internal {
   // This struct describes one allocated block, or one free block.
   struct AllocList {
     struct Header {
       intptr_t size;  // size of entire region, including this field. Must be
                       // first.  Valid in both allocated and unallocated blocks
       intptr_t magic; // kMagicAllocated or kMagicUnallocated xor this
       LowLevelAlloc::Arena *arena; // pointer to parent arena
       void *dummy_for_alignment;   // aligns regions to 0 mod 2*sizeof(void*)
     } header;
 
     // Next two fields: in unallocated blocks: freelist skiplist data
     //                  in allocated blocks: overlaps with client data
     int levels;           // levels in skiplist used
     AllocList *next[kMaxLevel];   // actually has levels elements.
                                   // The AllocList node may not have room for
                                   // all kMaxLevel entries.  See max_fit in
                                   // LLA_SkiplistLevels()
   };
 }
+using low_level_alloc_internal::AllocList;
+
 
 // ---------------------------------------------------------------------------
 // A trivial skiplist implementation.  This is used to keep the freelist
 // in address order while taking only logarithmic time per insert and delete.
 
 // An integer approximation of log2(size/base)
 // Requires size >= base.
 static int IntLog2(size_t size, size_t base) {
   int result = 0;
   for (size_t i = size; i > base; i >>= 1) { // i == floor(size/2**result)
@@ skipping 109 matching lines @@
 // do not want malloc hook reporting, so that for them there's no malloc hook
 // reporting even during arena creation.
 static struct LowLevelAlloc::Arena unhooked_arena;
 static struct LowLevelAlloc::Arena unhooked_async_sig_safe_arena;
 
 // magic numbers to identify allocated and unallocated blocks
 static const intptr_t kMagicAllocated = 0x4c833e95;
 static const intptr_t kMagicUnallocated = ~kMagicAllocated;
 
 namespace {
-  class ArenaLock {
+  class SCOPED_LOCKABLE ArenaLock {
    public:
     explicit ArenaLock(LowLevelAlloc::Arena *arena)
         EXCLUSIVE_LOCK_FUNCTION(arena->mu)
         : left_(false), mask_valid_(false), arena_(arena) {
       if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
       // We've decided not to support async-signal-safe arena use until
       // there a demonstrated need.  Here's how one could do it though
       // (would need to be made more portable).
 #if 0
         sigset_t all;
         sigfillset(&all);
         this->mask_valid_ =
             (pthread_sigmask(SIG_BLOCK, &all, &this->mask_) == 0);
 #else
         RAW_CHECK(false, "We do not yet support async-signal-safe arena.");
 #endif
       }
       this->arena_->mu.Lock();
     }
     ~ArenaLock() { RAW_CHECK(this->left_, "haven't left Arena region"); }
-    void Leave() UNLOCK_FUNCTION(arena_->mu) {
+    void Leave() UNLOCK_FUNCTION() {
       this->arena_->mu.Unlock();
 #if 0
       if (this->mask_valid_) {
         pthread_sigmask(SIG_SETMASK, &this->mask_, 0);
       }
 #endif
       this->left_ = true;
     }
    private:
     bool left_;       // whether left region
@@ skipping 266 matching lines @@
     // this call must be directly in the user-called allocator function
     // for MallocHook::GetCallerStackTrace to work properly
     MallocHook::InvokeNewHook(result, request);
   }
   return result;
 }
 
 LowLevelAlloc::Arena *LowLevelAlloc::DefaultArena() {
   return &default_arena;
 }