Phase

Enumerations
enum	tm_phase {   tm_ALLOC, tm_UNMARK, tm_ROOT, tm_SCAN,   tm_SWEEP, tm_phase_END }
	The phases of the allocator. More...
Functions
void	_tm_phase_init (int p)
	Initialize the collection/allocation phase.

---

Enumeration Type Documentation

enum tm_phase

The phases of the allocator.

These are similar to the phases in typical in a stop-the-world collector, except the work for these phases is done for short periods within tm_alloc().

Enumerator:

tm_ALLOC	Allocate nodes. (WHITE->ECRU)
tm_UNMARK	Unmark nodes. (BLACK->ECRU)
tm_ROOT	Begin mark roots. (ECRU->GREY)
tm_SCAN	Scan marked nodes. (ECRU->GREY, GREY->BLACK)
tm_SWEEP	Sweep unmarked nodes. (ECRU->WHITE)
tm_phase_END	Placeholder for size of arrays indexed by tm_phase.

Definition at line 40 of file internal.h.

              {
  /*! Allocate nodes.         (WHITE->ECRU) */
  tm_ALLOC,
  /*! Unmark nodes.           (BLACK->ECRU) */
  tm_UNMARK,
  /*! Begin mark roots.       (ECRU->GREY)  */ 
  tm_ROOT,
  /*! Scan marked nodes.      (ECRU->GREY, GREY->BLACK) */
  tm_SCAN,
  /*! Sweep unmarked nodes.   (ECRU->WHITE) */
  tm_SWEEP,
  /*! Placeholder for size of arrays indexed by tm_phase. */
  tm_phase_END
};

---

Function Documentation

void _tm_phase_init

(

int

p

)

Initialize the collection/allocation phase.

Initializes a new allocation phase.

• tm_ALLOC: allocate nodes until memory pressure is high.

• tm_UNMARK: begin unmarking tm_BLACK nodes as tm_ECRU:

Set up for unmarking.

Keep track of how many tm_BLACK nodes are in use.

• tm_ROOT: begin scanning roots for potential pointers:

Mark stack and data roots as un-mutated.

Initialize root mark loop.

• tm_SCAN: begin scanning tm_GREY nodes for internal pointers:

Mark stack and data roots as un-mutated.

Set up for marking.

• tm_SWEEP: begin reclaiming any ECRU nodes as WHITE.

Definition at line 285 of file tm.c.

References _tm_root_loop_init(), tm_data::alloc_id, tm_data::alloc_since_sweep, tm_data::allocating, tm_data::data_mutations, tm_data::marking, tm_data::n, tm_data::n_phase_transitions, tm_data::scanning, tm_data::stack_mutations, tm_data::sweeping, tm, tm_ALLOC, tm_assert_test, tm_BLACK, tm_ECRU, tm_fatal(), tm_GREY, tm_msg(), tm_node_LOOP_INIT, tm_NU, tm_phase_END, tm_phase_name, tm_ROOT, tm_SCAN, tm_stop(), tm_SWEEP, tm_UNMARK, tm_WHITE, and tm_data::unmarking.

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

{
  tm_msg("p %s\n", tm_phase_name[p]);

#if 0
  /* DEBUG: DELETE ME! */
  if ( tm.alloc_id == 1987 )
    tm_stop();
#endif

  ++ tm.n_phase_transitions[tm.phase][p];
  ++ tm.n_phase_transitions[tm.phase][tm_phase_END];
  ++ tm.n_phase_transitions[tm_phase_END][p];
  ++ tm.n_phase_transitions[tm_phase_END][tm_phase_END];

  if ( tm.phase == tm_SWEEP && tm.phase != p ) {
    tm.alloc_since_sweep = 0;
  }

#if 0
  fprintf(stderr, "\n%s->%s #%lu %lu %lu %lu %lu\n", tm_phase_name[tm.phase], tm_phase_name[p], (unsigned long) tm.alloc_id,
          (unsigned long) tm.n[tm_WHITE],
          (unsigned long) tm.n[tm_ECRU],
          (unsigned long) tm.n[tm_GREY],
          (unsigned long) tm.n[tm_BLACK],
          0
          );
#endif

  switch ( (tm.phase = p) ) {
  case tm_ALLOC:
    /**
     * - tm_ALLOC: allocate nodes until memory pressure is high.
     */
    tm.allocating = 1;
    tm.unmarking = 0;
    tm.marking = 0;
    tm.scanning = 0;
    tm.sweeping = 0;
    break;

  case tm_UNMARK:
    /**
     * - tm_UNMARK: begin unmarking tm_BLACK nodes as tm_ECRU:
     */
    tm.allocating = 0;
    tm.unmarking = 1;
    tm.marking = 0;
    tm.scanning = 0;
    tm.sweeping = 0;

    /*! Set up for unmarking. */
    tm_node_LOOP_INIT(tm_BLACK);

    /*! Keep track of how many tm_BLACK nodes are in use. */
    tm.n[tm_NU] = tm.n[tm_BLACK];
    break;

  case tm_ROOT:
    /**
     * - tm_ROOT: begin scanning roots for potential pointers:
     */
    tm.allocating = 0;
    tm.unmarking = 0;
    tm.marking = 1;
    tm.scanning = 0;
    tm.sweeping = 0;

    /*! Mark stack and data roots as un-mutated. */
    tm.stack_mutations = tm.data_mutations = 0;

    /*! Initialize root mark loop. */
    _tm_root_loop_init();
    break;

  case tm_SCAN:
    /**
     * - tm_SCAN: begin scanning tm_GREY nodes for internal pointers:
     */
    tm.allocating = 0;
    tm.unmarking = 0;
    tm.marking = 1;
    tm.scanning = 1;
    tm.sweeping = 0;

    /*! Mark stack and data roots as un-mutated. */
    tm.stack_mutations = tm.data_mutations = 0;

    /*! Set up for marking. */
    tm_node_LOOP_INIT(tm_GREY);
    break;

  case tm_SWEEP:
    /**
     * - tm_SWEEP: begin reclaiming any ECRU nodes as WHITE.
     */
    tm.allocating = 0;
    tm.unmarking = 0;
    tm.marking = 0;
    tm.scanning = 0;
    tm.sweeping = 1;

    tm_assert_test(tm.n[tm_GREY] == 0);

    /* Set up for scanning. */
    // tm_node_LOOP_INIT(tm_GREY);

    /* Set up for sweeping. */
    // tm_node_LOOP_INIT(tm_ECRU);
    break;

  default:
    tm_fatal();
    break;
  }

  if ( 1 || p == tm_SWEEP ) {
    // tm_print_stats();
  }
  //tm_validate_lists();
}

Here is the call graph for this function:

Here is the caller graph for this function: