Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-30 00:01:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1180072 - Remove PL_DHashTableEnumerate(). r=froydnj.

Browse Source 
It's no longer used, and the Iterator classes are much nicer. Yay.
This commit is contained in:
Nicholas Nethercote 2015-06-18 22:19:10 -07:00
parent 09a56713cb
commit b6a6d26147
3 changed files with 14 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
xpcom/glue/nsTHashtable.h
View File

@ -71,6 +71,16 @@
* @author "Benjamin Smedberg <bsmedberg@covad.net>"
*/
// These are the codes returned by |Enumerator| functions, which control
// EnumerateEntry()'s behavior. The PLD/PL_D prefix is because they originated
// in PLDHashTable, but that class no longer uses them.
enum PLDHashOperator
{
PL_DHASH_NEXT = 0, // enumerator says continue
PL_DHASH_STOP = 1, // enumerator says stop
PL_DHASH_REMOVE = 2 // enumerator says remove
};
template<class EntryType>
class nsTHashtable
{
@ -191,7 +201,10 @@ public:
typedef PLDHashOperator (*Enumerator)(EntryType* aEntry, void* userArg);
/**
* Enumerate all the entries of the function.
* Enumerate all the entries of the function. If any entries are removed via
* a PL_DHASH_REMOVE return value from |aEnumFunc|, the table may be shrunk
* at the end. Use RawRemoveEntry() instead if you wish to remove an entry
* without possibly shrinking the table.
* @param enumFunc the <code>Enumerator</code> function to call
* @param userArg a pointer to pass to the
* <code>Enumerator</code> function

70
xpcom/glue/pldhash.cpp
View File

@ -728,7 +728,6 @@ PLDHashTable::ShrinkIfAppropriate()
uint32_t capacity = Capacity();
if (mRemovedCount >= capacity >> 2 ||
(capacity > PL_DHASH_MIN_CAPACITY && mEntryCount <= MinLoad(capacity))) {
uint32_t log2;
BestCapacity(mEntryCount, &capacity, &log2);
@ -739,75 +738,6 @@ PLDHashTable::ShrinkIfAppropriate()
}
}
MOZ_ALWAYS_INLINE uint32_t
PLDHashTable::Enumerate(PLDHashEnumerator aEtor, void* aArg)
{
#ifdef DEBUG
// Enumerate() can be a read operation or a write operation, depending on
// whether PL_DHASH_REMOVE is used. Assume for now it's a read; once the
// enumeration is done we'll know if that is false, and if so,
// retrospectively check it as a write.
bool wasIdleAndWritableAtStart = mChecker.IsIdle() && mChecker.IsWritable();
AutoReadOp op(mChecker);
#endif
if (!mEntryStore) {
return 0;
}
char* entryAddr = mEntryStore;
uint32_t capacity = Capacity();
uint32_t tableSize = capacity * mEntrySize;
char* entryLimit = mEntryStore + tableSize;
uint32_t i = 0;
bool didRemove = false;
if (ChaosMode::isActive(ChaosMode::HashTableIteration)) {
// Start iterating at a random point in the hashtable. It would be
// even more chaotic to iterate in fully random order, but that's a lot
// more work.
entryAddr += ChaosMode::randomUint32LessThan(capacity) * mEntrySize;
}
for (uint32_t e = 0; e < capacity; ++e) {
PLDHashEntryHdr* entry = (PLDHashEntryHdr*)entryAddr;
if (ENTRY_IS_LIVE(entry)) {
PLDHashOperator op = aEtor(this, entry, i++, aArg);
if (op & PL_DHASH_REMOVE) {
PL_DHashTableRawRemove(this, entry);
didRemove = true;
}
if (op & PL_DHASH_STOP) {
break;
}
}
entryAddr += mEntrySize;
if (entryAddr >= entryLimit) {
entryAddr -= tableSize;
}
}
// This is the retrospective check mentioned above. If we removed anything,
// then the table should have been idle and writable before we did so.
MOZ_ASSERT_IF(didRemove, wasIdleAndWritableAtStart);
// Shrink the table if appropriate. Do this only if we removed above, so
// non-removing enumerations can count on stable |mEntryStore| until the next
// Add, Remove, or removing-Enumerate.
if (didRemove) {
ShrinkIfAppropriate();
}
return i;
}
uint32_t
PL_DHashTableEnumerate(PLDHashTable* aTable, PLDHashEnumerator aEtor,
void* aArg)
{
return aTable->Enumerate(aEtor, aArg);
}
MOZ_ALWAYS_INLINE size_t
PLDHashTable::SizeOfExcludingThis(
PLDHashSizeOfEntryExcludingThisFun aSizeOfEntryExcludingThis,

60
xpcom/glue/pldhash.h
View File

@ -83,60 +83,6 @@ private:
PLDHashNumber mKeyHash;
};
/*
* These are the codes returned by PLDHashEnumerator functions, which control
* PL_DHashTableEnumerate's behavior.
*/
enum PLDHashOperator
{
PL_DHASH_NEXT = 0, /* enumerator says continue */
PL_DHASH_STOP = 1, /* enumerator says stop */
PL_DHASH_REMOVE = 2 /* enumerator says remove */
};
/*
* Enumerate entries in table using etor:
*
* count = PL_DHashTableEnumerate(table, etor, arg);
*
* PL_DHashTableEnumerate calls etor like so:
*
* op = etor(table, entry, number, arg);
*
* where number is a zero-based ordinal assigned to live entries according to
* their order in aTable->mEntryStore.
*
* The return value, op, is treated as a set of flags. If op is PL_DHASH_NEXT,
* then continue enumerating. If op contains PL_DHASH_REMOVE, then clear (via
* aTable->mOps->clearEntry) and free entry. Then we check whether op contains
* PL_DHASH_STOP; if so, stop enumerating and return the number of live entries
* that were enumerated so far. Return the total number of live entries when
* enumeration completes normally.
*
* If etor calls PL_DHashTableAdd or PL_DHashTableRemove on table, it must
* return PL_DHASH_STOP; otherwise undefined behavior results.
*
* If any enumerator returns PL_DHASH_REMOVE, aTable->mEntryStore may be shrunk
* or compressed after enumeration, but before PL_DHashTableEnumerate returns.
* Such an enumerator therefore can't safely set aside entry pointers, but an
* enumerator that never returns PL_DHASH_REMOVE can set pointers to entries
* aside, e.g., to avoid copying live entries into an array of the entry type.
* Copying entry pointers is cheaper, and safe so long as the caller of such a
* "stable" Enumerate doesn't use the set-aside pointers after any call either
* to PL_DHashTableAdd or PL_DHashTableRemove, or to an "unstable" form of
* Enumerate, which might grow or shrink mEntryStore.
*
* If your enumerator wants to remove certain entries, but set aside pointers
* to other entries that it retains, it can use PL_DHashTableRawRemove on the
* entries to be removed, returning PL_DHASH_NEXT to skip them. Likewise, if
* you want to remove entries, but for some reason you do not want mEntryStore
* to be shrunk or compressed, you can call PL_DHashTableRawRemove safely on
* the entry being enumerated, rather than returning PL_DHASH_REMOVE.
*/
typedef PLDHashOperator (*PLDHashEnumerator)(PLDHashTable* aTable,
PLDHashEntryHdr* aHdr,
uint32_t aNumber, void* aArg);
typedef size_t (*PLDHashSizeOfEntryExcludingThisFun)(
PLDHashEntryHdr* aHdr, mozilla::MallocSizeOf aMallocSizeOf, void* aArg);
@ -372,8 +318,6 @@ public:
void RawRemove(PLDHashEntryHdr* aEntry);
uint32_t Enumerate(PLDHashEnumerator aEtor, void* aArg);
// This function is equivalent to
// ClearAndPrepareForLength(PL_DHASH_DEFAULT_INITIAL_LENGTH).
void Clear();
@ -676,10 +620,6 @@ PL_DHashTableRemove(PLDHashTable* aTable, const void* aKey);
*/
void PL_DHashTableRawRemove(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
uint32_t
PL_DHashTableEnumerate(PLDHashTable* aTable, PLDHashEnumerator aEtor,
void* aArg);
/**
* Measure the size of the table's entry storage, and if
* |aSizeOfEntryExcludingThis| is non-nullptr, measure the size of things