mark.h File Reference

Marking Primitives. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
static __inline int	_tm_node_mark (tm_node *n)
	Marks a node as in-use.
static __inline tm_node *	_tm_mark_possible_ptr (void *p)
	Mark a potential pointer.
void	_tm_root_loop_init ()
	Initialize root scanning loop.
void	_tm_register_scan ()
	Scan registers.
void	_tm_set_stack_ptr (void *stackvar)
	Set the stack pointer.
void	_tm_stack_scan ()
	Scan stack (and registers).
void	_tm_root_scan_all ()
	Scan all roots.
int	_tm_root_scan_some ()
	Scan some roots.
__inline void	_tm_range_scan (const void *b, const void *e)
size_t	_tm_node_scan_some (size_t amount)
	Scan node interiors for some pointers.
void	_tm_node_scan_all ()
	Scan until all tm_GREY nodes are tm_BLACK.

---

Detailed Description

Marking Primitives.

Definition in file mark.h.

---

Function Documentation

static __inline tm_node* _tm_mark_possible_ptr

(

void *

p

)

[static]

Mark a potential pointer.

Returns true if something was marked.

Definition at line 71 of file mark.h.

References _tm_node_mark(), tm_data::n, and tm_ptr_to_node().

Referenced by _tm_node_scan_some(), _tm_range_scan(), _tm_root_scan_some(), and tm_mark().

{
  tm_node *n;
  
  if ( p && (n = tm_ptr_to_node(p)) && _tm_node_mark(n) )
    return n;
    
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline int _tm_node_mark

(

tm_node *

n

)

[static]

Marks a node as in-use.

If tm_WHITE, we have a spurious pointer into a free node? ABORT!

If tm_ECRU, the node has not been scheduled for marking; So schedule it for marking. Return true to alert caller that work is to be done.

If tm_GREY, the node has already been scheduled for marking. DO NOTHING.

If tm_BLACK, the node has already been marked. DO NOTHING.

Otherwise, return false: there is nothing to do.

Definition at line 16 of file mark.h.

References tm_abort(), tm_BLACK, tm_ECRU, tm_GREY, tm_msg(), tm_node_color, tm_node_set_color(), tm_node_to_block(), and tm_WHITE.

Referenced by _tm_mark_possible_ptr().

{
  switch ( tm_node_color(n) ) {
  case tm_WHITE:
    /** If tm_WHITE, we have a spurious pointer into a free node?
     * ABORT!
     */
    tm_abort();
    break;

  case tm_ECRU:
    /**
     * If tm_ECRU,
     * the node has not been scheduled for marking;
     * So schedule it for marking.
     * Return true to alert caller that work is to be done.
     */
    tm_node_set_color(n, tm_node_to_block(n), tm_GREY);
#if 0
    tm_msg("m n%p\n", n);
#endif
    return 1;
    break;
    
  case tm_GREY:
    /**
     * If tm_GREY,
     * the node has already been scheduled for marking.
     * DO NOTHING.
     */
    break;
    
  case tm_BLACK:
    /**
     * If tm_BLACK,
     * the node has already been marked.
     * DO NOTHING.
     */
    break;

  default:
    tm_abort();
    break;
  }

  /*! Otherwise, return false: there is nothing to do. */
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

__inline void _tm_range_scan	(	const void *	b,
		const void *	e
	)

Definition at line 15 of file mark.c.

References _tm_mark_possible_ptr(), tm_data::n, tm_msg(), and tm_PTR_ALIGN.

Referenced by _tm_node_scan(), and _tm_root_scan_id().

{
  const char *p;

  /* Avoid overlapping pointer. */
  e = ((char *) e) - sizeof(void*);

  for ( p = b; 
        (char*) p <= (char*) e; 
        p += tm_PTR_ALIGN ) {
#if 0
    tm_node *n = 
#endif
      _tm_mark_possible_ptr(* (void**) p);

#if 0
    if ( n ) {
      tm_msg("M n%p p%p\n", n, p);
    }
#endif
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_register_scan

(

)

Scan registers.

Registers are in tm.root[0].

Definition at line 70 of file mark.c.

References _tm_root_scan_id().

Referenced by _tm_stack_scan().

{
  _tm_root_scan_id(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_root_loop_init

(

)

Initialize root scanning loop.

Definition at line 45 of file mark.c.

References tm_data::data_mutations, tm_root::l, tm_data::root_datai, tm_data::rooti, tm_data::roots, tm_data::rp, tm_data::stack_mutations, and tm.

Referenced by _tm_phase_init(), _tm_root_scan_all(), _tm_root_scan_some(), and tm_init().

{
  tm.rooti = tm.root_datai;
  tm.rp = tm.roots[tm.rooti].l;
  tm.data_mutations = tm.stack_mutations = 0;
}

Here is the caller graph for this function:

void _tm_root_scan_all

(

)

Scan all roots.

Definition at line 102 of file mark.c.

References _tm_root_loop_init(), _tm_root_scan_id(), tm_data::data_mutations, tm_data::n, tm_root::name, tm_data::roots, tm_data::stack_mutations, tm, tm_BLACK, tm_GREY, and tm_msg().

Referenced by _tm_alloc_type_inner(), _tm_check_sweep_error(), and _tm_gc_full_type_inner().

{
  int i;

  tm_msg("r G%lu B%lu {\n", tm.n[tm_GREY], tm.n[tm_BLACK]);
  for ( i = 0; tm.roots[i].name; ++ i ) {
    _tm_root_scan_id(i);
  }
  tm.data_mutations = tm.stack_mutations = 0;
  _tm_root_loop_init();
#if 0
  tm_msg("r G%lu B%lu }\n", tm.n[tm_GREY], tm.n[tm_BLACK]);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _tm_root_scan_some

(

)

Scan some roots.

Definition at line 121 of file mark.c.

References _tm_mark_possible_ptr(), _tm_root_loop_init(), tm_root::h, tm_root::l, tm_data::n, tm_root::name, tm_data::rooti, tm_data::roots, tm_data::rp, tm, tm_BLACK, tm_GREY, tm_msg(), tm_PTR_ALIGN, and tm_root_scan_some_size.

Referenced by _tm_alloc_type_inner().

{
  int result = 1;
  long left = tm_root_scan_some_size;

  tm_msg("r G%lu B%lu {\n", tm.n[tm_GREY], tm.n[tm_BLACK]);
  tm_msg("r [%p,%p] %s\n", 
         tm.roots[tm.rooti].l, 
         tm.roots[tm.rooti].h,
         tm.roots[tm.rooti].name 
         );

  do {
    /* Try marking some roots. */
    while ( (void*) (tm.rp + sizeof(void*)) >= tm.roots[tm.rooti].h ) {
      ++ tm.rooti;
      if ( ! tm.roots[tm.rooti].name ) {
        _tm_root_loop_init();
        tm_msg("r done\n");

        result = 0;
        goto done;
      }

      tm_msg("r [%p,%p] %s\n", 
             tm.roots[tm.rooti].l, 
             tm.roots[tm.rooti].h,
             tm.roots[tm.rooti].name);
      
      tm.rp = tm.roots[tm.rooti].l;
    }

    _tm_mark_possible_ptr(* (void**) tm.rp);

    tm.rp += tm_PTR_ALIGN;
    left -= tm_PTR_ALIGN;

  } while ( left > 0 );

 done:
#if 0
  tm_msg("r G%lu B%lu }\n", tm.n[tm_GREY], tm.n[tm_BLACK]);
#endif

  return result; /* We're not done. */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_stack_scan

(

)

Scan stack (and registers).

Mark stack as un-mutated.

Definition at line 91 of file mark.c.

References _tm_register_scan(), _tm_root_scan_id(), tm_data::stack_mutations, and tm.

{
  _tm_register_scan();
  _tm_root_scan_id(1);
  tm.stack_mutations = 0;
}

Here is the call graph for this function: