trustbridge/nss-cmake-static: nspr/lib/ds/plhash.c comparison

comparison nspr/lib/ds/plhash.c @ 0:1e5118fa0cb1

This is NSS with a Cmake Buildsyste To compile a static NSS library for Windows we've used the Chromium-NSS fork and added a Cmake buildsystem to compile it statically for Windows. See README.chromium for chromium changes and README.trustbridge for our modifications.

author	Andre Heinecke <andre.heinecke@intevation.de>
date	Mon, 28 Jul 2014 10:47:06 +0200
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:1e5118fa0cb1
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+* PL hash table package.
+*/
+#include "plhash.h"
+#include "prbit.h"
+#include "prlog.h"
+#include "prmem.h"
+#include "prtypes.h"
+#include <stdlib.h>
+#include <string.h>
+/* Compute the number of buckets in ht */
+#define NBUCKETS(ht)    (1 << (PL_HASH_BITS - (ht)->shift))
+/* The smallest table has 16 buckets */
+#define MINBUCKETSLOG2  4
+#define MINBUCKETS      (1 << MINBUCKETSLOG2)
+/* Compute the maximum entries given n buckets that we will tolerate, ~90% */
+#define OVERLOADED(n)   ((n) - ((n) >> 3))
+/* Compute the number of entries below which we shrink the table by half */
+#define UNDERLOADED(n)  (((n) > MINBUCKETS) ? ((n) >> 2) : 0)
+/*
+** Stubs for default hash allocator ops.
+*/
+static void * PR_CALLBACK
+DefaultAllocTable(void *pool, PRSize size)
+{
+return PR_MALLOC(size);
+}
+static void PR_CALLBACK
+DefaultFreeTable(void *pool, void *item)
+{
+PR_Free(item);
+}
+static PLHashEntry * PR_CALLBACK
+DefaultAllocEntry(void *pool, const void *key)
+{
+return PR_NEW(PLHashEntry);
+}
+static void PR_CALLBACK
+DefaultFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
+{
+if (flag == HT_FREE_ENTRY)
+PR_Free(he);
+}
+static PLHashAllocOps defaultHashAllocOps = {
+DefaultAllocTable, DefaultFreeTable,
+DefaultAllocEntry, DefaultFreeEntry
+};
+PR_IMPLEMENT(PLHashTable *)
+PL_NewHashTable(PRUint32 n, PLHashFunction keyHash,
+PLHashComparator keyCompare, PLHashComparator valueCompare,
+const PLHashAllocOps *allocOps, void *allocPriv)
+{
+PLHashTable *ht;
+PRSize nb;
+if (n <= MINBUCKETS) {
+n = MINBUCKETSLOG2;
+} else {
+n = PR_CeilingLog2(n);
+if ((PRInt32)n < 0)
+return 0;
+}
+if (!allocOps) allocOps = &defaultHashAllocOps;
+ht = (PLHashTable*)((*allocOps->allocTable)(allocPriv, sizeof *ht));
+if (!ht)
+	return 0;
+memset(ht, 0, sizeof *ht);
+ht->shift = PL_HASH_BITS - n;
+n = 1 << n;
+nb = n * sizeof(PLHashEntry *);
+ht->buckets = (PLHashEntry**)((*allocOps->allocTable)(allocPriv, nb));
+if (!ht->buckets) {
+(*allocOps->freeTable)(allocPriv, ht);
+return 0;
+}
+memset(ht->buckets, 0, nb);
+ht->keyHash = keyHash;
+ht->keyCompare = keyCompare;
+ht->valueCompare = valueCompare;
+ht->allocOps = allocOps;
+ht->allocPriv = allocPriv;
+return ht;
+}
+PR_IMPLEMENT(void)
+PL_HashTableDestroy(PLHashTable *ht)
+{
+PRUint32 i, n;
+PLHashEntry *he, *next;
+const PLHashAllocOps *allocOps = ht->allocOps;
+void *allocPriv = ht->allocPriv;
+n = NBUCKETS(ht);
+for (i = 0; i < n; i++) {
+for (he = ht->buckets[i]; he; he = next) {
+next = he->next;
+(*allocOps->freeEntry)(allocPriv, he, HT_FREE_ENTRY);
+}
+}
+#ifdef DEBUG
+memset(ht->buckets, 0xDB, n * sizeof ht->buckets[0]);
+#endif
+(*allocOps->freeTable)(allocPriv, ht->buckets);
+#ifdef DEBUG
+memset(ht, 0xDB, sizeof *ht);
+#endif
+(*allocOps->freeTable)(allocPriv, ht);
+}
+/*
+** Multiplicative hash, from Knuth 6.4.
+*/
+#define GOLDEN_RATIO    0x9E3779B9U  /* 2/(1+sqrt(5))*(2^32) */
+PR_IMPLEMENT(PLHashEntry **)
+PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key)
+{
+PLHashEntry *he, **hep, **hep0;
+PLHashNumber h;
+#ifdef HASHMETER
+ht->nlookups++;
+#endif
+h = keyHash * GOLDEN_RATIO;
+h >>= ht->shift;
+hep = hep0 = &ht->buckets[h];
+while ((he = *hep) != 0) {
+if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key)) {
+/* Move to front of chain if not already there */
+if (hep != hep0) {
+*hep = he->next;
+he->next = *hep0;
+*hep0 = he;
+}
+return hep0;
+}
+hep = &he->next;
+#ifdef HASHMETER
+ht->nsteps++;
+#endif
+}
+return hep;
+}
+/*
+** Same as PL_HashTableRawLookup but doesn't reorder the hash entries.
+*/
+PR_IMPLEMENT(PLHashEntry **)
+PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash,
+const void *key)
+{
+PLHashEntry *he, **hep;
+PLHashNumber h;
+#ifdef HASHMETER
+ht->nlookups++;
+#endif
+h = keyHash * GOLDEN_RATIO;
+h >>= ht->shift;
+hep = &ht->buckets[h];
+while ((he = *hep) != 0) {
+if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key)) {
+break;
+}
+hep = &he->next;
+#ifdef HASHMETER
+ht->nsteps++;
+#endif
+}
+return hep;
+}
+PR_IMPLEMENT(PLHashEntry *)
+PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep,
+PLHashNumber keyHash, const void *key, void *value)
+{
+PRUint32 i, n;
+PLHashEntry *he, *next, **oldbuckets;
+PRSize nb;
+/* Grow the table if it is overloaded */
+n = NBUCKETS(ht);
+if (ht->nentries >= OVERLOADED(n)) {
+oldbuckets = ht->buckets;
+nb = 2 * n * sizeof(PLHashEntry *);
+ht->buckets = (PLHashEntry**)
+((*ht->allocOps->allocTable)(ht->allocPriv, nb));
+if (!ht->buckets) {
+ht->buckets = oldbuckets;
+return 0;
+}
+memset(ht->buckets, 0, nb);
+#ifdef HASHMETER
+ht->ngrows++;
+#endif
+ht->shift--;
+for (i = 0; i < n; i++) {
+for (he = oldbuckets[i]; he; he = next) {
+next = he->next;
+hep = PL_HashTableRawLookup(ht, he->keyHash, he->key);
+PR_ASSERT(*hep == 0);
+he->next = 0;
+*hep = he;
+}
+}
+#ifdef DEBUG
+memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
+#endif
+(*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
+hep = PL_HashTableRawLookup(ht, keyHash, key);
+}
+/* Make a new key value entry */
+he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
+if (!he)
+	return 0;
+he->keyHash = keyHash;
+he->key = key;
+he->value = value;
+he->next = *hep;
+*hep = he;
+ht->nentries++;
+return he;
+}
+PR_IMPLEMENT(PLHashEntry *)
+PL_HashTableAdd(PLHashTable *ht, const void *key, void *value)
+{
+PLHashNumber keyHash;
+PLHashEntry *he, **hep;
+keyHash = (*ht->keyHash)(key);
+hep = PL_HashTableRawLookup(ht, keyHash, key);
+if ((he = *hep) != 0) {
+/* Hit; see if values match */
+if ((*ht->valueCompare)(he->value, value)) {
+/* key,value pair is already present in table */
+return he;
+}
+if (he->value)
+(*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
+he->value = value;
+return he;
+}
+return PL_HashTableRawAdd(ht, hep, keyHash, key, value);
+}
+PR_IMPLEMENT(void)
+PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he)
+{
+PRUint32 i, n;
+PLHashEntry *next, **oldbuckets;
+PRSize nb;
+*hep = he->next;
+(*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
+/* Shrink table if it's underloaded */
+n = NBUCKETS(ht);
+if (--ht->nentries < UNDERLOADED(n)) {
+oldbuckets = ht->buckets;
+nb = n * sizeof(PLHashEntry*) / 2;
+ht->buckets = (PLHashEntry**)(
+(*ht->allocOps->allocTable)(ht->allocPriv, nb));
+if (!ht->buckets) {
+ht->buckets = oldbuckets;
+return;
+}
+memset(ht->buckets, 0, nb);
+#ifdef HASHMETER
+ht->nshrinks++;
+#endif
+ht->shift++;
+for (i = 0; i < n; i++) {
+for (he = oldbuckets[i]; he; he = next) {
+next = he->next;
+hep = PL_HashTableRawLookup(ht, he->keyHash, he->key);
+PR_ASSERT(*hep == 0);
+he->next = 0;
+*hep = he;
+}
+}
+#ifdef DEBUG
+memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
+#endif
+(*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
+}
+}
+PR_IMPLEMENT(PRBool)
+PL_HashTableRemove(PLHashTable *ht, const void *key)
+{
+PLHashNumber keyHash;
+PLHashEntry *he, **hep;
+keyHash = (*ht->keyHash)(key);
+hep = PL_HashTableRawLookup(ht, keyHash, key);
+if ((he = *hep) == 0)
+return PR_FALSE;
+/* Hit; remove element */
+PL_HashTableRawRemove(ht, hep, he);
+return PR_TRUE;
+}
+PR_IMPLEMENT(void *)
+PL_HashTableLookup(PLHashTable *ht, const void *key)
+{
+PLHashNumber keyHash;
+PLHashEntry *he, **hep;
+keyHash = (*ht->keyHash)(key);
+hep = PL_HashTableRawLookup(ht, keyHash, key);
+if ((he = *hep) != 0) {
+return he->value;
+}
+return 0;
+}
+/*
+** Same as PL_HashTableLookup but doesn't reorder the hash entries.
+*/
+PR_IMPLEMENT(void *)
+PL_HashTableLookupConst(PLHashTable *ht, const void *key)
+{
+PLHashNumber keyHash;
+PLHashEntry *he, **hep;
+keyHash = (*ht->keyHash)(key);
+hep = PL_HashTableRawLookupConst(ht, keyHash, key);
+if ((he = *hep) != 0) {
+return he->value;
+}
+return 0;
+}
+/*
+** Iterate over the entries in the hash table calling func for each
+** entry found. Stop if "f" says to (return value & PR_ENUMERATE_STOP).
+** Return a count of the number of elements scanned.
+*/
+PR_IMPLEMENT(int)
+PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg)
+{
+PLHashEntry *he, **hep;
+PRUint32 i, nbuckets;
+int rv, n = 0;
+PLHashEntry *todo = 0;
+nbuckets = NBUCKETS(ht);
+for (i = 0; i < nbuckets; i++) {
+hep = &ht->buckets[i];
+while ((he = *hep) != 0) {
+rv = (*f)(he, n, arg);
+n++;
+if (rv & (HT_ENUMERATE_REMOVE | HT_ENUMERATE_UNHASH)) {
+*hep = he->next;
+if (rv & HT_ENUMERATE_REMOVE) {
+he->next = todo;
+todo = he;
+}
+} else {
+hep = &he->next;
+}
+if (rv & HT_ENUMERATE_STOP) {
+goto out;
+}
+}
+}
+out:
+hep = &todo;
+while ((he = *hep) != 0) {
+PL_HashTableRawRemove(ht, hep, he);
+}
+return n;
+}
+#ifdef HASHMETER
+#include <math.h>
+#include <stdio.h>
+PR_IMPLEMENT(void)
+PL_HashTableDumpMeter(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
+{
+double mean, variance;
+PRUint32 nchains, nbuckets;
+PRUint32 i, n, maxChain, maxChainLen;
+PLHashEntry *he;
+variance = 0;
+nchains = 0;
+maxChainLen = 0;
+nbuckets = NBUCKETS(ht);
+for (i = 0; i < nbuckets; i++) {
+he = ht->buckets[i];
+if (!he)
+continue;
+nchains++;
+for (n = 0; he; he = he->next)
+n++;
+variance += n * n;
+if (n > maxChainLen) {
+maxChainLen = n;
+maxChain = i;
+}
+}
+mean = (double)ht->nentries / nchains;
+variance = fabs(variance / nchains - mean * mean);
+fprintf(fp, "\nHash table statistics:\n");
+fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
+fprintf(fp, "     number of entries: %u\n", ht->nentries);
+fprintf(fp, "       number of grows: %u\n", ht->ngrows);
+fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
+fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
+/ ht->nlookups);
+fprintf(fp, "mean hash chain length: %g\n", mean);
+fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
+fprintf(fp, " max hash chain length: %u\n", maxChainLen);
+fprintf(fp, "        max hash chain: [%u]\n", maxChain);
+for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
+if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
+break;
+}
+#endif /* HASHMETER */
+PR_IMPLEMENT(int)
+PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
+{
+int count;
+count = PL_HashTableEnumerateEntries(ht, dump, fp);
+#ifdef HASHMETER
+PL_HashTableDumpMeter(ht, dump, fp);
+#endif
+return count;
+}
+PR_IMPLEMENT(PLHashNumber)
+PL_HashString(const void *key)
+{
+PLHashNumber h;
+const PRUint8 *s;
+h = 0;
+for (s = (const PRUint8*)key; *s; s++)
+h = PR_ROTATE_LEFT32(h, 4) ^ *s;
+return h;
+}
+PR_IMPLEMENT(int)
+PL_CompareStrings(const void *v1, const void *v2)
+{
+return strcmp((const char*)v1, (const char*)v2) == 0;
+}
+PR_IMPLEMENT(int)
+PL_CompareValues(const void *v1, const void *v2)
+{
+return v1 == v2;
+}

Mercurial > trustbridge > nss-cmake-static

comparison nspr/lib/ds/plhash.c @ 0:1e5118fa0cb1