Type

Data Structures
struct	tm_type
	A tm_type represents information about all tm_nodes of a specific size. More...
Functions
__inline void	tm_type_init (tm_type *t, size_t size)
	Initialize a new tm_type of a given size.
static __inline tm_type *	tm_type_new (size_t size)
	Returns a new tm_type for a given size.
static __inline int	tm_size_hash (size_t size)
	Returns the tm.type_hash[] index for a size.
static __inline tm_type *	tm_size_to_type_2 (size_t size)
	Look for a type by size.
static __inline tm_type *	tm_type_new_2 (size_t size)
	Returns a new tm_type for a given size.
tm_adesc *	tm_adesc_for_size (tm_adesc *desc, int force_new)
	WHAT DOES THIS DO???
static __inline tm_type *	tm_size_to_type (size_t size)
	Return a tm_type for a size.

---

Function Documentation

tm_adesc* tm_adesc_for_size	(	tm_adesc *	desc,
		int	force_new
	)

WHAT DOES THIS DO???

????

Definition at line 1368 of file tm.c.

References tm_type::desc, tm_adesc::hidden, tm_adesc::size, tm_size_to_type_2(), and tm_type_new_2().

{
  tm_type *t;

  if ( ! force_new ) {
    t = tm_size_to_type_2(desc->size);
    if ( t )
      return t->desc;
  }

  t = tm_type_new_2(desc->size);
  t->desc = desc;
  t->desc->hidden = t;

  return t->desc;
}

Here is the call graph for this function:

static __inline int tm_size_hash

(

size_t

size

)

[static]

Returns the tm.type_hash[] index for a size.

IMPLEMENT: support for big allocs.

Compute hash bucket index.

Modulus index into hash bucket index.

Definition at line 1296 of file tm.c.

References tm_ALLOC_ALIGN, tm_assert, tm_block_SIZE_MAX, and tm_type_hash_LEN.

Referenced by tm_size_to_type_2(), and tm_type_new_2().

{
  int i;

  /*! IMPLEMENT: support for big allocs. */
  tm_assert(size <= tm_block_SIZE_MAX);

  /*! Compute hash bucket index. */
  i = size / tm_ALLOC_ALIGN;

  /*! Modulus index into hash bucket index. */
  i %= tm_type_hash_LEN;

  return i;
}

Here is the caller graph for this function:

static __inline tm_type* tm_size_to_type

(

size_t

size

)

[static]

Return a tm_type for a size.

Align size to tm_ALLOC_ALIGN.

If there already exists a type of the size, return it.

Otherwise, align size to the next power of two.

Try to locate a bigger tm_type of that size.

Definition at line 1390 of file tm.c.

References POW2, tm_type::size, tm_ALLOC_ALIGN, tm_assert_test, tm_size_to_type_2(), and tm_type_new_2().

Referenced by _tm_alloc_inner(), and _tm_realloc_inner().

{
  tm_type *t;
  
  /*! Align size to tm_ALLOC_ALIGN. */
  size = (size + (tm_ALLOC_ALIGN - 1)) & ~(tm_ALLOC_ALIGN - 1);

  /*! If there already exists a type of the size, return it. */
  t = tm_size_to_type_2(size);

  if ( t )
    return t;

  /*! Otherwise, align size to the next power of two. */
#define POW2(i) if ( size <= (1UL << i) ) size = (1UL << i); else

  POW2(3)
  POW2(4)
  POW2(5)
  POW2(6)
  POW2(7)
  POW2(8)
  POW2(9)
  POW2(10)
  POW2(11)
  POW2(12)
  POW2(13)
  POW2(14)
  POW2(15)
  POW2(16)
  (void) 0;

#undef POW2

  /*! Try to locate a bigger tm_type of that size. */
  t = tm_size_to_type_2(size);

  /* If a tm_type was not found, create a new one. */
  if ( ! t ) {
    t = tm_type_new_2(size);
  }
  
  tm_assert_test(t->size == size);
  
  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline tm_type* tm_size_to_type_2

(

size_t

size

)

[static]

Look for a type by size.

Look for type by size using tm.type_hash.

If a type of the same size is found,

Definition at line 1317 of file tm.c.

References tm_type::hash_next, tm_type::size, tm, tm_size_hash(), and tm_data::type_hash.

Referenced by tm_adesc_for_size(), and tm_size_to_type().

{
  tm_type **tp, *t;
  int i;
  
  i = tm_size_hash(size);

  /*! Look for type by size using tm.type_hash. */
  for ( tp = &tm.type_hash[i]; (t = (*tp)); tp = &t->hash_next ) {
    /*! If a type of the same size is found, */
    if ( t->size == size ) {
      /* Move it to front of hash bucket. */
      *tp = t->hash_next;
      t->hash_next = tm.type_hash[i];
      tm.type_hash[i] = t;
      break;
    }
  }

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

__inline void tm_type_init	(	tm_type *	t,
		size_t	size
	)

Initialize a new tm_type of a given size.

Assign a the tm_type a unique id.

Initialize tm_type's global list pointers.

Mark the tm_type as live.

Initialize the tm_types.blocks list.

Initialize the tm_type node counts.

Initialize the tm_type.color_list.

Force a new tm_block to be allocated and parceled.

Zero the tm_type descriptor.

Definition at line 1217 of file tm.c.

References tm_type::blocks, tm_type::color_list, tm_type::desc, tm_type::id, tm_type::list, tm_type::n, tm_type::parcel_from_block, tm_type::size, tm, tm_list_init(), tm_list_set_color, tm_LIVE_BLOCK, tm_LIVE_TYPE, and tm_data::type_id.

Referenced by tm_init(), and tm_type_new().

{
  /*! Assign a the tm_type a unique id. */
  t->id = ++ tm.type_id;

  /*! Initialize tm_type's global list pointers. */
  tm_list_init(&t->list);
  
  /*! Mark the tm_type as live. */
  tm_list_set_color(&t->list, tm_LIVE_TYPE);
#if tm_name_GUARD
  t->name = "TYPE";
#endif
  t->size = size;

  /*! Initialize the tm_types.blocks list. */
  tm_list_init(&t->blocks);
  tm_list_set_color(&t->blocks, tm_LIVE_BLOCK);
  
  /*! Initialize the tm_type node counts. */
  memset(t->n, 0, sizeof(t->n));
  
  /*! Initialize the tm_type.color_list. */
  {
    int j;
    
    for ( j = 0; j < sizeof(t->color_list) / sizeof(t->color_list[0]); ++ j ) {
      tm_list_init(&t->color_list[j]);
      tm_list_set_color(&t->color_list[j], j);
    }
  }

  /*! Force a new tm_block to be allocated and parceled. */
  t->parcel_from_block = 0;

  /*! Zero the tm_type descriptor. */
  t->desc = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline tm_type* tm_type_new

(

size_t

size

)

[static]

Returns a new tm_type for a given size.

If possible take a tm_type from global tm.type_free list.

Initialize the tm_type.

Add to global tm.types list.

Allocate some tm_nodes now so the tm_type's free list (tm_WHITE) is not empty. to avoid triggering a collection.

Assume this is being called because an tm_alloc() is envitable.

Definition at line 1261 of file tm.c.

References _tm_node_parcel_or_alloc(), tm_type::hash_next, tm, tm_list_insert(), tm_type_init(), tm_data::type_free, and tm_data::types.

Referenced by tm_type_new_2().

{
  tm_type *t;

  /*! If possible take a tm_type from global tm.type_free list. */
  if ( tm.type_free ) {
    t = tm.type_free;
    tm.type_free = t->hash_next;
    t->hash_next = 0;
  } else {
    t = 0;
  }

  /*! Initialize the tm_type. */
  tm_type_init(t, size);

  /*! Add to global tm.types list. */
  tm_list_insert(&tm.types, t);
  
  /**
   * Allocate some tm_nodes now so the tm_type's free list (tm_WHITE) is not empty.
   * to avoid triggering a collection.
   *
   * Assume this is being called because an tm_alloc() is envitable.
   */
  _tm_node_parcel_or_alloc(t);

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static __inline tm_type* tm_type_new_2

(

size_t

size

)

[static]

Returns a new tm_type for a given size.

Allocate a new tm_type.

Add to tm.type_hash

Definition at line 1344 of file tm.c.

References tm_type::hash_next, tm_type::size, tm, tm_msg(), tm_size_hash(), tm_type_new(), and tm_data::type_hash.

Referenced by tm_adesc_for_size(), and tm_size_to_type().

{
  int i;
  tm_type *t;

  /*! Allocate a new tm_type. */
  t = tm_type_new(size);
  
  /*! Add to tm.type_hash */
  i = tm_size_hash(t->size);
  t->hash_next = tm.type_hash[i];
  tm.type_hash[i] = t;
  
#if 0
  tm_msg("t a t%p %lu\n", (void*) t, (unsigned long) size);
#endif

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function: