windows-xp/Source/XPSP1/NT/inetsrv/iis/lkrhash/samples/hashtest/hashtest.cpp

/*++

   Copyright    (c) 1998-2000    Microsoft Corporation

   Module  Name :
       HashTest.cpp

   Abstract:
       Test harness for LKRhash

   Author:
       George V. Reilly      (GeorgeRe)     06-Jan-1998

   Environment:
       Win32 - User Mode

   Project:
       Internet Information Server RunTime Library

   Revision History:

--*/

#include "precomp.hxx"



DECLARE_DEBUG_PRINTS_OBJECT();


#define HASHTEST_STATIC_DATA
#include "WordHash.h"
#include "IniFile.h"


void test_iterators(double highload, int initsize, int nsubtbls,
                    int nInsertIfNotFound);

#ifdef LKR_STL_ITERATORS
#pragma message("test STL iterators")
void test_stl_iterators(double highload, int initsize, int nsubtbls);
#endif // LKR_STL_ITERATORS

#ifndef LKRHASH_KERNEL_MODE
void print_table_statistics(const CLKRHashTableStats& stats);

# ifdef LOCK_INSTRUMENTATION
void print_lock_statistics(const CLKRHashTableStats &stats);
# endif
#endif // !LKRHASH_KERNEL_MODE

int  expand_key_set(int maxkeys, int numkeys, bool fVerbose) ;
#ifdef LKRHASH_KERNEL_MODE
void
#else
unsigned __stdcall
#endif
exercise_table(void *pinput);


// how many CPUs on this machine?
int
NumProcessors()
{
    static int s_nCPUs = 0;
    
    if (s_nCPUs == 0)
    {
#ifdef LKRHASH_KERNEL_MODE
        s_nCPUs = KeNumberProcessors;
#else  // !LKRHASH_KERNEL_MODE
        SYSTEM_INFO si;
        
        GetSystemInfo(&si);
        s_nCPUs = si.dwNumberOfProcessors;
#endif // !LKRHASH_KERNEL_MODE
    }
    return s_nCPUs;
}



// globals
int        g_nokeys=0 ;
CWord      g_wordtable[MAXKEYS];


bool
CheckRefCounts(
    LONG nRef,
    int iFirst =  0,
    int iLast  = -1)
{
    if (iLast == -1)
        iLast = g_nokeys;
    
    IRTLTRACE3("\nCheckRefCounts(%d, [%d,%d))\n", nRef, iFirst, iLast);
    bool f = true;

    for (int i = iFirst;  i != iLast;  ++i)
    {
        f = f && (g_wordtable[i].m_cRefs == nRef);
        if (g_wordtable[i].m_cRefs != nRef)
            IRTLTRACE4("\nCRC: %d, %hs, expected %d, got %d\n",
                      i, g_wordtable[i].m_str.m_psz, nRef,
                      g_wordtable[i].m_cRefs);
        IRTLASSERT(g_wordtable[i].m_cRefs == nRef);
    }

    return f;
}


bool CWordHash::sm_fCaseInsensitive = true;
bool CWordHash::sm_fMemCmp    = false;
int  CWordHash::sm_nLastChars = 16;
bool CWordHash::sm_fRefTrace  = false;
bool CWordHash::sm_fNonPagedAllocs = true;


struct thread_data
{
    CWordHash* ptbl ;

    int    threadno ;
    int    first_key ;
    int    last_key ;
    int    rounds ;
    int    lookup_freq ;
    float  highload ;

    int    cinserts ;
    int    cdeletes ;
    int    clookups ;
    int    cfailures ;
    int    m_nInsertIfNotFound;
    int    m_nFindKeyCopy;
    int    m_nSeed;            // random seed

    double duration ;
    HANDLE hevFinished;
    HANDLE hThread;
} ;



const TCHAR*
CommaNumber(
    int n,
    TCHAR* ptszBuff)
{
    TCHAR* ptsz = ptszBuff;
    TCHAR chComma = '\0';

    int aThousands[4];
    int iThousands = 0;
    unsigned int u = n;

    if (n < 0)
    {
        *ptsz++ = '-';
        u = -n;
    }

    do {
        aThousands[iThousands++] = u % 1000;
        u /= 1000;
    } while (u != 0);

    while (--iThousands >= 0)
    {
        u = aThousands[iThousands];

        if (chComma)
            *ptsz++ = chComma;

        unsigned d = u % 10;
        u /= 10;
        unsigned t = u % 10;
        u /= 10;
        unsigned h = u;

        if (h > 0  ||  chComma)
            *ptsz++ = h + '0';
        if (t > 0  ||  h > 0  ||  chComma)
            *ptsz++ = t + '0';
        *ptsz++ = d + '0';

        chComma = ',';
    }

    *ptsz = '\0';
        
    return ptszBuff;
}


#ifndef LKRHASH_KERNEL_MODE

typedef union {
    FILETIME ft;
    __int64  l64;
} FILETIME_UINT64;

# define FILETIME_1_SECOND     10000000
# define FILETIME_1_MILLISECOND   10000

HANDLE
HashTestCreateEvent()
{
    return CreateEvent(NULL,     // no security attributes
                       FALSE,    // auto reset
                       FALSE,    // not signalled
                       NULL);    // no name
}

void
HashTestResumeThread(
    HANDLE hThread)
{
    ResumeThread(hThread);
}

HANDLE
HashTestCreateThread(
    unsigned (__stdcall * pfnThreadProc) (void *),
    void* pvContext,
    bool  fSuspended)
{
    unsigned dummy;
    return (HANDLE) _beginthreadex(NULL, 0, pfnThreadProc, pvContext,
                                   fSuspended ? CREATE_SUSPENDED : 0,
                                   &dummy); 
}

DWORD
HashTestWaitForMultipleObjects(
    DWORD nCount,
    CONST HANDLE *lpHandles)
{
    return WaitForMultipleObjects(nCount, lpHandles, TRUE, INFINITE);
}

#else // LKRHASH_KERNEL_MODE

# define GetTickCount()         NtGetTickCount()
# define GetCurrentThread()     NtCurrentThread()

void
SetThreadIdealProcessor(
    HANDLE hThread,
    DWORD dwIdealProcessor
    )
{
    NtSetInformationThread(
                hThread,
                ThreadIdealProcessor,
                &dwIdealProcessor,
                sizeof(dwIdealProcessor)
                );
}

// non-threadsafe implementation of rand and srand, stolen from CRT
unsigned long _holdrand = 1234567890;

void __cdecl
srand(
    unsigned int seed)
{
    _holdrand = (unsigned long) seed;
}


int __cdecl
rand()
{
    return ((_holdrand = _holdrand * 214013L + 2531011L) >> 16) & 0x7fff;
}

HANDLE
HashTestCreateEvent()
{
    HANDLE hEvent = NULL;

    NTSTATUS status = NtCreateEvent(
        &hEvent,
        EVENT_ALL_ACCESS,
        NULL,
        SynchronizationEvent,
        FALSE);
    
    return hEvent;
}

void
HashTestResumeThread(
    HANDLE hThread)
{
    NtResumeThread(hThread, NULL);
}

HANDLE
HashTestCreateThread(
    void (* pfnThreadProc) (void *),
    void* pvContext,
    bool  fSuspended)
{
    NTSTATUS status;
    HANDLE threadHandle;
    OBJECT_ATTRIBUTES objectAttributes;

    //
    // Create the thread.
    //
    
    InitializeObjectAttributes(
        &objectAttributes,             // ObjectAttributes
        NULL,                          // ObjectName
        OBJ_KERNEL_HANDLE,             // Attributes
        NULL,                          // RootDirectory
        NULL                           // SecurityDescriptor
        );
    
    status = PsCreateSystemThread(
        &threadHandle,                 // ThreadHandle
        THREAD_ALL_ACCESS,             // DesiredAccess
        &objectAttributes,             // ObjectAttributes
        NULL,                          // ProcessHandle
        NULL,                          // ClientId
        pfnThreadProc,                 // StartRoutine
        pvContext                      // StartContext
        );

    if (!fSuspended)
        HashTestResumeThread(threadHandle);

    return threadHandle;
}

BOOL
CloseHandle(
    HANDLE h)
{
    return NT_SUCCESS(NtClose(h));
}

DWORD
HashTestWaitForMultipleObjects(
    DWORD nCount,
    CONST HANDLE *lpHandles)
{
    HANDLE ahHandles[MAX_THREADS+1];

    for (int i = 0;  i < nCount;  ++i)
        ahHandles[i] = lpHandles[i];
    
    return NtWaitForMultipleObjects((CHAR) nCount, ahHandles,
                                    WaitAll, FALSE, NULL);
}

BOOL
SetEvent(
    HANDLE hEvent)
{
    return NT_SUCCESS(NtSetEvent(hEvent, NULL));
}

#endif // LKRHASH_KERNEL_MODE



#ifdef _M_IX86
// Use RDTSC to read timestamp
void
GetCycleCount(
	LARGE_INTEGER *pliTimeStamp)
{
	ULONG Lo;
	LONG Hi;
	
	_asm {
		_emit 0x0f
		_emit 0x31
		mov Lo, eax
		mov Hi, edx
	} /* _asm */
	pliTimeStamp->LowPart = Lo;
	pliTimeStamp->HighPart = Hi;
}
#endif // _M_IX86


int
LKR_TestHashTable(
    CIniFileSettings& ifs)
{
    CWordHash    *pTbl ;
    int          num_threads ;
    thread_data  de_area[MAX_THREADS] ;
    HANDLE       ahEvents[MAX_THREADS];
    TCHAR        tsz[1024] ;
    FILE        *fp ;
    int          nodel=0;
    int          keys_per_thread ;
    int          i ;
    int          sum_ins, sum_dels, sum_lookups ;
    int          failures = 0, total_failures = 0;
    bool         fVerbose = false;
    double       dblSumDuration3 = 0;
    DWORD        dwRunTime = GetTickCount();
    int          nBaseOps = 0;

#ifdef _NO_TRACING_
    CREATE_DEBUG_PRINT_OBJECT("hashtest");
#endif

    SetThreadIdealProcessor(GetCurrentThread(), 0);

    _tprintf(_TEXT("\nTest driver for LKRhash\n")
#ifdef LKRHASH_KERNEL_MODE
           _TEXT(" (Kernel)")
#endif
#ifdef IRTLDEBUG
           _TEXT(" (Debug)")
#endif
#ifdef LKR_PUBLIC_API
           _TEXT(" (Public API)")
#else
           _TEXT(" (Internal API)")
#endif
#ifdef LKR_COUNTDOWN
           _TEXT(" (CountDown)")
#else
           _TEXT(" (CountUp)")
#endif
#ifdef LKR_CONTRACT
           _TEXT(" (Contraction)")
#else
           _TEXT(" (No Contraction)")
#endif
#ifdef LOCKS_SWITCH_TO_THREAD
           _TEXT(" (SwitchToThread)\n")
#endif
#ifdef LKR_DEPRECATED_ITERATORS
           _TEXT(" (Deprecated Iterators)")
#endif
#ifdef LKR_APPLY_IF
           _TEXT(" (ApplyIf)")
#endif
#ifdef LKR_EXPOSED_TABLE_LOCK
           _TEXT(" (Exposed Table Lock)")
#endif
#ifdef LKR_STL_ITERATORS
           _TEXT(" (STL-style Iterators")
# if LKR_STL_ITERATORS >= 2
           _TEXT(", verbose)")
# else
           _TEXT(")")
# endif
#else // !LKR_STL_ITERATORS
           _TEXT(" (No STL-style Iterators)")
#endif // !LKR_STL_ITERATORS
           _TEXT("\n\n")
           ) ;

#if defined(LKRHASH_ACACHE)
    const TCHAR tszAllocator[] = _TEXT("ACache");
#elif defined(LKRHASH_ROCKALL_FAST)
    const TCHAR tszAllocator[] = _TEXT("Rockall FAST_HEAP");
#elif defined(LKRHASH_PAGEDHEAP)
    const TCHAR tszAllocator[] = _TEXT("CPagedHeap");
#elif defined(LKRHASH_NONPAGEDHEAP)
    const TCHAR tszAllocator[] = _TEXT("CNonPagedHeap");
#elif defined(LKRHASH_NONPAGEDLOOKASIDE)
    const TCHAR tszAllocator[] = _TEXT("CNonPagedLookasideList");
#elif defined(LKRHASH_PAGEDLOOKASIDE)
    const TCHAR tszAllocator[] = _TEXT("CPagedLookasideList");
#else
    const TCHAR tszAllocator[] =
        _TEXT("Default allocator (global operator new)");
#endif

    _tprintf(_TEXT("%s version.\n"), tszAllocator);

#ifdef SAMPLE_LKRHASH_TESTCLASS
    Test(fVerbose);
    if (fVerbose)
        _tprintf(_TEXT("Test succeeded\n"));
#endif // SAMPLE_LKRHASH_TESTCLASS

    fp = _tfopen(ifs.m_tszDataFile, _TEXT("r") ) ;
    if (fp == NULL)
    {
        _tprintf(_TEXT("Can't open file `%s'.\n"), ifs.m_tszDataFile) ;
        return 1;
    }

    char sz[1024];

    _tprintf(_TEXT("Reading `%s' "), ifs.m_tszDataFile);
    for (g_nokeys = 0;  g_nokeys < ifs.m_nMaxKeys;  )
    {
        if (fgets(sz, sizeof(sz)/sizeof(sz[0]), fp) == NULL)
            break;
        int cch = strlen(sz);
        // TODO: check for duplicates
        if (cch > 0  &&  sz[cch-1] == '\n')
            sz[--cch] = '\0';
        if (cch >= MAX_STRSIZE)
            sz[MAX_STRSIZE-1] = '\0';
        if (cch > 0)
            g_wordtable[g_nokeys++].m_str.Set(sz, cch);
        if (g_nokeys % 10000 == 0)
            putchar('.');
    }

    fclose(fp) ;

    _tprintf(_TEXT("\nLoaded %s keys from `%s', "),
             CommaNumber(g_nokeys, tsz), ifs.m_tszDataFile);
    g_nokeys = expand_key_set(ifs.m_nMaxKeys, g_nokeys, true) ;
    _tprintf(_TEXT(" expanded to %s keys.\n\n"),
             CommaNumber(g_nokeys, tsz));

    int cchTotal = 0, cchMin = INT_MAX, cchMax = 0;
    for (i = 0;  i < g_nokeys;  ++i)
    {
        cchTotal += g_wordtable[i].m_str.m_cch;
        cchMin    = min(cchMin, g_wordtable[i].m_str.m_cch);
        cchMax    = max(cchMax, g_wordtable[i].m_str.m_cch);
    }

    srand(ifs.m_nSeed) ;

    _stprintf(tsz, _TEXT("%d"), ifs.m_nInitSize);
    if (ifs.m_nInitSize == LK_SMALL_TABLESIZE)
        _tcscpy(tsz, _TEXT("small"));
    else if (ifs.m_nInitSize == LK_MEDIUM_TABLESIZE)
        _tcscpy(tsz, _TEXT("medium"));
    else if (ifs.m_nInitSize == LK_LARGE_TABLESIZE)
        _tcscpy(tsz, _TEXT("large"));

    DWORD initsize2 = ifs.m_nInitSize;
    DWORD nsubtbls2 = ifs.m_nSubTables;
    LK_TABLESIZE lkts = CWordHash::NumSubTables(ifs.m_nInitSize, nsubtbls2);
    
    _tprintf(_TEXT("Max load=%.1f, initsize=%s, ")
             _TEXT("%d subtables (%d tables, size=%d, lkts=%d).\n"),
             ifs.m_dblHighLoad, tsz,
             ifs.m_nSubTables, nsubtbls2, initsize2, lkts);
    _tprintf(_TEXT("Lookup freq = %d, %d-%d threads, ")
             _TEXT("%d round%s.\n"),
             ifs.m_nLookupFreq, ifs.m_nMinThreads, ifs.m_nMaxThreads,
             ifs.m_nRounds, (ifs.m_nRounds==1 ? "" : "s"));
    _tprintf(_TEXT("%s keys from `%s'.\n"),
             CommaNumber(g_nokeys, tsz), ifs.m_tszDataFile);
    _tprintf(_TEXT("Key length: avg = %d, min = %d, max = %d.\n"),
             cchTotal / g_nokeys, cchMin, cchMax);
    _tprintf(_TEXT("Base Table = %s. Hash method = %s.\n"),
             CWordHash::ClassName(), CWordHash::HashMethod());
#ifdef LOCK_DEFAULT_SPIN_IMPLEMENTATION
# ifdef LKRHASH_GLOBAL_LOCK
    _tprintf(_TEXT("GlobalLock = %s, ")
             _TEXT("%d bytes, ")
             _TEXT("Spin Count = %hd, ")
             _TEXT("Adj Factor = %.1f.\n"),
             CWordHash::GlobalLock::ClassName(),
             sizeof(CWordHash::GlobalLock),
             ifs.m_wTableSpin,
             CWordHash::GlobalLock::GetDefaultSpinAdjustmentFactor());
# endif
    _tprintf(_TEXT("TableLock = %s, ")
             _TEXT("%d bytes, ")
             _TEXT("Spin Count = %hd, ")
             _TEXT("Adj Factor = %.1f.\n"),
             CWordHash::TableLock::ClassName(),
             sizeof(CWordHash::TableLock),
             ifs.m_wTableSpin,
             CWordHash::TableLock::GetDefaultSpinAdjustmentFactor());
    
    _tprintf(_TEXT("BucketLock = %s, ")
             _TEXT("%d bytes, ")
             _TEXT("Spin Count = %hd, ")
             _TEXT("Adj Factor = %.1f.\n"),
             CWordHash::BucketLock::ClassName(),
             sizeof(CWordHash::BucketLock),
             ifs.m_wBucketSpin,
             CWordHash::BucketLock::GetDefaultSpinAdjustmentFactor());
#endif // LOCK_DEFAULT_SPIN_IMPLEMENTATION
    
#ifdef LOCK_PER_LOCK_SPINCOUNTS
    _tprintf(_TEXT("Per"));
#else
    _tprintf(_TEXT("No per"));
#endif
    _tprintf(_TEXT("-lock spincounts.  #CPUs = %d.  Random seed = %d.  ")
             _TEXT("Nodes/Clump = %d.\n"),
             NumProcessors(), ifs.m_nSeed,
             CWordHash::NODES_PER_CLUMP
             );

    _tprintf(_TEXT("InsertIfNotFound = %d, FindKeyCopy = %d\n"),
             ifs.m_nInsertIfNotFound, ifs.m_nFindKeyCopy);
    _tprintf(_TEXT("NonPagedAllocs=%d, RefTrace=%d, Allocator=%s.\n"),
             ifs.m_fNonPagedAllocs, ifs.m_fRefTrace,
             CLKRhashAllocator::ClassName());

#ifndef LKRHASH_KERNEL_MODE
	time_t tmNow;
	time(&tmNow);

    _tprintf(_TEXT("\nRun: %s\n\n"), _tctime(&tmNow));
#endif // !LKRHASH_KERNEL_MODE

    if (ifs.m_fTestIterators)
    {
        test_iterators(ifs.m_dblHighLoad, ifs.m_nInitSize,
                       ifs.m_nSubTables, ifs.m_nInsertIfNotFound);
#ifdef LKR_STL_ITERATORS
        test_stl_iterators(ifs.m_dblHighLoad, ifs.m_nInitSize,
                           ifs.m_nSubTables);
#endif // LKR_STL_ITERATORS
    }

#ifndef LKRHASH_KERNEL_MODE
    // set multimedia timer's period to be 1 millisecond (or the closest
    // approximation that the hardware can manage). This is usually more
    // accurate than GetTickCount. I have had very dubious results from
    // QueryPerformanceCounter on multiprocessor machines, including
    // negative(!) durations (timer skew between processors?)
    timeBeginPeriod(1);
#endif // !LKRHASH_KERNEL_MODE

    _tprintf(_TEXT("Starting threads...\n\n"));

    int nTotalOps = 0;
    int step = (ifs.m_nMinThreads <= ifs.m_nMaxThreads) ? +1 : -1;

    dwRunTime = GetTickCount() - dwRunTime;

    for (num_threads =  ifs.m_nMinThreads;
         num_threads != ifs.m_nMaxThreads + step;
         num_threads += step )
    {
        IRTLTRACE1("\nStarting %8d\n", num_threads);

        pTbl = new CWordHash(ifs.m_dblHighLoad, ifs.m_nInitSize,
                             ifs.m_nSubTables) ;
        pTbl->SetTableLockSpinCount(ifs.m_wTableSpin);
        pTbl->SetBucketLockSpinCount(ifs.m_wBucketSpin);

        keys_per_thread = g_nokeys/num_threads ;
        for (i = 0; i < num_threads; i++)
        {
            de_area[i].ptbl        = pTbl ;
            de_area[i].threadno    = i+1 ;
            de_area[i].first_key   = i*keys_per_thread ;
            de_area[i].last_key    = ((i == num_threads - 1)
                                      ? g_nokeys
                                      : (i+1)*keys_per_thread) ;
            de_area[i].rounds      = ifs.m_nRounds ;
            de_area[i].highload    = (float) ifs.m_dblHighLoad ;
            de_area[i].lookup_freq = ifs.m_nLookupFreq ;
            de_area[i].m_nInsertIfNotFound = ifs.m_nInsertIfNotFound;
            de_area[i].m_nFindKeyCopy = ifs.m_nFindKeyCopy;
            de_area[i].m_nSeed     = ifs.m_nSeed;
            de_area[i].hevFinished = HashTestCreateEvent();
            IRTLASSERT(de_area[i].hevFinished != NULL);
            ahEvents[i] = de_area[i].hevFinished;

            de_area[i].hThread = HashTestCreateThread(exercise_table,
                                                      &de_area[i], true);
        }

#ifndef LKRHASH_KERNEL_MODE
        DWORD dwMMT1 = timeGetTime();
#endif // !LKRHASH_KERNEL_MODE
        
        for (i = 0; i < num_threads; i++)
        {
            HashTestResumeThread(de_area[i].hThread);
            CloseHandle(de_area[i].hThread);
        }

        DWORD dw = HashTestWaitForMultipleObjects(num_threads, ahEvents);

#ifndef LKRHASH_KERNEL_MODE
        DWORD dwMMT2 = timeGetTime();
#endif // !LKRHASH_KERNEL_MODE

        for (i = 0; i < num_threads; i++)
            CloseHandle(ahEvents[i]);

#ifndef LKRHASH_KERNEL_MODE
        double duration3 = double(dwMMT2 - dwMMT1) / 1000.0;
        dblSumDuration3 += duration3;

        dwRunTime += dwMMT2 - dwMMT1;
#endif // !LKRHASH_KERNEL_MODE

        sum_ins = sum_dels = sum_lookups = 0 ;

        for (i = 0; i < num_threads; i++)
        {
            sum_ins     += de_area[i].cinserts ;
            sum_dels    += de_area[i].cdeletes ;
            sum_lookups += de_area[i].clookups ;
            failures    += de_area[i].cfailures ;
        }
        int nOps = sum_ins + sum_dels + sum_lookups;

        total_failures += failures;
        nTotalOps += nOps;  // TODO: weight?

#ifdef LKRHASH_KERNEL_MODE
#else // !LKRHASH_KERNEL_MODE
        int nOpsRate3 = (int)(nOps / duration3);

        if (num_threads == ifs.m_nMinThreads)
            nBaseOps = nOpsRate3;

        TCHAR tszSumIns[16], tszSumDels[16], tszSumLookups[16];
        TCHAR tszNOps3[16];

#ifndef LOCK_INSTRUMENTATION
        if (num_threads == ifs.m_nMinThreads)
#endif // LOCK_INSTRUMENTATION
        {
            _tprintf(_TEXT("%5s %10s %9s %6s")
                     _TEXT("%8s %8s %8s\n"),
                     _TEXT("Thrds"), _TEXT("Ops/sec"),
                     _TEXT("Duration"), _TEXT("Ratio"),
                     _TEXT("Inserts"), _TEXT("Deletes"), _TEXT("Lookups"));
        }

        TCHAR tszSummary[200];

        _stprintf(tszSummary, _TEXT("%5d %10s %9.3f %6.3f")
                  _TEXT("%7sK %7sK %7sK\n"),
                  num_threads,
                  CommaNumber(nOpsRate3, tszNOps3),
                  duration3,
                  double(nOpsRate3) / double(nBaseOps),
                  CommaNumber((sum_ins + 500) / 1000,     tszSumIns),
                  CommaNumber((sum_dels + 500) / 1000,    tszSumDels),
                  CommaNumber((sum_lookups + 500) / 1000, tszSumLookups)
                  );
        _tprintf(tszSummary);
        IRTLTRACE1("%s", tszSummary);

        if (failures != 0)
            _tprintf(_TEXT("%d failed operations!\n"), failures);
#endif // !LKRHASH_KERNEL_MODE

#ifdef LOCK_INSTRUMENTATION
        print_lock_statistics(pTbl->GetStatistics());
 #ifdef LKRHASH_GLOBAL_LOCK
        CWordHash::GlobalLock::ResetGlobalStatistics();
 #endif
        CWordHash::BucketLock::ResetGlobalStatistics();
        CWordHash::TableLock::ResetGlobalStatistics();
        _tprintf(_TEXT("\n"));
#endif

        delete pTbl ;
    }

    TCHAR tszNTotalOps3[16];
    _tprintf(_TEXT("\nAverage Ops = %s. RunTime = %d:%02d.%03d.\n"),
             CommaNumber(int(nTotalOps / dblSumDuration3), tszNTotalOps3),
             dwRunTime / 60000, (dwRunTime / 1000) % 60, dwRunTime % 1000);

    if (total_failures != 0)
        _tprintf(_TEXT("%d total failed operations!\n"), total_failures);

#ifndef LKRHASH_KERNEL_MODE
    timeEndPeriod(1);
#endif // !LKRHASH_KERNEL_MODE

    return 0;
} // LKR_TestHashTable



void test_iterators(
    double highload,
    int    initsize,
    int    nsubtbls,
    int    nInsertIfNotFound)
{
    _tprintf(_TEXT("Testing iterators...\n"));

    int i;
    CWordHash *pTbl = new CWordHash(highload, initsize, nsubtbls) ;
    LK_RETCODE lkrc;

    IRTLASSERT(0 == pTbl->Size());
    IRTLASSERT(pTbl->CheckTable() == 0);

    IRTLTRACE0("Table is empty.  Building...\n");

    int cInsertIfNotFounds = 0;
    
    for (i = 0 ; i < g_nokeys ; i++ )
    {
        lkrc = pTbl->InsertRecord(&g_wordtable[i], false);
        if (lkrc != LK_SUCCESS)
            IRTLTRACE3("i = %d, word = `%hs', lkrc = %d\n",
                       i, g_wordtable[i].m_str.m_psz, lkrc);
        IRTLASSERT(lkrc == LK_SUCCESS);

#ifdef LKR_EXPOSED_TABLE_LOCK
        if (nInsertIfNotFound > 0  &&   rand() % nInsertIfNotFound == 0)
        {
            pTbl->WriteLock();

            int    x        = rand() % g_nokeys;
            CStr*  pstrKey  = &g_wordtable[x].m_str;
            CWord* pRec     = NULL;

            lkrc = pTbl->FindKey(pstrKey, &pRec);

            if (pRec != NULL)
            {
                IRTLASSERT(lkrc == LK_SUCCESS);
                IRTLASSERT(pRec == &g_wordtable[x]);
                IRTLASSERT(x <= i);
                --g_wordtable[x].m_cRefs;
            }
            else
            {
                ++cInsertIfNotFounds;
                IRTLASSERT(x > i);
                IRTLASSERT(lkrc == LK_NO_SUCH_KEY);

                lkrc = pTbl->InsertRecord(&g_wordtable[x], false);
                IRTLASSERT(lkrc == LK_SUCCESS);
                InterlockedIncrement(&g_wordtable[x].m_cInsertIfNotFounds);

                lkrc = pTbl->DeleteKey(&g_wordtable[x].m_str);
                IRTLASSERT(lkrc == LK_SUCCESS);
            }
            
            pTbl->WriteUnlock();
        }
#endif // LKR_EXPOSED_TABLE_LOCK
    }

    IRTLTRACE1("cInsertIfNotFounds = %d\n", cInsertIfNotFounds);
    
#ifdef LKR_EXPOSED_TABLE_LOCK
    pTbl->ReadLock();

    IRTLTRACE2("Checking that table has %d records (size = %d)\n",
              g_nokeys, pTbl->Size());
    IRTLASSERT(g_nokeys == (int) pTbl->Size());
    IRTLASSERT(pTbl->CheckTable() == 0);

    pTbl->ReadUnlock();
#endif // LKR_EXPOSED_TABLE_LOCK

    IRTLTRACE0("Clearing the table\n");
    pTbl->Clear();
    IRTLASSERT(0 == pTbl->Size());
    IRTLASSERT(pTbl->CheckTable() == 0);

    IRTLTRACE0("Seeing what crud is left in the table\n");
    size_t cRec = 0;

    for (i = 0 ; i < g_nokeys ; i++ )
    {
        CStr*  pstrKey  = &g_wordtable[i].m_str;
        CWord* pRec     = NULL;
        LK_RETCODE lkrc = pTbl->FindKey(pstrKey, &pRec);

        if (pRec != NULL)
        {
            IRTLASSERT(pRec == &g_wordtable[i]);
            --pRec->m_cRefs;
            IRTLTRACE1("%hs\n", g_wordtable[i].m_str.m_psz);
            ++cRec;
        }
    }
    IRTLTRACE1("Found %d records that shouldn't have been there\n", cRec);

    pTbl->Clear();
    delete pTbl;

    pTbl = new CWordHash(highload, initsize, nsubtbls) ;

    IRTLTRACE0("Rebuilding the table\n");
    for (i = 0 ; i < g_nokeys ; i++ )
        IRTLVERIFY(pTbl->InsertRecord(&g_wordtable[i]) == LK_SUCCESS);

    IRTLASSERT(g_nokeys == (int) pTbl->Size());
    IRTLASSERT(pTbl->CheckTable() == 0);

#ifdef LKR_DEPRECATED_ITERATORS
    IRTLTRACE0("Checking iterators\n");
    cRec = 0;
    CWordHash::CIterator iter(LKL_READLOCK);
    
    for (lkrc = pTbl->InitializeIterator(&iter);
         lkrc == LK_SUCCESS;
         lkrc = pTbl->IncrementIterator(&iter))
    {
        ++cRec;
        const CStr* pstrKey = iter.Key();
        CWord*      pRec    = iter.Record();
        
        IRTLASSERT(&g_wordtable[0] <= pRec  &&  pRec < &g_wordtable[g_nokeys]);
        IRTLASSERT(!pRec->m_fIterated);
        pRec->m_fIterated = true;

        if (CWordHash::TableLock::Recursion() != LOCK_NON_RECURSIVE
            &&  CWordHash::BucketLock::Recursion() != LOCK_NON_RECURSIVE)
        {
            // Check that the lock can be safely acquired recursively
            // (the table is already locked by the iterator).
            int x = rand() % g_nokeys;
            CStr*  pstrKey2 = &g_wordtable[x].m_str;
            CWord* pRec2    = NULL;
            LK_RETCODE lkrc2= pTbl->FindKey(pstrKey2, &pRec2);
            IRTLASSERT(lkrc2 == LK_SUCCESS  &&  pRec2 == &g_wordtable[x]);
            if (pRec2 != NULL)
                --pRec2->m_cRefs;
        }
    }
    
    IRTLASSERT(lkrc == LK_NO_MORE_ELEMENTS);
    IRTLASSERT((int) cRec == g_nokeys);

    lkrc = pTbl->CloseIterator(&iter);
    IRTLASSERT(lkrc == LK_SUCCESS);

    for (i = 0 ; i < g_nokeys ; i++ )
    {
        IRTLASSERT(g_wordtable[i].m_fIterated);
        g_wordtable[i].m_fIterated = false;
    }


    do {
        cRec = rand() % (g_nokeys - 1);
    } while (cRec == 0);
    IRTLTRACE1("Checking abandoning of const iterators after %d iterations\n",
              cRec);

    const CWordHash *pTblConst = pTbl;
    CWordHash::CConstIterator iterConst;

    for (lkrc = pTblConst->InitializeIterator(&iterConst);
         lkrc == LK_SUCCESS;
         lkrc = pTblConst->IncrementIterator(&iterConst))
    {
        if (--cRec == 0)
            break;
        const CStr*  pszKey = iterConst.Key();
        const CWord* pRec   = iterConst.Record();
        
        IRTLASSERT(&g_wordtable[0] <= pRec  &&  pRec < &g_wordtable[g_nokeys]);
    }
    
    IRTLASSERT(lkrc != LK_NO_MORE_ELEMENTS);

    lkrc = pTblConst->CloseIterator(&iterConst);
    IRTLASSERT(lkrc == LK_SUCCESS);
#endif // LKR_DEPRECATED_ITERATORS

    
#ifndef LKRHASH_KERNEL_MODE
    IRTLTRACE0("Gathering statistics\n");
    CLKRHashTableStats stats = pTbl->GetStatistics();
    print_table_statistics(stats);
#endif // !LKRHASH_KERNEL_MODE

#ifdef LOCK_INSTRUMENTATION
    print_lock_statistics(stats);
    CWordHash::BucketLock::ResetGlobalStatistics();
    CWordHash::TableLock::ResetGlobalStatistics();
#endif
    _tprintf(_TEXT("\n"));

    IRTLTRACE0("Cleaning up by hand\n");
    for (i = 0 ; i < g_nokeys ; i++ )
    {
        IRTLVERIFY(pTbl->DeleteKey(&g_wordtable[i].m_str) == LK_SUCCESS);
    }
    
    IRTLASSERT(0 == pTbl->Size());

    delete pTbl ;
}


#ifdef LKR_STL_ITERATORS

void test_stl_iterators2(
    CWordHash *pTbl);


void test_stl_iterators(
    double highload,
    int    initsize,
    int    nsubtbls)
{
    _tprintf(_TEXT("\nTesting STL iterators...\n"));

    _tprintf(_TEXT("subtable iter = %d, iter = %d\n"),
           sizeof(CLKRLinearHashTable::Iterator),
           sizeof(CLKRHashTable::Iterator));

    int i;
    bool f;
    CWordHash *pTbl;
    CWordHash::iterator iter;
    const int iFirst = 5; //     g_nokeys / 5;
    const int iLast  = 10; // 4 * g_nokeys / 5;

    // pTbl = new CWordHash(highload, initsize, nsubtbls) ;

    IRTLTRACE1("\n\nAbout to create table with %d records\n\n",
               iLast - iFirst);
    pTbl = new CWordHash(&g_wordtable[iFirst], &g_wordtable[iLast],
                        highload, initsize, nsubtbls) ;

    for (iter = pTbl->begin();  iter != pTbl->end();  ++iter)
    {
        const CStr* pstrKey = iter.Key();
        CWord*      pRec    = iter.Record();

        IRTLASSERT(&g_wordtable[iFirst] <= pRec
                   &&  pRec < &g_wordtable[iLast]);
        IRTLTRACE2("\nRecord: %p, %hs\n", pRec, pstrKey->m_psz);
    }

    IRTLTRACE1("\n\nAbout to search %d records\n\n", pTbl->Size());
    for (i = iFirst;  i != iLast;  ++i)
    {
        f = pTbl->Find(&g_wordtable[i].m_str, iter);
        IRTLASSERT(f  &&  iter.Record() == &g_wordtable[i]);
        IRTLTRACE2("\n\tFound: %d, %hs\n", i, iter.Key()->m_psz);
    }
        
    f = pTbl->Find(&g_wordtable[iLast].m_str, iter);
    IRTLASSERT(!f);
    IRTLASSERT(iter == pTbl->end());

    i = pTbl->Size();
    IRTLTRACE1("\n\nAbout to erase %d records\n\n", i);

    for (iter = pTbl->begin();  iter != pTbl->end();  --i)
    {
        IRTLTRACE1("\n\terase %d\n", i);
        IRTLVERIFY(pTbl->Erase(iter));
    }

    IRTLASSERT(i == 0);
    IRTLASSERT(pTbl->Size() == 0);
    CheckRefCounts(0);

    IRTLTRACE1("\n\nAbout to insert %d records\n\n", iLast - iFirst);
    for (i = iFirst;  i != iLast;  ++i)
    {
        f = pTbl->Insert(&g_wordtable[i], iter);
        IRTLASSERT(f  &&  iter.Record() == &g_wordtable[i]);
        IRTLTRACE2("\n\tInserted: %d, %hs\n", i, iter.Key()->m_psz);
    }

    // Reset iter so that it isn't pointing to anything, raising its refcount
    iter = pTbl->end();
    CheckRefCounts(1, iFirst, iLast);

    IRTLTRACE1("\n\nAbout to Erase2 %d records\n\n", iLast - iFirst);
    f = pTbl->Erase(pTbl->begin(), pTbl->end());
    IRTLASSERT(f  &&  pTbl->Size() == 0);

    CheckRefCounts(0);

    IRTLTRACE1("\n\nAbout to insert %d records, again\n\n", iLast - iFirst);
    for (i = iFirst;  i != iLast;  ++i)
    {
        f = pTbl->Insert(&g_wordtable[i], iter);
        IRTLASSERT(f  &&  iter.Record() == &g_wordtable[i]);
        IRTLTRACE2("\n\tInserted: %d, %hs\n", i, iter.Key()->m_psz);
    }

    // Reset iter so that it isn't pointing to anything, raising its refcount
    iter = pTbl->end();
    CheckRefCounts(1, iFirst, iLast);

    IRTLTRACE1("\nAbout to equalrange and erase2 %d records, backwards\n\n",
               iLast - iFirst);
    for (i = iLast;  --i >= iFirst;  )
    {
        CWordHash::iterator iterLast;

        f = pTbl->EqualRange(&g_wordtable[i].m_str, iter, iterLast);
        IRTLASSERT(f  &&  iter.Record() == &g_wordtable[i]);
        IRTLTRACE3("\n\tEqualRange: %d, \"%hs\", %d\n",
                   i, iter.Key()->m_psz, iter.Record()->m_cRefs);

        f = pTbl->Erase(iter, iterLast);
        IRTLASSERT(f);
        IRTLTRACE1("\n\tErase2d: %d\n", i);
    }

    IRTLASSERT(pTbl->Size() == 0);
    CheckRefCounts(0);

    delete pTbl;

#if 1
    pTbl = new CWordHash(highload, initsize, nsubtbls) ;
#else
    pTbl = new CWordHash(1, // LK_DFLT_MAXLOAD * 6,
                         100000, // LK_SMALL_TABLESIZE,
                         17); // # subtables
#endif

    CheckRefCounts(0);
    
    IRTLTRACE0("Building the table\n");
    for (i = 0 ; i < g_nokeys ; i++ )
    {
        g_wordtable[i].m_fIterated = false;
        IRTLVERIFY(pTbl->InsertRecord(&g_wordtable[i]) == LK_SUCCESS);
    }

    IRTLASSERT(g_nokeys == (int) pTbl->Size());
    IRTLASSERT(pTbl->CheckTable() == 0);

    test_stl_iterators2(pTbl);

    IRTLTRACE0("Cleaning up by hand\n");
    for (i = 0 ; i < g_nokeys ; i++ )
    {
        IRTLVERIFY(pTbl->DeleteKey(&g_wordtable[i].m_str) == LK_SUCCESS);
    }
    
    IRTLASSERT(0 == pTbl->Size());

    delete pTbl ;
}



void test_stl_iterators2(
    CWordHash *pTbl)
{
    IRTLTRACE0("Checking STL iterators\n");
    size_t cRec = 0;
    int i;
    
    for (CWordHash::iterator iter = pTbl->begin();
        iter != pTbl->end();
         ++iter)
    {
        ++cRec;
        const CStr* pstrKey = iter.Key();
        CWord*      pRec    = iter.Record();

        IRTLASSERT(&g_wordtable[0] <= pRec  &&  pRec < &g_wordtable[g_nokeys]);
        IRTLASSERT(!pRec->m_fIterated);
        pRec->m_fIterated = true;
        // IRTLTRACE3("%d: %p, %hs\n", cRec, pRec, pstrKey->m_psz);
    }
    
    IRTLASSERT((int) cRec == g_nokeys);

    IRTLTRACE1("Checking that all %d records were touched\n", g_nokeys);
    CheckRefCounts(1);

    for (i = 0 ; i < g_nokeys ; i++ )
    {
        IRTLASSERT(g_wordtable[i].m_fIterated);
        g_wordtable[i].m_fIterated = false;
    }
}

#endif // LKR_STL_ITERATORS



#ifndef LKRHASH_KERNEL_MODE

void print_table_statistics(const CLKRHashTableStats& stats)
{
    _tprintf(_TEXT("#Records=%d, #BucketChains=%d, ")
           _TEXT("DirSize=%d, LongestChain=%3d,\n"),
           stats.RecordCount, stats.TableSize,
           stats.DirectorySize, stats.LongestChain);
           
    _tprintf(_TEXT("#Empty Buckets=%d, Split Factor=%.2f, ")
           _TEXT("AvgSrchLen=%.2f, Expected SL=%.2f,\n"),
           stats.EmptySlots, stats.SplitFactor,
           stats.AvgSearchLength, stats.ExpSearchLength);

    _tprintf(_TEXT("Avg Unsuccessful SrchLen=%.2f, ExpUSL=%.2f.\n"),
           stats.AvgUSearchLength, stats.ExpUSearchLength);

    _tprintf(_TEXT("\nBucket Chain Lengths ")
           _TEXT("(node clump size = %d, bucket size = %d bytes):\n"),
           stats.NodeClumpSize, stats.CBucketSize);
    for (int j = 0;  j < CLKRHashTableStats::MAX_BUCKETS;  ++j)
    {
        if (stats.m_aBucketLenHistogram[j] == 0)
        {
            _tprintf(_TEXT("\n"));
            break;
        }
        _tprintf(_TEXT(" %10d: %6d"),
               stats.BucketSize(j), stats.m_aBucketLenHistogram[j]);
        if (j % 4 == 3)
            _tprintf(_TEXT("\n"));
    }

    _tprintf(_TEXT("\n"));
}


#ifdef LOCK_INSTRUMENTATION

void print_lock_statistics(const CLKRHashTableStats& stats)
{
    _tprintf(_TEXT("Global Locks Statistics:")
           _TEXT("\n   total locks created = %ld, ")
           _TEXT("total contentions = %ld, ")
           _TEXT("#sleeps = %ld,")
           _TEXT("\n   total spins = %I64d, ")
           _TEXT("av spins/contention = %.1f, ")
           _TEXT("\n   #readlocks = %d, ")
           _TEXT("#writelocks=%d\n"),
           stats.m_gls.m_cTotalLocks,
           stats.m_gls.m_cContendedLocks,
           stats.m_gls.m_nSleeps,
           stats.m_gls.m_cTotalSpins,
           stats.m_gls.m_nAverageSpins,
           stats.m_gls.m_nReadLocks,
           stats.m_gls.m_nWriteLocks
           );

    _tprintf(_TEXT("Averaged SubTable Locks Statistics:")
           _TEXT("\n   Total locks = %d, ")
           _TEXT("#contentions = %.1f, ")
           _TEXT("sleeps = %.1f; ")
           _TEXT("\n   total spins = %.1f, ")
           _TEXT("avg spins = %.1f, ")
           _TEXT("\n   #readlocks = %.1f, ")
           _TEXT("#writelocks=%.1f\n"),
           stats.m_alsTable.m_nItems,
           stats.m_alsTable.m_nContentions,
           stats.m_alsTable.m_nSleeps,
           stats.m_alsTable.m_nContentionSpins,
           stats.m_alsTable.m_nAverageSpins,
           stats.m_alsTable.m_nReadLocks,
           stats.m_alsTable.m_nWriteLocks);

    _tprintf(_TEXT("Averaged Bucket Locks Statistics:")
           _TEXT("\n   Total locks = %d, ")
           _TEXT("#contentions = %.1f, ")
           _TEXT("sleeps = %.1f; ")
           _TEXT("\n   total spins = %.1f, ")
           _TEXT("avg spins = %.1f, ")
           _TEXT("\n   #readlocks = %.1f, ")
           _TEXT("#writelocks=%.1f\n"),
           stats.m_alsBucketsAvg.m_nItems,
           stats.m_alsBucketsAvg.m_nContentions,
           stats.m_alsBucketsAvg.m_nSleeps,
           stats.m_alsBucketsAvg.m_nContentionSpins,
           stats.m_alsBucketsAvg.m_nAverageSpins,
           stats.m_alsBucketsAvg.m_nReadLocks,
           stats.m_alsBucketsAvg.m_nWriteLocks);

    _tprintf(_TEXT("\n"));
}

#endif // LOCK_INSTRUMENTATION

#endif // !LKRHASH_KERNEL_MODE
    
int expand_key_set(int maxkeys, int numkeys, bool fVerbose)
{
    int totkeys = numkeys ;
    if (totkeys > maxkeys)
        return maxkeys;

    char* pszTemp = new char [20 + CStr::sm_cchMax];

    for(int k = 0; TRUE; k++)
    {
        for(int i = 0; i < numkeys; i++)
        {
            if (totkeys == maxkeys)
            {
                delete [] pszTemp;
                return(totkeys) ;
            }

            sprintf(pszTemp, "%d%hs", k, g_wordtable[i].m_str.m_psz);
            g_wordtable[totkeys++].m_str.Set(pszTemp, strlen(pszTemp));
        }

        if (fVerbose)
            putchar('.');
    }
}



#ifdef LKRHASH_KERNEL_MODE
void
#else
unsigned __stdcall
#endif
exercise_table(
    void* pinput)
{
    CWordHash*    pTbl;
    thread_data*  pdea = (thread_data*) pinput ;
    int           cfailed_ins=0 ;
    int           cfailed_dels=0 ;
    int           cFoundSuccesses=0, cFoundFails=0 ;
    int           x, i ;
    LK_RETCODE    lkrc;

    SetThreadIdealProcessor(GetCurrentThread(),
                            pdea->threadno % NumProcessors());

#ifndef LKRHASH_KERNEL_MODE
    LARGE_INTEGER liFreq, liT1, liT2;
    IRTLVERIFY(QueryPerformanceFrequency(&liFreq));
    IRTLVERIFY(QueryPerformanceCounter(&liT1));
#endif // !LKRHASH_KERNEL_MODE

    pdea->cinserts = 0 ;
    pdea->cdeletes = 0 ;
    pdea->clookups = 0 ;
    pTbl = pdea->ptbl ;
    srand(pdea->m_nSeed);

    for (int rnd = 0; rnd < pdea->rounds; rnd++)
    {
        IRTLASSERT(pTbl->CheckTable() == 0);

        // Insert all the keys, randomly searching after each insertion
        for (i = pdea->first_key ; i < pdea->last_key ; i++ )
        {
#ifdef IRTLDEBUG
            CStr*  pstrKey = &g_wordtable[i].m_str;
            CWord* pRec     = NULL;
            lkrc = pTbl->FindKey(pstrKey, &pRec);
            IRTLASSERT(lkrc == LK_NO_SUCH_KEY  &&  pRec == NULL);
#endif // IRTLDEBUG

            if (pTbl->InsertRecord(&g_wordtable[i] ) != LK_SUCCESS )
            {
                cfailed_ins++ ;
            }
            else
            {
#ifdef IRTLDEBUG
                pstrKey = &g_wordtable[i].m_str;
                lkrc = pTbl->FindKey(pstrKey, &pRec);
                IRTLASSERT(lkrc == LK_SUCCESS  &&  pRec == &g_wordtable[i]);
                pTbl->AddRefRecord(pRec, LKAR_EXPLICIT_RELEASE);
#endif // IRTLDEBUG

                g_wordtable[i].m_fInserted = true;
            }

            pdea->cinserts++ ;

            for (int lu = 0; lu < pdea->lookup_freq; lu++)
            {
                x = rand() % (pdea->last_key - pdea->first_key)
                    + pdea->first_key;
                bool fPresent = (x <= i); // should it be found?
                CWord* pRec   = NULL;
                LK_RETCODE lkrc;

                if (pdea->m_nFindKeyCopy > 0
                    &&  rand() % pdea->m_nFindKeyCopy == 0)
                {
                    char szTemp[MAX_STRSIZE];
                    strcpy(szTemp, g_wordtable[x].m_str.m_psz);
                    CStr strTemp(szTemp, g_wordtable[x].m_str.m_cch, false);
                    lkrc = pTbl->FindKey(&strTemp, &pRec);
                }
                else
                    lkrc = pTbl->FindKey(&g_wordtable[x].m_str, &pRec);

                if (fPresent)
                {
                    if (lkrc != LK_SUCCESS  ||  pRec != &g_wordtable[x] )
                    {
                        ++g_wordtable[x].m_cNotFound;
                        IRTLTRACE(_TEXT("%d: Not found (%hs): x = %d, i = %d, ")
                              _TEXT("cnf = %d, rnd = %d, lkrc = %d, ")
                              _TEXT("pRec(%hs), %d\n"),
                              pdea->threadno, g_wordtable[x].m_str.m_psz, x, i,
                              g_wordtable[x].m_cNotFound, rnd, lkrc,
                              pRec != NULL ? pRec->m_str.m_psz : "<null>",
                              pRec != NULL ? (pRec - g_wordtable) / sizeof(CWord) : -1);
                        cFoundFails++ ;
                    }
                    else
                    {
                        pTbl->AddRefRecord(pRec, LKAR_EXPLICIT_RELEASE);
                        cFoundSuccesses++ ;
                    }
                }
                else // not fPresent
                {
                    IRTLASSERT(lkrc != LK_SUCCESS  &&  pRec == NULL);
                    if (lkrc == LK_SUCCESS  ||  pRec != NULL)
                    {
                        IRTLTRACE(_TEXT("%d: found when not present (%hs): ")
                              _TEXT("x = %d, i = %d, ")
                              _TEXT("cnf = %d, rnd = %d, lkrc = %d, ")
                              _TEXT("pRec(%hs), %d\n"),
                              pdea->threadno, g_wordtable[x].m_str.m_psz,
                              x, i,
                              g_wordtable[x].m_cNotFound, rnd, lkrc,
                              pRec != NULL ? pRec->m_str.m_psz : "<null>",
                              pRec != NULL ? (pRec - g_wordtable) / sizeof(CWord) : -1);
                        cFoundFails++ ;
                    }
                    else
                    {
                        // wasn't found, but it wasn't present, so this is good
                        cFoundSuccesses++ ;
                    }
                }
            }

            pdea->clookups += pdea->lookup_freq ;
            
#ifdef LKR_EXPOSED_TABLE_LOCK
            if (pdea->m_nInsertIfNotFound > 0
                &&  rand() % pdea->m_nInsertIfNotFound == 0)
            {
                bool fWrite = (rand() & 1) != 0;

                if (fWrite)
                    pTbl->WriteLock();
                else
                    pTbl->ReadLock();
                
                x = rand() % (pdea->last_key - pdea->first_key)
                    + pdea->first_key;
                bool fPresent   = (x <= i); // should it be found?
                CStr*  pstrKey  = &g_wordtable[x].m_str;
                CWord* pRec     = NULL;
                
                lkrc = pTbl->FindKey(pstrKey, &pRec);
                
                if (pRec != NULL)
                {
                    IRTLASSERT(lkrc == LK_SUCCESS);
                    IRTLASSERT(pRec == &g_wordtable[x]);
                    IRTLASSERT(x <= i);
                    pTbl->AddRefRecord(pRec, LKAR_EXPLICIT_RELEASE);
                }
                else if (fWrite)
                {
                    IRTLASSERT(x > i);
                    IRTLASSERT(lkrc == LK_NO_SUCH_KEY);

                    lkrc = pTbl->InsertRecord(&g_wordtable[x], false);
                    IRTLASSERT(lkrc == LK_SUCCESS);
                    InterlockedIncrement(&g_wordtable[x].m_cInsertIfNotFounds);
                    
                    lkrc = pTbl->DeleteKey(&g_wordtable[x].m_str);
                    IRTLASSERT(lkrc == LK_SUCCESS);
                }
            
                if (fWrite)
                    pTbl->WriteUnlock();
                else
                    pTbl->ReadUnlock();
            }
#endif // LKR_EXPOSED_TABLE_LOCK
        }

        IRTLASSERT(cfailed_ins == 0) ;
        IRTLASSERT(cFoundFails == 0) ;
        IRTLASSERT(cFoundSuccesses == ((2 * rnd + 1) * pdea->lookup_freq
                              * (pdea->last_key - pdea->first_key)));

        IRTLTRACE(_TEXT("Thrd %u, rnd %d: %d inserts done, not found %d, ")
                  _TEXT("f=%d, l=%d\n"), 
                  pdea->threadno, rnd, pdea->cinserts, cFoundFails,
                  pdea->first_key, pdea->last_key) ;
        IRTLASSERT(pTbl->CheckTable() == 0);

        // Delete all the keys, randomly searching before each deletion
        for (i = pdea->first_key ; i < pdea->last_key ; i++ )
        {
            for (int lu = 0; lu < pdea->lookup_freq; lu++)
            {
                x = rand() % (pdea->last_key - pdea->first_key)
                    + pdea->first_key;
                bool fPresent = (x >= i); // should it be found?
                CWord* pRec   = NULL;
                LK_RETCODE lkrc;

                if (pdea->m_nFindKeyCopy > 0
                    &&  rand() % pdea->m_nFindKeyCopy == 0)
                {
                    char szTemp[MAX_STRSIZE];
                    strcpy(szTemp, g_wordtable[x].m_str.m_psz);
                    CStr strTemp(szTemp, g_wordtable[x].m_str.m_cch, false);
                    lkrc = pTbl->FindKey(&strTemp, &pRec);
                }
                else
                    lkrc = pTbl->FindKey(&g_wordtable[x].m_str, &pRec);

                if (fPresent)
                {
                    if (lkrc != LK_SUCCESS  ||  pRec != &g_wordtable[x] )
                    {
                        ++g_wordtable[x].m_cNotFound;
                        IRTLTRACE(_TEXT("%d: Not found (%hs): x = %d, i = %d, ")
                              _TEXT("cnf = %d, rnd = %d, lkrc = %d, ")
                              _TEXT("pRec(%hs), %d\n"),
                              pdea->threadno, g_wordtable[x].m_str.m_psz, x, i,
                              g_wordtable[x].m_cNotFound, rnd, lkrc,
                              pRec != NULL ? pRec->m_str.m_psz : "<null>",
                              pRec != NULL ? (pRec - g_wordtable) / sizeof(CWord) : -1);
                        cFoundFails++ ;
                    }
                    else
                    {
                        pTbl->AddRefRecord(pRec, LKAR_EXPLICIT_RELEASE);
                        cFoundSuccesses++ ;
                    }
                }
                else // !fPresent
                {
                    IRTLASSERT(lkrc != LK_SUCCESS  &&  pRec == NULL);
                    if (lkrc == LK_SUCCESS  ||  pRec != NULL)
                    {
                        IRTLTRACE(_TEXT("%d: found when not present (%hs): ")
                              _TEXT("x = %d, i = %d, ")
                              _TEXT("cnf = %d, rnd = %d, lkrc = %d, ")
                              _TEXT("pRec(%hs), %d\n"),
                              pdea->threadno, g_wordtable[x].m_str.m_psz,
                              x, i,
                              g_wordtable[x].m_cNotFound, rnd, lkrc,
                              pRec != NULL ? pRec->m_str.m_psz : "<null>",
                              pRec != NULL ? (pRec - g_wordtable) / sizeof(CWord) : -1);
                        cFoundFails++ ;
                    }
                    else
                    {
                        // wasn't found, but it wasn't present, so this is good
                        cFoundSuccesses++ ;
                    }
                }
            }
            pdea->clookups += pdea->lookup_freq ;

#ifdef IRTLDEBUG
            CStr*  pstrKey  = &g_wordtable[i].m_str;
            CWord* pRec     = NULL;
            LK_RETCODE lkrc = pTbl->FindKey(pstrKey, &pRec);
            IRTLASSERT(lkrc == LK_SUCCESS  &&  pRec == &g_wordtable[i]);
            pTbl->AddRefRecord(pRec, LKAR_EXPLICIT_RELEASE);
#endif // IRTLDEBUG

            if (pTbl->DeleteKey(&g_wordtable[i].m_str) != LK_SUCCESS )
            {
                cfailed_dels++ ;
            }
            else
            {
#ifdef IRTLDEBUG
                pstrKey = &g_wordtable[i].m_str;
                lkrc = pTbl->FindKey(pstrKey, &pRec);
                IRTLASSERT(lkrc == LK_NO_SUCH_KEY  &&  pRec == NULL);
#endif // IRTLDEBUG

                g_wordtable[i].m_fInserted = false;
            }
            pdea->cdeletes++ ;
        }

#ifdef IRTLDEBUG
        int cBadKeys = 0;
        for (i = pdea->first_key ; i < pdea->last_key ; i++ )
        {
            if (g_wordtable[i].m_cNotFound > 0)
            {
                ++cBadKeys;
                IRTLTRACE(_TEXT("%-20hs: #not found = %d, hash = %d, %08x\n"),
                          g_wordtable[i].m_str.m_psz,
                          g_wordtable[i].m_cNotFound,
                          CWordHash::CalcKeyHash(CWordHash::ExtractKey(
                                                 &g_wordtable[i])),
                          CWordHash::CalcKeyHash(CWordHash::ExtractKey(
                                                 &g_wordtable[i])));
            }
        }
        if (cBadKeys > 0)
            IRTLTRACE1("%d bad keys\n", cBadKeys);
        IRTLASSERT(cBadKeys == 0);
#endif // IRTLDEBUG

        IRTLASSERT(cfailed_dels == 0 ) ;
        IRTLASSERT(cFoundFails == 0 ) ;
        IRTLASSERT(cFoundSuccesses == ((2 * rnd + 2) * pdea->lookup_freq
                              * (pdea->last_key - pdea->first_key)));
        IRTLTRACE(_TEXT("Thrd %u, rnd %d: %d deletes done, not found %d, ")
                  _TEXT("f=%d, l=%d\n"), 
                  pdea->threadno, rnd, pdea->cdeletes, cFoundFails,
                  pdea->first_key, pdea->last_key) ;
    } // (for rnd)

#ifndef LKRHASH_KERNEL_MODE
    IRTLVERIFY(QueryPerformanceCounter(&liT2));
    pdea->duration = (liT2.QuadPart-liT1.QuadPart) / (double) liFreq.QuadPart;
#endif // !LKRHASH_KERNEL_MODE

    IRTLASSERT(pTbl->CheckTable() == 0);

    IRTLTRACE3("Thread %u terminating: %d found, %d not found\n",
              pdea->threadno, cFoundSuccesses, cFoundFails) ;

    if (cFoundSuccesses != (2 * pdea->rounds * pdea->lookup_freq
                   * (pdea->last_key - pdea->first_key))
        ||  cFoundFails != 0  ||  cfailed_ins != 0  ||  cfailed_dels != 0)
    {
        _tprintf(_TEXT("Thread %u: found = %d, not found = %d, ")
               _TEXT("\nfailed inserts = %d, failed deletes = %d\n"),
               pdea->threadno, cFoundSuccesses, cFoundFails,
               cfailed_ins, cfailed_dels);
    }

    pdea->cfailures = cfailed_ins + cfailed_dels + cFoundFails;

    if (pdea->hevFinished != NULL)
        SetEvent(pdea->hevFinished);

#ifndef LKRHASH_KERNEL_MODE
    return 0;
#endif
}