src/third_party/tcmalloc/vendor/src/tests/memalign_unittest.cc

   1 // Copyright (c) 2004, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 // ---
  31 // Author: Sanjay Ghemawat
  32 //
  33 // Check memalign related routines.
  34 //
  35 // We can't really do a huge amount of checking, but at the very
  36 // least, the following code checks that return values are properly
  37 // aligned, and that writing into the objects works.
  38
  39 #include "config_for_unittests.h"
  40
  41 // Complicated ordering requirements.  tcmalloc.h defines (indirectly)
  42 // _POSIX_C_SOURCE, which it needs so stdlib.h defines posix_memalign.
  43 // unistd.h, on the other hand, requires _POSIX_C_SOURCE to be unset,
  44 // at least on Mac OS X, in order to define getpagesize.  The solution
  45 // is to #include unistd.h first.  This is safe because unistd.h
  46 // doesn't sub-include stdlib.h, so we'll still get posix_memalign
  47 // when we #include stdlib.h.  Blah.
  48 #ifdef HAVE_UNISTD_H
  49 #include <unistd.h>        // for getpagesize()
  50 #endif
  51 #include "tcmalloc.h"      // must come early, to pick up posix_memalign
  52 #include <assert.h>
  53 #include <stdlib.h>        // defines posix_memalign
  54 #include <stdio.h>         // for the printf at the end
  55 #ifdef HAVE_STDINT_H
  56 #include <stdint.h>        // for uintptr_t
  57 #endif
  58 #ifdef HAVE_UNISTD_H
  59 #include <unistd.h>        // for getpagesize()
  60 #endif
  61 // Malloc can be in several places on older versions of OS X.
  62 #if defined(HAVE_MALLOC_H)
  63 #include <malloc.h>        // for memalign() and valloc()
  64 #elif defined(HAVE_MALLOC_MALLOC_H)
  65 #include <malloc/malloc.h>
  66 #elif defined(HAVE_SYS_MALLOC_H)
  67 #include <sys/malloc.h>
  68 #endif
  69 #include "base/basictypes.h"
  70 #include "base/logging.h"
  71 #include "tests/testutil.h"
  72
  73
  74 // Return the next interesting size/delta to check.  Returns -1 if no more.
  75 static int NextSize(int size) {
  76   if (size < 100) {
  77     return size+1;
  78   } else if (size < 1048576) {
  79     // Find next power of two
  80     int power = 1;
  81     while (power < size) {
  82       power <<= 1;
  83     }
  84
  85     // Yield (power-1, power, power+1)
  86     if (size < power-1) {
  87       return power-1;
  88     } else if (size == power-1) {
  89       return power;
  90     } else {
  91       assert(size == power);
  92       return power+1;
  93     }
  94   } else {
  95     return -1;
  96   }
  97 }
  98
  99 // Shortform for cast
 100 static uintptr_t Number(void* p) {
 101   return reinterpret_cast<uintptr_t>(p);
 102 }
 103
 104 // Check alignment
 105 static void CheckAlignment(void* p, int align) {
 106   if ((Number(p) & (align-1)) != 0)
 107     LOG(FATAL, "wrong alignment; wanted 0x%x; got %p\n", align, p);
 108 }
 109
 110 // Fill a buffer of the specified size with a predetermined pattern
 111 static void Fill(void* p, int n, char seed) {
 112   unsigned char* buffer = reinterpret_cast<unsigned char*>(p);
 113   for (int i = 0; i < n; i++) {
 114     buffer[i] = ((seed + i) & 0xff);
 115   }
 116 }
 117
 118 // Check that the specified buffer has the predetermined pattern
 119 // generated by Fill()
 120 static bool Valid(const void* p, int n, char seed) {
 121   const unsigned char* buffer = reinterpret_cast<const unsigned char*>(p);
 122   for (int i = 0; i < n; i++) {
 123     if (buffer[i] != ((seed + i) & 0xff)) {
 124       return false;
 125     }
 126   }
 127   return true;
 128 }
 129
 130 int main(int argc, char** argv) {
 131   SetTestResourceLimit();
 132
 133   // Try allocating data with a bunch of alignments and sizes
 134   for (int a = 1; a < 1048576; a *= 2) {
 135     for (int s = 0; s != -1; s = NextSize(s)) {
 136       void* ptr = memalign(a, s);
 137       CheckAlignment(ptr, a);
 138       Fill(ptr, s, 'x');
 139       CHECK(Valid(ptr, s, 'x'));
 140       free(ptr);
 141
 142       if ((a >= sizeof(void*)) && ((a & (a-1)) == 0)) {
 143         CHECK(posix_memalign(&ptr, a, s) == 0);
 144         CheckAlignment(ptr, a);
 145         Fill(ptr, s, 'y');
 146         CHECK(Valid(ptr, s, 'y'));
 147         free(ptr);
 148       }
 149     }
 150   }
 151
 152   {
 153     // Check various corner cases
 154     void* p1 = memalign(1<<20, 1<<19);
 155     void* p2 = memalign(1<<19, 1<<19);
 156     void* p3 = memalign(1<<21, 1<<19);
 157     CheckAlignment(p1, 1<<20);
 158     CheckAlignment(p2, 1<<19);
 159     CheckAlignment(p3, 1<<21);
 160     Fill(p1, 1<<19, 'a');
 161     Fill(p2, 1<<19, 'b');
 162     Fill(p3, 1<<19, 'c');
 163     CHECK(Valid(p1, 1<<19, 'a'));
 164     CHECK(Valid(p2, 1<<19, 'b'));
 165     CHECK(Valid(p3, 1<<19, 'c'));
 166     free(p1);
 167     free(p2);
 168     free(p3);
 169   }
 170
 171   {
 172     // posix_memalign
 173     void* ptr;
 174     CHECK(posix_memalign(&ptr, 0, 1) == EINVAL);
 175     CHECK(posix_memalign(&ptr, sizeof(void*)/2, 1) == EINVAL);
 176     CHECK(posix_memalign(&ptr, sizeof(void*)+1, 1) == EINVAL);
 177     CHECK(posix_memalign(&ptr, 4097, 1) == EINVAL);
 178
 179     // Grab some memory so that the big allocation below will definitely fail.
 180     void* p_small = malloc(4*1048576);
 181     CHECK(p_small != NULL);
 182
 183     // Make sure overflow is returned as ENOMEM
 184     const size_t zero = 0;
 185     static const size_t kMinusNTimes = 10;
 186     for ( size_t i = 1; i < kMinusNTimes; ++i ) {
 187       int r = posix_memalign(&ptr, 1024, zero - i);
 188       CHECK(r == ENOMEM);
 189     }
 190
 191     free(p_small);
 192   }
 193
 194   const int pagesize = getpagesize();
 195   {
 196     // valloc
 197     for (int s = 0; s != -1; s = NextSize(s)) {
 198       void* p = valloc(s);
 199       CheckAlignment(p, pagesize);
 200       Fill(p, s, 'v');
 201       CHECK(Valid(p, s, 'v'));
 202       free(p);
 203     }
 204   }
 205
 206   {
 207     // pvalloc
 208     for (int s = 0; s != -1; s = NextSize(s)) {
 209       void* p = pvalloc(s);
 210       CheckAlignment(p, pagesize);
 211       int alloc_needed = ((s + pagesize - 1) / pagesize) * pagesize;
 212       Fill(p, alloc_needed, 'x');
 213       CHECK(Valid(p, alloc_needed, 'x'));
 214       free(p);
 215     }
 216   }
 217
 218   printf("PASS\n");
 219   return 0;
 220 }