From 5b2c2e1985cb6d48dacc1271ff611479e24190e8 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Sun, 20 Oct 2013 20:17:48 -0700 Subject: [PATCH] Bug 927705 (part 1) - Remove PL_DHashTableSetAlphaBounds() and the supporting machinery. r=jorendorff. --HG-- extra : rebase_source : 0b97b3276ec91d417fcfc12fe871d93b0cbd2263 --- xpcom/glue/pldhash.cpp | 69 ++++++++---------------------------------- xpcom/glue/pldhash.h | 52 ++----------------------------- 2 files changed, 15 insertions(+), 106 deletions(-) diff --git a/xpcom/glue/pldhash.cpp b/xpcom/glue/pldhash.cpp index f491715a223b..d5b911f30bdb 100644 --- a/xpcom/glue/pldhash.cpp +++ b/xpcom/glue/pldhash.cpp @@ -220,8 +220,6 @@ PL_DHashTableInit(PLDHashTable *table, const PLDHashTableOps *ops, void *data, if (capacity >= PL_DHASH_SIZE_LIMIT) return false; table->hashShift = PL_DHASH_BITS - log2; - table->maxAlphaFrac = (uint8_t)(0x100 * PL_DHASH_DEFAULT_MAX_ALPHA); - table->minAlphaFrac = (uint8_t)(0x100 * PL_DHASH_DEFAULT_MIN_ALPHA); table->entrySize = entrySize; table->entryCount = table->removedCount = 0; table->generation = 0; @@ -242,54 +240,13 @@ PL_DHashTableInit(PLDHashTable *table, const PLDHashTableOps *ops, void *data, } /* - * Compute max and min load numbers (entry counts) from table params. + * Compute max and min load numbers (entry counts). */ -#define MAX_LOAD(table, size) (((table)->maxAlphaFrac * (size)) >> 8) -#define MIN_LOAD(table, size) (((table)->minAlphaFrac * (size)) >> 8) - -void -PL_DHashTableSetAlphaBounds(PLDHashTable *table, - float maxAlpha, - float minAlpha) -{ - uint32_t size; - - /* - * Reject obviously insane bounds, rather than trying to guess what the - * buggy caller intended. - */ - NS_ASSERTION(0.5 <= maxAlpha && maxAlpha < 1 && 0 <= minAlpha, - "0.5 <= maxAlpha && maxAlpha < 1 && 0 <= minAlpha"); - if (maxAlpha < 0.5 || 1 <= maxAlpha || minAlpha < 0) - return; - - /* - * Ensure that at least one entry will always be free. If maxAlpha at - * minimum size leaves no entries free, reduce maxAlpha based on minimum - * size and the precision limit of maxAlphaFrac's fixed point format. - */ - NS_ASSERTION(PL_DHASH_MIN_SIZE - (maxAlpha * PL_DHASH_MIN_SIZE) >= 1, - "PL_DHASH_MIN_SIZE - (maxAlpha * PL_DHASH_MIN_SIZE) >= 1"); - if (PL_DHASH_MIN_SIZE - (maxAlpha * PL_DHASH_MIN_SIZE) < 1) { - maxAlpha = (float) - (PL_DHASH_MIN_SIZE - XPCOM_MAX(PL_DHASH_MIN_SIZE / 256, 1)) - / PL_DHASH_MIN_SIZE; - } - - /* - * Ensure that minAlpha is strictly less than half maxAlpha. Take care - * not to truncate an entry's worth of alpha when storing in minAlphaFrac - * (8-bit fixed point format). - */ - NS_ASSERTION(minAlpha < maxAlpha / 2, - "minAlpha < maxAlpha / 2"); - if (minAlpha >= maxAlpha / 2) { - size = PL_DHASH_TABLE_SIZE(table); - minAlpha = (size * maxAlpha - XPCOM_MAX(size / 256, 1u)) / (2 * size); - } - - table->maxAlphaFrac = (uint8_t)(maxAlpha * 256); - table->minAlphaFrac = (uint8_t)(minAlpha * 256); +static inline uint32_t MaxLoad(uint32_t size) { + return size - (size >> 2); // == size * 0.75 +} +static inline uint32_t MinLoad(uint32_t size) { + return size >> 2; // == size * 0.25 } /* @@ -592,7 +549,7 @@ PL_DHashTableOperate(PLDHashTable *table, const void *key, PLDHashOperator op) * are on the edge of being overloaded. */ size = PL_DHASH_TABLE_SIZE(table); - if (table->entryCount + table->removedCount >= MAX_LOAD(table, size)) { + if (table->entryCount + table->removedCount >= MaxLoad(size)) { /* Compress if a quarter or more of all entries are removed. */ if (table->removedCount >= size >> 2) { METER(table->stats.compresses++); @@ -650,7 +607,7 @@ PL_DHashTableOperate(PLDHashTable *table, const void *key, PLDHashOperator op) /* Shrink if alpha is <= .25 and table isn't too small already. */ size = PL_DHASH_TABLE_SIZE(table); if (size > PL_DHASH_MIN_SIZE && - table->entryCount <= MIN_LOAD(table, size)) { + table->entryCount <= MinLoad(size)) { METER(table->stats.shrinks++); (void) ChangeTable(table, -1); } @@ -726,15 +683,15 @@ PL_DHashTableEnumerate(PLDHashTable *table, PLDHashEnumerator etor, void *arg) /* * Shrink or compress if a quarter or more of all entries are removed, or - * if the table is underloaded according to the configured minimum alpha, - * and is not minimal-size already. Do this only if we removed above, so - * non-removing enumerations can count on stable table->entryStore until - * the next non-lookup-Operate or removing-Enumerate. + * if the table is underloaded according to the minimum alpha, and is not + * minimal-size already. Do this only if we removed above, so non-removing + * enumerations can count on stable table->entryStore until the next + * non-lookup-Operate or removing-Enumerate. */ if (didRemove && (table->removedCount >= capacity >> 2 || (capacity > PL_DHASH_MIN_SIZE && - table->entryCount <= MIN_LOAD(table, capacity)))) { + table->entryCount <= MinLoad(capacity)))) { METER(table->stats.enumShrinks++); capacity = table->entryCount; capacity += capacity >> 1; diff --git a/xpcom/glue/pldhash.h b/xpcom/glue/pldhash.h index ac4c00f52f9b..f0a7fcadc518 100644 --- a/xpcom/glue/pldhash.h +++ b/xpcom/glue/pldhash.h @@ -28,7 +28,7 @@ extern "C" { #define PL_DHASHMETER 1 #endif -/* Table size limit, do not equal or exceed (see min&maxAlphaFrac, below). */ +/* Table size limit, do not equal or exceed. */ #undef PL_DHASH_SIZE_LIMIT #define PL_DHASH_SIZE_LIMIT ((uint32_t)1 << 24) @@ -159,7 +159,7 @@ PL_DHASH_ENTRY_IS_LIVE(PLDHashEntryHdr* entry) * assuming esize is not too large (in which case, chaining should probably be * used for any alpha). For esize=2 and k=3, we want alpha >= .2; for esize=3 * and k=2, we want alpha >= .4. For k=4, esize could be 6, and alpha >= .5 - * would still obtain. See the PL_DHASH_MIN_ALPHA macro further below. + * would still obtain. * * The current implementation uses a configurable lower bound on alpha, which * defaults to .25, when deciding to shrink the table (while still respecting @@ -180,8 +180,6 @@ struct PLDHashTable { const PLDHashTableOps *ops; /* virtual operations, see below */ void *data; /* ops- and instance-specific data */ int16_t hashShift; /* multiplicative hash shift */ - uint8_t maxAlphaFrac; /* 8-bit fixed point max alpha */ - uint8_t minAlphaFrac; /* 8-bit fixed point min alpha */ uint32_t entrySize; /* number of bytes in an entry */ uint32_t entryCount; /* number of entries in table */ uint32_t removedCount; /* removed entry sentinels in table */ @@ -402,52 +400,6 @@ NS_COM_GLUE bool PL_DHashTableInit(PLDHashTable *table, const PLDHashTableOps *ops, void *data, uint32_t entrySize, uint32_t capacity); -/* - * Set maximum and minimum alpha for table. The defaults are 0.75 and .25. - * maxAlpha must be in [0.5, 0.9375] for the default PL_DHASH_MIN_SIZE; or if - * MinSize=PL_DHASH_MIN_SIZE <= 256, in [0.5, (float)(MinSize-1)/MinSize]; or - * else in [0.5, 255.0/256]. minAlpha must be in [0, maxAlpha / 2), so that - * we don't shrink on the very next remove after growing a table upon adding - * an entry that brings entryCount past maxAlpha * tableSize. - */ -NS_COM_GLUE void -PL_DHashTableSetAlphaBounds(PLDHashTable *table, - float maxAlpha, - float minAlpha); - -/* - * Call this macro with k, the number of pointer-sized words wasted per entry - * under chaining, to compute the minimum alpha at which double hashing still - * beats chaining. - */ -#define PL_DHASH_MIN_ALPHA(table, k) \ - ((float)((table)->entrySize / sizeof(void *) - 1) \ - / ((table)->entrySize / sizeof(void *) + (k))) - -/* - * Default max/min alpha, and macros to compute the value for the |capacity| - * parameter to PL_NewDHashTable and PL_DHashTableInit, given default or any - * max alpha, such that adding entryCount entries right after initializing the - * table will not require a reallocation (so PL_DHASH_ADD can't fail for those - * PL_DHashTableOperate calls). - * - * NB: PL_DHASH_CAP is a helper macro meant for use only in PL_DHASH_CAPACITY. - * Don't use it directly! - */ -#define PL_DHASH_DEFAULT_MAX_ALPHA 0.75 -#define PL_DHASH_DEFAULT_MIN_ALPHA 0.25 - -#define PL_DHASH_CAP(entryCount, maxAlpha) \ - ((uint32_t)((double)(entryCount) / (maxAlpha))) - -#define PL_DHASH_CAPACITY(entryCount, maxAlpha) \ - (PL_DHASH_CAP(entryCount, maxAlpha) + \ - (((PL_DHASH_CAP(entryCount, maxAlpha) * (uint8_t)(0x100 * (maxAlpha))) \ - >> 8) < (entryCount))) - -#define PL_DHASH_DEFAULT_CAPACITY(entryCount) \ - PL_DHASH_CAPACITY(entryCount, PL_DHASH_DEFAULT_MAX_ALPHA) - /* * Finalize table's data, free its entry storage using table->ops->freeTable, * and leave its members unchanged from their last live values (which leaves