|
|
2000/11-------* Refactored the code* Public API* C API* Kernel-mode support* Fixed a deadlock bug in the table lock. If you explicitly call Table::ReadLock and Table::WriteLock, you >need< this fix, or you will deadlock under stress.* Fixed a bug in table compaction: until now, the table never actually compacted after elements were deleted, as the test for compaction always evaluated to `false'.* Changed the signature of AddRefRecord. The second parameter is now an LK_ADDREF_REASON, instead of an int whose value is +1 or -1. The reason code aids in debugging refcount leaks. If its value is negative, the refcount should be decremented; otherwise the refcount should be incremented.* Changed behavior of ApplyIf locking: now locks one subtable at a time, instead of all subtables. Can use ReadLock or WriteLock to retain old behavior.* Changed names and signatures of void LKRHashTableInit() and void LKRHashTableUninit(), to BOOL LKR_Initialize(DWORD) and void LKR_Terminate(), respectively.
2000/07/31----------* >REALLY< fixed the bug in Clear that left certain internal state variables in an inconsistent state. If you later inserted/deleted enough new records, LKRhash would AV. (The fix in the 2000/03/22 release did not work in all cases.)
2000/04/24----------* I added support for STL-style iterators * New iterators DO NOT LOCK the table or a bucket chain. In a multithreaded situation, it is YOUR responsibility to call WriteLock (or ReadLock) on the table before initializing any iterators, and to call WriteUnlock (or ReadUnlock) when you are finished. * The table provides begin() and end() methods. As the compiler isn't quite smart enough to realize that end() always returns a trivial empty iterator, a loop such as MyTable::iterator iter; for (iter = pTbl->begin(); iter != pTbl->end(); ++iter) ... is more efficiently expressed as MyTable::iterator iter; MyTable::iterator iterEnd = pTbl->end(); for (iter = pTbl->begin(); iter != iterEnd; ++iter) ... * iterators can be pre- and post-incremented; i.e.: ++iter and iter++ Pre-increment is more efficient. * Table provides a constructor that accepts a range of iterators into another container. * Provides an Insert method that returns an iterator, pointing to the newly inserted record, or end() on failure. * Provides a Find method that returns an iterator pointing to the record with the passed-in key, or end() on failure. * Provides an EqualRange method that returns two iterators describing the range that contain all the records whose keys match the passed-in key. Until full support for multiple, identical keys is added, the range will contain either zero or one record(s). * Provides an Erase method that deletes the record pointed to by the iterator. Updates the iterator to point to the next record in the table. * Provides an Erase method that takes two iterators, which will delete all the records in the range described by the two iterators. * Unlike the old, deprecated iterators (CIterator), more than one iterator can be active at a time. It is best not to call the non-iterator insert/delete methods (InsertRecord, DeleteRecord, DeleteKey) while iterators are open, as the non-iterator methods can rebalance bucket chains, leading to invalid iterators, undercounting, and/or overcounting. This is true even if the table was WriteLocked, before the iterators were initialized. It is best to use the iterator Insert or Erase methods in such a case. * The iterators are reference-counted.
* I have provided an NTSD/CDB debugger extension, lkrdbg.dll, with one method, !lkrdbg.lkrhash: * !lkrhash -l[0-2] <addr> will dump the hashtable at <addr> at verbosity level l (default 0) * !lkrhash -g[0-2] will dump ALL hashtables at at verbosity level l (default 0) * I have provided an easy-to-use customization mechanism in <lkrcust.h> to provide custom dumps for different hashtables. It's keyed off the pszName parameter used in the hashtable constructor. You can provide a custom dump routine for the table (to dump whatever other fields you might have added), as well as a custom dump routine for the record class stored by the hashtable. Provided three examples of customization, based on the samples.
* Fixed various build issues * All debug code is now bracketed with #ifdef IRTLDEBUG (instead of #ifdef _DEBUG). Currently equivalent, but you can control this in <irtldbg.h> * Fix all Unicode build issues. Code is now TCHAR-aware. * Added lkrhash.rc to provide a version resource
* Turned on `LKRhash' and `HashFn' namespaces by default. See readme.txt.* Reorganized the samples into their own subtree.* Removed more old code that used to be present so that I could test some changes (e.g., stuff bracketed by LKR_OLD_SEGMENT, LKR_SIGS_NODES, etc).* Bucket Lock is once again CSmallSpinLock, unless LKR_DEPRECATED_ITERATORS is defined (off by default).* Moved a lot of nested classes out of the table classes, to be top-level classes.* Better compile-time and run-time assertions.
2000/03/22----------* Fixed a bug in Clear that left certain internal state variables in an inconsistent state. If you later inserted/deleted enough new records, LKRhash would AV.* Changed BucketLock to CReaderWriterLock3 (recursive MRSW lock) to support certain scenarios, such as being able to call FindKey while enumerating with an old-style iterator. Slightly slower, but the speed improvements below more than compensate.* Removed the 300-line example from the end of lkrhash.h. Now in hashtest.cpp, bracketed by SAMPLE_LKRHASH_TESTCLASS.* Replaced TRACE macro with IRTLTRACE so as not to interfere with other TRACE macros (e.g., MFC's)* Added dirs and sources files so that you can build LKRhash with the NT build environment.* Added STATIC_ASSERT macro for compile-time assertions. The IRTLASSERT macro is still used for run-time assertions.* Removed old code that used to be present so that I could test some changes (e.g., stuff bracketed by LKR_NEWCODE, LKR_MASK, LKR_SUBTABLE, LKR_COMPACT_DELETE, etc)* Upped LK_DFLT_MAXLOAD to 6 (NODES_PER_CLUMP) to get better memory usage* Added support for RockAll (not enabled by default)* Turned CSegment into a concrete base class. Somewhat hacky but faster.* Made the locks a little faster, esp. CReaderWriterLock3::IsWriteLocked* Experimented with countdown loops (turned out to be slightly slower).* Experimented with bitwise scrambling for subtable index calculation. Faster.* Experimented with using a bitwise mask for subtable index calculation. Faster.* Removed some inlines from lkrhash.h to improve modularity.* Removed unimplemented Print methods.* Bracketed global lists of hashtables with LKR_NO_GLOBAL_LIST.* Reduced number of subtables to min(1, #CPUs) for LK_SMALL_TABLESIZE Was min(2, #CPUs). Max number of subtables is now 64.
1999/11/04----------* New reader-writer locks* Smarter, faster simple spinlocks* compact delete* debugging support* increased default load factor from 4.0 to 5.0 after reducing size of spinlock => reduced memory usage* deprecated CIterator* better error checking* Win64 clean* expose table locks => composition of operations* global list* faster hash scrambling function* won't fail messily in low-memory situations* fixed a race condition in some of the assertions* enhanced test program
|
