hashnode ht_lookup_with_hash (hash_table *table, const unsigned char *str, size_t len, unsigned int hash, enum ht_lookup_option insert) { unsigned int hash2; unsigned int index; size_t sizemask; hashnode node; sizemask = table->nslots - 1; index = hash & sizemask; table->searches++; node = table->entries[index]; if (node != NULL) { if (node->hash_value == hash && HT_LEN (node) == (unsigned int) len && !memcmp (HT_STR (node), str, len)) { if (insert == HT_ALLOCED) /* The string we search for was placed at the end of the obstack. Release it. */ obstack_free (&table->stack, (void *) str); return node; } /* hash2 must be odd, so we're guaranteed to visit every possible location in the table during rehashing. */ hash2 = ((hash * 17) & sizemask) | 1; for (;;) { table->collisions++; index = (index + hash2) & sizemask; node = table->entries[index]; if (node == NULL) break; if (node->hash_value == hash && HT_LEN (node) == (unsigned int) len && !memcmp (HT_STR (node), str, len)) { if (insert == HT_ALLOCED) /* The string we search for was placed at the end of the obstack. Release it. */ obstack_free (&table->stack, (void *) str); return node; } } } if (insert == HT_NO_INSERT) return NULL; node = (*table->alloc_node) (table); table->entries[index] = node; HT_LEN (node) = (unsigned int) len; node->hash_value = hash; if (insert == HT_ALLOC) HT_STR (node) = (const unsigned char *) obstack_copy0 (&table->stack, str, len); else HT_STR (node) = str; if (++table->nelements * 4 >= table->nslots * 3) /* Must expand the string table. */ ht_expand (table); return node; }
void ht_dump_statistics (hash_table *table) { size_t nelts, nids, overhead, headers; size_t total_bytes, longest; double sum_of_squares, exp_len, exp_len2, exp2_len; hashnode *p, *limit; #define SCALE(x) ((unsigned long) ((x) < 1024*10 \ ? (x) \ : ((x) < 1024*1024*10 \ ? (x) / 1024 \ : (x) / (1024*1024)))) #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M')) total_bytes = longest = sum_of_squares = nids = 0; p = table->entries; limit = p + table->nslots; do if (*p) { size_t n = HT_LEN (*p); total_bytes += n; sum_of_squares += (double) n * n; if (n > longest) longest = n; nids++; } while (++p < limit); nelts = table->nelements; overhead = obstack_memory_used (&table->stack) - total_bytes; headers = table->nslots * sizeof (hashnode); fprintf (stderr, "\nString pool\nentries\t\t%lu\n", (unsigned long) nelts); fprintf (stderr, "identifiers\t%lu (%.2f%%)\n", (unsigned long) nids, nids * 100.0 / nelts); fprintf (stderr, "slots\t\t%lu\n", (unsigned long) table->nslots); fprintf (stderr, "bytes\t\t%lu%c (%lu%c overhead)\n", SCALE (total_bytes), LABEL (total_bytes), SCALE (overhead), LABEL (overhead)); fprintf (stderr, "table size\t%lu%c\n", SCALE (headers), LABEL (headers)); exp_len = (double)total_bytes / (double)nelts; exp2_len = exp_len * exp_len; exp_len2 = (double) sum_of_squares / (double) nelts; fprintf (stderr, "coll/search\t%.4f\n", (double) table->collisions / (double) table->searches); fprintf (stderr, "ins/search\t%.4f\n", (double) nelts / (double) table->searches); fprintf (stderr, "avg. entry\t%.2f bytes (+/- %.2f)\n", exp_len, approx_sqrt (exp_len2 - exp2_len)); fprintf (stderr, "longest entry\t%lu\n", (unsigned long) longest); #undef SCALE #undef LABEL }
hashnode ht_lookup_with_hash (cpp_hash_table *table, const unsigned char *str, size_t len, unsigned int hash, enum ht_lookup_option insert) { unsigned int hash2; unsigned int index; unsigned int deleted_index = table->nslots; size_t sizemask; hashnode node; sizemask = table->nslots - 1; index = hash & sizemask; table->searches++; node = table->entries[index]; if (node != NULL) { if (node == DELETED) deleted_index = index; else if (node->hash_value == hash && HT_LEN (node) == (unsigned int) len && !memcmp (HT_STR (node), str, len)) return node; /* hash2 must be odd, so we're guaranteed to visit every possible location in the table during rehashing. */ hash2 = ((hash * 17) & sizemask) | 1; for (;;) { table->collisions++; index = (index + hash2) & sizemask; node = table->entries[index]; if (node == NULL) break; if (node == DELETED) { if (deleted_index != table->nslots) deleted_index = index; } else if (node->hash_value == hash && HT_LEN (node) == (unsigned int) len && !memcmp (HT_STR (node), str, len)) return node; } } if (insert == HT_NO_INSERT) return NULL; /* We prefer to overwrite the first deleted slot we saw. */ if (deleted_index != table->nslots) index = deleted_index; node = (*table->alloc_node) (table); table->entries[index] = node; HT_LEN (node) = (unsigned int) len; node->hash_value = hash; if (table->alloc_subobject) { char *chars = (char *) table->alloc_subobject (len + 1); memcpy (chars, str, len); chars[len] = '\0'; HT_STR (node) = (const unsigned char *) chars; } else HT_STR (node) = (const unsigned char *) obstack_copy0 (&table->stack, str, len); if (++table->nelements * 4 >= table->nslots * 3) /* Must expand the string table. */ ht_expand (table); return node; }