Block

Data Structures
struct	tm_block
	A block allocated from the operating system. More...
Defines
#define	tm_block_unused(b)   ((b)->n[tm_WHITE] == b->n[tm_TOTAL])
	True if the tm_block has no used nodes; i.e.
#define	tm_block_type(b)   ((b)->type)
#define	tm_block_node_begin(b)   ((void*) (b)->begin)
	The begining address of any tm_nodes parcelled from a tm_block.
#define	tm_block_node_end(b)   ((void*) (b)->end)
	The end address of any tm_nodes parcelled from a tm_block.
#define	tm_block_node_next_parcel(b)   ((void*) (b)->next_parcel)
	The address of the next tm_node to be parcelled from a tm_block.
#define	tm_block_node_size(b)   ((b)->type->size + tm_node_HDR_SIZE)
	The total size of a tm_node with a useable size based on the tm_block's tm_type size.
#define	tm_block_node_next(b, n)   ((void*) (((char*) (n)) + tm_block_node_size(b)))
	The adddress of the next tm_node after n, parcelled from tm_block.
#define	_tm_block_validate(b)   ((void) 0)
Functions
static __inline void	_tm_type_add_block (tm_type *t, tm_block *b)
	Add a tm_block to a tm_type.
static __inline void	_tm_type_remove_block (tm_type *t, tm_block *b)
	Remove a tm_block from its tm_type.
static __inline void	tm_block_init (tm_block *b)
	Initialize a new tm_block.
static __inline size_t	tm_block_align_size (size_t size)
	Align size to a multiple of tm_block_SIZE.
static tm_block *	_tm_block_alloc_from_free_list (size_t size)
	Allocate a tm_block from the free list.
static tm_block *	_tm_block_alloc (size_t size)
	Allocate a tm_block of a given size.
static tm_block *	tm_block_scavenge (tm_type *t)
	Scavenges all tm_types for an unused tm_block.
static __inline void	_tm_node_delete (tm_node *n, tm_block *b)
	Deletes a WHITE tm_node from a tm_block.
static int	_tm_block_unparcel_nodes (tm_block *b)
	Unparcels the tm_nodes in a tm_block.
static __inline void	_tm_block_reclaim (tm_block *b)
	Reclaim a live tm_block.
static __inline void	_tm_block_free (tm_block *b)
	Frees a block either returning the block to the OS or keeping it on a free list.
static tm_block *	_tm_block_alloc_for_type (tm_type *t)
	Allocates a tm_block of tm_block_SIZE for a tm_type.

---

Define Documentation

#define _tm_block_validate

(

b

)

((void) 0)

Definition at line 107 of file block.h.

Referenced by tm_node_to_type(), tm_print_block_stats(), tm_ptr_to_node(), and tm_validate_lists().

#define tm_block_node_begin

(

b

)

((void*) (b)->begin)

The begining address of any tm_nodes parcelled from a tm_block.

Definition at line 80 of file block.h.

Referenced by _tm_block_unparcel_nodes(), _tm_node_parcel_some(), and tm_ptr_to_node().

#define tm_block_node_end

(

b

)

((void*) (b)->end)

The end address of any tm_nodes parcelled from a tm_block.

Definition at line 83 of file block.h.

Referenced by _tm_node_parcel_some().

#define tm_block_node_next	(	b,
		n		)	((void*) (((char*) (n)) + tm_block_node_size(b)))

The adddress of the next tm_node after n, parcelled from tm_block.

Definition at line 92 of file block.h.

Referenced by _tm_block_unparcel_nodes(), and _tm_node_parcel_some().

#define tm_block_node_next_parcel

(

b

)

((void*) (b)->next_parcel)

The address of the next tm_node to be parcelled from a tm_block.

Definition at line 86 of file block.h.

Referenced by _tm_block_unparcel_nodes(), _tm_node_parcel_some(), and tm_ptr_to_node().

#define tm_block_node_size

(

b

)

((b)->type->size + tm_node_HDR_SIZE)

The total size of a tm_node with a useable size based on the tm_block's tm_type size.

Definition at line 89 of file block.h.

Referenced by tm_ptr_to_node().

#define tm_block_type

(

b

)

((b)->type)

Definition at line 77 of file block.h.

#define tm_block_unused

(

b

)

((b)->n[tm_WHITE] == b->n[tm_TOTAL])

True if the tm_block has no used nodes; i.e.

it can be returned to the OS.

Definition at line 75 of file block.h.

Referenced by _tm_block_free(), _tm_block_unparcel_nodes(), _tm_node_sweep(), and tm_block_scavenge().

---

Function Documentation

static tm_block* _tm_block_alloc

(

size_t

size

)

[static]

Allocate a tm_block of a given size.

Try to allocate from block free list.

Otherwise, allocate a new tm_block from the OS.

Make sure it's aligned to tm_block_SIZE.

Return 0 if OS denied.

Force allocation of a new block id.

Initialize its size.

Increment OS block stats.

Initialize the tm_block.

Increment global block stats.

Return the new or reused tm_block.

Definition at line 698 of file tm.c.

References _tm_block_alloc_from_free_list(), _tm_os_alloc_aligned(), tm_data::blocks_allocated_since_gc, tm_block::id, tm_data::n, tm_block::size, tm, tm_B, tm_b_OS, tm_B_OS, tm_b_OS_M, tm_B_OS_M, tm_block_align_size(), tm_block_init(), tm_block_SIZE, and tm_msg().

Referenced by _tm_block_alloc_for_type().

{
  tm_block *b;

  size = tm_block_align_size(size);

  /*! Try to allocate from block free list. */
  b = _tm_block_alloc_from_free_list(size);

  /** 
   * Otherwise, allocate a new tm_block from the OS.
   */
  if ( ! b ) {
    /*! Make sure it's aligned to tm_block_SIZE. */
    b = _tm_os_alloc_aligned(size);

    /*! Return 0 if OS denied. */
    if ( ! b )
      return 0;

    /*! Force allocation of a new block id. */
    b->id = 0;

    /*! Initialize its size. */
    b->size = size;
    
    /*! Increment OS block stats. */
    ++ tm.n[tm_B_OS];
    if ( tm.n[tm_B_OS_M] < tm.n[tm_B_OS] )
      tm.n[tm_B_OS_M] = tm.n[tm_B_OS];

    tm.n[tm_b_OS] += size;
    if ( tm.n[tm_b_OS_M] < tm.n[tm_b_OS] )
      tm.n[tm_b_OS_M] = tm.n[tm_b_OS];

    tm_msg("b a os b%p\n", (void*) b);

    /*! Initialize the tm_block. */
    tm_block_init(b);
    
    /*! Increment global block stats. */
    ++ tm.n[tm_B];
    tm.blocks_allocated_since_gc += size / tm_block_SIZE;
  }

  // tm_validate_lists();

  // fprintf(stderr, "  _tm_block_alloc(%p)\n", b);

  /*! Return the new or reused tm_block. */
  return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static tm_block* _tm_block_alloc_for_type

(

tm_type *

t

)

[static]

Allocates a tm_block of tm_block_SIZE for a tm_type.

Allocate a new tm_block from free list or OS.

Add it to the tm_type.blocks list

Definition at line 972 of file tm.c.

References _tm_block_alloc(), _tm_type_add_block(), and tm_block_SIZE.

Referenced by _tm_node_parcel_or_alloc().

{
  tm_block *b;
  
  /*! Allocate a new tm_block from free list or OS. */
  b = _tm_block_alloc(tm_block_SIZE);

  // fprintf(stderr, "  _tm_block_alloc(%d) => %p\n", tm_block_SIZE, b);

  /*! Add it to the tm_type.blocks list */
  if ( b ) {
    _tm_type_add_block(t, b);
  }

  // tm_msg("b a b%p t%p\n", (void*) b, (void*) t);

  return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static tm_block * _tm_block_alloc_from_free_list

(

size_t

size

)

[static]

Allocate a tm_block from the free list.

Force allocation to a multiple of tm_block_SIZE.

Scan global tm_block free list for a block of the right size.

Initialize the tm_block.

Increment global block stats.

Return 0 if no free blocks exist.

Definition at line 652 of file tm.c.

References tm_data::blocks_allocated_since_gc, tm_data::free_blocks, tm_data::free_blocks_n, tm_data::n, tm_block::size, tm, tm_assert_test, tm_B, tm_block_align_size(), tm_block_init(), tm_block_SIZE, tm_FREE_BLOCK, tm_list_color, tm_list_LOOP, tm_list_LOOP_END, tm_list_remove(), and tm_msg().

Referenced by _tm_block_alloc(), and _tm_node_parcel_some().

{
  tm_block *b = 0;

  size = tm_block_align_size(size);

  /*! Scan global tm_block free list for a block of the right size. */
  {
    tm_block *bi;

    tm_list_LOOP(&tm.free_blocks, bi);
    {
      if ( bi->size == size &&
           tm_list_color(bi) == tm_FREE_BLOCK
           ) {
        tm_assert_test(tm.free_blocks_n);
        -- tm.free_blocks_n;

        tm_list_remove(bi);

        b = bi;

        tm_msg("b a fl b%p %d\n", (void*) b, tm.free_blocks_n);
        break;
      }
    }
    tm_list_LOOP_END;
  }
  
  if ( b ) {
    /*! Initialize the tm_block. */
    tm_block_init(b);
    
    /*! Increment global block stats. */
    ++ tm.n[tm_B];
    tm.blocks_allocated_since_gc += size / tm_block_SIZE;
  }

  /*! Return 0 if no free blocks exist. */
  return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline void _tm_block_free

(

tm_block *

b

)

[static]

Frees a block either returning the block to the OS or keeping it on a free list.

• If using mmap(), the block is returned to the OS only if there are enough blocks on the free list (see: tm_block_min_free).
• If using sbrk(), the block is returned to the OS only if it was the most recient block allocated by sbrk().

Reclaim tm_block from its tm_type.blocks list.

If using mmap(), reduce calls to _tm_os_free() by keeping tm_block_min_free free blocks.

If block should return to OS,

Decrement global OS block stats.

And return aligned block back to OS.

Otherwise, remove from t->blocks list and add to global free block list.

Mark block as tm_FREE_BLOCK.

Reset block sweep iterator.

Return.

Definition at line 897 of file tm.c.

References _tm_block_reclaim(), _tm_block_sweep_init(), _tm_os_free_aligned(), tm_block::end, tm_data::free_blocks, tm_data::free_blocks_n, tm_block::id, tm_data::n, tm_block::size, tm, tm_assert, tm_assert_test, tm_b_OS, tm_B_OS, tm_block_min_free, tm_block_unused, tm_FREE_BLOCK, tm_list_remove_and_append(), tm_list_set_color, tm_msg(), and tm_ptr_h.

Referenced by _tm_node_sweep().

{
  int os_free = 0;

  tm_assert(tm_block_unused(b));

  /*! Reclaim tm_block from its tm_type.blocks list. */
  _tm_block_reclaim(b);

#if tm_USE_MMAP
  /*! If using mmap(), reduce calls to _tm_os_free() by keeping tm_block_min_free free blocks. */
  if ( tm.free_blocks_n > tm_block_min_free ) {
    // fprintf(stderr, "  tm_block_free too many free blocks: %d\n", tm.free_blocks_n);
    os_free = 1;
  } else {
    os_free = 0;
  }
#endif

#if tm_USE_SBRK
  /*! If using sbrk() and b was the last block allocated from the OS, */
  if ( sbrk(0) == (void*) b->end ) {
    /*! Reduce valid node ptr range. */
    tm_assert(tm_ptr_h == b->end);
    tm_ptr_h = b;

    /*! And plan to return block to OS. */
    os_free = 1;
  } else {
    os_free = 0;
  }
#endif

  /*! If block should return to OS, */
  if ( os_free ) {
    /*! Decrement global OS block stats. */
    tm_assert_test(tm.n[tm_B_OS]);
    -- tm.n[tm_B_OS];

    tm_assert_test(tm.n[tm_b_OS] > b->size);
    tm.n[tm_b_OS] -= b->size;

    b->id = 0;

    /*! And return aligned block back to OS. */
    _tm_os_free_aligned(b, b->size);

    tm_msg("b f os b%p\n", (void*) b);
  } else {
    /*! Otherwise, remove from t->blocks list and add to global free block list. */
    tm_list_remove_and_append(&tm.free_blocks, b);
    ++ tm.free_blocks_n;

    /*! Mark block as tm_FREE_BLOCK. */
    tm_list_set_color(b, tm_FREE_BLOCK);

    tm_msg("b f fl b%p %d\n", (void*) b, tm.free_blocks_n);
  }

  /*! Reset block sweep iterator. */
  _tm_block_sweep_init();

  // tm_validate_lists();

  // fprintf(stderr, "  _tm_block_free(%p)\n", b);
  // tm_msg("b f b%p\n", (void*) b);

  /*! Return. */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline void _tm_block_reclaim

(

tm_block *

b

)

[static]

Reclaim a live tm_block.

Unparcel any allocated nodes from type free lists.

Avoid pointers into block.

Decrement global block stats.

Remove reference from tm.block_first and tm.block_last, if necessary.

Remove tm_block from tm_type.

Mark tm_block's pages as unused.

Definition at line 858 of file tm.c.

References _tm_block_unparcel_nodes(), _tm_page_mark_unused_range(), _tm_type_remove_block(), tm_block::begin, tm_data::block_first, tm_data::block_last, tm_data::n, tm_block::next_parcel, tm_block::size, tm, tm_assert_test, tm_B, tm_list_color, tm_LIVE_BLOCK, and tm_block::type.

Referenced by _tm_block_free().

{
  tm_assert_test(b);
  tm_assert_test(tm_list_color(b) == tm_LIVE_BLOCK);

  /*! Unparcel any allocated nodes from type free lists. */
  _tm_block_unparcel_nodes(b);

  /*! Avoid pointers into block. */
  b->next_parcel = b->begin;

  /*! Decrement global block stats. */
  tm_assert_test(tm.n[tm_B]);
  -- tm.n[tm_B];

  /*! Remove reference from tm.block_first and tm.block_last, if necessary. */
  if ( tm.block_last == b ) {
    tm.block_last = 0;
  }
  if ( tm.block_first == b ) {
    tm.block_first = 0;
  }

  /*! Remove tm_block from tm_type. */
  _tm_type_remove_block(b->type, b);

  /*! Mark tm_block's pages as unused. */
  _tm_page_mark_unused_range(b, b->size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _tm_block_unparcel_nodes

(

tm_block *

b

)

[static]

Unparcels the tm_nodes in a tm_block.

• Removes each tm_node allocated from the tm_block from its WHITE list.
• All tm_nodes in the tm_block must be WHITE.

If all nodes in the block are free, remove all nodes in the block from any lists.

Start at first tm_node in tm_block.

Remove node from tm_WHITE list and advance.

Decrement tm_WHITE and tm_TOTAL counts:

• Decrement type node counts.

• Decrement block node counts.

• Decrement global node counts.

Definition at line 797 of file tm.c.

References _tm_node_delete(), tm_block::n, tm_type::n, tm_data::n, tm_block::size, tm, tm_assert_test, tm_block_node_begin, tm_block_node_next, tm_block_node_next_parcel, tm_block_unused, tm_node_color, tm_TOTAL, tm_WHITE, and tm_block::type.

Referenced by _tm_block_reclaim().

{
  int count = 0, bytes = 0;
  tm_type *t = b->type;
  
  tm_assert_test(b->type);

  /**
   * If all nodes in the block are free, 
   * remove all nodes in the block from any lists.
  */
  tm_assert_test(tm_block_unused(b));

  {
    tm_node *n;
    
    /*! Start at first tm_node in tm_block. */
    n = tm_block_node_begin(b);
    while ( (void*) n < tm_block_node_next_parcel(b) ) {
      /*! Remove node from tm_WHITE list and advance. */
      ++ count;
      bytes += b->size;

      tm_assert_test(tm_node_color(n) == tm_WHITE);
      _tm_node_delete(n, b);

      n = tm_block_node_next(b, n);
    }
  }

  /*! Decrement tm_WHITE and tm_TOTAL counts: */

  /*! - Decrement type node counts. */
  tm_assert_test(t->n[tm_WHITE] >= count);
  t->n[tm_WHITE] -= count;
  tm_assert_test(t->n[tm_TOTAL] >= count);
  t->n[tm_TOTAL] -= count;

  /*! - Decrement block node counts. */
  tm_assert_test(b->n[tm_WHITE] >= count);
  b->n[tm_WHITE] -= count;
  tm_assert_test(b->n[tm_WHITE] == 0);

  tm_assert_test(b->n[tm_TOTAL] >= count);
  b->n[tm_TOTAL] -= count;
  tm_assert_test(b->n[tm_TOTAL] == 0);

  /*! - Decrement global node counts. */
  tm_assert_test(tm.n[tm_WHITE] >= count);
  tm.n[tm_WHITE] -= count;
  tm_assert_test(tm.n[tm_TOTAL] >= count);
  tm.n[tm_TOTAL] -= count;

  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Deletes a WHITE tm_node from a tm_block.

Remove tm_node from tm_type's color list.

Definition at line 1048 of file tm.c.

References tm_data::n, tm_block::n, tm_type::n, tm_type::size, tm, tm_assert_test, tm_list_remove(), tm_msg(), tm_node_color, tm_TOTAL, tm_WHITE, and tm_block::type.

Referenced by _tm_block_unparcel_nodes().

{
  tm_type *t;
  tm_color nc = tm_node_color(n);

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

#if 0 /* See _tm_block_unparcel_nodes() */
  /*! Decrement type node counts. */
  tm_assert_test(t->n[tm_TOTAL]);
  -- t->n[tm_TOTAL];
  tm_assert_test(t->n[nc]);
  -- t->n[nc];

  /*! Decrement block node counts. */
  tm_assert_test(b->n[tm_TOTAL] > 0);
  -- b->n[tm_TOTAL];
  tm_assert_test(b->n[nc]) > 0);
  -- b->n[nc];

  /*! Decrement global node counts. */
  tm_assert_test(tm.n[tm_TOTAL] > 0);
  -- tm.n[tm_TOTAL];
  tm_assert_test(tm.n[nc] > 0);
  -- tm.n[nc];
#endif

  /*! Remove tm_node from tm_type's color list. */
  tm_list_remove(n);

  // tm_validate_lists();

#if 0
  tm_msg("N d n%p[%lu] t%p\n", 
         (void*) n,
         (unsigned long) t->size,
         (void*) t);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline void _tm_type_add_block	(	tm_type *	t,
		tm_block *	b
	)			[static]

Add a tm_block to a tm_type.

Assert that tm_block is not already associated with a tm_type.

Associate tm_block with the tm_type.

Compute the capacity of this block.

Begin parceling from this block.

Increment type block stats.

Decrement global block stats.

Add to type's block list.

Definition at line 515 of file tm.c.

References tm_block::begin, tm_type::blocks, tm_block::end, tm_data::n, tm_type::n, tm_block::n, tm_type::parcel_from_block, tm_type::size, tm, tm_assert_test, tm_B, tm_CAPACITY, tm_list_insert(), and tm_block::type.

Referenced by _tm_block_alloc_for_type(), and _tm_node_parcel_some().

{
  tm_assert_test(t);
  tm_assert_test(b);
  /*! Assert that tm_block is not already associated with a tm_type. */
  tm_assert_test(b->type == 0);

  /*! Associate tm_block with the tm_type. */
  b->type = t;

  /*! Compute the capacity of this block. */
  tm_assert_test(! b->n[tm_CAPACITY]);
  b->n[tm_CAPACITY] = (b->end - b->begin) / (sizeof(tm_node) + t->size); 

  /*! Begin parceling from this block. */
  tm_assert_test(! t->parcel_from_block);
  t->parcel_from_block = b;

  /*! Increment type block stats. */
  ++ t->n[tm_B];

  /*! Decrement global block stats. */
  ++ tm.n[tm_B];

  /*! Add to type's block list. */
  tm_list_insert(&t->blocks, b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline void _tm_type_remove_block	(	tm_type *	t,
		tm_block *	b
	)			[static]

Remove a tm_block from its tm_type.

Decrement type block stats.

Decrement global block stats.

Do not parcel nodes from it any more.

Remove tm-block from tm_type.block list.

Dissassociate tm_block with the tm_type.

Definition at line 548 of file tm.c.

References tm_data::n, tm_type::n, tm_type::parcel_from_block, tm, tm_assert_test, tm_B, tm_list_remove(), and tm_block::type.

Referenced by _tm_block_reclaim().

{
  tm_assert_test(t);
  tm_assert_test(b->type);
  tm_assert_test(b->type == t);

  /*! Decrement type block stats. */
  tm_assert_test(t->n[tm_B]);
  -- t->n[tm_B];

  /*! Decrement global block stats. */
  tm_assert_test(tm.n[tm_B]);
  -- tm.n[tm_B];

  /*! Do not parcel nodes from it any more. */
  if ( t->parcel_from_block == b ) {
    t->parcel_from_block = 0;
  }

  /*! Remove tm-block from tm_type.block list. */
  tm_list_remove(b);

  /*! Dissassociate tm_block with the tm_type. */
  b->type = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline size_t tm_block_align_size

(

size_t

size

)

[static]

Align size to a multiple of tm_block_SIZE.

Force allocation to a multiple of tm_block_SIZE.

Definition at line 634 of file tm.c.

References tm_block_SIZE.

Referenced by _tm_block_alloc(), and _tm_block_alloc_from_free_list().

{
  size_t offset;

  /*! Force allocation to a multiple of tm_block_SIZE. */
  if ( (offset = (size % tm_block_SIZE)) )
    size += tm_block_SIZE - offset;

  return size;
}

Here is the caller graph for this function:

static __inline void tm_block_init

(

tm_block *

b

)

[static]

Initialize a new tm_block.

Initialize the block id.

Initialize tm_block list pointers.

Mark tm_block as tm_LIVE_BLOCK.

Disassocate the tm_block with any tm_type.

Initialize bounds of the tm_block's allocation space.

Initialize next tm_node parcel to beginning of valid useable space.

Clear tm_block stats.

Reset tm_block sweep iterator.

Remember the first block and most recent blocks allocated.

Definition at line 579 of file tm.c.

References _tm_block_sweep_init(), tm_block::begin, tm_data::block_first, tm_data::block_id, tm_data::block_last, tm_block::end, tm_block::id, tm_block::list, tm_block::n, tm_block::next_parcel, tm_block::size, tm, tm_assert, tm_assert_test, tm_block_GUARD, tm_block_HDR_SIZE, tm_list_init(), tm_list_set_color, tm_LIVE_BLOCK, and tm_block::type.

Referenced by _tm_block_alloc(), and _tm_block_alloc_from_free_list().

{
  tm_assert_test(b->size);

  /*! Initialize the block id. */
  if ( ! b->id ) {
    b->id = ++ tm.block_id;
  }

  /*! Initialize tm_block list pointers. */
  tm_list_init(&b->list);
  /*! Mark tm_block as tm_LIVE_BLOCK. */
  tm_list_set_color(b, tm_LIVE_BLOCK);

#if tm_name_GUARD
  b->name = "BLOCK";
#endif

  /*! Disassocate the tm_block with any tm_type. */
  b->type = 0;

  /*! Initialize bounds of the tm_block's allocation space. */
  b->begin = (char*) b + tm_block_HDR_SIZE;
  b->end   = (char*) b + b->size;
  
  /*! Initialize next tm_node parcel to beginning of valid useable space. */
  b->next_parcel = b->begin;

#if tm_block_GUARD
  b->guard1 = b->guard2 = tm_block_hash(b);
#endif

  /*! Clear tm_block stats. */
  memset(b->n, 0, sizeof(b->n));

  /*! Reset tm_block sweep iterator. */
  _tm_block_sweep_init();

  /*! Remember the first block and most recent blocks allocated. */
  tm.block_last = b;
  if ( ! tm.block_first ) {
    tm.block_first = b;
  } else {
#if tm_USE_SBRK
    /* Make sure heap grows up, other code depends on it. */
    tm_assert((void*) b >= (void*) tm.block_first);
#endif
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static tm_block* tm_block_scavenge

(

tm_type *

t

)

[static]

Scavenges all tm_types for an unused tm_block.

NOT USED!

Definition at line 758 of file tm.c.

References tm_type::blocks, tm_block::n, tm, tm_block_unused, tm_list_LOOP, tm_list_LOOP_END, tm_TOTAL, tm_block::type, and tm_data::types.

{
  tm_type *type = 0;

  tm_list_LOOP(&tm.types, type);
  {
    tm_block *block = 0;

    tm_list_LOOP(&type->blocks, block);
    {
      if ( block->type != t && 
           tm_block_unused(block) &&
           block->n[tm_TOTAL]
           ) {
        return block;
      }
    }
    tm_list_LOOP_END;
  }
  tm_list_LOOP_END;

  return 0;
}