Marking

Functions
void	tm_mark (void *ptr)
	Marks a possible pointer.
void	_tm_node_scan (tm_node *n)
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.

---

Function Documentation

void _tm_node_scan

(

tm_node *

n

)

If the node was fully scanned, Move the tm_GREY node to the marked (tm_BLACK) list.

Definition at line 185 of file mark.c.

References _tm_range_scan(), tm_BLACK, tm_node_ptr, tm_node_set_color(), tm_node_to_block(), and tm_node_type.

{
  _tm_range_scan(tm_node_ptr(n), tm_node_ptr(n) + tm_node_type(n)->size);

  /**
   * If the node was fully scanned,
   * Move the tm_GREY node to the marked (tm_BLACK) list.
   */
  tm_node_set_color(n, tm_node_to_block(n), tm_BLACK);

#if 0
  fprintf(stderr, "[B]");
  fflush(stderr);
#endif
}

Here is the call graph for this function:

void _tm_node_scan_all

(

)

Scan until all tm_GREY nodes are tm_BLACK.

Definition at line 291 of file mark.c.

References _tm_node_scan_some(), tm_GREY, and tm_node_LOOP_INIT.

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

{
  tm_node_LOOP_INIT(tm_GREY);
  while ( _tm_node_scan_some(~ 0UL) ) {
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t _tm_node_scan_some

(

size_t

amount

)

Scan node interiors for some pointers.

Amount is in pointer-aligned words.

Until amount has been scanned, or nothing is left to scan.

If a there is a tm_node region to scan,

Scan until end of tm_node region,

Attempt to mark node at a possible pointer at the scan pointer,

And increment the current scan pointer.

Stop scanning if the given amount has been scanned.

If the node was fully scanned, Move the tm_GREY node to the marked (tm_BLACK) list.

Reset scan pointers.

Done scanning gi->scan_node.

If there is an tm_GREY node,

Schedule the now BLACK node for interior pointer scanning. Avoid words that overlap the end of the node's data region.

Return true if there are remaining tm_GREY nodes or some node is still being scanned.

Definition at line 207 of file mark.c.

References _tm_mark_possible_ptr(), gi, tm_data::n, tm, tm_assert_test, tm_BLACK, tm_GREY, tm_msg(), tm_node_color, tm_node_iterator_next(), tm_node_ptr, tm_node_set_color(), tm_node_to_block(), and tm_PTR_ALIGN.

Referenced by _tm_alloc_type_inner(), and _tm_node_scan_all().

{
  size_t count = 0, bytes = 0;
#define gi (&tm.node_color_iter[tm_GREY])

  /*! Until amount has been scanned, or nothing is left to scan. */
  do {
    tm_node *n;

    /**
     * If a there is a tm_node region to scan,
     */
    if ( gi->scan_ptr ) {
      /*! Scan until end of tm_node region, */
      while ( gi->scan_ptr <= gi->scan_end ) {
        /*! Attempt to mark node at a possible pointer at the scan pointer, */
        _tm_mark_possible_ptr(* (void **) gi->scan_ptr);
      
        /*! And increment the current scan pointer. */
        gi->scan_ptr += tm_PTR_ALIGN;

        ++ count;
        bytes += tm_PTR_ALIGN;

        /*! Stop scanning if the given amount has been scanned. */
        if ( -- amount <= 0 ) {
          goto done;
        }
      }

      /**
       * If the node was fully scanned,
       * Move the tm_GREY node to the marked (tm_BLACK) list.
       */
      tm_node_set_color(gi->scan_node, tm_node_to_block(gi->scan_node), tm_BLACK);

#if 0
      fprintf(stderr, "B");
      fflush(stderr);
#endif

      /*! Reset scan pointers. */
      gi->scan_node = 0;
      gi->scan_ptr = 0;
      gi->scan_end = 0;
      gi->scan_size = 0;
    }
    /*! Done scanning gi->scan_node. */

    /*! If there is an tm_GREY node, */
    if ( (n = tm_node_iterator_next(gi)) ) {
      tm_assert_test(tm_node_color(n) == tm_GREY);

#if 0
      fprintf(stderr, "s");
      fflush(stderr);
#endif

      /**
       * Schedule the now BLACK node for interior pointer scanning.
       * Avoid words that overlap the end of the node's data region. 
       */
      gi->scan_node = n;
      gi->scan_ptr  = tm_node_ptr(n);
      gi->scan_size = gi->type->size;
      gi->scan_end  = gi->scan_ptr + gi->scan_size - sizeof(void*);
    } else {
      goto done;
    }
  } while ( amount > 0 );

 done:
#if 0
  if ( count )
    tm_msg("M c%lu b%lu l%lu\n", count, bytes, tm.n[tm_GREY]);
#endif

  /*! Return true if there are remaining tm_GREY nodes or some node is still being scanned. */
  return tm.n[tm_GREY] || gi->scan_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tm_mark

(

void *

ptr

)

Marks a possible pointer.

tm_root_write() should be called after modifing a root ptr.

Definition at line 179 of file mark.c.

References _tm_mark_possible_ptr().

{
  _tm_mark_possible_ptr(ptr);
}

Here is the call graph for this function: