Internal: Routine

Defines
#define	_tm_clear_some_stack_words()
Functions
void	_tm_phase_init (int p)
	Initializes a new allocation phase.
void	tm_node_set_color (tm_node *n, tm_block *b, tm_color c)
	Sets the color of a tm_node, in a tm_block.
void	_tm_set_stack_ptr (void *ptr)
	Set the stack pointer.
void	__tm_clear_some_stack_words ()
	Clears the stack and initializes register root set.
void *	_tm_alloc_inner (size_t size)
	Allocates a node of a particular size.
void *	_tm_alloc_desc_inner (tm_adesc *desc)
	Allocates a node of a particular type.
void *	_tm_realloc_inner (void *ptr, size_t size)
	Reallocates a node to a particular size.
void	_tm_free_inner (void *ptr)
	Manually returns a node back to its tm_type free list.
void	_tm_gc_full_inner ()
	Force a full GC sequence.

---

Define Documentation

 

#define _tm_clear_some_stack_words

(

)

Value:

setjmp(tm.jb); \
__tm_clear_some_stack_words()

Definition at line 429 of file internal.h.

Referenced by tm_alloc(), tm_alloc_desc(), tm_free(), tm_gc_full(), and tm_realloc().

---

Function Documentation

void __tm_clear_some_stack_words

(

)

Clears the stack and initializes register root set.

Clears the stack and initializes register root set.

Avoid leaving garbage on the stack Note: Do not move this in to user.c, it might be optimized away.

Definition at line 2171 of file tm.c.

{
  int some_words[64];
  memset(some_words, 0, sizeof(some_words));
}

void* _tm_alloc_desc_inner

(

tm_adesc *

desc

)

Allocates a node of a particular type.

Definition at line 2109 of file tm.c.

References _tm_alloc_type_inner(), tm_data::alloc_request_size, tm_data::alloc_request_type, tm_adesc::hidden, tm_type::size, and tm.

Referenced by tm_alloc_desc().

{
  tm_type *type = (tm_type*) desc->hidden;
  tm.alloc_request_size = type->size;
  tm.alloc_request_type = type;
  return _tm_alloc_type_inner(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* _tm_alloc_inner

(

size_t

size

)

Allocates a node of a particular size.

Definition at line 2097 of file tm.c.

References _tm_alloc_type_inner(), tm_data::alloc_request_size, tm_data::alloc_request_type, tm, and tm_size_to_type().

Referenced by _tm_realloc_inner(), and tm_alloc().

{
  tm_type *type = tm_size_to_type(size);
  tm.alloc_request_size = size;
  tm.alloc_request_type = type;
  return _tm_alloc_type_inner(type);  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_free_inner

(

void *

ptr

)

Manually returns a node back to its tm_type free list.

Assumes that ptr is pure pointer to the beginning of a tm_node's data space.

Definition at line 2148 of file tm.c.

References tm_data::n, tm_assert, tm_node_color, tm_node_set_color(), tm_node_to_block(), tm_pure_ptr_to_node(), and tm_WHITE.

Referenced by tm_free().

{
  tm_block *b;
  tm_node *n;

  n = tm_pure_ptr_to_node(ptr);
  b = tm_node_to_block(n);
  // _tm_block_validate(b);
  tm_assert(tm_node_color(n) != tm_WHITE);
  tm_node_set_color(n, b, tm_WHITE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_gc_full_inner

(

)

Force a full GC sequence.

Definition at line 1749 of file tm.c.

References _tm_gc_full_type_inner().

Referenced by tm_alloc(), and tm_gc_full().

{
  _tm_gc_full_type_inner(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_phase_init

(

int

p

)

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:

void* _tm_realloc_inner	(	void *	ptr,
		size_t	size
	)

Reallocates a node to a particular size.

Definition at line 2121 of file tm.c.

References _tm_alloc_inner(), tm_type::size, tm_node_to_type(), tm_pure_ptr_to_node(), and tm_size_to_type().

Referenced by tm_realloc().

{
  char *ptr = 0;
  tm_type *t, *oldt;

  oldt = tm_node_to_type(tm_pure_ptr_to_node(oldptr));
  t = tm_size_to_type(size);

  if ( oldt == t ) {
    ptr = oldptr;
  } else {
    ptr = _tm_alloc_inner(size);
    memcpy(ptr, oldptr, size < oldt->size ? size : oldt->size);
  }
  
  return (void*) ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_set_stack_ptr

(

void *

stackvar

)

Set the stack pointer.

Adjust for slack.

Definition at line 80 of file mark.c.

Referenced by tm_alloc(), tm_alloc_desc(), tm_free(), tm_gc_full(), tm_init(), and tm_realloc().

{
  *tm.stack_ptrp = (char*) stackvar - 64;
}

Here is the caller graph for this function:

void tm_node_set_color	(	tm_node *	n,
		tm_block *	b,
		tm_color	c
	)

Sets the color of a tm_node, in a tm_block.

Sets the color of a tm_node, in a tm_block.

The tm_node must reside in the tm_block.

Removes the tm_node from its current tm_type color list and appends the tm_node to the new color_list.

Definition at line 487 of file tm.c.

References _tm_node_set_color(), tm_type::color_list, tm_assert_test, tm_list_remove_and_append(), and tm_block::type.

Referenced by _tm_check_sweep_error(), _tm_free_inner(), _tm_node_init(), _tm_node_mark(), _tm_node_scan(), _tm_node_scan_some(), _tm_node_sweep(), _tm_node_unmark_some(), _tm_type_alloc_node_from_free_list(), and tm_write_barrier_node().

{
  tm_type *t;

  tm_assert_test(b);
  // _tm_block_validate(b);
  tm_assert_test(b->type);
  t = b->type;

  _tm_node_set_color(n, b, t, c);

  tm_list_remove_and_append(&t->color_list[c], n);
 
  // _tm_validate_lists();
}

Here is the call graph for this function:

Here is the caller graph for this function: