Initialization

Functions
void	tm_init (int *argcp, char ***argvp, char ***envpp)
	API: Initialize the tm allocator.

---

Function Documentation

void tm_init	(	int *	argcp,
		char ***	argvp,
		char ***	envpp
	)

API: Initialize the tm allocator.

This should be called from main():

 int main(int argc, char **argv, char **envp)
 {
   tm_init(&argc, &argv, &envp);
   ...
 }
 

Initialize time stat names.

Initialize tm_msg() ignore table.

Warn if already initalized.

Error if argcp and argvp are not given.

Default envpp = &environ, if not given.

Initialize possible pointer range.

Initialize root sets.

Initialize root set for the register set, using a jmpbuf struct.

Initialize roots set for the stack.

Remove anti-roots: do not scan tm's internal data structures.

Initialize root set for initialized and uninitialize (zeroed) data segments.

IMPLEMENT: Support dynamically-loaded library data segments.

Dump the tm_root sets.

Validate tm_root sets.

Initialize root marking loop.

Initialize global tm_type list.

Initialize tm_node color iterators.

Initialize page managment.

Initialize tm_block free list.

Initialize tm_type free list.

Initialize size to tm_type hash table.

Initialize block sweep iterator.

Initialize phase: start by unmarking.

Set up write barrier hooks.

Mark system as initialized.

Definition at line 77 of file init.c.

References __tm_write_barrier(), __tm_write_barrier_pure(), __tm_write_barrier_root(), _tm_block_sweep_init(), _tm_phase_init(), _tm_root_loop_init(), _tm_set_stack_ptr(), _tm_user_bss, _tm_user_data, _tm_write_barrier, _tm_write_barrier_pure, _tm_write_barrier_root, tm_data::data_mutations, tm_data::free_blocks, tm_data::free_blocks_n, tm_root::h, tm_type::hash_next, tm_data::inited, tm_data::initing, tm_data::jb, tm_root::l, tm_root::name, tm_time_stat::name, tm_data::nroots, tm_data::page_in_use, tm_data::root_datai, tm_data::roots, tm_data::stack_grows, tm_data::stack_mutations, tm_data::stack_ptrp, tm, tm_assert, tm_BLACK, tm_ECRU, tm_FREE_BLOCK, tm_GREY, tm_list_assert_layout(), tm_list_init(), tm_list_set_color, tm_LIVE_TYPE, tm_msg(), tm_msg_enable(), tm_msg_enable_all, tm_msg_enable_default, tm_phase_name, tm_ptr_h, tm_ptr_is_in_root_set(), tm_ptr_l, tm_root_add(), tm_root_remove(), tm_stack_growth(), tm_type_hash_LEN, tm_type_init(), tm_UNMARK, tm_WHITE, tm_data::ts_alloc, tm_data::ts_barrier, tm_data::ts_barrier_black, tm_data::ts_barrier_pure, tm_data::ts_barrier_root, tm_data::ts_free, tm_data::ts_gc, tm_data::ts_gc_inner, tm_data::ts_os_alloc, tm_data::ts_os_free, tm_data::ts_phase, tm_data::type_free, tm_data::type_hash, tm_data::type_reserve, tm_data::types, and X.

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

{
  int i;

  tm_assert(sizeof(unsigned long) == sizeof(void *));

  /*! Initialize time stat names. */
  tm.ts_os_alloc.name = "tm_os_alloc";
  tm.ts_os_free.name = "tm_os_free";
  tm.ts_alloc.name = "tm_alloc";
  tm.ts_free.name = "tm_free";
  tm.ts_gc.name = "gc";
  tm.ts_gc_inner.name = "gc_inner";
  tm.ts_barrier.name = "tm_barrier";
  tm.ts_barrier_pure.name = "tm_barrier_p";
  tm.ts_barrier_root.name = "tm_barrier_r";
  tm.ts_barrier_black.name = "tm_barrier B";

  for ( i = 0; i < (sizeof(tm.ts_phase) / sizeof(tm.ts_phase[0])); ++ i ) {
    tm.ts_phase[i].name = tm_phase_name[i];
  }

  /*! Initialize tm_msg() ignore table. */
  if ( tm_msg_enable_all ) {
    tm_msg_enable("\1", 1);
  } else {
    tm_msg_enable(tm_msg_enable_default, 1);
    tm_msg_enable(" \t\n\r", 1);
  }

  tm_msg_enable("WF", 1);
  // tm_msg_enable("b", 1);

  tm_list_assert_layout();

  /*! Warn if already initalized. */
  if ( tm.inited ) {
    tm_msg("WARNING: tm_init() called more than once.\nf");
  }
  tm.initing ++;

  /*! Error if argcp and argvp are not given. */
  if ( ! argcp || ! argvp ) {
    tm_msg("WARNING: tm_init() not called from main().\n");
  }

  /*! Default envpp = &environ, if not given. */
  if ( ! envpp ) {
    extern char **environ;
    tm_msg("WARNING: tm_init(): not passed &envp.\n");
    envpp = (char ***) &environ;
  }

#if 0
#define P(X) tm_msg(" %s = %ld\n", #X, (long) X);
  P(sizeof(tm_list));
  P(sizeof(tm_node));
  P(sizeof(tm_block));
  P(sizeof(tm_type));
  P(sizeof(struct tm_data));
#undef P
#endif

  /*! Initialize possible pointer range. */
  tm_ptr_l = (void*) ~0UL;
  tm_ptr_h = 0;

  /*! Initialize root sets. */
  tm.nroots = 0;
  tm.data_mutations = tm.stack_mutations = 0;

  tm.root_datai = -1;

  /*! Initialize root set for the register set, using a jmpbuf struct. */
  /* A C jmpbuf struct contains the saved registers set, hopefully. */
  tm_root_add("register", &tm.jb, (&tm.jb) + 1);

  /*! Initialize roots set for the stack. */

  {
    void *bottom_of_stack, *top_of_stack = (void*) &i;

#ifndef tm_ENVIRON_0_ALLOCATED_ON_STACK
#define tm_ENVIRON_0_ALLOCATED_ON_STACK 1
#endif

#if tm_ENVIRON_0_ALLOCATED_ON_STACK
    {
      extern char **environ;
      bottom_of_stack = (void*) environ[0];
    }
#else
  /* argvp contains a caller's auto variable. */
  /* Hope that we are being called from somewhere close to the bottom of the stack. */
    bottom_of_stack = (void*) argvp;
#endif

    {
      void *l = top_of_stack;
      void *h = bottom_of_stack;
      
      /* Determine direction of stack growth. */
      if ( tm_stack_growth((char*) &l, 5) < 0 ) {
        tm.stack_grows = -1;
      } else {
        void *t = l;
        l = h;
        h = t;
        tm.stack_grows = 1;
      }
      
      /* Attempt to nudge to page boundaries. */
      {
        size_t stack_page_size = 4096;
        l = (void*) ((unsigned long) (l) - ((unsigned long) (l) % stack_page_size));
        h = (void*) ((unsigned long) (h) + (stack_page_size - ((unsigned long) (h) % stack_page_size)));
      }

      i = tm_root_add("stack", l, h);
    }

    /* Remember where to put the stack pointer. */
    if ( tm.stack_grows < 0 ) {
      tm.stack_ptrp = (void**) &tm.roots[i].l;
    } else {
      tm.stack_ptrp = (void**) &tm.roots[i].h;
    }

    tm.root_datai = i + 1;

    /* IMPLEMENT: Support for multithreading stacks. */
  }


  /*! Remove anti-roots: do not scan tm's internal data structures. */
  tm_root_remove("tm", &tm, &tm + 1);

  /*! Initialize root set for initialized and uninitialize (zeroed) data segments. */
#ifdef __win32__
  {
    extern int _data_start__, _data_end__, _bss_start__, _bss_end__;

    tm_root_add("initialized data", &_data_start__, &_data_end__);
    tm_root_add("uninitialized data", &_bss_start__, &_bss_end__);

  }
#define tm_roots_data_segs
#endif

#ifdef __linux__
  {
    extern int __data_start, __bss_start, _end;

#if 0
    fprintf(stderr, "__data_start = %d\n", __data_start);
    fprintf(stderr, "__bss_start = %d\n", __bss_start);
    fprintf(stderr, "_end = %d\n", _end);
#endif

#if 1
    tm_assert(&__data_start < &__bss_start && &__bss_start < &_end);
    tm_root_add("initialized data", &__data_start, &__bss_start);
    tm_root_add("uninitialized data", &__bss_start, &_end);
#endif
  }
#define tm_roots_data_segs
#endif

#ifndef tm_roots_data_segs
#error must specify how to find the data segment(s) for root marking.
#endif


  /*! IMPLEMENT: Support dynamically-loaded library data segments. */

  /*! Dump the tm_root sets. */
  tm_msg_enable("R", 1);

  tm_msg("R ROOTS {\n");
  for ( i = 0; tm.roots[i].name; ++ i ) {
    if ( tm.roots[i].l != tm.roots[i].h ) {
      tm_msg("R \t [%p,%p] %s %d\n",
             tm.roots[i].l,
             tm.roots[i].h,
             tm.roots[i].name,
             i);
    }
  }
  tm_msg("R }\n");

  tm_msg_enable("R", 0);

  /*! Validate tm_root sets. */
  {
    extern int _tm_user_bss[], _tm_user_data[];

    tm_assert(tm_ptr_is_in_root_set(_tm_user_bss),  ": _tm_user_bss = %p", _tm_user_bss);
    tm_assert(tm_ptr_is_in_root_set(_tm_user_data), ": _tm_user_data = %p", _tm_user_data);
    _tm_set_stack_ptr(&i);
    tm_assert(tm_ptr_is_in_root_set(&i), ": &i = %p", &i);
  }

  /*! Initialize root marking loop. */
  _tm_root_loop_init();

  /*! Initialize global tm_type list. */
  tm_type_init(&tm.types, 0);
  tm_list_set_color(&tm.types, tm_LIVE_TYPE);

  /*! Initialize tm_node color iterators. */
#define X(C) \
  tm.node_color_iter[C].color = C; \
  tm_node_LOOP_INIT(C)
  
  X(tm_WHITE);
  X(tm_ECRU);
  X(tm_GREY);
  X(tm_BLACK);

#undef X

  /*! Initialize page managment. */
  memset(tm.page_in_use, 0, sizeof(tm.page_in_use));

  /*! Initialize tm_block free list. */
  tm_list_init(&tm.free_blocks);
  tm_list_set_color(&tm.free_blocks, tm_FREE_BLOCK);
  tm.free_blocks_n = 0;

  /* Types. */

  /*! Initialize tm_type free list. */
  for ( i = 0; i < sizeof(tm.type_reserve)/sizeof(tm.type_reserve[0]); ++ i ) {
    tm_type *t = &tm.type_reserve[i];
    t->hash_next = (void*) tm.type_free;
    tm.type_free = t;
  }
  
  /*! Initialize size to tm_type hash table. */
  for ( i = 0; i < tm_type_hash_LEN; i ++ ) {
    tm.type_hash[i] = 0;
  }

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

  /*! Initialize phase: start by unmarking. */
  _tm_phase_init(tm_UNMARK);
  
  /*! Set up write barrier hooks. */
  _tm_write_barrier = __tm_write_barrier;
  _tm_write_barrier_pure = __tm_write_barrier_pure;
  _tm_write_barrier_root = __tm_write_barrier_root;
  
  /*! Mark system as initialized. */
  -- tm.initing;
  ++ tm.inited;
  tm_msg_enable("WF", 0);
}

Here is the call graph for this function:

Here is the caller graph for this function: