libs/basekit/source/Common.c

   1 /*#io
   2 docCopyright("Steve Dekorte", 2002)
   3 docLicense("BSD revised")
   4 */
   5
   6 #include "Common.h"
   7 #include <stdio.h>
   8
   9 #ifdef IO_CHECK_ALLOC
  10
  11 static long allocs = 0;
  12 static long reallocs = 0;
  13 static long allocatedBytes = 0;
  14 static long maxAllocatedBytes = 0;
  15 static long frees = 0;
  16
  17 /*
  18 typedef struct
  19 {
  20         long allocs = 0;
  21         long reallocs = 0;
  22         long allocatedBytes = 0;
  23         long maxAllocatedBytes = 0;
  24         long frees = 0;
  25 } Allocator;
  26
  27 Allocator *Allocator_new(void)
  28 {
  29         Allocator *self = calloc(1, sizeof(Allocator));
  30         return self;
  31 }
  32
  33 void Allocator_free(Allocator *self)
  34 {
  35         free(self);
  36 }
  37
  38 size_t Allocator_allocs(Allocator *self)
  39 {
  40         return self->allocs;
  41 }
  42
  43 size_t Allocator_frees(Allocator *self)
  44 {
  45         return self->frees;
  46 }
  47
  48 size_t Allocator_allocatedBytes(Allocator *self)
  49 {
  50         return self->allocatedBytes;
  51 }
  52
  53 size_t Allocator_maxAllocatedBytes(Allocator *self)
  54 {
  55         return self->maxAllocatedBytes;
  56 }
  57
  58 void Allocator_resetMaxAllocatedBytes(Allocator *self)
  59 {
  60         self->maxAllocatedBytes = self->allocatedBytes;
  61 }
  62
  63 void Allocator_show(Allocator *self)
  64 {
  65         printf("allocs              %i\n", self->allocs);
  66         printf("reallocs            %i\n", self->reallocs);
  67         printf("frees               %i\n", self->frees);
  68         printf("allocsMinusfrees    %i\n", self->allocs - self->frees);
  69         printf("allocatedBytes      %i\n", self->allocatedBytes);
  70         printf("maxAllocatedBytes   %i\n", self->maxAllocatedBytes);
  71         //printf("allocs  %i  bytes   %i\n", self->allocs, self->allocatedBytes);
  72 }
  73
  74 static Allocator *_globalAllocator;
  75
  76 Allocator *globalAllocator(void)
  77 {
  78         if(!_globalAllocator) Allocator_new();
  79         return _globalAllocator;
  80 }
  81 */
  82
  83 // -------------------------------------------------------
  84
  85 typedef struct MemoryBlock MemoryBlock;
  86
  87 struct MemoryBlock
  88 {
  89         size_t size;
  90         size_t allocNum;
  91         char *file;
  92         int line;
  93         MemoryBlock *next;
  94         MemoryBlock *prev;
  95         char padding[40 - (sizeof(size_t) + sizeof(size_t) + sizeof(char *) + sizeof(int) + sizeof(void *) + sizeof(void *))];
  96 };
  97
  98 MemoryBlock *PtrToMemoryBlock(void *ptr)
  99 {
 100         return (MemoryBlock *)(((char *)ptr) - sizeof(MemoryBlock));
 101 }
 102
 103 void *MemoryBlockToPtr(MemoryBlock *self)
 104 {
 105         return (void *)(((char *)self) + sizeof(MemoryBlock));
 106 }
 107
 108 static MemoryBlock *_baseblock = NULL;
 109
 110 inline MemoryBlock *baseblock(void)
 111 {
 112         if(!_baseblock) _baseblock = calloc(1, sizeof(MemoryBlock));
 113         return _baseblock;
 114 }
 115
 116 void MemoryBlock_remove(MemoryBlock *self)
 117 {
 118         if (self->next) self->next->prev = self->prev;
 119         if (self->prev) self->prev->next = self->next;
 120 }
 121
 122 void MemoryBlock_insertAfter_(MemoryBlock *self, MemoryBlock *other)
 123 {
 124         self->next = other->next;
 125         self->prev = other;
 126         other->next = self;
 127         if (self->next) self->next->prev = self;
 128 }
 129
 130 MemoryBlock *MemoryBlock_newWithSize_file_line_(size_t size, char *file, int line)
 131 {
 132         MemoryBlock *self = calloc(1, sizeof(MemoryBlock) + size);
 133         self->size = size;
 134         self->allocNum = allocs;
 135         self->file = file;
 136         self->line = line;
 137         MemoryBlock_insertAfter_(self, baseblock());
 138
 139         allocs ++;
 140         allocatedBytes += size;
 141         if (allocatedBytes > maxAllocatedBytes) maxAllocatedBytes = allocatedBytes;
 142         return self;
 143 }
 144
 145 MemoryBlock *MemoryBlock_reallocToSize_(MemoryBlock *self, size_t size)
 146 {
 147         MemoryBlock *prev = self->prev;
 148         MemoryBlock_remove(self);
 149         allocatedBytes -= self->size;
 150         allocatedBytes += size;
 151         reallocs ++;
 152         self = realloc(self, sizeof(MemoryBlock) + size);
 153         self->size = size;
 154         MemoryBlock_insertAfter_(self, prev);
 155         return self;
 156 }
 157
 158 void MemoryBlock_free(MemoryBlock *self)
 159 {
 160         MemoryBlock_remove(self);
 161         allocatedBytes -= self->size;
 162         frees ++;
 163         free(self);
 164 }
 165
 166 size_t MemoryBlock_size(MemoryBlock *self)
 167 {
 168         return self->size;
 169 }
 170
 171 void MemoryBlock_show(MemoryBlock *self)
 172 {
 173         char *file = strrchr(self->file, '/');
 174         file = file ? file + 1 : self->file;
 175         //printf("  MemoryBlock %p:\n", (void *)self);
 176         //printf("\tsize %i\n", self->size);
 177         //printf("\tfile %s\n", file);
 178         //printf("\tline %i\n", self->line);
 179         printf("\t%i %p %s:%i\t\t%i bytes\n", self->allocNum, MemoryBlockToPtr(self), file, self->line, self->size);
 180 }
 181
 182 // ----------------------------------------------------------------------------
 183
 184 void *io_real_malloc(size_t size, char *file, int line)
 185 {
 186         MemoryBlock *m = MemoryBlock_newWithSize_file_line_(size, file, line);
 187         return MemoryBlockToPtr(m);
 188 }
 189
 190 void *io_real_calloc(size_t count, size_t size, char *file, int line)
 191 {
 192         return io_real_malloc(count * size, file, line);
 193 }
 194
 195 void *io_real_realloc(void *ptr, size_t size, char *file, int line)
 196 {
 197         if (ptr)
 198         {
 199                 MemoryBlock *m = MemoryBlock_reallocToSize_(PtrToMemoryBlock(ptr), size);
 200                 return MemoryBlockToPtr(m);
 201         }
 202
 203         return io_real_malloc(size, file, line);
 204 }
 205
 206 void io_free(void *ptr)
 207 {
 208         MemoryBlock_free(PtrToMemoryBlock(ptr));
 209 }
 210
 211 // --------------------------------------------------------------------------
 212
 213 void io_show_mem(char *s)
 214 {
 215         printf("\n--- %s ---\n", s ? s : "");
 216         printf("allocs              %i\n", allocs);
 217         printf("reallocs            %i\n", reallocs);
 218         printf("frees               %i\n", frees);
 219         printf("allocsMinusfrees    %i\n", allocs - frees);
 220         printf("allocatedBytes      %i\n", allocatedBytes);
 221         printf("maxAllocatedBytes   %i\n", maxAllocatedBytes);
 222         //printf("allocs  %i  bytes   %i\n", allocs, allocatedBytes);
 223         //printf("\n");
 224 }
 225
 226 size_t io_maxAllocatedBytes(void)
 227 {
 228         return maxAllocatedBytes;
 229 }
 230
 231 void io_resetMaxAllocatedBytes(void)
 232 {
 233         maxAllocatedBytes = allocatedBytes;
 234 }
 235
 236 size_t io_frees(void)
 237 {
 238         return frees;
 239 }
 240
 241 size_t io_allocatedBytes(void)
 242 {
 243         return allocatedBytes;
 244 }
 245
 246 size_t io_allocs(void)
 247 {
 248         return allocs;
 249 }
 250
 251 void io_showUnfreed(void)
 252 {
 253         MemoryBlock *m = baseblock()->next;
 254         size_t sum = 0;
 255         int n = 0;
 256
 257         while (m)
 258         {
 259                 MemoryBlock_show(m);
 260                 sum += m->size;
 261                 n ++;
 262                 m = m->next;
 263         }
 264
 265         printf("\n  %i bytes in %i blocks\n", (int)sum, n);
 266 }
 267
 268 #endif
 269
 270 void *cpalloc(const void *p, size_t size)
 271 {
 272         void *n = io_malloc(size);
 273         if(p) memcpy(n, p, size);
 274         return n;
 275 }
 276
 277 void *io_freerealloc(void *p, size_t size)
 278 {
 279         return realloc(p, size);
 280         /*
 281         void *n = io_malloc(size);
 282
 283         if (p != NULL)
 284         {
 285                 memcpy(n, p, size);
 286                 free(p);
 287         }
 288
 289         return n;
 290         */
 291 }
 292