Modify allocator_shim to support _aligned_alloc(), _aligned_free().

base/allocator/allocator_unittests.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <algorithm>   // for min()
 #include "base/atomicops.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 461 matching lines @@
       unsigned char* dst =
           reinterpret_cast<unsigned char*>(_recalloc(src, 1, dst_size));
       EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
       EXPECT_TRUE(Valid(dst, dst_size));
       if (dst != NULL)
         free(dst);
     }
   }
 }
+
+// Test windows specific _aligned_malloc() and _aligned_free() methods.
+TEST(Allocators, AlignedMalloc) {
+  // Try allocating data with a bunch of alignments and sizes
+  static const int kTestAlignments[] = {8, 16, 256, 4096};
+  for (int size = 1; size < 1048576; size *= 2) {

[jar (doing other things), 2012/07/30 23:04:22]

By accident, tcmalloc will tend(?) to pass this test, as new (never before seen)
sizes are usually allocated out of a thread-local heap of a given "size class." 
Each time we try a new size, we will usually get the first element of a span,
which is a 4K aligned allocation).

It would probably be nicer if you would try for some larger alignment factors
(over 4K), and it would also be nicer if you asked for two aligned allocation of
each size (so that we'd be assured we weren't just getting the first item from a
class.

[DaleCurtis, 2012/07/31 00:44:22]

Added 8192, 16384 alignments and allocate two per pass.

+    for (int i = 0; i < ARRAYSIZE(kTestAlignments); ++i) {
+      unsigned char* ptr = reinterpret_cast<unsigned char*>(
+          _aligned_malloc(size, kTestAlignments[i]));

[jar (doing other things), 2012/07/30 23:04:22]

I'd also suggest you allocate "size + 1" to avoid asking for powers of 2, which
*might* have a better shot an nice alignment IMO.

[DaleCurtis, 2012/07/31 00:44:22]

Switched to using NextSize() as many of the other tests here are using.  Tries
power_of_2-1, power_of_2, power_of_2+1.

+      CheckAlignment(ptr, kTestAlignments[i]);
+      Fill(ptr, size);
+      EXPECT_TRUE(Valid(ptr, size));
+      _aligned_free(ptr);
+    }
+  }
+}
+
 #endif
 
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }