Main Page | Class List | Directories | File List | Class Members | File Members
src

gc.h File Reference

#include "global.h"
#include "callback.h"
#include "queue.h"
#include "threads.h"
#include "interpret.h"
#include "pike_rusage.h"
#include "block_alloc_h.h"

Go to the source code of this file.

Classes

struct  marker

Defines

#define GC_MIN_ALLOC_THRESHOLD   1000
#define GC_MAX_ALLOC_THRESHOLD   (ALLOC_COUNT_TYPE_MAX - 10000000)
#define ALLOC_COUNT_TYPE   unsigned long
#define ALLOC_COUNT_TYPE_MAX   ULONG_MAX
#define PRINT_ALLOC_COUNT_TYPE   "%lu"
#define gc_destruct_everything   0
#define gc_keep_markers   0
#define ADD_GC_CALLBACK()   do { if(!gc_evaluator_callback) gc_evaluator_callback=add_to_callback(&evaluator_callbacks,(callback_func)do_gc,0,0); }while(0)
#define LOW_GC_ALLOC(OBJ)
#define GC_ALLOC(OBJ)
#define GC_FREE_SIMPLE_BLOCK(PTR)   do {} while (0)
#define GC_FREE_BLOCK(PTR)   do {} while (0)
#define GC_FREE(PTR)
#define GC_MARKED   0x0001
#define GC_NOT_REFERENCED   0x0002
#define GC_CYCLE_CHECKED   0x0004
#define GC_LIVE   0x0008
#define GC_LIVE_OBJ   0x0010
#define GC_LIVE_RECURSE   0x0020
#define GC_GOT_DEAD_REF   0x0040
#define GC_FREE_VISITED   0x0080
#define GC_USER_1   0x0100
#define GC_USER_2   0x0200
#define GC_PRETOUCHED   0x4000
#define GC_MIDDLETOUCHED   0x8000
#define DMALLOC_TOUCH_MARKER(X, EXPR)   (EXPR)
#define gc_check(VP)   DMALLOC_TOUCH_MARKER(VP, real_gc_check(debug_malloc_pass(VP)))
#define gc_check_weak(VP)   DMALLOC_TOUCH_MARKER(VP, real_gc_check_weak(debug_malloc_pass(VP)))
#define gc_mark_enqueue(FN, DATA)   enqueue (&gc_mark_queue, (FN), (DATA))
#define gc_mark_run_queue()   run_queue (&gc_mark_queue)
#define gc_mark_discard_queue()   discard_queue (&gc_mark_queue)
#define GC_ENTER(THING, TYPE)   do
#define GC_LEAVE   while (0)
#define debug_gc_check(X, PLACE)   gc_check (X)
#define debug_gc_check_weak(X, PLACE)   gc_check_weak (X)
#define debug_gc_check_svalues(S, NUM, PLACE)   gc_check_svalues ((S), (NUM))
#define debug_gc_check_weak_svalues(S, NUM, PLACE)   gc_check_weak_svalues ((S), (NUM))
#define gc_fatal   fprintf(stderr, "%s:%d: GC fatal:\n", __FILE__, __LINE__), debug_gc_fatal
#define gc_checked_as_weak(X)   do {} while (0)
#define gc_assert_checked_as_weak(X)   do {} while (0)
#define gc_assert_checked_as_nonweak(X)   do {} while (0)
#define gc_recurse_svalues(S, N)
#define gc_recurse_short_svalue(U, T)
#define gc_recurse_weak_svalues(S, N)
#define gc_recurse_weak_short_svalue(U, T)
#define GC_RECURSE_THING(V, T)
#define gc_recurse_array(V)   GC_RECURSE_THING((V), array)
#define gc_recurse_mapping(V)   GC_RECURSE_THING((V), mapping)
#define gc_recurse_multiset(V)   GC_RECURSE_THING((V), multiset)
#define gc_recurse_object(V)   GC_RECURSE_THING((V), object)
#define gc_recurse_program(V)   GC_RECURSE_THING((V), program)
#define gc_is_referenced(X)   !(get_marker(X)->flags & GC_NOT_REFERENCED)
#define add_gc_callback(X, Y, Z)   dmalloc_touch(struct callback *,debug_add_gc_callback((X),(Y),(Z)))
#define gc_add_extra_ref(X)   (++*(INT32 *)(X))
#define gc_free_extra_ref(X)
#define GC_PASS_PREPARE   50
#define GC_PASS_PRETOUCH   90
#define GC_PASS_CHECK   100
#define GC_PASS_MARK   200
#define GC_PASS_CYCLE   250
#define GC_PASS_ZAP_WEAK   260
#define GC_PASS_MIDDLETOUCH   270
#define GC_PASS_FREE   300
#define GC_PASS_KILL   400
#define GC_PASS_DESTRUCT   500
#define GC_PASS_POSTTOUCH   510
#define GC_PASS_LOCATE   -1
#define GC_PASS_DISABLED   -2
#define GC_CYCLE_ENTER(X, TYPE, WEAK)
#define GC_CYCLE_ENTER_OBJECT(X, WEAK)
#define GC_CYCLE_LEAVE

Typedefs

typedef void gc_cycle_check_cb (void *data, int weak)

Functions

 PTR_HASH_ALLOC_FIXED_FILL_PAGES (marker, n/a)
callback * debug_add_gc_callback (callback_func call, void *arg, callback_func free_func)
void dump_gc_info (void)
int attempt_to_identify (void *something, void **inblock)
void describe_location (void *real_memblock, int real_type, void *location, int indent, int depth, int flags)
void debug_gc_fatal (void *a, int flags, const char *fmt,...)
void low_describe_something (void *a, int t, int indent, int depth, int flags, void *inblock)
void describe_something (void *a, int t, int indent, int depth, int flags, void *inblock)
PMOD_EXPORT void describe (void *x)
void debug_describe_svalue (struct svalue *s)
void gc_watch (void *a)
void debug_gc_touch (void *a)
PMOD_EXPORT int real_gc_check (void *a)
int real_gc_check_weak (void *a)
void exit_gc (void)
void locate_references (void *a)
void debug_gc_add_extra_ref (void *a)
void debug_gc_free_extra_ref (void *a)
int debug_gc_is_referenced (void *a)
int gc_mark_external (void *a, const char *place)
void debug_really_free_gc_frame (struct gc_frame *l)
int gc_do_weak_free (void *a)
void gc_delayed_free (void *a, int type)
void debug_gc_mark_enqueue (queue_call call, void *data)
int gc_mark (void *a)
PMOD_EXPORT void gc_cycle_enqueue (gc_cycle_check_cb *checkfn, void *data, int weak)
void gc_cycle_run_queue (void)
int gc_cycle_push (void *x, struct marker *m, int weak)
void do_gc_recurse_svalues (struct svalue *s, int num)
void do_gc_recurse_short_svalue (union anything *u, int type)
int gc_do_free (void *a)
size_t do_gc (void *ignored, int explicit_call)
void f__gc_status (INT32 args)
void cleanup_gc (void)

Variables

int gc_enabled
double gc_garbage_ratio_low
double gc_time_ratio
double gc_garbage_ratio_high
double gc_average_slowness
INT32 num_objects
ALLOC_COUNT_TYPE num_allocs
ALLOC_COUNT_TYPE alloc_threshold
PMOD_EXPORT int Pike_in_gc
int gc_generation
int gc_trace
int gc_debug
cpu_time_t auto_gc_time
callback * gc_evaluator_callback
size_t gc_ext_weak_refs
pike_queue gc_mark_queue

Define Documentation

#define add_gc_callback (  X,
Y,
Z   )     dmalloc_touch(struct callback *,debug_add_gc_callback((X),(Y),(Z)))
 

 
#define ADD_GC_CALLBACK (   )     do { if(!gc_evaluator_callback) gc_evaluator_callback=add_to_callback(&evaluator_callbacks,(callback_func)do_gc,0,0); }while(0)
 

#define ALLOC_COUNT_TYPE   unsigned long
 

#define ALLOC_COUNT_TYPE_MAX   ULONG_MAX
 

#define debug_gc_check (  X,
PLACE   )     gc_check (X)
 

#define debug_gc_check_svalues (  S,
NUM,
PLACE   )     gc_check_svalues ((S), (NUM))
 

#define debug_gc_check_weak (  X,
PLACE   )     gc_check_weak (X)
 

#define debug_gc_check_weak_svalues (  S,
NUM,
PLACE   )     gc_check_weak_svalues ((S), (NUM))
 

#define DMALLOC_TOUCH_MARKER (  X,
EXPR   )     (EXPR)
 

#define gc_add_extra_ref (  X   )     (++*(INT32 *)(X))
 

#define GC_ALLOC (  OBJ   ) 
 

Value:

do{                                             \
  LOW_GC_ALLOC(OBJ);                                                    \
  if(num_allocs >= alloc_threshold)                                     \
    ADD_GC_CALLBACK();                                                  \
} while(0)

#define gc_assert_checked_as_nonweak (  X   )     do {} while (0)
 

#define gc_assert_checked_as_weak (  X   )     do {} while (0)
 

#define gc_check (  VP   )     DMALLOC_TOUCH_MARKER(VP, real_gc_check(debug_malloc_pass(VP)))
 

#define gc_check_weak (  VP   )     DMALLOC_TOUCH_MARKER(VP, real_gc_check_weak(debug_malloc_pass(VP)))
 

#define gc_checked_as_weak (  X   )     do {} while (0)
 

#define GC_CYCLE_CHECKED   0x0004
 

#define GC_CYCLE_ENTER (  X,
TYPE,
WEAK   ) 
 

Value:

do {                            \
  void *_thing_ = (X);                                                  \
  struct marker *_m_ = get_marker(_thing_);                             \
  if (!(_m_->flags & GC_MARKED)) {                                      \
    DO_IF_DEBUG(                                                        \
      if (gc_in_cycle_check)                                            \
        Pike_fatal("Recursing immediately in gc cycle check.\n");       \
      gc_in_cycle_check = 1;                                            \
    );                                                                  \
    if (gc_cycle_push(_thing_, _m_, (WEAK))) {

#define GC_CYCLE_ENTER_OBJECT (  X,
WEAK   ) 
 

Value:

do {                            \
  struct object *_thing_ = (X);                                         \
  struct marker *_m_ = get_marker(_thing_);                             \
  if (!(_m_->flags & GC_MARKED)) {                                      \
    if (_thing_->prog && FIND_LFUN(_thing_->prog, LFUN_DESTROY) != -1)  \
      _m_->flags |= GC_LIVE|GC_LIVE_OBJ;                                \
    DO_IF_DEBUG(                                                        \
      if (gc_in_cycle_check)                                            \
        Pike_fatal("Recursing immediately in gc cycle check.\n");       \
      gc_in_cycle_check = 1;                                            \
    );                                                                  \
    if (gc_cycle_push(_thing_, _m_, (WEAK))) {

#define GC_CYCLE_LEAVE
 

Value:

}                                                                       \
    DO_IF_DEBUG(gc_in_cycle_check = 0);                                 \
  }                                                                     \
} while (0)

#define gc_destruct_everything   0
 

#define GC_ENTER (  THING,
TYPE   )     do
 

#define gc_fatal   fprintf(stderr, "%s:%d: GC fatal:\n", __FILE__, __LINE__), debug_gc_fatal
 

#define GC_FREE (  PTR   ) 
 

Value:

do {                                            \
  GC_FREE_BLOCK(PTR);                                                   \
  DO_IF_DEBUG(                                                          \
    if(num_objects < 1)                                                 \
      Pike_fatal("Panic!! less than zero objects!\n");                  \
  );                                                                    \
  num_objects-- ;                                                       \
}while(0)

#define GC_FREE_BLOCK (  PTR   )     do {} while (0)
 

#define gc_free_extra_ref (  X   ) 
 

#define GC_FREE_SIMPLE_BLOCK (  PTR   )     do {} while (0)
 

#define GC_FREE_VISITED   0x0080
 

#define GC_GOT_DEAD_REF   0x0040
 

#define gc_is_referenced (  X   )     !(get_marker(X)->flags & GC_NOT_REFERENCED)
 

#define gc_keep_markers   0
 

#define GC_LEAVE   while (0)
 

#define GC_LIVE   0x0008
 

#define GC_LIVE_OBJ   0x0010
 

#define GC_LIVE_RECURSE   0x0020
 

 
#define gc_mark_discard_queue (   )     discard_queue (&gc_mark_queue)
 

#define gc_mark_enqueue (  FN,
DATA   )     enqueue (&gc_mark_queue, (FN), (DATA))
 

 
#define gc_mark_run_queue (   )     run_queue (&gc_mark_queue)
 

#define GC_MARKED   0x0001
 

#define GC_MAX_ALLOC_THRESHOLD   (ALLOC_COUNT_TYPE_MAX - 10000000)
 

#define GC_MIDDLETOUCHED   0x8000
 

#define GC_MIN_ALLOC_THRESHOLD   1000
 

#define GC_NOT_REFERENCED   0x0002
 

#define GC_PASS_CHECK   100
 

#define GC_PASS_CYCLE   250
 

#define GC_PASS_DESTRUCT   500
 

#define GC_PASS_DISABLED   -2
 

#define GC_PASS_FREE   300
 

#define GC_PASS_KILL   400
 

#define GC_PASS_LOCATE   -1
 

#define GC_PASS_MARK   200
 

#define GC_PASS_MIDDLETOUCH   270
 

#define GC_PASS_POSTTOUCH   510
 

#define GC_PASS_PREPARE   50
 

#define GC_PASS_PRETOUCH   90
 

#define GC_PASS_ZAP_WEAK   260
 

#define GC_PRETOUCHED   0x4000
 

#define gc_recurse_array (  V   )     GC_RECURSE_THING((V), array)
 

#define gc_recurse_mapping (  V   )     GC_RECURSE_THING((V), mapping)
 

#define gc_recurse_multiset (  V   )     GC_RECURSE_THING((V), multiset)
 

#define gc_recurse_object (  V   )     GC_RECURSE_THING((V), object)
 

#define gc_recurse_program (  V   )     GC_RECURSE_THING((V), program)
 

#define gc_recurse_short_svalue (  U,
T   ) 
 

Value:

(Pike_in_gc == GC_PASS_CYCLE ?                                  \
   gc_cycle_check_short_svalue((U), (T)) : gc_mark_short_svalue((U), (T)))

#define gc_recurse_svalues (  S,
N   ) 
 

Value:

(Pike_in_gc == GC_PASS_CYCLE ?                                  \
   gc_cycle_check_svalues((S), (N)) : gc_mark_svalues((S), (N)))

#define GC_RECURSE_THING (  V,
T   ) 
 

Value:

(DMALLOC_TOUCH_MARKER(V, Pike_in_gc == GC_PASS_CYCLE) ?         \
   PIKE_CONCAT(gc_cycle_check_, T)(V, 0) :                              \
   PIKE_CONCAT3(gc_mark_, T, _as_referenced)(V))

#define gc_recurse_weak_short_svalue (  U,
T   ) 
 

Value:

(Pike_in_gc == GC_PASS_CYCLE ?                                  \
   gc_cycle_check_weak_short_svalue((U), (T)) : gc_mark_weak_short_svalue((U), (T)))

#define gc_recurse_weak_svalues (  S,
N   ) 
 

Value:

(Pike_in_gc == GC_PASS_CYCLE ?                                  \
   gc_cycle_check_weak_svalues((S), (N)) : gc_mark_weak_svalues((S), (N)))

#define GC_USER_1   0x0100
 

#define GC_USER_2   0x0200
 

#define LOW_GC_ALLOC (  OBJ   ) 
 

Value:

do {                                            \
 extern int d_flag;                                                     \
 num_objects++;                                                         \
 num_allocs++;                                                          \
 DO_IF_DEBUG(                                                           \
   if(d_flag) CHECK_INTERPRETER_LOCK();                                 \
   if(Pike_in_gc > GC_PASS_PREPARE && Pike_in_gc < GC_PASS_FREE)        \
     Pike_fatal("Allocating new objects within gc is not allowed!\n");  \
 )                                                                      \
 if (Pike_in_gc) remove_marker(OBJ);                                    \
} while (0)

#define PRINT_ALLOC_COUNT_TYPE   "%lu"
 

Typedef Documentation

typedef void gc_cycle_check_cb(void *data, int weak)
 

Function Documentation

int attempt_to_identify (  void *  something,
void **  inblock
) 
 

void cleanup_gc (  void   ) 
 

struct callback* debug_add_gc_callback (  callback_func  call,
void *  arg,
callback_func  free_func
) 
 

void debug_describe_svalue (  struct svalue *  s  ) 
 

void debug_gc_add_extra_ref (  void *  a  ) 
 

void debug_gc_fatal (  void *  a,
int  flags,
const char *  fmt,
  ...
) 
 

void debug_gc_free_extra_ref (  void *  a  ) 
 

int debug_gc_is_referenced (  void *  a  ) 
 

void debug_gc_mark_enqueue (  queue_call  call,
void *  data
) 
 

void debug_gc_touch (  void *  a  ) 
 

void debug_really_free_gc_frame (  struct gc_frame *  l  ) 
 

PMOD_EXPORT void describe (  void *  x  ) 
 

void describe_location (  void *  real_memblock,
int  real_type,
void *  location,
int  indent,
int  depth,
int  flags
) 
 

void describe_something (  void *  a,
int  t,
int  indent,
int  depth,
int  flags,
void *  inblock
) 
 

size_t do_gc (  void *  ignored,
int  explicit_call
) 
 

void do_gc_recurse_short_svalue (  union anything *  u,
int  type
) 
 

void do_gc_recurse_svalues (  struct svalue *  s,
int  num
) 
 

void dump_gc_info (  void   ) 
 

void exit_gc (  void   ) 
 

void f__gc_status (  INT32  args  ) 
 

PMOD_EXPORT void gc_cycle_enqueue (  gc_cycle_check_cb *  checkfn,
void *  data,
int  weak
) 
 

int gc_cycle_push (  void *  x,
struct marker *  m,
int  weak
) 
 

void gc_cycle_run_queue (  void   ) 
 

void gc_delayed_free (  void *  a,
int  type
) 
 

int gc_do_free (  void *  a  ) 
 

int gc_do_weak_free (  void *  a  ) 
 

int gc_mark (  void *  a  ) 
 

int gc_mark_external (  void *  a,
const char *  place
) 
 

void gc_watch (  void *  a  ) 
 

void locate_references (  void *  a  ) 
 

void low_describe_something (  void *  a,
int  t,
int  indent,
int  depth,
int  flags,
void *  inblock
) 
 

PTR_HASH_ALLOC_FIXED_FILL_PAGES (  marker  ,
n/  a
) 
 

PMOD_EXPORT int real_gc_check (  void *  a  ) 
 

int real_gc_check_weak (  void *  a  ) 
 

Variable Documentation

ALLOC_COUNT_TYPE alloc_threshold
 

cpu_time_t auto_gc_time
 

double gc_average_slowness
 

int gc_debug
 

int gc_enabled
 

struct callback* gc_evaluator_callback
 

size_t gc_ext_weak_refs
 

double gc_garbage_ratio_high
 

double gc_garbage_ratio_low
 

int gc_generation
 

struct pike_queue gc_mark_queue
 

double gc_time_ratio
 

int gc_trace
 

ALLOC_COUNT_TYPE num_allocs
 

INT32 num_objects
 

PMOD_EXPORT int Pike_in_gc
 

Generated on Fri Jul 22 23:44:29 2005 for Pike by  doxygen 1.3.9.1