Reorder checks in tcmalloc.

third_party/tcmalloc/chromium/src/tcmalloc.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 1044 matching lines @@
 }
 
 // Helper for do_malloc().
 inline void* do_malloc_pages(ThreadCache* heap, size_t size) {
   void* result;
   bool report_large;
 
   Length num_pages = tcmalloc::pages(size);
   size = num_pages << kPageShift;
 
-  heap->AddToByteAllocatedTotal(size);  // Chromium profiling.
+  // Chromium profiling.  Measurements in March 2013 suggest this
+  // imposes a small enough runtime cost that there's no reason to
+  // try to optimize it.
+  heap->AddToByteAllocatedTotal(size);
 
   if ((FLAGS_tcmalloc_sample_parameter > 0) && heap->SampleAllocation(size)) {
     result = DoSampledAllocation(size);
 
     SpinLockHolder h(Static::pageheap_lock());
     report_large = should_report_large(num_pages);
   } else {
     SpinLockHolder h(Static::pageheap_lock());
     Span* span = Static::pageheap()->New(num_pages);
     result = (span == NULL ? NULL : SpanToMallocResult(span));
     report_large = should_report_large(num_pages);
   }
 
   if (report_large) {
     ReportLargeAlloc(num_pages, result);
   }
   return result;
 }
 
 inline void* do_malloc(size_t size) {
   AddRoomForMark(&size);
 
   void* ret = NULL;
 
   // The following call forces module initialization
   ThreadCache* heap = ThreadCache::GetCache();
-  // First, check if our security policy allows this size.
-  if (IsAllocSizePermitted(size)) {
-    if (size <= kMaxSize) {
-      size_t cl = Static::sizemap()->SizeClass(size);
-      size = Static::sizemap()->class_to_size(cl);
+  if (size <= kMaxSize && IsAllocSizePermitted(size)) {
+    size_t cl = Static::sizemap()->SizeClass(size);
+    size = Static::sizemap()->class_to_size(cl);
 
-      // TODO(jar): If this has any detectable performance impact, it can be
-      // optimized by only tallying sizes if the profiler was activated to
-      // recall these tallies.  I don't think this is performance critical, but
-      // we really should measure it.
-      heap->AddToByteAllocatedTotal(size);  // Chromium profiling.
+    // Chromium profiling.  Measurements in March 2013 suggest this
+    // imposes a small enough runtime cost that there's no reason to
+    // try to optimize it.
+    heap->AddToByteAllocatedTotal(size);
 
-      if ((FLAGS_tcmalloc_sample_parameter > 0) &&
-          heap->SampleAllocation(size)) {
-        ret = DoSampledAllocation(size);
-        MarkAllocatedRegion(ret);
-      } else {
-        // The common case, and also the simplest.  This just pops the
-        // size-appropriate freelist, after replenishing it if it's empty.
-        ret = CheckMallocResult(heap->Allocate(size, cl));
-      }
+    if ((FLAGS_tcmalloc_sample_parameter > 0) &&
+        heap->SampleAllocation(size)) {
+      ret = DoSampledAllocation(size);
+      MarkAllocatedRegion(ret);
     } else {
-      ret = do_malloc_pages(heap, size);
-      MarkAllocatedRegion(ret);
+      // The common case, and also the simplest.  This just pops the
+      // size-appropriate freelist, after replenishing it if it's empty.
+      ret = CheckMallocResult(heap->Allocate(size, cl));
     }
+  } else if (IsAllocSizePermitted(size)) {
+    ret = do_malloc_pages(heap, size);
+    MarkAllocatedRegion(ret);
   }
   if (ret == NULL) errno = ENOMEM;
+  ASSERT(IsAllocSizePermitted(size) || ret == NULL);
   return ret;
 }
 
 inline void* do_calloc(size_t n, size_t elem_size) {
   // Overflow check
   const size_t size = n * elem_size;
   if (elem_size != 0 && size / elem_size != n) return NULL;
 
   void* result = do_malloc_or_cpp_alloc(size);
   if (result != NULL) {
@@ skipping 742 matching lines @@
   *mark = ~allocated_mark;  //  Distinctively not allocated.
 }
 
 static void MarkAllocatedRegion(void* ptr) {
   if (ptr == NULL) return;
   MarkType* mark = GetMarkLocation(ptr);
   *mark = GetMarkValue(ptr, mark);
 }
 
 #endif  // TCMALLOC_VALIDATION