Back to index

plt-scheme  4.2.1
Defines | Functions | Variables
alloc.c File Reference
#include "private/gc_priv.h"
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include "version.h"

Go to the source code of this file.

Defines

#define IF_THREADS(x)
#define NWORDS   64
#define GC_RATE   10
#define MAX_PRIOR_ATTEMPTS   1

Functions

GC_bool GC_collection_in_progress ()
int GC_never_stop_func GC_PROTO ((void))
static word min_words_allocd ()
word GC_adj_words_allocd ()
void GC_clear_a_few_frames ()
GC_bool GC_should_collect ()
void GC_notify_full_gc ()
void GC_maybe_gc ()
GC_collect_start_callback_Proc GC_set_collect_start_callback (GC_collect_start_callback_Proc func)
GC_collect_end_callback_Proc GC_set_collect_end_callback (GC_collect_end_callback_Proc func)
GC_bool GC_try_to_collect_inner (GC_stop_func stop_func)
void GC_collect_a_little_inner (int n)
int GC_collect_a_little GC_PROTO (())
GC_bool GC_stopped_mark (GC_stop_func stop_func)
void GC_set_fl_marks (ptr_t q)
void GC_clear_fl_marks (ptr_t q)
void GC_finish_collection ()
int GC_try_to_collect (GC_stop_func stop_func)
void GC_add_to_heap (struct hblk *p, word bytes)
void GC_print_heap_sects ()
ptr_t GC_max (ptr_t x, ptr_t y)
ptr_t GC_min (ptr_t x, ptr_t y)
void GC_set_max_heap_size (GC_word n)
GC_bool GC_expand_hp_inner (word n)
int GC_expand_hp (size_t bytes)
GC_bool GC_collect_or_expand (word needed_blocks, GC_bool ignore_off_page)
ptr_t GC_allocobj (word sz, int kind)

Variables

word GC_non_gc_bytes = 0
word GC_gc_no = 0
int GC_incremental = 0
int GC_parallel = FALSE
int GC_full_freq = 19
GC_bool GC_need_full_gc = FALSE
word GC_used_heap_size_after_full = 0
char * GC_copyright []
signed_word GC_mem_found
GC_bool GC_dont_expand = 0
word GC_free_space_divisor = 4
unsigned long GC_time_limit = TIME_LIMIT
CLOCK_TYPE GC_start_time
int GC_n_attempts = 0
static word GC_collect_at_heapsize = (word)(-1)
GC_bool GC_is_full_gc = FALSE
GC_collect_start_callback_Proc GC_collect_start_callback = NULL
GC_collect_end_callback_Proc GC_collect_end_callback = NULL
int GC_deficit = 0
word GC_n_heap_sects = 0
GC_PTR GC_least_plausible_heap_addr = (GC_PTR)ONES
GC_PTR GC_greatest_plausible_heap_addr = 0
GC_word GC_max_retries = 0
void(* GC_out_of_memory )(void) = NULL
unsigned GC_fail_count = 0

Define Documentation

#define GC_RATE   10

Definition at line 430 of file alloc.c.

#define IF_THREADS (   x)

Definition at line 79 of file alloc.c.

#define MAX_PRIOR_ATTEMPTS   1

Definition at line 431 of file alloc.c.

#define NWORDS   64

Function Documentation

void GC_add_to_heap ( struct hblk p,
word  bytes 
)

Definition at line 825 of file alloc.c.

{
    word words;
    hdr * phdr;
    
    if (GC_n_heap_sects >= MAX_HEAP_SECTS) {
       ABORT("Too many heap sections: Increase MAXHINCR or MAX_HEAP_SECTS");
    }
    phdr = GC_install_header(p);
    if (0 == phdr) {
       /* This is extremely unlikely. Can't add it.  This will        */
       /* almost certainly result in a    0 return from the allocator,       */
       /* which is entirely appropriate.                       */
       return;
    }
    GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p;
    GC_heap_sects[GC_n_heap_sects].hs_bytes = bytes;
    GC_n_heap_sects++;
    words = BYTES_TO_WORDS(bytes);
    phdr -> hb_sz = words;
    phdr -> hb_map = (unsigned char *)1;   /* A value != GC_invalid_map      */
    phdr -> hb_flags = 0;
    GC_freehblk(p);
    GC_heapsize += bytes;
    if ((ptr_t)p <= (ptr_t)GC_least_plausible_heap_addr
        || GC_least_plausible_heap_addr == 0) {
        GC_least_plausible_heap_addr = (GC_PTR)((ptr_t)p - sizeof(word));
              /* Making it a little smaller than necessary prevents   */
              /* us from getting a false hit from the variable */
              /* itself.  There's some unintentional reflection       */
              /* here.                                         */
    }
    if ((ptr_t)p + bytes >= (ptr_t)GC_greatest_plausible_heap_addr) {
        GC_greatest_plausible_heap_addr = (GC_PTR)((ptr_t)p + bytes);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 186 of file alloc.c.

{
    register signed_word result;
    register signed_word expl_managed =
              BYTES_TO_WORDS((long)GC_non_gc_bytes
                            - (long)GC_non_gc_bytes_at_gc);
    
    /* Don't count what was explicitly freed, or newly allocated for  */
    /* explicit management.  Note that deallocating an explicitly     */
    /* managed object should not alter result, assuming the client    */
    /* is playing by the rules.                                       */
    result = (signed_word)GC_words_allocd
            - (signed_word)GC_mem_freed 
            + (signed_word)GC_finalizer_mem_freed - expl_managed;
    if (result > (signed_word)GC_words_allocd) {
        result = GC_words_allocd;
       /* probably client bug or unfortunate scheduling */
    }
    result += GC_words_finalized;
       /* We count objects enqueued for finalization as though they   */
       /* had been reallocated this round. Finalization is user       */
       /* visible progress.  And if we don't count this, we have      */
       /* stability problems for programs that finalize all objects.  */
    if ((signed_word)(GC_words_wasted >> 3) < result)
        result += GC_words_wasted;
       /* This doesn't reflect useful work.  But if there is lots of  */
       /* new fragmentation, the same is probably true of the heap,   */
       /* and the collection will be correspondingly cheaper.         */
    if (result < (signed_word)(GC_words_allocd >> 3)) {
       /* Always count at least 1/8 of the allocations.  We don't want       */
       /* to collect too infrequently, since that would inhibit       */
       /* coalescing of free storage blocks.                          */
       /* This also makes us partially robust against client bugs.    */
        return(GC_words_allocd >> 3);
    } else {
        return(result);
    }
}

Here is the caller graph for this function:

ptr_t GC_allocobj ( word  sz,
int  kind 
)

Definition at line 1092 of file alloc.c.

{
    ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]);
    GC_bool tried_minor = FALSE;
    
    if (sz == 0) return(0);

    while (*flh == 0) {
      ENTER_GC();
      /* Do our share of marking work */
        if(TRUE_INCREMENTAL) GC_collect_a_little_inner(1);
      /* Sweep blocks for objects of this size */
        GC_continue_reclaim(sz, kind);
      EXIT_GC();
      if (*flh == 0) {
        GC_new_hblk(sz, kind);
      }
      if (*flh == 0) {
        ENTER_GC();
       if (GC_incremental && GC_time_limit == GC_TIME_UNLIMITED
           && ! tried_minor ) {
           GC_collect_a_little_inner(1);
           tried_minor = TRUE;
       } else {
          if (!GC_collect_or_expand((word)1,FALSE)) {
           EXIT_GC();
           return(0);
         }
       }
       EXIT_GC();
      }
    }
    /* Successful allocation; reset failure count.      */
    GC_fail_count = 0;
    
    return(*flh);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 231 of file alloc.c.

{
#   define NWORDS 64
    word frames[NWORDS];
    /* Some compilers will warn that frames was set but never used.   */
    /* That's the whole idea ...                               */
    register int i;
    
    for (i = 0; i < NWORDS; i++) frames[i] = 0;
}

Here is the caller graph for this function:

Definition at line 629 of file alloc.c.

{
   ptr_t p;
   struct hblk * h, * last_h = 0;
   hdr *hhdr;
   int word_no;

   for (p = q; p != 0; p = obj_link(p)){
       h = HBLKPTR(p);
       if (h != last_h) {
         last_h = h; 
         hhdr = HDR(h);
       }
       word_no = (((word *)p) - ((word *)h));
       clear_mark_bit_from_hdr(hhdr, word_no);
#      ifdef GATHERSTATS
           GC_mem_found -= hhdr -> hb_sz;
#      endif
   }
}

Here is the caller graph for this function:

Definition at line 440 of file alloc.c.

{
    register int i;
    
    if (GC_dont_gc) return;
    if (GC_incremental && GC_collection_in_progress()) {
       for (i = GC_deficit; i < GC_RATE*n; i++) {
           if (GC_mark_some((ptr_t)0)) {
               /* Need to finish a collection */
#             ifdef SAVE_CALL_CHAIN_IN_GC
                  GC_save_callers(GC_last_stack);
#             endif
#             ifdef PARALLEL_MARK
                  GC_wait_for_reclaim();
#             endif
              if (GC_n_attempts < MAX_PRIOR_ATTEMPTS
                  && GC_time_limit != GC_TIME_UNLIMITED) {
                GET_TIME(GC_start_time);
                if (!GC_stopped_mark(GC_timeout_stop_func)) {
                  GC_n_attempts++;
                  break;
                }
              } else {
                (void)GC_stopped_mark(GC_never_stop_func);
              }
               GC_finish_collection();
               break;
           }
       }
       if (GC_deficit > 0) GC_deficit -= GC_RATE*n;
       if (GC_deficit < 0) GC_deficit = 0;
    } else {
        GC_maybe_gc();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GC_bool GC_collect_or_expand ( word  needed_blocks,
GC_bool  ignore_off_page 
)

Definition at line 1027 of file alloc.c.

{
    if (!GC_incremental && !GC_dont_gc &&
       ((GC_dont_expand && GC_words_allocd > 0) || GC_should_collect())) {
      GC_gcollect_inner();
    } else {
      word blocks_to_get = GC_heapsize/(HBLKSIZE*GC_free_space_divisor)
                        + needed_blocks;
      
      if (blocks_to_get > MAXHINCR) {
          word slop;
          
         /* Get the minimum required to make it likely that we        */
         /* can satisfy the current request in the presence of black- */
         /* listing.  This will probably be more than MAXHINCR.       */
          if (ignore_off_page) {
              slop = 4;
          } else {
             slop = 2*divHBLKSZ(BL_LIMIT);
             if (slop > needed_blocks) slop = needed_blocks;
         }
          if (needed_blocks + slop > MAXHINCR) {
              blocks_to_get = needed_blocks + slop;
          } else {
              blocks_to_get = MAXHINCR;
          }
      }
      if (!GC_expand_hp_inner(blocks_to_get)
        && !GC_expand_hp_inner(needed_blocks)) {
       if (GC_fail_count++ < GC_max_retries) {
         /* PLTSCHEME: rather not see this message */
#if 0
           WARN("Out of Memory!  Trying to continue ...\n", 0);
#endif
           GC_gcollect_inner();
       } else {
           /* PLTSCHEME */
           if (GC_out_of_memory)
             GC_out_of_memory();

#          if !defined(AMIGA) || !defined(GC_AMIGA_FASTALLOC)
             WARN("Out of Memory!  Returning NIL!\n", 0);
#          endif
           return(FALSE);
       }
      } else {
#        ifdef CONDPRINT
            if (GC_fail_count && GC_print_stats) {
             GC_printf0("Memory available again ...\n");
           }
#        endif
      }
    }
    return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 129 of file mark.c.

{
    return(GC_mark_state != MS_NONE);
}

Here is the caller graph for this function:

int GC_expand_hp ( size_t  bytes)

Definition at line 1006 of file alloc.c.

{
    int result;
    DCL_LOCK_STATE;
    
    DISABLE_SIGNALS();
    LOCK();
    if (!GC_is_initialized) GC_init_inner();
    result = (int)GC_expand_hp_inner(divHBLKSZ((word)bytes));
    if (result) GC_requested_heapsize += bytes;
    UNLOCK();
    ENABLE_SIGNALS();
    return(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 921 of file alloc.c.

{
    word bytes;
    struct hblk * space;
    word expansion_slop;    /* Number of bytes by which we expect the */
                            /* heap to expand soon.                     */

    if (n < MINHINCR) n = MINHINCR;
    bytes = n * HBLKSIZE;
    /* Make sure bytes is a multiple of GC_page_size */
      {
       word mask = GC_page_size - 1;
       bytes += mask;
       bytes &= ~mask;
      }
    
    if (GC_max_heapsize != 0 && GC_heapsize + bytes > GC_max_heapsize) {
        /* Exceeded self-imposed limit */
        return(FALSE);
    }
    space = GET_MEM(bytes);
    if( space == 0 ) {
#      ifdef CONDPRINT
         if (GC_print_stats) {
           GC_printf1("Failed to expand heap by %ld bytes\n",
                     (unsigned long)bytes);
         }
#       endif
       return(FALSE);
    }
#   ifdef CONDPRINT
      if (GC_print_stats) {
       GC_printf2("Increasing heap size by %lu after %lu allocated bytes\n",
                  (unsigned long)bytes,
                  (unsigned long)WORDS_TO_BYTES(GC_words_allocd));
#      ifdef UNDEFINED
         GC_printf1("Root size = %lu\n", GC_root_size);
         GC_print_block_list(); GC_print_hblkfreelist();
         GC_printf0("\n");
#      endif
      }
#   endif
    expansion_slop = WORDS_TO_BYTES(min_words_allocd()) + 4*MAXHINCR*HBLKSIZE;
    if (GC_last_heap_addr == 0 && !((word)space & SIGNB)
        || (GC_last_heap_addr != 0 && GC_last_heap_addr < (ptr_t)space)) {
        /* Assume the heap is growing up */
        GC_greatest_plausible_heap_addr =
            (GC_PTR)GC_max((ptr_t)GC_greatest_plausible_heap_addr,
                           (ptr_t)space + bytes + expansion_slop);
    } else {
        /* Heap is growing down */
        GC_least_plausible_heap_addr =
            (GC_PTR)GC_min((ptr_t)GC_least_plausible_heap_addr,
                           (ptr_t)space - expansion_slop);
    }
#   if defined(LARGE_CONFIG)
      if (((ptr_t)GC_greatest_plausible_heap_addr <= (ptr_t)space + bytes
           || (ptr_t)GC_least_plausible_heap_addr >= (ptr_t)space)
         && GC_heapsize > 0) {
       /* GC_add_to_heap will fix this, but ... */
       WARN("Too close to address space limit: blacklisting ineffective\n", 0);
      }
#   endif
    GC_prev_heap_addr = GC_last_heap_addr;
    GC_last_heap_addr = (ptr_t)space;
    GC_add_to_heap(space, bytes);
    /* Force GC before we are likely to allocate past expansion_slop */
      GC_collect_at_heapsize =
         GC_heapsize + expansion_slop - 2*MAXHINCR*HBLKSIZE;
#     if defined(LARGE_CONFIG)
        if (GC_collect_at_heapsize < GC_heapsize /* wrapped */)
         GC_collect_at_heapsize = (word)(-1);
#     endif
    return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 654 of file alloc.c.

{
#   ifdef PRINTTIMES
       CLOCK_TYPE start_time;
       CLOCK_TYPE finalize_time;
       CLOCK_TYPE done_time;
       
       GET_TIME(start_time);
       finalize_time = start_time;
#   endif

#   ifdef GATHERSTATS
        GC_mem_found = 0;
#   endif
#   if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
       if (getenv("GC_PRINT_ADDRESS_MAP") != 0) {
         GC_print_address_map();
       }
#   endif
    COND_DUMP;
    if (GC_find_leak) {
      /* Mark all objects on the free list.  All objects should be */
      /* marked when we're done.                           */
       {
         register word size;              /* current object size             */
         int kind;
         ptr_t q;

         for (kind = 0; kind < GC_n_kinds; kind++) {
           for (size = 1; size <= MAXOBJSZ; size++) {
             q = GC_obj_kinds[kind].ok_freelist[size];
             if (q != 0) GC_set_fl_marks(q);
           }
         }
       }
       GC_start_reclaim(TRUE);
         /* The above just checks; it doesn't really reclaim anything. */
    }

    GC_finalize();
#   ifdef STUBBORN_ALLOC
      GC_clean_changing_list();
#   endif

#   ifdef PRINTTIMES
      GET_TIME(finalize_time);
#   endif

    if (GC_print_back_height) {
#     ifdef MAKE_BACK_GRAPH
       GC_traverse_back_graph();
#     else
#      ifndef SMALL_CONFIG
         GC_err_printf0("Back height not available: "
                       "Rebuild collector with -DMAKE_BACK_GRAPH\n");
#      endif
#     endif
    }

    /* Clear free list mark bits, in case they got accidentally marked   */
    /* (or GC_find_leak is set and they were intentionally marked).    */
    /* Also subtract memory remaining from GC_mem_found count.           */
    /* Note that composite objects on free list are cleared.             */
    /* Thus accidentally marking a free list is not a problem;  only     */
    /* objects on the list itself will be marked, and that's fixed here. */
      {
       register word size;         /* current object size             */
       register ptr_t q;    /* pointer to current object       */
       int kind;

       for (kind = 0; kind < GC_n_kinds; kind++) {
         for (size = 1; size <= MAXOBJSZ; size++) {
           q = GC_obj_kinds[kind].ok_freelist[size];
           if (q != 0) GC_clear_fl_marks(q);
         }
       }
      }


#   ifdef PRINTSTATS
       GC_printf1("Bytes recovered before sweep - f.l. count = %ld\n",
                 (long)WORDS_TO_BYTES(GC_mem_found));
#   endif
    /* Reconstruct free lists to contain everything not marked */
        GC_start_reclaim(FALSE);
        if (GC_is_full_gc)  {
           GC_used_heap_size_after_full = USED_HEAP_SIZE;
           GC_need_full_gc = FALSE;
       } else {
           GC_need_full_gc =
               BYTES_TO_WORDS(USED_HEAP_SIZE - GC_used_heap_size_after_full)
               > min_words_allocd();
       }

#   ifdef PRINTSTATS
       GC_printf2(
                "Immediately reclaimed %ld bytes in heap of size %lu bytes",
                 (long)WORDS_TO_BYTES(GC_mem_found),
                 (unsigned long)GC_heapsize);
#      ifdef USE_MUNMAP
         GC_printf1("(%lu unmapped)", GC_unmapped_bytes);
#      endif
       GC_printf2(
              "\n%lu (atomic) + %lu (composite) collectable bytes in use\n",
               (unsigned long)WORDS_TO_BYTES(GC_atomic_in_use),
               (unsigned long)WORDS_TO_BYTES(GC_composite_in_use));
#   endif

      GC_n_attempts = 0;
      GC_is_full_gc = FALSE;
    /* Reset or increment counters for next cycle */
      GC_words_allocd_before_gc += GC_words_allocd;
      GC_non_gc_bytes_at_gc = GC_non_gc_bytes;
      GC_words_allocd = 0;
      GC_words_wasted = 0;
      GC_mem_freed = 0;
      GC_finalizer_mem_freed = 0;
      
#   ifdef USE_MUNMAP
      GC_unmap_old();
#   endif
#   ifdef PRINTTIMES
       GET_TIME(done_time);
       GC_printf2("Finalize + initiate sweep took %lu + %lu msecs\n",
                  MS_TIME_DIFF(finalize_time,start_time),
                  MS_TIME_DIFF(done_time,finalize_time));
#   endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

ptr_t GC_max ( ptr_t  x,
ptr_t  y 
)

Definition at line 890 of file alloc.c.

{
    return(x > y? x : y);
}

Here is the caller graph for this function:

Definition at line 269 of file alloc.c.

{
    static int n_partial_gcs = 0;

    if (GC_should_collect()) {
        if (!GC_incremental) {
            GC_gcollect_inner();
            n_partial_gcs = 0;
            return;
        } else {
#        ifdef PARALLEL_MARK
           GC_wait_for_reclaim();
#        endif
         if (GC_need_full_gc || n_partial_gcs >= GC_full_freq) {
#          ifdef CONDPRINT
             if (GC_print_stats) {
               GC_printf2(
                 "***>Full mark for collection %lu after %ld allocd bytes\n",
                (unsigned long) GC_gc_no+1,
                (long)WORDS_TO_BYTES(GC_words_allocd));
             }
#           endif
           GC_promote_black_lists();
           (void)GC_reclaim_all((GC_stop_func)0, TRUE);
           GC_clear_marks();
            n_partial_gcs = 0;
           GC_notify_full_gc();
           GC_is_full_gc = TRUE;
          } else {
            n_partial_gcs++;
          }
       }
        /* We try to mark with the world stopped.       */
        /* If we run out of time, this turns into       */
        /* incremental marking.                  */
#      ifndef NO_CLOCK
          if (GC_time_limit != GC_TIME_UNLIMITED) { GET_TIME(GC_start_time); }
#      endif
        if (GC_stopped_mark(GC_time_limit == GC_TIME_UNLIMITED? 
                         GC_never_stop_func : GC_timeout_stop_func)) {
#           ifdef SAVE_CALL_CHAIN_IN_GC
                GC_save_callers(GC_last_stack);
#           endif
            GC_finish_collection();
        } else {
           if (!GC_is_full_gc) {
              /* Count this as the first attempt */
               GC_n_attempts++;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ptr_t GC_min ( ptr_t  x,
ptr_t  y 
)

Definition at line 896 of file alloc.c.

{
    return(x < y? x : y);
}

Here is the caller graph for this function:

Definition at line 254 of file alloc.c.

{
    if (GC_start_call_back != (void (*) GC_PROTO((void)))0) {
       (*GC_start_call_back)();
    }
}

Here is the caller graph for this function:

Definition at line 865 of file alloc.c.

{
    register unsigned i;
    
    GC_printf1("Total heap size: %lu\n", (unsigned long) GC_heapsize);
    for (i = 0; i < GC_n_heap_sects; i++) {
        unsigned long start = (unsigned long) GC_heap_sects[i].hs_start;
        unsigned long len = (unsigned long) GC_heap_sects[i].hs_bytes;
        struct hblk *h;
        unsigned nbl = 0;
        
       GC_printf3("Section %ld from 0x%lx to 0x%lx ", (unsigned long)i,
                 start, (unsigned long)(start + len));
       for (h = (struct hblk *)start; h < (struct hblk *)(start + len); h++) {
           if (GC_is_black_listed(h, HBLKSIZE)) nbl++;
       }
       GC_printf2("%lu/%lu blacklisted\n", (unsigned long)nbl,
                 (unsigned long)(len/HBLKSIZE));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GC_never_stop_func GC_PROTO ( (void )

Definition at line 117 of file alloc.c.

{ return(0); }
int GC_collect_a_little GC_PROTO ( ()  )

Definition at line 477 of file alloc.c.

{
    int result;
    DCL_LOCK_STATE;

    DISABLE_SIGNALS();
    LOCK();
    GC_collect_a_little_inner(1);
    result = (int)GC_collection_in_progress();
    UNLOCK();
    ENABLE_SIGNALS();
    if (!result && GC_debugging_started) GC_print_all_smashed();
    return(result);
}

Here is the call graph for this function:

Definition at line 331 of file alloc.c.

Here is the caller graph for this function:

Definition at line 325 of file alloc.c.

Here is the caller graph for this function:

Definition at line 604 of file alloc.c.

{
   ptr_t p;
   struct hblk * h, * last_h = 0;
   hdr *hhdr;
   int word_no;

   for (p = q; p != 0; p = obj_link(p)){
       h = HBLKPTR(p);
       if (h != last_h) {
         last_h = h; 
         hhdr = HDR(h);
       }
       word_no = (((word *)p) - ((word *)h));
       set_mark_bit_from_hdr(hhdr, word_no);
   }
}

Here is the caller graph for this function:

Definition at line 905 of file alloc.c.

{
    GC_max_heapsize = n;
}

Here is the caller graph for this function:

Definition at line 247 of file alloc.c.

Here is the call graph for this function:

Here is the caller graph for this function:

GC_bool GC_stopped_mark ( GC_stop_func  stop_func)

Definition at line 498 of file alloc.c.

{
    register int i;
    int dummy;
#   if defined(PRINTTIMES) || defined(CONDPRINT)
       CLOCK_TYPE start_time, current_time;
#   endif
       
#   ifdef PRINTTIMES
       GET_TIME(start_time);
#   endif
#   if defined(CONDPRINT) && !defined(PRINTTIMES)
       if (GC_print_stats) GET_TIME(start_time);
#   endif
#   if defined(REGISTER_LIBRARIES_EARLY)
        GC_cond_register_dynamic_libraries();
#   endif
    STOP_WORLD();
    IF_THREADS(GC_world_stopped = TRUE);
#   ifdef CONDPRINT
      if (GC_print_stats) {
       GC_printf1("--> Marking for collection %lu ",
                  (unsigned long) GC_gc_no + 1);
       GC_printf2("after %lu allocd bytes + %lu wasted bytes\n",
                 (unsigned long) WORDS_TO_BYTES(GC_words_allocd),
                 (unsigned long) WORDS_TO_BYTES(GC_words_wasted));
      }
#   endif
#   ifdef MAKE_BACK_GRAPH
      if (GC_print_back_height) {
        GC_build_back_graph();
      }
#   endif

    /* Mark from all roots.  */
        /* Minimize junk left in my registers and on the stack */
            GC_clear_a_few_frames();
            GC_noop(0,0,0,0,0,0);
       GC_initiate_gc();
       for(i = 0;;i++) {
           if ((*stop_func)()) {
#                 ifdef CONDPRINT
                    if (GC_print_stats) {
                     GC_printf0("Abandoned stopped marking after ");
                     GC_printf1("%lu iterations\n",
                               (unsigned long)i);
                    }
#                 endif
                  GC_deficit = i; /* Give the mutator a chance. */
                    IF_THREADS(GC_world_stopped = FALSE);
                   START_WORLD();
                   return(FALSE);
           }
           if (GC_mark_some((ptr_t)(&dummy))) break;
       }
       
    GC_gc_no++;
#   ifdef PRINTSTATS
      GC_printf2("Collection %lu reclaimed %ld bytes",
                (unsigned long) GC_gc_no - 1,
                (long)WORDS_TO_BYTES(GC_mem_found));
#   else
#     ifdef CONDPRINT
        if (GC_print_stats) {
         GC_printf1("Collection %lu finished", (unsigned long) GC_gc_no - 1);
       }
#     endif
#   endif /* !PRINTSTATS */
#   ifdef CONDPRINT
      if (GC_print_stats) {
        GC_printf1(" ---> heapsize = %lu bytes\n",
                  (unsigned long) GC_heapsize);
        /* Printf arguments may be pushed in funny places.  Clear the */
        /* space.                                              */
        GC_printf0("");
      }
#   endif  /* CONDPRINT  */

    /* Check all debugged objects for consistency */
        if (GC_debugging_started) {
            (*GC_check_heap)();
        }
    
    IF_THREADS(GC_world_stopped = FALSE);
    START_WORLD();
#   ifdef PRINTTIMES
       GET_TIME(current_time);
       GC_printf1("World-stopped marking took %lu msecs\n",
                  MS_TIME_DIFF(current_time,start_time));
#   else
#     ifdef CONDPRINT
       if (GC_print_stats) {
         GET_TIME(current_time);
         GC_printf1("World-stopped marking took %lu msecs\n",
                    MS_TIME_DIFF(current_time,start_time));
       }
#     endif
#   endif
    return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GC_try_to_collect ( GC_stop_func  stop_func)

Definition at line 787 of file alloc.c.

{
    int result;
    DCL_LOCK_STATE;
    
    if (GC_debugging_started) GC_print_all_smashed();
    GC_INVOKE_FINALIZERS();
    DISABLE_SIGNALS();
    LOCK();
    ENTER_GC();
    if (!GC_is_initialized) GC_init_inner();
    /* Minimize junk left in my registers */
      GC_noop(0,0,0,0,0,0);
    result = (int)GC_try_to_collect_inner(stop_func);
    EXIT_GC();
    UNLOCK();
    ENABLE_SIGNALS();
    if(result) {
        if (GC_debugging_started) GC_print_all_smashed();
        GC_INVOKE_FINALIZERS();
    }
    return(result);
}

Here is the call graph for this function:

GC_bool GC_try_to_collect_inner ( GC_stop_func  stop_func)

Definition at line 343 of file alloc.c.

{
#   ifdef CONDPRINT
        CLOCK_TYPE start_time, current_time;
#   endif
    if (GC_dont_gc) return FALSE;
    /* PLTSCHEME */
    if (GC_collect_start_callback)
      GC_collect_start_callback();
    if (GC_incremental && GC_collection_in_progress()) {
#   ifdef CONDPRINT
      if (GC_print_stats) {
       GC_printf0(
           "GC_try_to_collect_inner: finishing collection in progress\n");
      }
#   endif /* CONDPRINT */
      /* Just finish collection already in progress.    */
       while(GC_collection_in_progress()) {
           if (stop_func()) return(FALSE);
           GC_collect_a_little_inner(1);
       }
    }
    if (stop_func == GC_never_stop_func) GC_notify_full_gc();
#   ifdef CONDPRINT
      if (GC_print_stats) {
        if (GC_print_stats) GET_TIME(start_time);
       GC_printf2(
          "Initiating full world-stop collection %lu after %ld allocd bytes\n",
          (unsigned long) GC_gc_no+1,
          (long)WORDS_TO_BYTES(GC_words_allocd));
      }
#   endif
    GC_promote_black_lists();
    /* Make sure all blocks have been reclaimed, so sweep routines    */
    /* don't see cleared mark bits.                                   */
    /* If we're guaranteed to finish, then this is unnecessary.              */
    /* In the find_leak case, we have to finish to guarantee that     */
    /* previously unmarked objects are not reported as leaks.         */
#       ifdef PARALLEL_MARK
           GC_wait_for_reclaim();
#       endif
       if ((GC_find_leak || stop_func != GC_never_stop_func)
           && !GC_reclaim_all(stop_func, FALSE)) {
           /* Aborted.  So far everything is still consistent. */
           return(FALSE);
       }
    GC_invalidate_mark_state();  /* Flush mark stack.   */
    GC_clear_marks();
#   ifdef SAVE_CALL_CHAIN_IN_GC
        GC_save_callers(GC_last_stack);
#   endif
    GC_is_full_gc = TRUE;
    if (!GC_stopped_mark(stop_func)) {
      if (!GC_incremental) {
       /* We're partially done and have no way to complete or use     */
       /* current work.  Reestablish invariants as cheaply as         */
       /* possible.                                            */
       GC_invalidate_mark_state();
       GC_unpromote_black_lists();
      } /* else we claim the world is already still consistent.  We'll       */
        /* finish incrementally.                               */
      return(FALSE);
    }
    GC_finish_collection();
#   if defined(CONDPRINT)
      if (GC_print_stats) {
        GET_TIME(current_time);
        GC_printf1("Complete collection took %lu msecs\n",
                   MS_TIME_DIFF(current_time,start_time));
      }
#   endif
    /* PLTSCHEME */
    if (GC_collect_end_callback)
      GC_collect_end_callback();
    return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static word min_words_allocd ( ) [static]

Definition at line 155 of file alloc.c.

{
#   ifdef THREADS
       /* We punt, for now. */
       register signed_word stack_size = 10000;
#   else
        int dummy;
        register signed_word stack_size = (ptr_t)(&dummy) - GC_stackbottom;
#   endif
    word total_root_size;       /* includes double stack size, */
                                /* since the stack is expensive       */
                                /* to scan.                           */
    word scan_size;         /* Estimate of memory to be scanned       */
                            /* during normal GC.               */
    
    if (stack_size < 0) stack_size = -stack_size;
    total_root_size = 2 * stack_size + GC_root_size;
    scan_size = BYTES_TO_WORDS(GC_heapsize - GC_large_free_bytes
                            + (GC_large_free_bytes >> 2)
                               /* use a bit more of large empty heap */
                            + total_root_size);
    if (TRUE_INCREMENTAL) {
        return scan_size / (2 * GC_free_space_divisor);
    } else {
        return scan_size / GC_free_space_divisor;
    }
}

Here is the caller graph for this function:


Variable Documentation

word GC_collect_at_heapsize = (word)(-1) [static]

Definition at line 244 of file alloc.c.

Definition at line 324 of file alloc.c.

Definition at line 323 of file alloc.c.

char* GC_copyright[]
Initial value:
{"Copyright 1988,1989 Hans-J. Boehm and Alan J. Demers ",
"Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved. ",
"Copyright (c) 1996-1998 by Silicon Graphics.  All rights reserved. ",
"Copyright (c) 1999-2001 by Hewlett-Packard Company.  All rights reserved. ",
"THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY",
" EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.",
"See source code for details." }

Definition at line 84 of file alloc.c.

Definition at line 437 of file alloc.c.

Definition at line 110 of file alloc.c.

unsigned GC_fail_count = 0

Definition at line 1023 of file alloc.c.

Definition at line 112 of file alloc.c.

Definition at line 68 of file alloc.c.

Definition at line 60 of file alloc.c.

Definition at line 888 of file alloc.c.

Definition at line 63 of file alloc.c.

Definition at line 261 of file alloc.c.

Definition at line 887 of file alloc.c.

Definition at line 912 of file alloc.c.

Definition at line 20 of file reclaim.c.

Definition at line 124 of file alloc.c.

Definition at line 819 of file alloc.c.

Definition at line 72 of file alloc.c.

Definition at line 58 of file alloc.c.

Definition at line 999 of file alloc.c.

Definition at line 66 of file alloc.c.

Definition at line 121 of file alloc.c.

unsigned long GC_time_limit = TIME_LIMIT

Definition at line 119 of file alloc.c.

Definition at line 82 of file alloc.c.