Node

Data Structures
struct	tm_node
	An allocation node representing the data ptr returned from tm_alloc(). More...
struct	tm_node_large
	An allocation for a large node. More...
struct	tm_node_iterator
	Colored Node Iterator. More...
Defines
#define	tm_node_color(n)   ((tm_color) tm_list_color(n))
	The color of a tm_node.
#define	tm_node_ptr(n)   ((void*)(((tm_node*) n) + 1))
	A pointer to the data of a tm_node.
#define	tm_node_type(n)   tm_block_type(tm_node_to_block(n))
	Return the tm_node's tm_type.
Functions
static __inline void	_tm_node_init (tm_node *n, tm_block *b)
	Initialize a tm_node from a tm_block.
static __inline int	_tm_node_parcel_some (tm_type *t, long left)
	Parcel some nodes for a tm_type from a tm_block already allocated from the OS.
static __inline int	_tm_node_parcel_or_alloc (tm_type *t)
	Parcel some nodes from an existing tm_block, or allocate a new tm_block and try again.

---

Define Documentation

#define tm_node_color

(

n

)

((tm_color) tm_list_color(n))

The color of a tm_node.

Definition at line 37 of file node.h.

Referenced by _tm_block_unparcel_nodes(), _tm_check_sweep_error(), _tm_free_inner(), _tm_node_delete(), _tm_node_mark(), _tm_node_parcel_some(), _tm_node_scan_some(), _tm_node_set_color(), _tm_node_sweep(), _tm_node_sweep_some(), _tm_node_unmark_some(), _tm_type_alloc_node_from_free_list(), tm_node_iterator_next(), tm_ptr_to_node(), tm_validate_lists(), and tm_write_barrier_node().

#define tm_node_ptr

(

n

)

((void*)(((tm_node*) n) + 1))

A pointer to the data of a tm_node.

Definition at line 40 of file node.h.

Referenced by _tm_node_parcel_some(), _tm_node_scan(), and _tm_node_scan_some().

#define tm_node_type

(

n

)

tm_block_type(tm_node_to_block(n))

Return the tm_node's tm_type.

Definition at line 43 of file node.h.

Referenced by _tm_node_scan().

---

Function Documentation

static __inline void _tm_node_init	(	tm_node *	n,
		tm_block *	b
	)			[static]

Initialize a tm_node from a tm_block.

Set the tm_block.type.

Initialize its list pointers.

Increment type node counts.

Increment block node counts

Increment global node counts.

Place tm_node on tm_type tm_WHITE list.

Definition at line 1002 of file tm.c.

References tm_node::list, tm_data::n, tm_block::n, tm_type::n, tm, tm_assert_test, tm_list_color, tm_list_init(), tm_list_set_color, tm_node_set_color(), tm_TOTAL, tm_WHITE, and tm_block::type.

Referenced by _tm_node_parcel_some().

{
  tm_type *t;

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

  /*! Set the tm_block.type. */
  t = b->type;

  /*! Initialize its list pointers. */
  tm_list_init(&n->list);

#if 1
  tm_assert_test(tm_list_color(&n->list) == tm_WHITE);
#else
  /*! Set the tm_node color to tm_WHITE. */
  tm_list_set_color(n, tm_WHITE);
#endif

  /*! Increment type node counts. */
  ++ t->n[tm_TOTAL];
  ++ t->n[tm_WHITE];

  /*! Increment block node counts */
  ++ b->n[tm_TOTAL];
  ++ b->n[tm_WHITE];
    
  /*! Increment global node counts. */
  ++ tm.n[tm_TOTAL];
  ++ tm.n[tm_WHITE];
  
  /*! Place tm_node on tm_type tm_WHITE list. */
  tm_node_set_color(n, b, tm_WHITE);
  
  // tm_validate_lists();

  // tm_msg("N n%p t%p\n", (void*) n, (void*) t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline int _tm_node_parcel_or_alloc

(

tm_type *

t

)

[static]

Parcel some nodes from an existing tm_block, or allocate a new tm_block and try again.

Return the number of tm_node parcelled.

Definition at line 1191 of file tm.c.

References _tm_block_alloc_for_type(), _tm_node_parcel_some(), and tm_node_parcel_some_size.

Referenced by _tm_alloc_type_inner(), and tm_type_new().

{
  int count;

  count = _tm_node_parcel_some(t, tm_node_parcel_some_size);
  if ( ! count ) {
    if ( ! _tm_block_alloc_for_type(t) )
      return 0;
    count = _tm_node_parcel_some(t, tm_node_parcel_some_size);
  }

  /*! Return the number of tm_node parcelled. */
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline int _tm_node_parcel_some	(	tm_type *	t,
		long	left
	)			[static]

Parcel some nodes for a tm_type from a tm_block already allocated from the OS.

If a tm_block is already scheduled for parceling, parcel from it. Otherwise, try to allocate a block from the free list and schedule it for parceling.

Until end of tm_block parcel space is reached,

Parcel a tm_node from the tm_block.

Increment tm_block parcel pointer.

Update global valid node pointer range.

Initialize the tm_node.

Update local accounting.

If enough nodes have been parceled, stop.

If the end of the tm_block was reached, Force a new tm_block allocation next time.

Return the number of tm_nodes actually allocated.

Definition at line 1097 of file tm.c.

References _tm_block_alloc_from_free_list(), _tm_node_init(), _tm_type_add_block(), tm_type::n, tm_data::n, tm_block::next_parcel, tm_type::parcel_from_block, tm_data::parceling, tm_type::size, tm, tm_assert_test, tm_block_node_begin, tm_block_node_end, tm_block_node_next, tm_block_node_next_parcel, tm_block_SIZE, tm_msg(), tm_node_color, tm_node_ptr, tm_ptr_h, tm_ptr_l, and tm_WHITE.

Referenced by _tm_node_parcel_or_alloc().

{
  int count = 0;
  size_t bytes = 0;
  tm_block *b;
  
  ++ tm.parceling;

  /**
   * If a tm_block is already scheduled for parceling, parcel from it.
   * Otherwise, try to allocate a block from the free list and schedule it for parceling.
   */
  if ( ! t->parcel_from_block ) {
    if ( (b = _tm_block_alloc_from_free_list(tm_block_SIZE)) ) {
      _tm_type_add_block(t, b);
    } else {
      goto done;
    }
  }

  b = t->parcel_from_block;

  // _tm_block_validate(b);
  
  {
    /*! Until end of tm_block parcel space is reached, */
    void *pe = tm_block_node_begin(b);
    
    while ( (pe = tm_block_node_next(b, tm_block_node_next_parcel(b))) 
            <= tm_block_node_end(b)
            ) {
      tm_node *n;
        
      // _tm_block_validate(b);
      
      /*! Parcel a tm_node from the tm_block. */
      n = tm_block_node_next_parcel(b);
      
      /*! Increment tm_block parcel pointer. */
      b->next_parcel = pe;
      
      /*! Update global valid node pointer range. */
      {
        void *ptr;

        if ( tm_ptr_l > (ptr = tm_node_ptr(n)) ) {
          tm_ptr_l = ptr;
        }
        if ( tm_ptr_h < (ptr = pe) ) {
          tm_ptr_h = ptr;
        }
      }
  
      /*! Initialize the tm_node. */
      _tm_node_init(n, b);

      tm_assert_test(tm_node_color(n) == tm_WHITE);

      /*! Update local accounting. */
      ++ count;
      bytes += t->size;
      
      /*! If enough nodes have been parceled, stop. */
      if ( -- left <= 0 ) {
        goto done;
      }
    }
    
    /** 
     * If the end of the tm_block was reached,
     * Force a new tm_block allocation next time. 
     */
    t->parcel_from_block = 0;
  }

  done:

  -- tm.parceling;

#if 0
  if ( count )
    tm_msg("N i n%lu b%lu t%lu\n", count, bytes, t->n[tm_WHITE]);
#endif

  /*! Return the number of tm_nodes actually allocated. */
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function: