| 1 | #ifndef MMEMORY_H |
|---|
| 2 | #define MMEMORY_H |
|---|
| 3 | /**************************************** |
|---|
| 4 | * Computer Algebra System SINGULAR * |
|---|
| 5 | ****************************************/ |
|---|
| 6 | /* $Id: mmemory.h,v 1.17 1999-03-19 17:42:30 obachman Exp $ */ |
|---|
| 7 | /* |
|---|
| 8 | * ABSTRACT |
|---|
| 9 | */ |
|---|
| 10 | #include <stdlib.h> |
|---|
| 11 | |
|---|
| 12 | #ifdef __cplusplus |
|---|
| 13 | extern "C" { |
|---|
| 14 | #endif |
|---|
| 15 | |
|---|
| 16 | #include "structs.h" |
|---|
| 17 | #include "mmheap.h" |
|---|
| 18 | |
|---|
| 19 | /********************************************************************** |
|---|
| 20 | * |
|---|
| 21 | * Memory allocation |
|---|
| 22 | * |
|---|
| 23 | **********************************************************************/ |
|---|
| 24 | |
|---|
| 25 | #ifndef MDEBUG |
|---|
| 26 | |
|---|
| 27 | void * mmAllocBlock( size_t ); |
|---|
| 28 | void * mmAllocBlock0( size_t ); |
|---|
| 29 | void mmFreeBlock( void*, size_t ); |
|---|
| 30 | void * mmReallocBlock( void*, size_t, size_t ); |
|---|
| 31 | void * mmReallocBlock0( void*, size_t, size_t ); |
|---|
| 32 | void * mmAlloc( size_t ); |
|---|
| 33 | void * mmRealloc( void*, size_t ); |
|---|
| 34 | void mmFree( void* ); |
|---|
| 35 | char * mmStrdup( const char* ); |
|---|
| 36 | void * mmAllocAlignedBlock( size_t ); |
|---|
| 37 | void * mmAllocAlignedBlock0( size_t ); |
|---|
| 38 | void mmFreeAlignedBlock( void*, size_t ); |
|---|
| 39 | |
|---|
| 40 | #define AllocHeap mmAllocHeap |
|---|
| 41 | #define FreeHeap mmFreeHeap |
|---|
| 42 | #define Alloc mmAllocBlock |
|---|
| 43 | #define Alloc0 mmAllocBlock0 |
|---|
| 44 | #define Free mmFreeBlock |
|---|
| 45 | #define ReAlloc mmReallocBlock |
|---|
| 46 | #define ReAlloc0 mmReallocBlock0 |
|---|
| 47 | #define FreeL mmFree |
|---|
| 48 | #define AllocL mmAlloc |
|---|
| 49 | #define mstrdup mmStrdup |
|---|
| 50 | #define AllocAligned0 mmAllocAlignedBlock0 |
|---|
| 51 | #define AllocAligned mmAllocAlignedBlock |
|---|
| 52 | #define FreeAligned mmFreeAlignedBlock |
|---|
| 53 | |
|---|
| 54 | #else /* MDEBUG */ |
|---|
| 55 | |
|---|
| 56 | void * mmDBAllocHeap(memHeap heap, char*, int ); |
|---|
| 57 | void mmDBFreeHeap(void* addr, memHeap heap, char*, int ); |
|---|
| 58 | void * mmDBAllocBlock( size_t, char*, int ); |
|---|
| 59 | void * mmDBAllocBlock0( size_t, char*, int); |
|---|
| 60 | void mmDBFreeBlock( void*, size_t, char*, int); |
|---|
| 61 | void * mmDBReallocBlock( void*, size_t, size_t, char*, int ); |
|---|
| 62 | void * mmDBReallocBlock0( void*, size_t, size_t, char*, int ); |
|---|
| 63 | void * mmDBAlloc( size_t, char*, int ); |
|---|
| 64 | void * mmDBRealloc( void*, size_t, char*, int ); |
|---|
| 65 | void mmDBFree( void*, char*, int ); |
|---|
| 66 | char * mmDBStrdup( const char * s, char *fname, int lineno); |
|---|
| 67 | void * mmDBAllocAlignedBlock( size_t, char*, int ); |
|---|
| 68 | void * mmDBAllocAlignedBlock0( size_t, char*, int); |
|---|
| 69 | void mmDBFreeAlignedBlock( void*, size_t, char*, int ); |
|---|
| 70 | |
|---|
| 71 | #define AllocHeap(res, heap)\ |
|---|
| 72 | ((void*)(res)) = mmDBAllocHeap(heap, __FILE__, __LINE__) |
|---|
| 73 | #define FreeHeap(addr, heap)\ |
|---|
| 74 | mmDBFreeHeap(addr, heap, __FILE__, __LINE__) |
|---|
| 75 | #define Alloc(s) mmDBAllocBlock(s, __FILE__, __LINE__) |
|---|
| 76 | #define Alloc0(s) mmDBAllocBlock0(s, __FILE__, __LINE__) |
|---|
| 77 | #define Free(a,s) mmDBFreeBlock(a, s, __FILE__, __LINE__) |
|---|
| 78 | #define ReAlloc(a,o,n) mmDBReallocBlock(a, o, n, __FILE__, __LINE__) |
|---|
| 79 | #define ReAlloc0(a,o,n) mmDBReallocBlock0(a, o, n, __FILE__, __LINE__) |
|---|
| 80 | #define AllocL(s) mmDBAlloc(s, __FILE__, __LINE__) |
|---|
| 81 | #define FreeL(a) mmDBFree(a,__FILE__,__LINE__) |
|---|
| 82 | #define mstrdup(s) mmDBStrdup(s, __FILE__, __LINE__) |
|---|
| 83 | #define AllocAligned(s) mmDBAllocAlignedBlock(s, __FILE__, __LINE__) |
|---|
| 84 | #define AllocAligned0(s) mmDBAllocAlignedBlock0(s, __FILE__, __LINE__) |
|---|
| 85 | #define FreeAligned(a,s) mmDBFreeAlignedBlock(a, s, __FILE__, __LINE__) |
|---|
| 86 | |
|---|
| 87 | #endif /* MDEBUG */ |
|---|
| 88 | |
|---|
| 89 | |
|---|
| 90 | /********************************************************************** |
|---|
| 91 | * |
|---|
| 92 | * Tests of memory (for MDEBUG, only) |
|---|
| 93 | * |
|---|
| 94 | **********************************************************************/ |
|---|
| 95 | |
|---|
| 96 | #ifdef MDEBUG |
|---|
| 97 | |
|---|
| 98 | /* use this variables to control level of MDEBUG at run-time |
|---|
| 99 | (see mod2.h for details) */ |
|---|
| 100 | extern int mm_MDEBUG; |
|---|
| 101 | |
|---|
| 102 | BOOLEAN mmDBTestHeapBlock(const void* adr, const memHeap heap, |
|---|
| 103 | const char * fname, const int lineno ); |
|---|
| 104 | BOOLEAN mmDBTestBlock(const void* adr, const size_t size, |
|---|
| 105 | const char * fname, const int lineno ); |
|---|
| 106 | BOOLEAN mmDBTest(const void* adr, const char * fname, const int lineno); |
|---|
| 107 | |
|---|
| 108 | #define mmTestHeap(a, h)\ |
|---|
| 109 | mmDBTestHeapBlock(a, h, __FILE__, __LINE__) |
|---|
| 110 | #define mmTest(A,B) mmDBTestBlock(A,B,__FILE__,__LINE__) |
|---|
| 111 | #define mmTestL(A) mmDBTest(A,__FILE__,__LINE__) |
|---|
| 112 | #define mmTestP(A,B) mmDBTestBlock(A,B,__FILE__,__LINE__) |
|---|
| 113 | #define mmTestLP(A) mmDBTest(A,__FILE__,__LINE__) |
|---|
| 114 | |
|---|
| 115 | int mmTestMemory(); |
|---|
| 116 | int mmTestHeaps(); |
|---|
| 117 | |
|---|
| 118 | void mmPrintUsedList(); |
|---|
| 119 | void mmMarkInitDBMCB(); |
|---|
| 120 | void mmTestList (int all); |
|---|
| 121 | |
|---|
| 122 | #else |
|---|
| 123 | |
|---|
| 124 | |
|---|
| 125 | #define mmTestHeap(addr, heap) mmCheckHeapAddr(addr, heap) |
|---|
| 126 | #define mmTest(A,B) TRUE |
|---|
| 127 | #define mmTestL(A) TRUE |
|---|
| 128 | #define mmTestP(A,B) |
|---|
| 129 | #define mmTestLP(A) |
|---|
| 130 | #define mmTestMemory 1 |
|---|
| 131 | #define mmTestHeaps 1 |
|---|
| 132 | #define mmMarkInitDBMCB() |
|---|
| 133 | #define mmTestList(a) |
|---|
| 134 | |
|---|
| 135 | #endif /* MDEBUG */ |
|---|
| 136 | |
|---|
| 137 | |
|---|
| 138 | /********************************************************************** |
|---|
| 139 | * |
|---|
| 140 | * Misc stuff |
|---|
| 141 | * |
|---|
| 142 | **********************************************************************/ |
|---|
| 143 | |
|---|
| 144 | /* For handling of monomials */ |
|---|
| 145 | size_t mmSpecializeBlock( size_t ); |
|---|
| 146 | size_t mmGetSpecSize(); |
|---|
| 147 | extern memHeap mm_specHeap; |
|---|
| 148 | |
|---|
| 149 | /* for handling of memory statistics */ |
|---|
| 150 | int mmMemAlloc( void ); |
|---|
| 151 | int mmMemUsed( void ); |
|---|
| 152 | #ifdef HAVE_SBRK |
|---|
| 153 | int mmMemPhysical( void ); |
|---|
| 154 | #endif |
|---|
| 155 | void mmPrintStat(); |
|---|
| 156 | |
|---|
| 157 | size_t mmSizeL( void* ); |
|---|
| 158 | |
|---|
| 159 | /* max size of blocks which our memory managment handles */ |
|---|
| 160 | #define MAX_BLOCK_SIZE (((SIZE_OF_HEAP_PAGE) / 16)*4) |
|---|
| 161 | |
|---|
| 162 | /********************************************************************** |
|---|
| 163 | * |
|---|
| 164 | * Some operations on linked lists of memory |
|---|
| 165 | * |
|---|
| 166 | **********************************************************************/ |
|---|
| 167 | /* The following routines assume that Next(list) == *((void**) list) */ |
|---|
| 168 | /* Removes element from list, if contained in it and returns list */ |
|---|
| 169 | void* mmRemoveFromList(void* list, void* element); |
|---|
| 170 | /* Returns the length of a memory list; assumes list has no cycles */ |
|---|
| 171 | int mmListLength(void* list); |
|---|
| 172 | /* Returns last non-NULL element of list; assumes list has no cycles */ |
|---|
| 173 | void* mmListLast(void* list); |
|---|
| 174 | /* returns 1, if addr is contained in memory list |
|---|
| 175 | * 0, otherwise */ |
|---|
| 176 | int mmIsAddrOnList(void* addr, void* list); |
|---|
| 177 | /* Checks whether memory list has cycles: If yes, returns address of |
|---|
| 178 | * first element of list which is contained at least twice in memory |
|---|
| 179 | * list. If no, NULL is returned */ |
|---|
| 180 | void* mmListHasCycle(void* list); |
|---|
| 181 | |
|---|
| 182 | /* The following routines assume that Next(list) == *((void**) list + next) */ |
|---|
| 183 | |
|---|
| 184 | /* Returns the length of a memory list; assumes list has no cycles */ |
|---|
| 185 | int mmGListLength(void* list, int next); |
|---|
| 186 | /* Returns last non-NULL element of list; assumes list has no cycles */ |
|---|
| 187 | void* mmGListLast(void* list, int next); |
|---|
| 188 | /* returns 1, if addr is contained in memory list |
|---|
| 189 | * 0, otherwise */ |
|---|
| 190 | int mmIsAddrOnGList(void* addr, void* list, int next); |
|---|
| 191 | /* Checks whether memory list has cycles: If yes, returns address of |
|---|
| 192 | * first element of list which is contained at least twice in memory |
|---|
| 193 | * list. If no, NULL is returned */ |
|---|
| 194 | void* mmGListHasCycle(void* list, int next); |
|---|
| 195 | |
|---|
| 196 | /********************************************************************** |
|---|
| 197 | * |
|---|
| 198 | * some fast macros for basic memory operations |
|---|
| 199 | * |
|---|
| 200 | **********************************************************************/ |
|---|
| 201 | #ifdef DO_DEEP_PROFILE |
|---|
| 202 | extern void _memcpyW(void* p1, void* p2, long l); |
|---|
| 203 | #define memcpy_nwEVEN(p1, p2, l) _memcpyW((void*) p1, (void*) p2, (long) l) |
|---|
| 204 | #define memcpy_nwODD(p1, p2, l) _memcpyW((void*) p1, (void*) p2, (long) l) |
|---|
| 205 | #define memcpyW(p1, p2, l) _memcpyW((void*) p1, (void*) p2, (long) l) |
|---|
| 206 | |
|---|
| 207 | extern void _memaddW(void* p1, void* p2, void* p3, long l); |
|---|
| 208 | #define memaddW(p1, p2, p3, l) _memaddW(p1, p2, p3, l) |
|---|
| 209 | #define memadd_nwODD(p1, p2, p3, l) _memaddW(p1, p2, p3, l) |
|---|
| 210 | #define memadd_nwEVEN(p1, p2, p3, l) _memaddW(p1, p2, p3, l) |
|---|
| 211 | #define memadd_nwONE(p1, p2, p3) _memaddW(p1, p2, p3, 1) |
|---|
| 212 | #define memadd_nwTWO(p1, p2, p3) _memaddW(p1, p2, p3, 2) |
|---|
| 213 | |
|---|
| 214 | extern void _memsetW(void* p1, long w, long l); |
|---|
| 215 | #define memsetW(p1, w, l) _memsetW(p1, w, l) |
|---|
| 216 | |
|---|
| 217 | #else /* ! DO_DEEP_PROFILE */ |
|---|
| 218 | |
|---|
| 219 | #define memcpyW(p1, p2, l) \ |
|---|
| 220 | do \ |
|---|
| 221 | { \ |
|---|
| 222 | long _i = l; \ |
|---|
| 223 | long* _s1 = (long*) p1; \ |
|---|
| 224 | const long* _s2 = (long*) p2; \ |
|---|
| 225 | \ |
|---|
| 226 | for (;;) \ |
|---|
| 227 | { \ |
|---|
| 228 | *_s1 = *_s2; \ |
|---|
| 229 | _i--; \ |
|---|
| 230 | if (_i == 0) break; \ |
|---|
| 231 | _s1++; \ |
|---|
| 232 | _s2++; \ |
|---|
| 233 | } \ |
|---|
| 234 | } \ |
|---|
| 235 | while(0) |
|---|
| 236 | |
|---|
| 237 | #define memcpy_nwODD(p1, p2, l) \ |
|---|
| 238 | do \ |
|---|
| 239 | { \ |
|---|
| 240 | long _i = l - 1; \ |
|---|
| 241 | long* _s1 = (long*) p1; \ |
|---|
| 242 | const long* _s2 = (long*) p2; \ |
|---|
| 243 | \ |
|---|
| 244 | *_s1++ = *_s2++; \ |
|---|
| 245 | for (;;) \ |
|---|
| 246 | { \ |
|---|
| 247 | *_s1++ = *_s2++; \ |
|---|
| 248 | *_s1++ = *_s2++; \ |
|---|
| 249 | _i -= 2; \ |
|---|
| 250 | if (_i == 0) break; \ |
|---|
| 251 | } \ |
|---|
| 252 | } \ |
|---|
| 253 | while(0) |
|---|
| 254 | |
|---|
| 255 | #define memcpy_nwEVEN(p1, p2, l) \ |
|---|
| 256 | do \ |
|---|
| 257 | { \ |
|---|
| 258 | long _i = l; \ |
|---|
| 259 | long* _s1 = (long*) p1; \ |
|---|
| 260 | const long* _s2 = (long*) p2; \ |
|---|
| 261 | \ |
|---|
| 262 | for (;;) \ |
|---|
| 263 | { \ |
|---|
| 264 | *_s1++ = *_s2++; \ |
|---|
| 265 | *_s1++ = *_s2++; \ |
|---|
| 266 | _i -= 2; \ |
|---|
| 267 | if (_i == 0) break; \ |
|---|
| 268 | } \ |
|---|
| 269 | } \ |
|---|
| 270 | while(0) |
|---|
| 271 | |
|---|
| 272 | #define memaddW(P1, P2, P3, L) \ |
|---|
| 273 | do \ |
|---|
| 274 | { \ |
|---|
| 275 | unsigned long* _p1 = P1; \ |
|---|
| 276 | const unsigned long* _p2 = P2; \ |
|---|
| 277 | const unsigned long* _p3 = P3; \ |
|---|
| 278 | unsigned long l = L; \ |
|---|
| 279 | \ |
|---|
| 280 | do \ |
|---|
| 281 | { \ |
|---|
| 282 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 283 | l--; \ |
|---|
| 284 | } \ |
|---|
| 285 | while(l); \ |
|---|
| 286 | } \ |
|---|
| 287 | while(0) |
|---|
| 288 | |
|---|
| 289 | #define memadd_nwODD(P1, P2, P3, L) \ |
|---|
| 290 | do \ |
|---|
| 291 | { \ |
|---|
| 292 | unsigned long* _p1 = P1; \ |
|---|
| 293 | const unsigned long* _p2 = P2; \ |
|---|
| 294 | const unsigned long* _p3 = P3; \ |
|---|
| 295 | unsigned long l = L; \ |
|---|
| 296 | \ |
|---|
| 297 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 298 | l--; \ |
|---|
| 299 | \ |
|---|
| 300 | do \ |
|---|
| 301 | { \ |
|---|
| 302 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 303 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 304 | l -=2; \ |
|---|
| 305 | } \ |
|---|
| 306 | while(l); \ |
|---|
| 307 | } \ |
|---|
| 308 | while(0) |
|---|
| 309 | |
|---|
| 310 | #define memadd_nwEVEN(P1, P2, P3, L) \ |
|---|
| 311 | do \ |
|---|
| 312 | { \ |
|---|
| 313 | unsigned long* _p1 = P1; \ |
|---|
| 314 | const unsigned long* _p2 = P2; \ |
|---|
| 315 | const unsigned long* _p3 = P3; \ |
|---|
| 316 | unsigned long l = L; \ |
|---|
| 317 | \ |
|---|
| 318 | do \ |
|---|
| 319 | { \ |
|---|
| 320 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 321 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 322 | l -=2; \ |
|---|
| 323 | } \ |
|---|
| 324 | while(l); \ |
|---|
| 325 | } \ |
|---|
| 326 | while(0) |
|---|
| 327 | |
|---|
| 328 | #define memadd_nwONE(P1, P2, P3) \ |
|---|
| 329 | do \ |
|---|
| 330 | { \ |
|---|
| 331 | unsigned long* _p1 = P1; \ |
|---|
| 332 | const unsigned long* _p2 = P2; \ |
|---|
| 333 | const unsigned long* _p3 = P3; \ |
|---|
| 334 | \ |
|---|
| 335 | *_p1 = *_p2 + *_p3; \ |
|---|
| 336 | } \ |
|---|
| 337 | while(0) |
|---|
| 338 | |
|---|
| 339 | #define memadd_nwTWO(P1, P2, P3) \ |
|---|
| 340 | do \ |
|---|
| 341 | { \ |
|---|
| 342 | unsigned long* _p1 = P1; \ |
|---|
| 343 | const unsigned long* _p2 = P2; \ |
|---|
| 344 | const unsigned long* _p3 = P3; \ |
|---|
| 345 | \ |
|---|
| 346 | *_p1++ = *_p2++ + *_p3++; \ |
|---|
| 347 | *_p1 = *_p2 + *_p3; \ |
|---|
| 348 | } \ |
|---|
| 349 | while(0) |
|---|
| 350 | |
|---|
| 351 | #define memsetW(P1, W, L) \ |
|---|
| 352 | do \ |
|---|
| 353 | { \ |
|---|
| 354 | long* _p1 = P1; \ |
|---|
| 355 | unsigned long _l = L; \ |
|---|
| 356 | long _w = W; \ |
|---|
| 357 | \ |
|---|
| 358 | while(_l) \ |
|---|
| 359 | { \ |
|---|
| 360 | *_p1++ = W; \ |
|---|
| 361 | _l--; \ |
|---|
| 362 | } \ |
|---|
| 363 | } \ |
|---|
| 364 | while(0) |
|---|
| 365 | |
|---|
| 366 | #endif /* DO_DEEP_PROFILE */ |
|---|
| 367 | |
|---|
| 368 | #ifdef __cplusplus |
|---|
| 369 | } |
|---|
| 370 | #endif |
|---|
| 371 | |
|---|
| 372 | |
|---|
| 373 | #endif |
|---|
