source: git/Singular/mmalloc.c @ afa7a25

spielwiese
Last change on this file since afa7a25 was afa7a25, checked in by Olaf Bachmann <obachman@…>, 25 years ago
* corrected syntax error git-svn-id: file:///usr/local/Singular/svn/trunk@2825 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 11.3 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: mmalloc.c,v 1.12 1999-02-03 13:18:59 obachman Exp $ */
5
6/*
7* ABSTRACT:
8*/
9
10
11#include <string.h>
12#include <stdio.h>
13#include <stdlib.h>
14#include "mod2.h"
15#ifdef HAVE_MALLOC_H
16#include "malloc.h"
17#endif
18#include "structs.h"
19#include "febase.h"
20#include "tok.h"
21#include "mmemory.h"
22#include "mmprivate.h"
23
24#undef HAVE_ASSUME
25#define HAVE_ASSUME
26
27#ifndef MDEBUG
28
29/**********************************************************************
30 *
31 * Block Routines
32 *
33 **********************************************************************/
34
35void* mmAllocBlock(size_t size)
36{
37  int i;
38  assume(size > 0);
39 
40  i = mmGetIndex(size);
41 
42  if (i < 0)
43  {
44    void *res=(void*)malloc( size );
45    if (res==NULL)
46    {
47      WerrorS("out of memory");
48      m2_end(99);
49    }
50    mm_bytesMalloc += size;
51    if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
52    return res;
53  }
54  else
55  {
56    void* res;
57    AllocHeap(res, &mm_theList[i]);
58    return res;
59  }
60}
61
62void mmFreeBlock(void* adr, size_t size)
63{
64  int i;
65  if (adr == NULL ||  size == 0) return;
66 
67  i = mmGetIndex(size);
68 
69  if (i < 0)
70  {
71    mm_bytesMalloc -= size;
72    if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
73    free( adr );
74  }
75  else
76  {
77    FreeHeap(adr, &(mm_theList[i]));
78  }
79}
80
81void * mmAllocBlock0( size_t size )
82{
83  void *result=mmAllocBlock(size);
84  memset(result,0,size);
85  return result;
86}
87
88void * mmReallocBlock( void* adr, size_t oldsize, size_t newsize )
89{
90  int i = (oldsize == 0 ? -1: mmGetIndex( oldsize ));
91  int j = mmGetIndex( newsize );
92
93  if ( ( i < 0 ) && ( j < 0 ) )
94  {
95    void *res=(void *)realloc( adr, newsize );
96    if (res==NULL)
97    {
98      WerrorS("out of memory");
99      m2_end(99);
100    }
101    mm_bytesMalloc += ( (int)newsize - (int)oldsize );
102    if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
103    return res;
104  }
105  else if ( i == j )
106    return adr;
107  else
108  {
109    /* since we know i and j this can be done better, this is the quick way */
110    void *newadr = mmAllocBlock( newsize );
111    memcpy( newadr, adr, (oldsize < newsize) ? oldsize : newsize );
112    mmFreeBlock( adr, oldsize );
113    return newadr;
114  }
115}
116
117void * mmReallocBlock0( void* adr, size_t oldsize, size_t newsize )
118{
119  void* result = mmReallocBlock(adr, oldsize, newsize);
120  if (oldsize < newsize)
121    memset(&(((char*)result)[oldsize]), 0, newsize-oldsize);
122
123  return result;
124}
125
126/**********************************************************************
127 *
128 * Routines for chunks of memory
129 *
130 **********************************************************************/
131   
132void * mmAlloc( size_t size )
133{
134  size_t thesize = size + sizeof( ADDRESS );
135  size_t * dummy = (size_t*)mmAllocBlock( thesize );
136  *dummy = thesize;
137  return (void*)(dummy+1);
138}
139
140void mmFree( void* adr )
141{
142  if (adr!=NULL)
143  {
144    adr = (size_t*)adr-1;
145    mmFreeBlock( adr, *(size_t*)adr );
146  }
147}
148
149void * mmRealloc( void* adr, size_t newsize )
150{
151  size_t *aadr=(size_t*)(adr)-1;
152  size_t oldsize = *aadr;
153  void* newadr = mmAlloc( newsize );
154  memcpy( newadr, adr, min(oldsize-sizeof(ADDRESS),newsize) );
155  mmFreeBlock( aadr,oldsize );
156  return newadr;
157}
158
159char * mmStrdup( const char * s)
160{
161  if (s==NULL) return NULL;
162  {
163    char * rc = (char*)mmAlloc( 1 + strlen( s ));
164    strcpy( rc, s );
165    return rc;
166  }
167}
168
169#else /* MDEBUG */
170
171/**********************************************************************
172 *
173 * Heap routines
174 *
175 **********************************************************************/
176static void * mmDBAllocHeapS(memHeap heap, size_t size,
177                             char* fname, int lineno)
178{
179  DBMCB* result;
180
181#ifdef HEAP_DEBUG
182  result = mmDebugAllocHeap(heap, fname, lineno);
183#else
184  mmAllocHeap((void*) result, heap);
185#endif 
186
187  if (! mmCheckDBMCB(result, SizeFromRealSize(mmGetHeapBlockSize(heap)),
188                     MM_FREEFLAG))
189  {
190    mmPrintFL( fname, lineno );
191    return result;
192  }
193   
194  mmMoveDBMCB( &mm_theDBfree, &mm_theDBused, result );
195  mmFillDBMCB(result, size, heap, MM_USEDFLAG, fname, lineno);
196
197  return (void*) &(result->data);
198}
199
200static void mmDBFreeHeapS(void* addr, memHeap heap, size_t size,
201                          char* fname, int lineno)
202{
203  DBMCB *what = (DBMCB*) ((char*) addr - DebugOffsetFront);
204
205  if ( ! mmCheckDBMCB(what, size, MM_USEDFLAG))
206  {
207    mmPrintFL( fname, lineno );
208    return;
209  }
210
211 
212#ifdef HEAP_DEBUG
213  mmDebugFreeHeap(what, heap, fname, lineno);
214#else
215  assume(heap != NULL);
216  mmFreeHeap(what, heap);
217#endif
218 
219  mmMoveDBMCB( &mm_theDBused, &mm_theDBfree, what );
220  mmFillDBMCB(what, SizeFromRealSize(mmGetHeapBlockSize(heap)),
221              heap, MM_FREEFLAG, fname, lineno);
222}
223
224void * mmDBAllocHeap(memHeap heap, char* f, int l)
225{
226  return mmDBAllocHeapS(heap, SizeFromRealSize(mmGetHeapBlockSize(heap)),f,l);
227}
228
229                 
230void   mmDBFreeHeap(void* addr, memHeap heap, char*f, int l)
231{
232  mmDBFreeHeapS(addr, heap, SizeFromRealSize(mmGetHeapBlockSize(heap)),f,l);
233}
234
235
236/**********************************************************************
237 *
238 * Block Routines
239 *
240 **********************************************************************/
241 
242void * mmDBAllocBlock( size_t size,  char * fname, int lineno)
243{
244  int i;
245
246  if (size==0)
247  {
248    fprintf(stderr,"alloc(0) in %s:%d\n",fname,lineno);
249    size = 1;
250  }
251
252  i = mmGetIndex( size );
253  if ( i < 0 )
254  {
255    DBMCB * result=NULL;
256    int tmpsize=RealSizeFromSize(size);
257    if ((result = (DBMCB*)malloc(tmpsize))!=NULL)
258    {
259      mm_bytesMalloc += tmpsize;
260      if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
261
262      mmMoveDBMCBInto( &mm_theDBused, result );
263     
264      if ( mm_minAddr == NULL )
265      {
266        mm_minAddr = (void*)result;
267        mm_maxAddr = (void*)result;
268      }
269      else if ( (void*)result < mm_minAddr )
270        mm_minAddr = (void*)result;
271      else if ( (void*)result > mm_maxAddr )
272        mm_maxAddr = (void*)result;
273
274      mmFillDBMCB(result, size, NULL, MM_USEDFLAG, fname, lineno);
275     
276      return (void*) &(result->data);
277    }
278    else
279    {
280      WerrorS("out of memory");
281      m2_end(99);
282      return NULL;
283    }
284  }
285  else
286  {
287    return mmDBAllocHeapS(&(mm_theList[i]), size, fname, lineno);
288  }
289}
290
291void mmDBFreeBlock(void* adr, size_t size, char * fname, int lineno)
292{
293  int i;
294 
295  if ( ( adr == NULL ) || ( size == 0 ) ) return;
296
297  i = mmGetIndex( size );
298  if ( i < 0 )
299  {
300    DBMCB * what = (DBMCB*) ((char*) adr - DebugOffsetFront);
301    int tmpsize=RealSizeFromSize(size);
302
303    if ( ! mmCheckDBMCB(what, size, MM_USEDFLAG))
304    {
305      mmPrintFL( fname, lineno );
306      return;
307    }
308    mm_bytesMalloc -= tmpsize;
309    mmTakeOutDBMCB(what );
310    free( what );
311    if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
312  }
313  else
314  {
315    mmDBFreeHeapS(adr, &(mm_theList[i]), size, fname, lineno);
316  }
317}
318
319void * mmDBAllocBlock0( size_t size, char * fname, int lineno )
320{
321  void *result=mmDBAllocBlock(size, fname,lineno);
322  memset(result,0,size);
323  return result;
324}
325
326
327void * mmDBReallocBlock( void* adr, size_t oldsize, size_t newsize, 
328                         char * fname, int lineno )
329{
330  void* newadr;
331
332  newadr = mmDBAllocBlock( newsize, fname, lineno);
333  memcpy( newadr, adr, (oldsize < newsize) ? oldsize : newsize );
334  mmDBFreeBlock( adr, oldsize, fname, lineno);
335
336  return newadr;
337}
338
339void * mmDBReallocBlock0( void* adr, size_t oldsize, size_t newsize, 
340                          char * fname, int lineno )
341{
342  void* newadr;
343
344  newadr = mmDBAllocBlock0( newsize, fname, lineno);
345  memcpy( newadr, adr, (oldsize < newsize) ? oldsize : newsize );
346  mmDBFreeBlock( adr, oldsize, fname, lineno);
347
348  return newadr;
349}
350
351
352/**********************************************************************
353 *
354 * Routines for chunks of memory
355 *
356 **********************************************************************/
357
358void * mmDBAlloc( size_t size, char* fname, int lineno )
359{
360  size_t thesize = size + sizeof( ADDRESS );
361  size_t * dummy = (size_t*)mmDBAllocBlock( thesize, fname, lineno);
362  *dummy = thesize;
363  return (void*)(dummy+1);
364}
365
366void mmDBFree( void* adr, char* fname, int lineno )
367{
368  if (adr!=NULL)
369  {
370    adr = (size_t*)adr-1;
371    mmDBFreeBlock( adr,*(size_t *)adr, fname, lineno);
372  }
373}
374
375void * mmDBRealloc( void* adr, size_t newsize, char* fname, int lineno )
376{
377  size_t *aadr=(size_t*)(adr)-1;
378  size_t oldsize = *aadr;
379  void* newadr = mmDBAlloc( newsize, fname, lineno );
380  memcpy( newadr, adr, min(oldsize-sizeof(ADDRESS), newsize) );
381  mmDBFreeBlock( aadr, oldsize, fname, lineno);
382  return newadr;
383}
384
385char * mmDBStrdup( const char * s, char *fname, int lineno)
386{
387  if (s==NULL) return NULL;
388  {
389    char * rc = (char*)mmDBAlloc( 1 + strlen( s ),fname,lineno );
390    strcpy( rc, s );
391    return rc;
392  }
393}
394
395#endif /* MDEBUG */
396
397
398/**********************************************************************
399 *
400 * Routines for aligned memory allocation
401 *
402 **********************************************************************/
403   
404#if SIZEOF_DOUBLE == SIZEOF_VOIDP + SIZEOF_VOIDP
405
406#ifdef MDEBUG
407void * mmDBAllocAlignedBlock( size_t size, char* f, int l)   
408#else
409void * mmAllocAlignedBlock( size_t size)
410#endif
411{
412  int i = mmGetIndex(size);
413 
414  if (i < 0)
415  {
416#ifdef MDEBUG
417    unsigned long ret = 
418      (unsigned long) mmDBAllocBlock(size + SIZEOF_DOUBLE + 1, f, l);
419#else
420    unsigned long ret = 
421      (unsigned long) mmAllocBlock(size+SIZEOF_DOUBLE+1);
422#endif
423    unsigned char shift = (ret + 1) & (SIZEOF_DOUBLE - 1);
424    *((unsigned char*) ret) = (unsigned char) shift;
425
426    assume(ret != 0);
427    ret = ((ret + 1) & ~(SIZEOF_DOUBLE - 1));
428
429    assume(ret % SIZEOF_DOUBLE == 0);
430
431    return (void*) ret;
432  }
433  else
434  {
435#if SIZEOF_DOUBLE != SIZEOF_VOIDP
436    void *garbage = NULL, *good, *temp;
437
438    while (1)
439    {
440#endif /* SIZEOF_DOUBLE != SIZEOF_VOIDP */
441
442#ifdef MDEBUG
443      good = mmDBAllocHeapS(&(mm_theList[i]), size, f, l);
444#else
445      AllocHeap(good, &(mm_theList[i]));
446#endif
447      assume(good != NULL);
448
449#if SIZEOF_DOUBLE != SIZEOF_VOIDP
450   
451      if (((unsigned long) good) & (SIZEOF_DOUBLE - 1))
452      {
453        *((void**) good) = garbage;
454        garbage = good;
455      }
456      else
457      {
458        break;
459      }
460    }
461 
462    while (garbage != NULL)
463    {
464      temp = garbage;
465      garbage = *((void**) garbage);
466#ifdef MDEBUG
467      mmDBFreeHeapS(temp, &(mm_theList[i]), size, f, l);
468#else
469      FreeHeap(temp, &(mm_theList[i]));
470#endif
471    }
472#endif /* SIZEOF_DOUBLE != SIZEOF_VOIDP */
473
474    assume(((unsigned long) good) % SIZEOF_DOUBLE == 0);
475   
476    return good;
477  }
478}
479
480
481#ifdef MDEBUG
482void * mmDBAllocAlignedBlock0( size_t size, char* f, int l)   
483#else
484void * mmAllocAlignedBlock0( size_t size)
485#endif
486{
487  void* good;
488#ifdef MDEBUG
489  good = mmDBAllocAlignedBlock(size, f, l);
490#else
491  good = mmAllocAlignedBlock(size);
492#endif
493 
494  memset(good, 0, size);
495 
496  return good;
497}
498
499#ifdef MDEBUG
500void  mmDBFreeAlignedBlock( void* addr, size_t size, char* f, int l)   
501#else
502void  mmFreeAlignedBlock( void* addr, size_t size)
503#endif
504{
505  int i = mmGetIndex(size);
506
507  assume((unsigned long) addr % SIZEOF_DOUBLE == 0);
508 
509  if (i < 0)
510  {
511    unsigned char* adj_addr = ((unsigned char*) addr) - 1;
512    unsigned char shift = *adj_addr;
513
514#ifdef MDEBUG   
515    mmDBFreeBlock(adj_addr - shift, size + SIZEOF_DOUBLE + 1, f, l);
516#else
517    mmFreeBlock(adj_addr - shift, size + SIZEOF_DOUBLE + 1);
518#endif
519  }
520  else
521  {
522#ifdef MDEBUG
523    mmDBFreeHeapS(addr, &(mm_theList[i]), size, f, l);
524#else
525    FreeHeap(addr, &(mm_theList[i]));
526#endif
527  }
528}
529
530#endif /* SIZEOF_DOUBLE == SIZEOF_VOIDP + SIZEOF_VOIDP */
531   
532
533
534 
535 
536 
537
Note: See TracBrowser for help on using the repository browser.