Changeset f983ed in git for Singular


Ignore:
Timestamp:
Oct 19, 1999, 4:55:41 PM (25 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')
Children:
c9335424d94d418fe72c2574131c4ae119b585d2
Parents:
0d4422570e6808f44db426df44c4ad3ae8e6517b
Message:
* bug fixes and first try at AUTOMATIC_GC


git-svn-id: file:///usr/local/Singular/svn/trunk@3734 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • Singular/mmalloc.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmalloc.c,v 1.17 1999-10-18 11:19:29 obachman Exp $ */
     4/* $Id: mmalloc.c,v 1.18 1999-10-19 14:55:38 obachman Exp $ */
    55
    66/*
    … …  
    637637}
    638638
    639 void* mmAllocPageFromSystem()
     639void* mmVallocFromSystem(size_t size)
    640640{
    641641  void* page = PALLOC(SIZE_OF_PAGE);
    … …  
    657657}
    658658
    659 void mmFreePageToSystem(void* page)
     659void mmVfreeToSystem(void* page, size_t size)
    660660{
    661661  PFREE(page);
    662   mm_bytesValloc -= SIZE_OF_PAGE;
     662  mm_bytesValloc -= size;
    663663  if (BVERBOSE(V_SHOW_MEM)) mmCheckPrint();
    664664}

  • Singular/mmcheck.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmcheck.c,v 1.12 1999-10-15 16:07:08 obachman Exp $ */
     4/* $Id: mmcheck.c,v 1.13 1999-10-19 14:55:38 obachman Exp $ */
    55
    66/*
    … …  
    7272}
    7373
     74#ifndef HAVE_AUTOMATIC_GC
    7475void mmDBSetHeapsOfBlocks(memHeap fromheap, memHeap toheap)
    7576{
     77
    7678  memHeapPage pages = fromheap->pages;
    7779  int nblocks = SIZE_OF_HEAP_PAGE / toheap->size;
    … …  
    9193  }
    9294}
    93 
    94 void mmDBInitNewHeapPage(memHeap heap)
    95 {
     95#endif
     96
     97void mmDBInitNewHeapPage(memHeap heap, memHeapPage page)
     98{
     99#ifndef HAVE_AUTOMATIC_GC
    96100  DBMCB* what = (DBMCB*) heap->current;
     101#else
     102  DBMCB* what =  (DBMCB*) page->current;
     103#endif
     104 
    97105  DBMCB* prev = NULL;
    98106  size_t size = SizeFromRealSize(heap->size);
    … …  
    342350    if (flags & MM_USEDFLAG)
    343351    {
    344       mmRemoveFromCurrentHeap(what->heap, what);
    345352      mmMoveDBMCB(&mm_theDBfree, &mm_theDBused, what);
    346353      what->flags |= MM_USEDFLAG;

  • Singular/mmemory.h

    r0d44225 rf983ed  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: mmemory.h,v 1.25 1999-10-18 11:19:29 obachman Exp $ */
     6/* $Id: mmemory.h,v 1.26 1999-10-19 14:55:39 obachman Exp $ */
    77/*
    88* ABSTRACT
    … …  
    210210#endif /* HEAP_DEBUG */
    211211
     212// #define HAVE_AUTOMATIC_GC
     213#ifndef HAVE_AUTOMATIC_GC
    212214/* removes chunks in freelist which fill one page */
    213215/* if strict & 1, does it even if free ptr  has not changed w.r.t. last gc */
    … …  
    216218extern void mmGarbageCollectHeaps(int strict);
    217219extern void mmGarbageCollectHeap(memHeap heap, int strict);
     220#else
     221#define  mmGarbageCollectHeaps(s)
     222#define  mmGarbageCollectHeap(h, s)
     223#endif /* HAVE_AUTOMATIC_GC */
    218224
    219225/* Returns a heap of the given size */
    … …  
    224230/* Merges what is free in Heap "what" into free list of heap "into" */
    225231extern void mmMergeHeap(memHeap into, memHeap what);
    226 /* Removes addr from freelist of heap, provided it finds it there */
    227 extern void mmRemoveFromCurrentHeap(memHeap heap, void* addr);
    228232
    229233/**********************************
    … …  
    237241#define mmCheckHeap(heap)           1
    238242#define mmCheckHeapAddr(addr, heap) 1
     243
    239244#else
    240245/*
    … …  
    271276 **********************************/
    272277/* Need to define it here, has to be known to macros */
     278
     279/* array of static heaps */
     280extern struct sip_memHeap mm_theList[];
     281extern memHeapPage mmAllocNewHeapPage(memHeap heap);
     282
     283#ifndef  HAVE_AUTOMATIC_GC
     284struct sip_memHeapPage
     285{
     286  memHeapPage next;
     287  long counter;
     288};
     289
     290/* Change this appropriately, if you change sip_memHeapPage           */
     291/* However, make sure that sizeof(sip_memHeapPage) is a multiple of 8 */
     292#define SIZE_OF_HEAP_PAGE_HEADER (SIZEOF_VOIDP + SIZEOF_LONG)
     293#define SIZE_OF_HEAP_PAGE (SIZE_OF_PAGE - SIZE_OF_HEAP_PAGE_HEADER)
     294
    273295struct sip_memHeap
    274296{
    … …  
    279301};
    280302
    281 /* array of static heaps */
    282 extern struct sip_memHeap mm_theList[];
    283 
    284 extern void mmAllocNewHeapPage(memHeap heap);
    285303/* Allocates memory block from a heap */
    286304#define _mmAllocHeap(what, heap)                            \
    … …  
    303321}                                               \
    304322while (0)
     323
     324#else /* HAVE_AUTOMATIC_GC */
     325
     326struct sip_memHeapPage
     327{
     328  long          used_blocks;    /* number of used blocks of this page */
     329  void*         current;        /* pointer to current freelist */
     330  memHeapPage   next;           /* next/prev pointer of pages */
     331  memHeapPage   prev;
     332};
     333
     334/* Change this appropriately, if you change sip_memHeapPage           */
     335/* However, make sure that sizeof(sip_memHeapPage) is a multiple of 8 */
     336#define SIZE_OF_HEAP_PAGE_HEADER (3*SIZEOF_VOIDP + SIZEOF_LONG)
     337#define SIZE_OF_HEAP_PAGE (SIZE_OF_PAGE - SIZE_OF_HEAP_PAGE_HEADER)
     338
     339struct sip_memHeap
     340{
     341  memHeapPage current_page;   /* pointer to page of current freelist */
     342  memHeapPage first_free;
     343  memHeapPage last_free;
     344  long size;           /* size of blocks */
     345};
     346
     347extern memHeapPage  mmGetNewCurrentPage(memHeap heap);
     348extern void mmRearrangeHeapPages(memHeapPage page, memHeap heap);
     349extern struct sip_memHeapPage mmZeroPage[];
     350#ifndef mmGetPageOfAddr
     351#define mmGetPageOfAddr(addr) \
     352  ((void*) ((long) (addr) & ~(SIZE_OF_SYSTEM_PAGE -1)))
     353#endif
     354
     355#define _mmAllocHeap(what, heap)                                    \
     356do                                                                  \
     357{                                                                   \
     358  register memHeapPage _page = (heap)->current_page;                \
     359  if (_page->current == NULL) _page = mmGetNewCurrentPage(heap);    \
     360  (_page->used_blocks)++;                                           \
     361  what = (void *)((_page)->current);                                \
     362  (_page)->current =  *((void**)(_page)->current);                  \
     363}                                                                   \
     364while (0)
     365
     366#ifdef GC_KEEP_SORTED
     367#define _mmFreeHeap(addr, heap)                         \
     368do                                                      \
     369{                                                       \
     370  register memHeapPage _page = mmGetPageOfAddr(addr);   \
     371  _page->used_blocks--;                                 \
     372  if (_page->used_blocks < _page->next->used_blocks)    \
     373    mmRearrangeHeapPages(_page, heap);                  \
     374  *((void**) addr) = _page->current;                    \
     375  _page->current = addr;                                \
     376}                                                       \
     377while (0)
     378#else
     379#define _mmFreeHeap(addr, heap)                         \
     380do                                                      \
     381{                                                       \
     382  register memHeapPage _page = mmGetPageOfAddr(addr);   \
     383  _page->used_blocks--;                                 \
     384  if (_page->used_blocks == 0)                          \
     385    mmRearrangeHeapPages(_page, heap,addr);             \
     386  else                                                  \
     387  {                                                     \
     388    *((void**) addr) = _page->current;                  \
     389    _page->current = addr;                              \
     390  }                                                     \
     391}                                                       \
     392while (0)
     393#endif
     394
     395#endif /* ! HAVE_AUTOMATIC_GC */
    305396
    306397#define MM_HEAP_ADDR_UNKNOWN_FLAG 0 

  • Singular/mmheap.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmheap.c,v 1.12 1999-10-18 11:19:30 obachman Exp $ */
     4/* $Id: mmheap.c,v 1.13 1999-10-19 14:55:39 obachman Exp $ */
    55#include <stdio.h>
    66#include "mod2.h"
    … …  
    1111
    1212
    13 
    1413/*****************************************************************
    1514 *
    … …  
    1716 *
    1817 *****************************************************************/
    19 void mmInitHeap(memHeap heap, size_t size)
    20 {
    21   heap->current = NULL;
    22   heap->pages = NULL;
    23   heap->size = size;
    24   heap->last_gc= NULL;
    25 }
    26 
    27 memHeap mmCreateHeap(size_t size)
    28 {
    29   memHeap heap = (memHeap) AllocSizeOf(ip_memHeap);
    30   mmInitHeap(heap, size);
    31   return heap;
    32 }
    33 
    3418#ifndef HEAP_DEBUG
    3519void mmDestroyHeap(memHeap *heap)
    3620#else
     21static int mmPrintHeapError(char* msg, void* addr, memHeap heap,
     22                            const char* fn, int l);
    3723void mmDebugDestroyHeap(memHeap *heap, const char* file, int line)
    3824#endif
    … …  
    4733}
    4834
     35memHeapPage mmAllocNewHeapPage(memHeap heap)
     36{
     37#ifndef HAVE_AUTOMATIC_GC
     38  if (heap->size > MAX_HEAP_CHUNK_SIZE)
     39  {
     40    heap->current = mmMallocFromSystem(heap->size);
     41    *((void**) heap->current) = NULL;
     42    heap->pages = (void*) ((int)heap->pages + 1);
     43#ifdef MDEBUG
     44    mmDBInitNewHeapPage(heap, NULL);
     45#endif
     46    return NULL;
     47  }
     48  else
     49#endif
     50  {
     51    memHeapPage newpage;
     52    int i = 1, n = SIZE_OF_HEAP_PAGE / heap->size;
     53    void* tmp;
     54    if (n > 0) newpage = mmGetPage();
     55    else newpage = mmVallocFromSystem(heap->size + SIZE_OF_HEAP_PAGE_HEADER);
     56   
     57    assume(mmIsAddrPageAligned((void*) newpage));
     58
     59#ifndef HAVE_AUTOMATIC_GC
     60    newpage->next = heap->pages;
     61    heap->pages = newpage;
     62    heap->current = (void*) (((char*)newpage) + SIZE_OF_HEAP_PAGE_HEADER);
     63    tmp = heap->current;
     64#else
     65    newpage->used_blocks = 0;
     66    newpage->current = (void*) (((char*)newpage) + SIZE_OF_HEAP_PAGE_HEADER);
     67    tmp = newpage->current;
     68#endif   
     69
     70    while (i < n)
     71    {
     72      *((void**)tmp) = (void*) (((char*)tmp) + heap->size);
     73      tmp = *((void**)tmp);
     74      i++;
     75    }
     76    *((void**)tmp) = NULL;
     77#ifdef MDEBUG
     78    mmDBInitNewHeapPage(heap, newpage);
     79#endif
     80    return newpage;
     81  }
     82}
     83
     84#ifndef HAVE_AUTOMATIC_GC
     85memHeap mmCreateHeap(size_t size)
     86{
     87  memHeap heap = (memHeap) AllocSizeOf(ip_memHeap);
     88  heap->current = NULL;
     89  heap->pages = NULL;
     90  heap->size = size;
     91  heap->last_gc= NULL;
     92  return heap;
     93}
     94
    4995#ifndef HEAP_DEBUG
    5096void mmClearHeap(memHeap heap)
    51 #else
    52 void _mmClearHeap(memHeap heap)
    53 #endif
    5497{
    5598  memHeapPage page, next_page;
    … …  
    67110  heap->last_gc = NULL;
    68111}
    69 
    70 void mmAllocNewHeapPage(memHeap heap)
    71 {
    72   if (heap->size > MAX_HEAP_CHUNK_SIZE)
    73   {
    74     heap->current = mmMallocFromSystem(heap->size);
    75     *((void**) heap->current) = NULL;
    76     heap->pages = (void*) ((int)heap->pages + 1);
    77   }
    78   else
    79   {
    80     memHeapPage newpage = (memHeapPage) mmGetPage();
    81     int i = 1, n = SIZE_OF_HEAP_PAGE / heap->size;
    82     void* tmp;
    83     assume(heap != NULL && newpage != NULL && heap->current == NULL);
    84     assume(mmIsAddrPageAligned((void*) newpage));
    85 
    86     newpage->next = heap->pages;
    87     heap->pages = newpage;
    88  
    89     heap->current = (void*) (((char*)newpage) + SIZE_OF_HEAP_PAGE_HEADER);
    90     tmp = heap->current;
    91 
    92     while (i < n)
    93     {
    94       *((void**)tmp) = (void*) (((char*)tmp) + heap->size);
    95       tmp = *((void**)tmp);
    96       i++;
    97     }
    98     *((void**)tmp) = NULL;
    99   }
    100 #ifdef MDEBUG
    101     mmDBInitNewHeapPage(heap);
    102 #endif
    103 }
     112#else
     113void mmDebugClearHeap(memHeap heap, const char* file, int line)
     114{
     115  mmCheckHeap(heap);
     116  mmGarbageCollectHeap(heap, 1);
     117  if (heap->current != NULL)
     118  {
     119    mmPrintHeapError("ClearHeap: Heap not empty", 0, heap, file, line);
     120  }
     121}
     122#endif
    104123
    105124void mmMergeHeap(memHeap into, memHeap what)
    … …  
    141160}
    142161
    143 void mmRemoveFromCurrentHeap(memHeap heap, void* addr)
    144 {
    145   heap->current = mmRemoveFromList((void*) heap->current, addr);
    146 }
    147 
    148 void mmRemoveHeapBlocksOfPage(memHeap heap, memHeapPage hpage)
     162static void mmRemoveHeapBlocksOfPage(memHeap heap, memHeapPage hpage)
    149163{
    150164  void *prev = NULL, *new_current = NULL, *current = heap->current;
    … …  
    262276}
    263277
     278#else /* HAVE_AUTOMATIC_GC */
     279
     280memHeapPage mmGetNewCurrentPage(memHeap heap)
     281{
     282  assume(heap->current_page->current == NULL);
     283  assume(heap->current_page == mmZeroPage ||
     284         (heap->current_page->next->prev == heap->current_page &&
     285          heap->current_page->prev->next == heap->current_page));
     286  if (heap->current_page != mmZeroPage &&
     287      heap->current_page->next->current != NULL)
     288  {
     289    heap->current_page = heap->current_page->next;
     290  }
     291  else
     292  {
     293    memHeapPage new_page = mmAllocNewHeapPage(heap);
     294    if (heap->current_page == mmZeroPage)
     295    {
     296      new_page->next = new_page;
     297      new_page->prev = new_page;
     298    }
     299    else
     300    {
     301      new_page->next = heap->current_page->next;
     302      new_page->prev = heap->current_page->prev;
     303      if (heap->current_page->next != heap->current_page)
     304      {
     305        assume(heap->current_page->prev != heap->current_page &&
     306               heap->current_page->prev != heap->current_page->next);
     307        heap->current_page->prev->next = new_page;
     308        heap->current_page->next->prev = new_page;
     309      }
     310    }
     311    heap->current_page = new_page;
     312  }
     313  assume(heap->current_page->next->prev == heap->current_page);
     314  assume(heap->current_page->prev->next == heap->current_page);
     315  return heap->current_page;
     316}
     317
     318void mmRearrangeHeapPages(memHeapPage page, memHeap heap)
     319{
     320  assume(page != mmZeroPage &&
     321         page->used_blocks < page->next->used_blocks);
     322
     323  if (page->used_blocks == 0)
     324  {
     325    if (heap->current_page == page)
     326      heap->current_page = heap->current_page->next;
     327    page->prev->next = page->next;
     328    page->next->prev = page->prev;
     329    if (SIZE_OF_HEAP_PAGE / heap->size > 0)
     330      mmFreePage(page);
     331    else
     332      mmVfreeToSystem(page, heap->size + SIZE_OF_HEAP_PAGE_HEADER);
     333  }
     334  else
     335  {
     336    memHeapPage next_page = page->next;
     337
     338    if (heap->current_page->current == NULL)
     339      heap->current_page = page;
     340    else if (heap->current_page == page && next_page->current != NULL)
     341      heap->current_page = next_page;
     342
     343    while (page->used_blocks < next_page->used_blocks)
     344      next_page = next_page->next;
     345
     346    if (next_page != page->next)
     347    {
     348      page->prev->next = page->next;
     349      page->next->prev = page->prev;
     350      page->prev = next_page;
     351      page->next = next_page->next;
     352      next_page->next->prev = page;
     353      next_page->next = page;
     354    }
     355  }
     356  mmCheckHeap(heap);
     357}
     358
     359memHeap mmCreateHeap(size_t size)
     360{
     361  memHeap heap = (memHeap) AllocSizeOf(ip_memHeap);
     362  heap->current_page = mmZeroPage;
     363  heap->size = size;
     364  return heap;
     365}
     366
     367#ifndef HEAP_DEBUG
     368void mmClearHeap(memHeap heap)
     369#else
     370void mmDebugClearHeap(memHeap heap, const char* file, int line)
     371#endif
     372{
     373#ifdef HEAP_DEBUG 
     374  mmCheckHeap(heap);
     375  if (heap->current_page != mmZeroPage && 
     376      (heap->current_page->used_blocks != 0 ||
     377       heap->current_page->next != heap->current_page ||
     378       heap->current_page->prev != heap->current_page))
     379    mmPrintHeapError("ClearHeap: Heap not empty", NULL, heap, file, line);
     380#endif
     381  if (heap->current_page != mmZeroPage)
     382  {
     383    if (SIZE_OF_HEAP_PAGE / heap->size > 0)
     384      mmFreePage(heap->current_page);
     385    else
     386      mmVfreeToSystem(heap->current_page,
     387                      heap->size + SIZE_OF_HEAP_PAGE_HEADER);
     388  }
     389  heap->current_page = mmZeroPage;
     390}
     391
     392void  mmMergeHeap(memHeap into, memHeap what)
     393{/* TBC */}
     394
     395#endif /* HAVE_AUTOMATIC_GC */
     396 
    264397#ifdef HEAP_DEBUG
    265398int mm_HEAP_DEBUG = HEAP_DEBUG;
    … …  
    274407}
    275408
    276 void mmDebugClearHeap(memHeap heap, const char* file, int line)
    277 {
    278   mmCheckHeap(heap);
    279   mmGarbageCollectHeap(heap, 1);
    280   if (heap->current != NULL)
    281   {
    282     mmPrintHeapError("ClearHeap: Heap not empty", 0, heap, file, line);
    283   }
    284 }
    285 
     409#ifndef HAVE_AUTOMATIC_GC
    286410static int mmDebugCheckSingleHeapAddr(void* addr, memHeap heap,
    287411                                      const char* fn, int l)
    … …  
    360484}
    361485
     486#else /* HAVE_AUTOMATIC_GC */
     487static int mmDebugCheckSingleHeapAddr(void* addr, memHeap heap,
     488                                      const char* fn, int l)
     489{
     490  void* page;
     491  memHeapPage hpage;
     492 
     493  if (heap == NULL)
     494  {
     495    fprintf(stderr, "NULL heap in %s:%d\n", fn, l);
     496    assume(0);
     497    return 0;
     498  }
     499
     500  if (addr == NULL)
     501    return mmPrintHeapError("NULL addr", addr, heap, fn, l);
     502
     503  if (! mmIsNotAddrOnFreePage(addr))
     504    return mmPrintHeapError("Addr on freed page", addr, heap, fn, l);
     505
     506#if 0 
     507  page = mmGetPageOfAddr(addr);
     508 
     509  if (! mmIsAddrOnList(page, heap->pages))
     510    return mmPrintHeapError("addr not on heap page", addr, heap, fn, l);
     511
     512  if ( (((long) (((char*) addr) - ((char*) page + SIZE_OF_HEAP_PAGE_HEADER)))
     513        % heap->size) != 0)
     514    return mmPrintHeapError("addr unaligned within heap", addr, heap, fn, l);
     515  hpage = (memHeapPage) page;
     516#endif
     517  return 1;
     518}
     519
     520
     521static int mmDebugCheckHeapAddrContainment(void* addr, memHeap heap, int flag,
     522                                           const char* fn, int l)
     523{
     524  if (flag == MM_HEAP_ADDR_FREE_FLAG)
     525  {
     526    if (! mmIsAddrOnList(addr, heap->current_page->current))
     527      return mmPrintHeapError("addr not on heap free list",
     528                              addr, heap, fn, l);
     529  }
     530  else if (flag == MM_HEAP_ADDR_USED_FLAG)
     531  {
     532    if (mmIsAddrOnList(addr, heap->current_page->current))
     533      return mmPrintHeapError("used addr on heap free list",
     534                              addr, heap, fn, l);
     535  }
     536  return 1;
     537}
     538
     539int mmDebugCheckHeap(memHeap heap, const char* fn, int l)
     540{
     541  void* p;
     542  memHeapPage page;
     543  long prev_used_blocks;
     544 
     545  long has_changed = FALSE;
     546  long max_blocks = SIZE_OF_HEAP_PAGE / heap->size;
     547  if (max_blocks == 0) max_blocks = 1;
     548 
     549  if (heap->current_page == mmZeroPage) return 1;
     550
     551  // check used_blocks
     552  page = heap->current_page;
     553  prev_used_blocks = heap->current_page->prev->used_blocks;
     554  do
     555  {
     556    if (page->prev->next != page || page->next->prev != page)
     557      return mmPrintHeapError("page list damaged",  NULL, heap, fn, l);
     558    if (page->used_blocks == 0)
     559      return mmPrintHeapError("No used blocks",  NULL, heap, fn, l);
     560    if (page->used_blocks < 0 || page->used_blocks > max_blocks)
     561      return mmPrintHeapError("used_blocks out of bounds", NULL, heap, fn, l);
     562    if (max_blocks - mmListLength(page->current) != page->used_blocks)
     563    {
     564      fprintf(stderr, "used_blocks wrong: should be %ld, is %ld\n",
     565              max_blocks - mmListLength(page->current), page->used_blocks);
     566      return mmPrintHeapError("", NULL, heap, fn, l);
     567    }
     568    if (page->used_blocks > heap->current_page->used_blocks)
     569    {
     570      fprintf(stderr, "used_blocks %ld larger than %ld", page->used_blocks,
     571              heap->current_page->used_blocks);
     572      return mmPrintHeapError("", NULL, heap, fn, l);
     573    }
     574    if (prev_used_blocks < page->used_blocks)
     575    {
     576      if (has_changed)
     577      {
     578        fprintf(stderr, "pages not decr order with change at %ld and %ld\n",
     579                has_changed, page->used_blocks);
     580        return mmPrintHeapError("", NULL, heap, fn, l);
     581      }
     582      else
     583      {
     584        has_changed = page->used_blocks;
     585      }
     586
     587      p = page->current;
     588      while (p != NULL)
     589      {
     590        if (mmGetPageOfAddr(p) != page)
     591          return mmPrintHeapError("addr in freelist not on page",
     592                                  p, heap, fn, l);
     593        if (!mmDebugCheckSingleHeapAddr(p, heap, fn, l)  ||
     594            !mmDebugCheckHeapAddrContainment(p, heap, MM_HEAP_ADDR_FREE_FLAG,
     595                                             fn, l))
     596          return 0;
     597        p = *((void**) p);
     598      }
     599    }
     600    prev_used_blocks = page->used_blocks;
     601    page = page->next;
     602  }
     603  while(page != heap->current_page);
     604
     605  return 1;
     606}
     607#endif /* ! HAVE_AUTOMATIC_GC */
     608
     609
    362610int mmDebugCheckHeapAddr(void* addr, memHeap heap, int flag,
    363611                         const char* fn, int l)

  • Singular/mmisc.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmisc.c,v 1.17 1999-10-19 14:03:50 obachman Exp $ */
     4/* $Id: mmisc.c,v 1.18 1999-10-19 14:55:39 obachman Exp $ */
    55
    66/*
    … …  
    149149}
    150150
    151 
     151#ifndef HAVE_AUTOMATIC_GC
    152152void mmGarbageCollectHeaps(int strict)
    153153{
    … …  
    197197#endif
    198198}
     199#endif
    199200 
    200201size_t mmSizeL( void* adr )
    … …  
    219220  memSpecHeap s_heap;
    220221
     222#ifndef HAVE_AUTOMATIC_GC
    221223  for (i=0; mmGetSize(i) <= MAX_BLOCK_SIZE; i++)
    222224    bytesfree += mmListLength(mm_theList[i].current)*mm_theList[i].size;
    … …  
    234236    s_heap = s_heap->next;
    235237  }
     238#endif
    236239  return
    237240    mm_bytesMalloc + mm_bytesValloc
    … …  
    282285static void mmPrintHeapStat(memHeap heap, int i)
    283286{
     287#ifndef HAVE_AUTOMATIC_GC
    284288  long l,a;
    285289  if (i >= 0) printf("%d", i);
    … …  
    317321    printf(" +");
    318322  printf("\n");
     323#endif
    319324  fflush(stdout);
    320325}

  • Singular/mmpage.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmpage.c,v 1.3 1999-10-14 14:27:20 obachman Exp $ */
     4/* $Id: mmpage.c,v 1.4 1999-10-19 14:55:40 obachman Exp $ */
    55
    66/*
    … …  
    3838  else
    3939#endif
    40     return mmAllocPageFromSystem();
     40    return mmVallocFromSystem(SIZE_OF_PAGE);
    4141}
    4242
    … …  
    5757  {
    5858    next = *((void**)mm_FreePages);
    59     mmFreePageToSystem(mm_FreePages);
     59    mmVfreeToSystem(mm_FreePages, SIZE_OF_PAGE);
    6060    mm_FreePages = next;
    6161  }

  • Singular/mmprivate.h

    r0d44225 rf983ed  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: mmprivate.h,v 1.13 1999-10-14 14:27:21 obachman Exp $ */
     6/* $Id: mmprivate.h,v 1.14 1999-10-19 14:55:40 obachman Exp $ */
    77/*
    88* ABSTRACT
    … …  
    7474
    7575void mmPrintFL( const char* fname, const int lineno );
    76 void mmDBInitNewHeapPage(memHeap heap);
     76void mmDBInitNewHeapPage(memHeap heap, memHeapPage page);
    7777int mmCheckDBMCB ( DBMCB * what, int size , int flags);
    7878void mmFillDBMCB(DBMCB* what, size_t size, memHeap heap,
    … …  
    9595void  mmFreeToSystem(void* addr, size_t size);
    9696
    97 void* mmAllocPageFromSystem();
    98 void  mmFreePageToSystem(void* page);
     97void* mmVallocFromSystem(size_t size);
     98void  mmVfreeToSystem(void* page, size_t size);
    9999
    100100extern int mm_bytesMalloc;
    … …  
    114114 *
    115115 **********************************************************************/
    116 struct sip_memHeapPage
    117 {
    118   memHeapPage next;
    119   long counter;
    120 };
    121 
    122 /* Change this appropriately, if you change sip_memHeapPage           */
    123 /* However, make sure that sizeof(sip_memHeapPage) is a multiple of 8 */
    124 #define SIZE_OF_HEAP_PAGE_HEADER (SIZEOF_VOIDP + SIZEOF_LONG)
    125 #define SIZE_OF_HEAP_PAGE (SIZE_OF_PAGE - SIZE_OF_HEAP_PAGE_HEADER)
    126 
    127116/* size of max cunk of memory which is treated by "normal" (static) heaps */
    128117#define MAX_BLOCK_SIZE  (((SIZE_OF_HEAP_PAGE) / 16)*4)
    … …  
    137126
    138127#define mmGetHeapPageOfAddr(addr) (memHeapPage) mmGetPageOfAddr(addr)
    139 #define mmIncrHeapPageCounterOfAddr(addr)       \
    140 do                                              \
    141 {                                               \
    142   register memHeapPage page = mmGetHeapPageOfAddr(addr); \
    143   (page->counter)++;                            \
    144 }                                               \
    145 while (0)
    146128
    147 extern void mmRemoveHeapBlocksOfPage(memHeap heap, memHeapPage hpage);
    148 #define mmDecrCurrentHeapPageCounter(heap)                          \
    149 do                                                                  \
    150 {                                                                   \
    151   register memHeapPage page = mmGetHeapPageOfAddr((heap)->current); \
    152   if (--(page->counter) == 0) mmRemoveHeapBlocksOfPage(heap, page); \
    153 }                                                                   \
    154 while (0)
    155 
    156 /* Initializes Heap */
    157 extern void mmInitHeap(memHeap heap, size_t size);
    158129/* creates and initializes heap */
    159130extern memHeap mmCreateHeap(size_t size);

  • Singular/mmtables.c

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mmtables.c,v 1.4 1999-10-18 11:19:30 obachman Exp $ */
     4/* $Id: mmtables.c,v 1.5 1999-10-19 14:55:40 obachman Exp $ */
    55
    66/*
    … …  
    313313  printf("#ifndef MDEBUG\n");
    314314  for (i=0;  mm_mcbSizes[i] < MAX_BLOCK_SIZE; i++)
     315  {
     316#ifndef HAVE_AUTOMATIC_GC
    315317    printf("{NULL, NULL, NULL, %d},\n", mm_mcbSizes[i]);
    316   printf("{NULL, NULL, NULL, %d}\n};\n", mm_mcbSizes[i]);
     318#else
     319    printf("{mmZeroPage, %d},\n", mm_mcbSizes[i]);
     320#endif
     321  }
     322#ifndef HAVE_AUTOMATIC_GC
     323    printf("{NULL, NULL, NULL, %d}\n};\n", mm_mcbSizes[i]);
     324#else
     325    printf("{mmZeroPage, %d}\n};\n", mm_mcbSizes[i]);
     326#endif
    317327  printf("#else /* MDEBUG */\n");
    318328  for (i=0; mm_mcbSizes[i] < MAX_BLOCK_SIZE; i++)
     329  {
     330#ifndef HAVE_AUTOMATIC_GC
    319331    printf("{NULL, NULL, NULL, %d},\n", RealSizeFromSize(mm_mcbSizes[i]));
     332#else
     333    printf("{mmZeroPage, %d},\n",RealSizeFromSize(mm_mcbSizes[i]));
     334#endif
     335  }
     336#ifndef HAVE_AUTOMATIC_GC
    320337  printf("{NULL, NULL, NULL, %d}\n};\n", RealSizeFromSize(mm_mcbSizes[i]));
     338#else
     339  printf("{mmZeroPage, %d}\n};\n",RealSizeFromSize(mm_mcbSizes[i]));
     340#endif
    321341  printf("#endif /* ! MDEBUG */\n");
    322342}
    … …  
    351371#include \"mmprivate.h\"
    352372");
     373#ifdef HAVE_AUTOMATIC_GC
     374  printf("struct sip_memHeapPage mmZeroPage[] = {{0, NULL, NULL, NULL}};\n");
     375#endif
    353376  printf("#ifdef ALIGN_8\n");
    354377  OutputIndexTable(mm_IndiciesAlign8);

  • Singular/syz2.cc

    r0d44225 rf983ed  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz2.cc,v 1.3 1999-10-19 12:42:50 obachman Exp $ */
     4/* $Id: syz2.cc,v 1.4 1999-10-19 14:55:41 obachman Exp $ */
    55/*
    66* ABSTRACT: resolutions
    … …  
    751751            rChangeSComps(currcomponents,
    752752                          currShiftedComponents,
    753                           IDELEMS(syzstr->res[index]));
     753                          IDELEMS(syzstr->res[index-1]));
    754754            number up = kBucketPolyRed(syzstr->bucket,redset[j].p,
    755755                         redset[j].length, NULL);
    … …  
    771771        kBucketClear(syzstr->bucket,&tso.p,&tso.length);
    772772        currcomponents = syzstr->truecomponents[index];
     773        currShiftedComponents = syzstr->ShiftedComponents[index];
     774        rChangeSComps(currcomponents,
     775                      currShiftedComponents,
     776                      IDELEMS(syzstr->res[index]));
    773777        int il;
    774778        kBucketClear(syzstr->syz_bucket,&tso.syz,&il);
    775779        currcomponents = syzstr->truecomponents[index-1];
     780        currShiftedComponents = syzstr->ShiftedComponents[index-1];
     781        rChangeSComps(currcomponents,
     782                      currShiftedComponents,
     783                      IDELEMS(syzstr->res[index-1]));
    776784      }
    777785#ifdef SHOW_PROT
    … …  
    11481156  for (i=0;i<IDELEMS(arg);i++)
    11491157  {
    1150     temp->m[i] = pOrdPolyInsertSetm(pCopy(arg->m[i]));
     1158    temp->m[i] = pFetchCopy(origR, arg->m[i]);
    11511159    if (temp->m[i]!=NULL)
    11521160    {
    … …  
    12501258    pComp0=oldComp0;
    12511259  }
    1252   if (ord!=NULL)
    1253   {
    1254     Free((ADDRESS)ord,3*sizeof(int));
    1255     Free((ADDRESS)b0,3*sizeof(int));
    1256     Free((ADDRESS)b1,3*sizeof(int));
    1257   }
    12581260  if (TEST_OPT_PROT) PrintLn();
    12591261  return syzstr;
Note: See TracChangeset for help on using the changeset viewer.