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

third_party/tcmalloc/chromium/src/packed-cache-inl.h

 // 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 94 matching lines @@
 // entry is the high bits of a key and a value, packed together.
 // E.g., a 20 bit key and a 7 bit value only require a uint16 for each
 // entry if kHashbits >= 11.
 //
 // Alternatives to this scheme will be added as needed.
 
 #ifndef TCMALLOC_PACKED_CACHE_INL_H_
 #define TCMALLOC_PACKED_CACHE_INL_H_
 
 #include "config.h"
+#include <stddef.h>                     // for size_t
 #ifdef HAVE_STDINT_H
-#include <stdint.h>
+#include <stdint.h>                     // for uintptr_t
 #endif
-#include "base/basictypes.h"  // for COMPILE_ASSERT
+#include "base/basictypes.h"
 #include "internal_logging.h"
 
 // A safe way of doing "(1 << n) - 1" -- without worrying about overflow
 // Note this will all be resolved to a constant expression at compile-time
 #define N_ONES_(IntType, N)                                     \
   ( (N) == 0 ? 0 : ((static_cast<IntType>(1) << ((N)-1))-1 +    \
                     (static_cast<IntType>(1) << ((N)-1))) )
 
 // The types K and V provide upper bounds on the number of valid keys
 // and values, but we explicitly require the keys to be less than
 // 2^kKeybits and the values to be less than 2^kValuebits.  The size of
 // the table is controlled by kHashbits, and the type of each entry in
 // the cache is T.  See also the big comment at the top of the file.
 template <int kKeybits, typename T>
 class PackedCache {
  public:
   typedef uintptr_t K;
   typedef size_t V;
+#ifdef TCMALLOC_SMALL_BUT_SLOW
+  // Decrease the size map cache if running in the small memory mode.
   static const int kHashbits = 12;
+#else
+  static const int kHashbits = 16;
+#endif
   static const int kValuebits = 7;
   static const bool kUseWholeKeys = kKeybits + kValuebits <= 8 * sizeof(T);
 
   explicit PackedCache(V initial_value) {
     COMPILE_ASSERT(kKeybits <= sizeof(K) * 8, key_size);
     COMPILE_ASSERT(kValuebits <= sizeof(V) * 8, value_size);
     COMPILE_ASSERT(kHashbits <= kKeybits, hash_function);
     COMPILE_ASSERT(kKeybits - kHashbits + kValuebits <= kTbits,
                    entry_size_must_be_big_enough);
     Clear(initial_value);
@@ skipping 75 matching lines @@
   static const V kValueMask = N_ONES_(V, kValuebits);
 
   // array_ is the cache.  Its elements are volatile because any
   // thread can write any array element at any time.
   volatile T array_[1 << kHashbits];
 };
 
 #undef N_ONES_
 
 #endif  // TCMALLOC_PACKED_CACHE_INL_H_