memcheck/tests/solaris/memalign.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <assert.h>
   4 #include "tests/malloc.h"
   5 #include <errno.h>
   6 #include "../../../config.h"
   7
   8
   9 int main (void)
  10 {
  11    int* p;
  12    int* piece;
  13    assert(sizeof(long int) == sizeof(void*));
  14
  15    p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
  16    assert(0 == (long)p % (1024 * 1024));
  17    piece = malloc(1024 * 1000); assert (piece);
  18    free (piece);
  19    free (p);
  20
  21    p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
  22    assert(0 == (long)p % (1024 * 1024));
  23    piece = malloc(1024 * 100); assert (piece);
  24    free (p);
  25    free (piece);
  26
  27    // Illumos doesn't allow a size of 0
  28    errno = 0;
  29    p = memalign(64, 0);
  30    assert(!p);
  31    assert(errno == EINVAL);
  32
  33    // Doesn't allow an alignment of 0 either
  34    p = memalign(0, 100);
  35    assert(!p);
  36    assert(errno == EINVAL);
  37
  38    // and most peculiar compared to other memaligns
  39    // the alignment must be a multiple of 4
  40    // but not necessarily a power of 2
  41
  42    // I think that the
  43    p = memalign(1, 100);
  44    assert(!p);
  45    assert(errno == EINVAL);
  46    p = memalign(2, 100);
  47    assert(!p);
  48    assert(errno == EINVAL);
  49    p = memalign(3, 100);
  50    assert(!p);
  51    assert(errno == EINVAL);
  52    p = memalign(4, 100);
  53    assert(p && 0 == (long)p % 8);
  54    p = memalign(5, 100);
  55    assert(!p);
  56    assert(errno == EINVAL);
  57    errno = 0;
  58    p = memalign(7, 100);
  59    assert(!p);
  60    assert(errno == EINVAL);
  61    p = memalign(8, 100);
  62    assert(p && 0 == (long)p % 8);
  63    errno= 0;
  64    p = memalign(9, 100);
  65    assert(!p);
  66    assert(errno == EINVAL);
  67    p = memalign(12, 100);
  68    assert(p && 0 == (long)p % 16);
  69    errno = 0;
  70    p = memalign(31, 100);
  71    assert(!p);
  72    assert(errno == EINVAL);
  73    p = memalign(32, 100);
  74    assert(p && 0 == (long)p % 32);
  75    errno = 0;
  76    p = memalign(33, 100);
  77    assert(!p);
  78    assert(errno == EINVAL);
  79    errno = 0;
  80    p = memalign(4095, 100);
  81    assert(!p);
  82    assert(errno == EINVAL);
  83    p = memalign(4096, 100);
  84    assert(p && 0 == (long)p % 4096);
  85    errno = 0;
  86    p = memalign(4097, 100);
  87    assert(!p);
  88    assert(errno == EINVAL);
  89
  90    p = memalign(4 * 1024 * 1024, 100);
  91    assert(p && 0 == (long)p % (4 * 1024 * 1024));
  92    p = memalign(16 * 1024 * 1024, 100);
  93    assert(p && 0 == (long)p % (16 * 1024 * 1024));
  94 }