Beispiel #1
0
/* Puts a new, heap allocated VgHashNode, into the VgHashTable.  Prepends
   the node to the appropriate chain. */
void VG_(HT_add_node) ( VgHashTable table, void* vnode )
{
   VgHashNode* node     = (VgHashNode*)vnode;
   UInt chain           = CHAIN_NO(node->key, table);
   node->next           = table->chains[chain];
   table->chains[chain] = node;
}
Beispiel #2
0
/* Looks up a VgHashNode in the table.  Also returns the address of
   the previous node's 'next' pointer which allows it to be removed from the
   list later without having to look it up again.  */
void* VG_(HT_get_node) ( VgHashTable table, UWord key,
                         /*OUT*/VgHashNode*** next_ptr )
{
   VgHashNode *prev, *curr;
   Int       chain;

   chain = CHAIN_NO(key, table);

   prev = NULL;
   curr = table->chains[chain];
   while (True) {
      if (curr == NULL)
         break;
      if (key == curr->key)
         break;
      prev = curr;
      curr = curr->next;
   }

   if (NULL == prev)
      *next_ptr = & (table->chains[chain]);
   else
      *next_ptr = & (prev->next);

   return curr;
}
Beispiel #3
0
/* Looks up a HashNode in the table.  Returns NULL if not found. */
void* HT_lookup ( BasicBlockHashTable table, UWord key )
{
   HashNode* curr = table->chains[ CHAIN_NO(key, table) ];

   while (curr) {

      #ifdef DEBUG_HASH
	  printf("chain no: %d key=%x curr-key=%x\n",CHAIN_NO(key, table), key, curr->key);
      #endif

      if (key == curr->key) {
         return curr;
      }
      curr = curr->next;
   }
   return NULL;
}
Beispiel #4
0
/* Looks up a VgHashNode in the table.  Returns NULL if not found. */
void * HT_lookup(HashTable * table, UWord key) {
    HashNode * curr = table->chains[CHAIN_NO(key, table)];
    
    while (curr) {
        if (key == curr->key)
            return curr;
        curr = curr->next;
    }
    return NULL;
}
Beispiel #5
0
/* Looks up a VgHashNode in the table.  Returns NULL if not found. */
void* VG_(HT_lookup) ( VgHashTable table, UWord key )
{
   VgHashNode* curr = table->chains[ CHAIN_NO(key, table) ];

   while (curr) {
      if (key == curr->key) {
         return curr;
      }
      curr = curr->next;
   }
   return NULL;
}
Beispiel #6
0
static void resize(HashTable * table) {
    Int i;
    SizeT sz;
    SizeT old_chains = table->n_chains;
    SizeT new_chains = old_chains + 1;
    HashNode ** chains;
    HashNode * node;
    
    /* If we've run out of primes, do nothing. */
    if (old_chains == primes[N_HASH_PRIMES - 1])
        return;
    
    vg_assert(old_chains >= primes[0]
            && old_chains < primes[N_HASH_PRIMES-1]);
    
    for (i = 0; i < N_HASH_PRIMES; i++) {
        if (primes[i] > new_chains) {
            new_chains = primes[i];
            break;
        }
    }
    
    vg_assert(new_chains > old_chains);
    vg_assert(new_chains > primes[0]
            && new_chains <= primes[N_HASH_PRIMES-1]);
    
#if DEBUG_ALLOCATION
    UInt q;
    for (q = 0; q < (new_chains - table->n_chains); q++)
    APROF_(add_alloc)(HTC_S);
    //VG_(umsg)("Adding %lu chains\n", new_chains - table->n_chains);
#endif
    
    table->n_chains = new_chains;
    sz = new_chains * sizeof(HashNode *);
    chains = VG_(calloc)("chains", 1, sz);
    
    for (i = 0; i < old_chains; i++) {
        node = table->chains[i];
        while (node != NULL) {
            HashNode * next = node->next;
            UWord chain = CHAIN_NO(node->key, table);
            node->next = chains[chain];
            chains[chain] = node;
            node = next;
        }
    }
    
    VG_(free)(table->chains);
    table->chains = chains;
    
}
static void resize ( VgHashTable *table )
{
   Int          i;
   SizeT        sz;
   SizeT        old_chains = table->n_chains;
   SizeT        new_chains = old_chains + 1;
   VgHashNode** chains;
   VgHashNode * node;

   /* If we've run out of primes, do nothing. */
   if (old_chains == primes[N_HASH_PRIMES-1])
      return;

   vg_assert(old_chains >= primes[0] 
             && old_chains < primes[N_HASH_PRIMES-1]);

   for (i = 0; i < N_HASH_PRIMES; i++) {
      if (primes[i] > new_chains) {
         new_chains = primes[i];
         break;
      }
   }

   vg_assert(new_chains > old_chains);
   vg_assert(new_chains > primes[0] 
             && new_chains <= primes[N_HASH_PRIMES-1]);

   VG_(debugLog)(
      1, "hashtable",
         "resizing table `%s' from %lu to %lu (total elems %lu)\n",
         table->name, (UWord)old_chains, (UWord)new_chains,
         (UWord)table->n_elements );

   table->n_chains = new_chains;
   sz = new_chains * sizeof(VgHashNode*);
   chains = VG_(calloc)("hashtable.resize.1", 1, sz);

   for (i = 0; i < old_chains; i++) {
      node = table->chains[i];
      while (node != NULL) {
         VgHashNode* next = node->next;
         UWord chain = CHAIN_NO(node->key, table);
         node->next = chains[chain];
         chains[chain] = node;
         node = next;
      }
   }

   VG_(free)(table->chains);
   table->chains = chains;
}
/* Looks up a VgHashNode by node in the table.  Returns NULL if not found.
   GEN!!! marks the lines that differs from VG_(HT_lookup). */
void* VG_(HT_gen_lookup) ( const VgHashTable *table, const void* node,
                           HT_Cmp_t cmp )
{
   const VgHashNode* hnode = node; // GEN!!!
   VgHashNode* curr = table->chains[ CHAIN_NO(hnode->key, table) ]; // GEN!!!

   while (curr) {
      if (cmp (hnode, curr) == 0) { // GEN!!!
         return curr;
      }
      curr = curr->next;
   }
   return NULL;
}
/* Puts a new, heap allocated VgHashNode, into the VgHashTable.  Prepends
   the node to the appropriate chain.  No duplicate key detection is done. */
void VG_(HT_add_node) ( VgHashTable *table, void* vnode )
{
   VgHashNode* node     = (VgHashNode*)vnode;
   UWord chain          = CHAIN_NO(node->key, table);
   node->next           = table->chains[chain];
   table->chains[chain] = node;
   table->n_elements++;
   if ( (1 * (ULong)table->n_elements) > (1 * (ULong)table->n_chains) ) {
      resize(table);
   }

   /* Table has been modified; hence HT_Next should assert. */
   table->iterOK = False;
}
Beispiel #10
0
/* Removes a VgHashNode from the table.  Returns NULL if not found. */
void* VG_(HT_remove) ( VgHashTable table, UWord key )
{
   Int          chain         = CHAIN_NO(key, table);
   VgHashNode*  curr          =   table->chains[chain];
   VgHashNode** prev_next_ptr = &(table->chains[chain]);

   while (curr) {
      if (key == curr->key) {
         *prev_next_ptr = curr->next;
         return curr;
      }
      prev_next_ptr = &(curr->next);
      curr = curr->next;
   }
   return NULL;
}
Beispiel #11
0
/* Puts a new, heap allocated VgHashNode, into the VgHashTable.  Prepends
 the node to the appropriate chain.  No duplicate key detection is done. */
void HT_add_node(HashTable * table, UWord key, void * n) {
    
    HashNode * node = (HashNode *) n;
    node->next = NULL;
    //vg_assert(node->key == key);
    UWord chain = CHAIN_NO(key, table);
    node->next = table->chains[chain];
    table->chains[chain] = node;
    table->n_elements++;
    if ((1 * (ULong) table->n_elements) > (1 * (ULong) table->n_chains)) {
        resize(table);
    }
    
    /* Table has been modified; hence HT_Next should assert. */
    table->iterOK = False;
}
Beispiel #12
0
/* Puts a new, heap allocated HashNode, into the BasicBlockHashTable.  Prepends
   the node to the appropriate chain. */
void HT_add_node ( BasicBlockHashTable table, void* vnode )
{
   HashNode* node     = (HashNode*)vnode;
   UInt chain           = CHAIN_NO(node->key, table);

   #ifdef DEBUG_HASH
   printf("\n%d node->key = %x chain in HT\n",chain, node->key);
   #endif

   node->next           = table->chains[chain];
   table->chains[chain] = node;

   #ifdef DEBUG_HASH
   printf("inserted node->key = %x chain in HT\n",table->chains[chain]->key);
   #endif
}
Beispiel #13
0
/* Removes a HashNode from the table.  Returns NULL if not found. */
void* HT_remove( BasicBlockHashTable table, UWord key )
{
   Int          chain         = CHAIN_NO(key, table);
   HashNode*  curr          =   table->chains[chain];
   HashNode** prev_next_ptr = &(table->chains[chain]);

   while (curr) {
      if (key == curr->key) {
         *prev_next_ptr = curr->next;
         free(curr);
         return curr;
      }
      prev_next_ptr = &(curr->next);
      curr = curr->next;
   }
   return NULL;
}
Beispiel #14
0
/* Removes a VgHashNode from the table.  Returns NULL if not found. */
void * HT_remove(HashTable * table, UWord key) {
    UWord chain = CHAIN_NO(key, table);
    HashNode* curr = table->chains[chain];
    HashNode** prev_next_ptr = &(table->chains[chain]);
    
    /* Table has been modified; hence HT_Next should assert. */
    table->iterOK = False;
    
    while (curr) {
        if (key == curr->key) {
            *prev_next_ptr = curr->next;
            table->n_elements--;
            return curr;
        }
        prev_next_ptr = &(curr->next);
        curr = curr->next;
    }
    return NULL;
}
Beispiel #15
0
/* Removes a VgHashNode by node from the table.  Returns NULL if not found.
   GEN!!! marks the lines that differs from VG_(HT_remove). */
void* VG_(HT_gen_remove) ( VgHashTable *table, const void* node, HT_Cmp_t cmp  )
{
   const VgHashNode* hnode    = node; // GEN!!!
   UWord        chain         = CHAIN_NO(hnode->key, table); // GEN!!!
   VgHashNode*  curr          =   table->chains[chain];
   VgHashNode** prev_next_ptr = &(table->chains[chain]);

   /* Table has been modified; hence HT_Next should assert. */
   table->iterOK = False;

   while (curr) {
      if (cmp(hnode, curr) == 0) { // GEN!!!
         *prev_next_ptr = curr->next;
         table->n_elements--;
         return curr;
      }
      prev_next_ptr = &(curr->next);
      curr = curr->next;
   }
   return NULL;
}