sys/src/libventi/mem.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <venti.h>
   4
   5 enum {
   6         IdealAlignment = 32,
   7         ChunkSize       = 128*1024
   8 };
   9
  10 void
  11 vtfree(void *p)
  12 {
  13         free(p);
  14 }
  15
  16 void *
  17 vtmalloc(ulong size)
  18 {
  19         void *p = mallocz(size, 0);
  20         if(p == nil){
  21                 fprint(2, "vtmalloc: out of memory allocating %lud", size);
  22                 abort();
  23         }
  24         setmalloctag(p, getcallerpc(&size));
  25         return p;
  26 }
  27
  28 void *
  29 vtmallocz(ulong size)
  30 {
  31         void *p = mallocz(size, 1);
  32         if(p == nil){
  33                 fprint(2, "vtmallocz: out of memory allocating %lud", size);
  34                 abort();
  35         }
  36         setmalloctag(p, getcallerpc(&size));
  37         return p;
  38 }
  39
  40 void *
  41 vtrealloc(void *p, ulong size)
  42 {
  43         p = realloc(p, size);
  44         if(p == 0 && size != 0){
  45                 fprint(2, "vtrealloc: out of memory allocating %lud", size);
  46                 abort();
  47         }
  48         setrealloctag(p, getcallerpc(&size));
  49         return p;
  50 }
  51
  52 void *
  53 vtbrk(ulong n)
  54 {
  55         static Lock lk;
  56         static uchar *buf;
  57         static ulong nbuf, nchunk;
  58         ulong align, pad;
  59         void *p;
  60
  61         if(n >= IdealAlignment)
  62                 align = IdealAlignment;
  63         else if(n > 8)
  64                 align = 8;
  65         else
  66                 align = 4;
  67
  68         if(n > ChunkSize){
  69                 p = sbrk(n);
  70                 if(p == (void*)-1)
  71                         sysfatal("Failed to allocate permanent chunk size %lud", n);
  72                 memset(p, 0, n);
  73                 return (uchar*)p;
  74         }
  75         lock(&lk);
  76         pad = (align - (uintptr)buf) & (align-1);
  77         if(n + pad > nbuf) {
  78                 buf = sbrk(ChunkSize);
  79                 if(buf == (void*)-1)
  80                         sysfatal("Failed to allocate permanent chunk size %ud", ChunkSize);
  81                 memset(buf, 0, ChunkSize);
  82                 nbuf = ChunkSize;
  83                 pad = (align - (uintptr)buf) & (align-1);
  84                 nchunk++;
  85         }
  86
  87         assert(n + pad <= nbuf);
  88
  89         p = buf + pad;
  90         buf += pad + n;
  91         nbuf -= pad + n;
  92         unlock(&lk);
  93
  94         return p;
  95 }
  96