doubly-linked free-lists for thread caches and page heaps

third_party/tcmalloc/chromium/src/common.h

-// Copyright (c) 2008, Google Inc.
+// Copyright (c) 2011, 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
@@ skipping 12 matching lines @@
 // 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.
 
 // ---
 // Author: Sanjay Ghemawat <opensource@google.com>
 //
 // Common definitions for tcmalloc code.
-
 #ifndef TCMALLOC_COMMON_H_
 #define TCMALLOC_COMMON_H_
 
 #include "config.h"
 #include <stddef.h>                     // for size_t
 #ifdef HAVE_STDINT_H
 #include <stdint.h>                     // for uintptr_t, uint64_t
 #endif
+#include "free_list.h"  // for SIZE_CLASS macros
 #include "internal_logging.h"  // for ASSERT, etc
 
 // Type that can hold a page number
 typedef uintptr_t PageID;
 
 // Type that can hold the length of a run of pages
 typedef uintptr_t Length;
 
 //-------------------------------------------------------------------
 // Configuration
@@ skipping 115 matching lines @@
       (((1 << kPageShift) * 8u + 127 + (120 << 7)) >> 7) + 1;
   unsigned char class_array_[kClassArraySize];
 
   // Compute index of the class_array[] entry for a given size
   static inline int ClassIndex(int s) {
     ASSERT(0 <= s);
     ASSERT(s <= kMaxSize);
     const bool big = (s > kMaxSmallSize);
     const int add_amount = big ? (127 + (120<<7)) : 7;
     const int shift_amount = big ? 7 : 3;
-    return (s + add_amount) >> shift_amount;
+    const int size_class = (s + add_amount) >> shift_amount;
+    if (HAS_64_BIT_POINTERS && s > 0 &&
+        size_class < FIRST_NON_0_SIZE_CLASS)
+      return FIRST_NON_0_SIZE_CLASS;

[jar (doing other things), 2011/08/26 18:56:29]

I haven't measured it... but I've been told that compilers optimize for the
if-true case, and assume that is most likely. The if-false case generally
requires a branch (and is slower).  As a result, I liked the code you had in the
last version better (since this seems to be a heavilly optimized piece of code).
 Possibly even better would be to test last for for the (rarer) s == 0 case. 
The code would then read:

if (!HAS_64_BIT_POINTERS ||
    (size_class > FIRST_NON_0_SIZE_CLASS) || (s == 0))
  return size_class;
return FIRST_NON_0_SIZE_CLASS;

[bxx, 2011/08/26 21:45:10]

Done.

+    return size_class;
   }
 
   int NumMoveSize(size_t size);
 
   // Mapping from size class to max size storable in that class
   size_t class_to_size_[kNumClasses];
 
   // Mapping from size class to number of pages to allocate at a time
   size_t class_to_pages_[kNumClasses];
 
@@ skipping 55 matching lines @@
 static const int kMaxStackDepth = 31;
 struct StackTrace {
   uintptr_t size;          // Size of object
   uintptr_t depth;         // Number of PC values stored in array below
   void*     stack[kMaxStackDepth];
 };
 
 }  // namespace tcmalloc
 
 #endif  // TCMALLOC_COMMON_H_