config/gen/platform/darwin/memalign.c

   1 /*
   2  * $Id$
   3  * Copyright (C) 2007, The Perl Foundation.
   4  */
   5
   6 /*
   7
   8 =head1 NAME
   9
  10 memalign.c
  11
  12 =head1 DESCRIPTION
  13
  14 memalign related stuff
  15
  16 =head2 Functions
  17
  18 =over 4
  19
  20 =cut
  21
  22 */
  23
  24 #include <mach/vm_map.h>
  25 #include <mach/mach_init.h>
  26
  27 /*
  28
  29 =item C<static unsigned log2int(unsigned x)>
  30
  31 RT#48260: Not yet documented!!!
  32
  33 =cut
  34
  35 */
  36
  37 static unsigned log2int(unsigned x) {
  38     return (x<2) ? 0 : log2int(x>>1)+1;
  39 }
  40
  41 /*
  42
  43 =item C<static unsigned roundDownPowerOf2(unsigned x)>
  44
  45 RT#48260: Not yet documented!!!
  46
  47 =cut
  48
  49 */
  50
  51 static unsigned roundDownPowerOf2(unsigned x) {
  52     return (1 << log2int(x));
  53 }
  54
  55 /*
  56
  57 =item C<static unsigned roundUpPowerOf2(unsigned x)>
  58
  59 RT#48260: Not yet documented!!!
  60
  61 =cut
  62
  63 */
  64
  65 static unsigned roundUpPowerOf2(unsigned x)
  66 {
  67     static unsigned one = 1;
  68     unsigned log2Int = log2int(x);
  69
  70     return ((one << log2Int) == x) ? x : (one << (log2Int + 1));
  71 }
  72
  73 /*
  74
  75 =item C<static unsigned roundUpToPageBoundary(unsigned x)>
  76
  77 RT#48260: Not yet documented!!!
  78
  79 =cut
  80
  81 */
  82
  83 static unsigned roundUpToPageBoundary(unsigned x)
  84 {
  85     unsigned roundedDown = trunc_page(x);
  86
  87     return (roundedDown == x) ? x : (roundedDown + vm_page_size);
  88 }
  89
  90 typedef struct _memalign_marker_t {
  91                     vm_address_t start;
  92                     vm_size_t size; } memalign_marker_t;
  93
  94 /*
  95
  96 =item C<void *
  97 Parrot_memalign(size_t align, size_t size)>
  98
  99 RT#48260: Not yet documented!!!
 100
 101 =cut
 102
 103 */
 104
 105 void *
 106 Parrot_memalign(size_t align, size_t size)
 107 {
 108     size_t effectiveAlign = align;
 109     size_t padding = 0;
 110     size_t amountToAllocate = 0;
 111
 112     if (effectiveAlign < sizeof (void *))
 113     {
 114         effectiveAlign = roundUpPowerOf2(sizeof (void *));
 115     }
 116     else
 117     {
 118         effectiveAlign = roundUpPowerOf2(effectiveAlign);
 119     }
 120
 121     if (effectiveAlign < sizeof (memalign_marker_t))
 122     {
 123         padding = sizeof (memalign_marker_t);
 124     }
 125     else
 126     {
 127         padding = effectiveAlign;
 128     }
 129
 130     amountToAllocate = roundUpToPageBoundary(size + padding);
 131
 132     {
 133         vm_address_t p = (vm_address_t)NULL;
 134         kern_return_t status = vm_allocate(mach_task_self(), &p,
 135                                                 amountToAllocate, 1);
 136
 137         if (status != KERN_SUCCESS)
 138         {
 139             return NULL;
 140         }
 141         else
 142         {
 143             vm_size_t logEffectiveAlign = log2int(effectiveAlign);
 144             vm_address_t lowestAvaliableAddress =
 145                                 p + sizeof (memalign_marker_t);
 146             vm_address_t roundedDownAddress =
 147                             ((lowestAvaliableAddress >> logEffectiveAlign)
 148                                                         << logEffectiveAlign);
 149             vm_address_t returnAddress =
 150                             (roundedDownAddress == lowestAvaliableAddress) ?
 151                                 lowestAvaliableAddress :
 152                                     (roundedDownAddress + effectiveAlign);
 153             vm_address_t firstUnneededPage = 0;
 154
 155             memalign_marker_t *marker =
 156                                 (memalign_marker_t *)returnAddress - 1;
 157
 158             /* lowest address used, then round down to vm_page boundary */
 159             vm_address_t usedPageBase = trunc_page((vm_address_t)marker);
 160             marker->start = usedPageBase;
 161             marker->size = returnAddress + size - usedPageBase;
 162
 163             if (usedPageBase > p)
 164             {
 165                 status = vm_deallocate(mach_task_self(), p, usedPageBase - p);
 166
 167                 if (status != KERN_SUCCESS)
 168                 {
 169                     fprintf(stderr,
 170                             "Parrot_memalign(%zx, %zx) failed to deallocate extra header space.\n",
 171                             align, size);
 172                 }
 173             }
 174
 175             firstUnneededPage = roundUpToPageBoundary(returnAddress + size);
 176
 177             if (firstUnneededPage < p + amountToAllocate)
 178             {
 179                 status = vm_deallocate(mach_task_self(), firstUnneededPage,
 180                                     p + amountToAllocate - firstUnneededPage);
 181
 182                 if (status != KERN_SUCCESS)
 183                 {
 184                     fprintf(stderr,
 185                             "Parrot_memalign(%zx, %zx) failed to deallocate extra footer space.\n",
 186                             align, size);
 187                 }
 188             }
 189
 190             return (void *)returnAddress;
 191         }
 192     }
 193 }
 194
 195 /*
 196
 197 =item C<void
 198 Parrot_free_memalign(void *p)>
 199
 200 RT#48260: Not yet documented!!!
 201
 202 =cut
 203
 204 */
 205
 206 void
 207 Parrot_free_memalign(void *p)
 208 {
 209     memalign_marker_t *marker = (memalign_marker_t *)p - 1;
 210
 211     kern_return_t status = vm_deallocate(mach_task_self(),
 212                                             marker->start, marker->size);
 213
 214     if (status != KERN_SUCCESS)
 215     {
 216         fprintf(stderr, "Parrot_free_memalign(%p) failed!\n", p);
 217     }
 218 }
 219
 220 /*
 221
 222 =back
 223
 224 =cut
 225
 226 */
 227
 228 /*
 229  * Local variables:
 230  *   c-file-style: "parrot"
 231  * End:
 232  * vim: expandtab shiftwidth=4:
 233  */