Turn streamer cache to pointer_map

[Jan Hubicka]

Hi,
according to oprofile, libiberty hashing takes about 30% of streaming in time
and according to callgrind, the most busy cache is node_map cache in the
streamer.

This patch turns it into pointer-map that also saves about 400MB of memory
and is bit prettier.  I get about 8-10% speedup on Mozilla streaming.
There are other uses of tree_int map, I could probably convert them, too.

Bootstrapped/regtested x86_64-linux, OK?

Honza

        * lto-streamer.c (lto_streamer_cache_insert_1,
        lto_streamer_cache_lookup, lto_streamer_cache_create,
        lto_streamer_cache_delete): Use pointer map instead of hashtable.
        * lto-streamer.h (lto_streamer_cache_d): Turn node_map into pointer_map.
Index: lto-streamer.c
===================================================================
*** lto-streamer.c      (revision 173251)
--- lto-streamer.c      (working copy)
*************** lto_streamer_cache_insert_1 (struct lto_
*** 348,373 ****
                             bool insert_at_next_slot_p)
  {
    void **slot;
-   struct tree_int_map d_entry, *entry;
    unsigned ix;
    bool existed_p;
  
    gcc_assert (t);
  
!   d_entry.base.from = t;
!   slot = htab_find_slot (cache->node_map, &d_entry, INSERT);
!   if (*slot == NULL)
      {
        /* Determine the next slot to use in the cache.  */
        if (insert_at_next_slot_p)
        ix = VEC_length (tree, cache->nodes);
        else
        ix = *ix_p;
! 
!       entry = (struct tree_int_map *)pool_alloc (cache->node_map_entries);
!       entry->base.from = t;
!       entry->to = ix;
!       *slot = entry;
  
        lto_streamer_cache_add_to_node_array (cache, ix, t);
  
--- 348,367 ----
                             bool insert_at_next_slot_p)
  {
    void **slot;
    unsigned ix;
    bool existed_p;
  
    gcc_assert (t);
  
!   slot = pointer_map_insert (cache->node_map, t);
!   if (!*slot)
      {
        /* Determine the next slot to use in the cache.  */
        if (insert_at_next_slot_p)
        ix = VEC_length (tree, cache->nodes);
        else
        ix = *ix_p;
!        *slot = (void *)(size_t) (ix);
  
        lto_streamer_cache_add_to_node_array (cache, ix, t);
  
*************** lto_streamer_cache_insert_1 (struct lto_
*** 376,383 ****
      }
    else
      {
!       entry = (struct tree_int_map *) *slot;
!       ix = entry->to;
  
        if (!insert_at_next_slot_p && ix != *ix_p)
        {
--- 370,376 ----
      }
    else
      {
!       ix = (size_t) *slot;
  
        if (!insert_at_next_slot_p && ix != *ix_p)
        {
*************** lto_streamer_cache_lookup (struct lto_st
*** 442,455 ****
                           unsigned *ix_p)
  {
    void **slot;
-   struct tree_int_map d_slot;
    bool retval;
    unsigned ix;
  
    gcc_assert (t);
  
!   d_slot.base.from = t;
!   slot = htab_find_slot (cache->node_map, &d_slot, NO_INSERT);
    if (slot == NULL)
      {
        retval = false;
--- 435,446 ----
                           unsigned *ix_p)
  {
    void **slot;
    bool retval;
    unsigned ix;
  
    gcc_assert (t);
  
!   slot = pointer_map_contains  (cache->node_map, t);
    if (slot == NULL)
      {
        retval = false;
*************** lto_streamer_cache_lookup (struct lto_st
*** 458,464 ****
    else
      {
        retval = true;
!       ix = ((struct tree_int_map *) *slot)->to;
      }
  
    if (ix_p)
--- 449,455 ----
    else
      {
        retval = true;
!       ix = (size_t) *slot;
      }
  
    if (ix_p)
*************** lto_streamer_cache_create (void)
*** 608,618 ****
  
    cache = XCNEW (struct lto_streamer_cache_d);
  
!   cache->node_map = htab_create (101, tree_int_map_hash, tree_int_map_eq, 
NULL);
! 
!   cache->node_map_entries = create_alloc_pool ("node map",
!                                              sizeof (struct tree_int_map),
!                                              100);
  
    /* Load all the well-known tree nodes that are always created by
       the compiler on startup.  This prevents writing them out
--- 599,605 ----
  
    cache = XCNEW (struct lto_streamer_cache_d);
  
!   cache->node_map = pointer_map_create ();
  
    /* Load all the well-known tree nodes that are always created by
       the compiler on startup.  This prevents writing them out
*************** lto_streamer_cache_delete (struct lto_st
*** 636,643 ****
    if (c == NULL)
      return;
  
!   htab_delete (c->node_map);
!   free_alloc_pool (c->node_map_entries);
    VEC_free (tree, heap, c->nodes);
    free (c);
  }
--- 623,629 ----
    if (c == NULL)
      return;
  
!   pointer_map_destroy (c->node_map);
    VEC_free (tree, heap, c->nodes);
    free (c);
  }
Index: lto-streamer.h
===================================================================
*** lto-streamer.h      (revision 173251)
--- lto-streamer.h      (working copy)
*************** typedef void (lto_free_section_data_f) (
*** 346,355 ****
  struct lto_streamer_cache_d
  {
    /* The mapping between tree nodes and slots into the nodes array.  */
!   htab_t node_map;
! 
!   /* Node map to store entries into.  */
!   alloc_pool node_map_entries;
  
    /* The nodes pickled so far.  */
    VEC(tree,heap) *nodes;
--- 346,352 ----
  struct lto_streamer_cache_d
  {
    /* The mapping between tree nodes and slots into the nodes array.  */
!   struct pointer_map_t GTY((skip)) *node_map;
  
    /* The nodes pickled so far.  */
    VEC(tree,heap) *nodes;