hl2sdk/public/tier1/thash.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================

#ifndef THASH_H
#define THASH_H
#ifdef _WIN32
#pragma once
#endif

#include <typeinfo>

//#define DBGFLAG_THASH			// Perform extra sanity checks on the THash


// THash
// This is a heavyweight, templatized version of DHash.
// It differs from DHash in the following ways:
// - It's templetized, and automatically constructs and destructs its records as appropriate
// - It provides a scheduling service, which can be used to touch every record in the table
//		at a specified interval.  The scheduler is low-overhead, and provides a very smooth
//		distribution of touches across frames.

// Template arguments:
//		Data: the class to be stored in the hash table
//		I: the type of the primary key (uint32 by default)
template<class Data, typename I=uint32>
class CTHash
{
private:
	// RecHdr
	// We insert one of these at the beginning of every record.  It's used for
	// keeping the records in a linked list.
	typedef struct RecHdr_t
	{
		RecHdr_t *m_pRecHdrNext;		// Next item in our linked list
		RecHdr_t *m_pRecHdrPrev;		// Previous item in our linked list
		I m_unKey;						// Key of this item
		int m_iBucket;					// The bucket we're in
		int m_nRunRatio;				// We want to run 1 cycle out of every m_nRunRatio
										// cycles (not at all if 0).
#ifdef DBGFLAG_THASH
		uint m_iCycleLast;				// Last cycle we were visited (whether or not we ran)
#endif
	} RecHdr_t;

	// Bucket
	// Each hash bucket is represented by a Bucket structure, which points to the 
	// first record with the bucket's hash.
	typedef struct Bucket_t
	{
		RecHdr_t *m_pRecHdrFirst;		// First record in our list
	} Bucket_t;


public:
	// Constructors & destructors
	CTHash( int cFramesPerCycle );
	~CTHash();

	// Initializer
	void Init( int cRecordInit, int cBuckets );

	// Insert a record into the table
	Data *PvRecordInsert( I unKey );
	// Insert a record into the table and set the allocated object's pointer as the hash key
	Data *PvRecordInsertAutoKey();
	// Changes the key for a previously inserted item
	void ChangeKey( Data * pvRecord, I unOldKey, I unNewKey );

	// Remove a record
	void Remove( I unKey );
	// Remove a record
	void Remove( Data * pvRecord );
	// Remove all records
	void RemoveAll();
	
	// Find a record
	Data *PvRecordFind( I unKey ) const;

	// How many records do we have
	int Count() const { return m_cRecordInUse; }

	// Iterate through our members
	Data *PvRecordFirst() const;
	Data *PvRecordNext( Data *pvRecordCur ) const;

	// We provide a scheduling service.  Call StartFrameSchedule when you want to start running
	// records in a given frame, and repeatedly call PvRecordRun until it returns NULL (or you
	// run our of time).
	void SetRunRatio( Data *pvRecord, int nRunRatio );
	void SetMicroSecPerCycle( int cMicroSecPerCycle, int cMicroSecPerFrame ) { m_cFramesPerCycle = cMicroSecPerCycle / cMicroSecPerFrame; }
	void StartFrameSchedule( bool bNewFrame );
	Data *PvRecordRun();

	bool BCompletedPass();

#ifdef DBGFLAG_VALIDATE
	virtual void Validate( CValidator &validator, const char *pchName );
#endif // DBGFLAG_VALIDATE


private:
	// Insert a record into the table
	Data *PvRecordInsertInternal( RecHdr_t *pRecHdr, I unKey );

	// Get the record associated with a THashHdr
	Data *PvRecordFromPRecHdr( RecHdr_t *pRecHdr ) const { return ( Data * ) ( ( ( uint8 * ) pRecHdr + sizeof( RecHdr_t ) ) ); }

	// Get the RecHdr preceding a PvRecord
	RecHdr_t *PRecHdrFromPvRecord( Data *pvRecord ) const { return ( ( ( RecHdr_t * ) pvRecord ) - 1 ); }

	// Get the hash bucket corresponding to a key
	int IBucket( I unKey ) const;

	void InsertIntoHash( RecHdr_t *pRecHdr, I unKey );
	void RemoveFromHash( Data * pvRecord );

	int m_cBucket;						// # of hash buckets we have
	Bucket_t *m_pBucket;				// Big array of hash buckets

	CUtlMemoryPool *m_pMemoryPoolRecord;	// All our data records

	int m_cRecordInUse;					// # of records in use
	RecHdr_t m_RecHdrHead;				// Head of our linked list
	RecHdr_t m_RecHdrTail;				// Tail of our linked list

	int m_cFramesPerCycle;				// Run each of our records once every m_cFramesPerCycle frames
	RecHdr_t *m_pRecHdrRunNext;			// Next record to run (be careful-- this is more complicated than it sounds)
	int m_iBucketRunMax;				// Stop running when we get to this bucket
	uint m_iCycleCur;					// Current cycle (ie, how many times we've made a complete scheduler pass)
	uint m_iCycleLast;					// Our previous cycle
	uint m_iFrameCur;					// Our current frame (incremented once each StartFrameSchedule)
	uint m_iCycleLastReported;			// Last cycle checked by BCompletedPass()
};


//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input:	cMicroSecRunInterval -		How often we want the scheduler to run each of our records
//-----------------------------------------------------------------------------
template<class Data, class I>
CTHash<Data,I>::CTHash( int cFramesPerCycle )
{
	m_cBucket = 0;
	m_pBucket = NULL;
	m_pMemoryPoolRecord = NULL;
	m_cRecordInUse = 0;

	m_cFramesPerCycle = cFramesPerCycle;
	m_pRecHdrRunNext = &m_RecHdrTail;		// This will make us start at the beginning on our first frame
	m_iBucketRunMax = 0;
	m_iCycleCur = 0;
	m_iCycleLast = 0;
	m_iFrameCur = 0;
	m_iCycleLastReported = 0;

	m_RecHdrHead.m_pRecHdrPrev = NULL;
	m_RecHdrHead.m_pRecHdrNext = &m_RecHdrTail;
	m_RecHdrHead.m_iBucket = -1;

	m_RecHdrTail.m_pRecHdrPrev = &m_RecHdrHead;
	m_RecHdrTail.m_pRecHdrNext = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
template<class Data, class I>
CTHash<Data,I>::~CTHash()
{
	RemoveAll();

	if ( NULL != m_pBucket )
		FreePv( m_pBucket );
	m_pBucket = NULL;

	if ( NULL != m_pMemoryPoolRecord )
		delete( m_pMemoryPoolRecord );
	m_pMemoryPoolRecord = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Initializer.  Allocate our various arrays, and set up the free
//			list.
// Input:	cRecordInit -		Initial # of data records we can contain
//			cBucket -			# of hash buckets we should use
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::Init( int cRecordInit, int cBucket )
{
	Assert( cRecordInit > 0 );	// need to init with non-zero value or memory pool will never grow

	// Copy our parameters
	m_cBucket = cBucket;

	// Alloc our arrays
	m_pBucket = ( Bucket_t * ) PvAlloc( sizeof( Bucket_t ) * m_cBucket );
	m_pMemoryPoolRecord = new CUtlMemoryPool( sizeof( Data ) + sizeof( RecHdr_t ), cRecordInit,
		CUtlMemoryPool::GROW_SLOW );

	// Init the hash buckets
	for ( int iBucket = 0; iBucket < m_cBucket; iBucket++ )
		m_pBucket[iBucket].m_pRecHdrFirst = NULL;

	// Make the tail have an illegally large bucket
	m_RecHdrTail.m_iBucket = m_cBucket + 1;
}


//-----------------------------------------------------------------------------
// Purpose: Inserts a new record into the table
// Input:	unKey -			Primary key of the new record
// Output:	Pointer to the new record
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordInsert( I unKey )
{
	Assert( PvRecordFind( unKey ) == NULL );	// keys are unique; no record with this key may exist

	// Find a free record
	RecHdr_t *pRecHdr = ( RecHdr_t * ) m_pMemoryPoolRecord->Alloc();
	
	return PvRecordInsertInternal( pRecHdr, unKey );
}


//-----------------------------------------------------------------------------
// Purpose: Inserts a new record into the table and sets its key to the pointer
//			value of the record
// Output:	Pointer to the new record
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordInsertAutoKey()
{
	// Find a free record
	RecHdr_t *pRecHdr = ( RecHdr_t * ) m_pMemoryPoolRecord->Alloc();
	
	return PvRecordInsertInternal( pRecHdr, (I) PvRecordFromPRecHdr( pRecHdr ) );
}


//-----------------------------------------------------------------------------
// Purpose: Inserts an allocated record into the hash table with specified key
//			and calls the constructor of the allocated object
// Input:	pRecHdr - record to insert
//			unKey - hash key to use for record
// Output:	Pointer to the new record
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordInsertInternal( RecHdr_t *pRecHdr, I unKey )
{
	InsertIntoHash( pRecHdr, unKey );

	// assert that we don't have too many items per bucket
	static bool s_bPerfWarning = false;
	if ( !s_bPerfWarning && Count() >= ( 5 * m_cBucket ) )
	{
		s_bPerfWarning = true;
		AssertMsg( false, "Performance warning: too many items, not enough buckets" );
		Msg( "not enough buckets in thash class %s (%d records, %d buckets)\n",
#ifdef _WIN32
		 typeid(*this).raw_name(),
#else
		typeid(*this).name(),
#endif
		Count(), m_cBucket );
	}

	// Construct ourselves
	Data *pData = PvRecordFromPRecHdr( pRecHdr );
	Construct<Data>( pData );
	return pData;
}

//-----------------------------------------------------------------------------
// Purpose: Changes key on previously inserted item
// Input:	pvRecord -		record to change key for
//			unOldKey -		old key (not strictly needed, but helpful consistency check)
//			unNewKey -		new key to use
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::ChangeKey( Data * pvRecord, I unOldKey, I unNewKey )
{
	Data * pvRecordFound = PvRecordFind( unOldKey );
	Assert( pvRecordFound == pvRecord );
	if ( pvRecordFound == pvRecord )
	{
		RemoveFromHash( pvRecord );
		InsertIntoHash( PRecHdrFromPvRecord( pvRecord), unNewKey );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Removes the entry with a specified key from the table
// Input:	unKey -		Key of the entry to remove
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::Remove( I unKey )
{
	Data *pvRemove = ( Data * ) PvRecordFind( unKey );
	Assert( pvRemove );
	if ( !pvRemove )
		return;
	Remove( pvRemove );
}


//-----------------------------------------------------------------------------
// Purpose: Removes the specified entry from the table
// Input:	pvRemove -		Pointer to the entry to remove
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::Remove( Data * pvRemove )
{
	// Destruct the record we're removing
	Destruct<Data>( pvRemove );

	RemoveFromHash( pvRemove );
	m_pMemoryPoolRecord->Free( PRecHdrFromPvRecord( pvRemove ) );
}


//-----------------------------------------------------------------------------
// Purpose: Removes all entries from the table
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::RemoveAll()
{
	Data * pvRecord = PvRecordFirst();
	while ( pvRecord )
	{
		Data *pvRecordNext = PvRecordNext( pvRecord );
		Remove( pvRecord );
		pvRecord = pvRecordNext;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Finds the entry with a specified key
// Input:	unKey -		Key to find
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordFind( I unKey ) const
{
	// Find our hash bucket
	int iBucket = IBucket( unKey );

	// Walk the bucket's list looking for an exact match
	for ( RecHdr_t *pRecHdr = m_pBucket[iBucket].m_pRecHdrFirst;
		NULL != pRecHdr && pRecHdr->m_iBucket == iBucket;
		pRecHdr = pRecHdr->m_pRecHdrNext )
	{
		if ( unKey == pRecHdr->m_unKey )
			return PvRecordFromPRecHdr( pRecHdr );
	}

	// Didn't find a match
	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Finds our first record
// Output:	Pointer to our first record
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordFirst() const
{
	if ( &m_RecHdrTail != m_RecHdrHead.m_pRecHdrNext )
		return PvRecordFromPRecHdr( m_RecHdrHead.m_pRecHdrNext );
	else
		return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Iterates to the record after a given record
// Input:	Pointer to a current record
// Output:	Pointer to the next record
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordNext( Data *pvRecordCur ) const
{
	RecHdr_t *pRecHdr = PRecHdrFromPvRecord( pvRecordCur );
	if ( &m_RecHdrTail == pRecHdr->m_pRecHdrNext )
		return NULL;

	return PvRecordFromPRecHdr( pRecHdr->m_pRecHdrNext );
}


//-----------------------------------------------------------------------------
// Purpose: Sets the run ratio of a particular record in the hash table.
//			The record will be run 1 cycle out of every nRunRatio cycles.
// Input:	pvRecord -		The record we're setting
//			nRunRatio -		The run ratio for this record
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::SetRunRatio( Data *pvRecord, int nRunRatio )
{
	PRecHdrFromPvRecord( pvRecord )->m_nRunRatio = nRunRatio;
}


//-----------------------------------------------------------------------------
// Purpose: Prepares us to run all records that are due to be run this frame.
//			Records are run at a particular time dependent on their hash bucket,
//			regardless of when they were last run.
// Input:	bNewFrame -		True if this is a new frame.  If false, we've run
//							off the end of the list and are checking whether
//							we need to keep going at the beginning.
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::StartFrameSchedule( bool bNewFrame )
{
	// Calculate our current frame and cycle cycle
	if ( bNewFrame )
	{
		m_iCycleLast = m_iCycleCur;
		m_iFrameCur++;
		m_iCycleCur = m_iFrameCur / m_cFramesPerCycle;
	}

	// Calculate the last bucket to run
	int iFrameInCycle = m_iFrameCur % m_cFramesPerCycle;
	m_iBucketRunMax = ( int ) ( ( ( int64 ) ( iFrameInCycle + 1 ) * ( int64 ) m_cBucket )
		/ ( int64 ) m_cFramesPerCycle );
	AssertFatal( m_iBucketRunMax >= 0 && m_iBucketRunMax <= m_cBucket );

	// Are we starting a new cycle?
	if ( m_iCycleCur > m_iCycleLast )
	{
#ifdef DBGFLAG_THASH
		Assert( m_iCycleCur == m_iCycleLast + 1 );
#endif

		// Did we finish the last cycle?
		if ( &m_RecHdrTail == m_pRecHdrRunNext )
		{
			m_pRecHdrRunNext = m_RecHdrHead.m_pRecHdrNext;
		}
		// No-- finish it up before moving on
		else
		{
			m_iBucketRunMax = m_cBucket + 1;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the next record to run, if any
// Output:	Pointer to the next record that needs to run (NULL if we're done)
//-----------------------------------------------------------------------------
template<class Data, class I>
Data *CTHash<Data,I>::PvRecordRun()
{
	// Loop until we find a record to run, or until we pass m_iBucketRunMax
	for ( ; ; )
	{
		// Are we past our stopping point?
		if ( m_pRecHdrRunNext->m_iBucket >= m_iBucketRunMax )
		{
			// If this cycle ran to the very end, see if we need to start over
			if ( m_iBucketRunMax > m_cBucket )
			{
				StartFrameSchedule( false );
				continue;
			}

			return NULL;
		}

#ifdef DBGFLAG_THASH
		Assert( m_pRecHdrRunNext->m_iBucket >= m_iBucketRunFirst );
		if ( 0 != m_pRecHdrRunNext->m_iCycleLast )
		{
			if ( m_pRecHdrRunNext->m_iCycleLast == m_iCycleCur )
			{
				DMsg( SPEW_CONSOLE,  1, "Double cycle: hdr = 0x%x, last frame = %d, curFrame = %d, first = %d, last = %d, bucket = %d\n",
					m_pRecHdrRunNext, m_pRecHdrRunNext->m_iFrameLast, m_iFrame,
					m_iBucketRunFirst, m_iBucketRunMax, m_pRecHdrRunNext->m_iBucket );
			}
			else if ( m_pRecHdrRunNext->m_iCycleLast != m_iCycleCur - 1 )
			{
				DMsg( SPEW_CONSOLE,  1, "Skipped cycle: hdr = 0x%x, cycleLast = %u, cycleCur = %u (missed %u cycles)\n",
					m_pRecHdrRunNext, m_pRecHdrRunNext->m_iCycleLast, m_iCycleCur,
					m_iCycleCur - m_pRecHdrRunNext->m_iCycleLast );
				Assert( false );
			}
		}
		m_pRecHdrRunNext->m_iCycleLast = m_iCycleCur;
		m_pRecHdrRunNext->m_iFrameLast = m_iFrame;
#endif

		// Set up the record to run next time
		RecHdr_t *pRecHdrCur = m_pRecHdrRunNext;
		m_pRecHdrRunNext = m_pRecHdrRunNext->m_pRecHdrNext;

		// Does this record need to run?
		if ( 0 == pRecHdrCur->m_nRunRatio )
			continue;

		if ( 0 == m_iCycleCur % pRecHdrCur->m_nRunRatio )
			return PvRecordFromPRecHdr( pRecHdrCur );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Return true if we've completed a scheduler pass since last called
//-----------------------------------------------------------------------------
template<class Data, class I>
bool CTHash<Data,I>::BCompletedPass()
{
	if ( m_iCycleCur != m_iCycleLastReported )
	{
		m_iCycleLastReported = m_iCycleCur;
		return true;
	}
	return false;
}


extern const unsigned char g_CTHashRandomValues[256];  // definition lives in globals.cpp

//-----------------------------------------------------------------------------
// Purpose: Returns the index of the hash bucket corresponding to a particular key
// Input:	unKey -		Key to find
// Output:	Index of the hash bucket corresponding to unKey
//-----------------------------------------------------------------------------
template<class Data, class I>
int CTHash<Data,I>::IBucket( I unKey ) const
{
	AssertFatal( m_cBucket > 0 );

	// This is a pearsons hash variant that returns a maximum of 32 bits
	size_t size = sizeof(I);
	const uint8 *	k    = (const uint8 *) &unKey;
	uint32 byte_one = 0, byte_two = 0, byte_three = 0, byte_four = 0, n;

	while (size)
	{
		--size;
		n    = *k++;
		byte_one = g_CTHashRandomValues[byte_one ^ n];
		
		if (size)
		{
			--size;
			n   = *k++;
			byte_two = g_CTHashRandomValues[byte_two ^ n];
		}
		else
			break;
		
		if (size)
		{
			--size;
			n   = *k++;
			byte_three = g_CTHashRandomValues[byte_three ^ n];
		}
		else
			break;
		
		if (size)
		{
			--size;
			n   = *k++;
			byte_four = g_CTHashRandomValues[byte_four ^ n];
		}
		else
			break;
	}

	uint32 idx = ( byte_four << 24 ) | ( byte_three << 16 ) | ( byte_two << 8 ) | byte_one;
	idx = idx % m_cBucket;
	return ( (int) idx ); 
}


#ifdef DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Run a global validation pass on all of our data structures and memory
//			allocations.
// Input:	validator -		Our global validator object
//			pchName -		Our name (typically a member var in our container)
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::Validate( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE();

	validator.ClaimMemory( m_pBucket );
	ValidatePtr( m_pMemoryPoolRecord );

#if defined( _DEBUG )
	// first verify m_cRecordInUse
	Data * pvRecord = PvRecordFirst();
	int cItems = 0;
	while ( pvRecord )
	{
		Data *pvRecordNext = PvRecordNext( pvRecord );
		cItems++;
		pvRecord = pvRecordNext;
	}
	Assert( m_cRecordInUse == cItems );
	// then ask the mempool to verify this
	if ( m_pMemoryPoolRecord )
		m_pMemoryPoolRecord->LeakCheck( cItems );
#endif // _DEBUG
}
#endif // DBGFLAG_VALIDATE


//-----------------------------------------------------------------------------
// Purpose: Inserts a new record into the table
// Input:	unKey -			Primary key of the new record
// Output:	Pointer to the new record
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::InsertIntoHash( RecHdr_t *pRecHdr, I unKey )
{
	m_cRecordInUse++;

	// Init the RecHdr
	pRecHdr->m_unKey = unKey;
	pRecHdr->m_nRunRatio = 1;

	// Find our hash bucket
	int iBucket = IBucket( unKey );
	pRecHdr->m_iBucket = iBucket;
#ifdef DBGFLAG_THASH
	pRecHdr->m_iCycleLast = 0;
#endif

	// Find where to insert ourselves in the linked list
	RecHdr_t *pRecHdrInsertBefore = &m_RecHdrTail;
	// Find the first bucket with anything in it that's at or after our bucket
	for ( int iBucketT = iBucket; iBucketT < m_cBucket; iBucketT++ )
	{
		if ( NULL != m_pBucket[iBucketT].m_pRecHdrFirst )
		{
			pRecHdrInsertBefore = m_pBucket[iBucketT].m_pRecHdrFirst;
			break;
		}
	}

	// Insert ourselves
	pRecHdr->m_pRecHdrNext = pRecHdrInsertBefore;
	pRecHdr->m_pRecHdrPrev = pRecHdrInsertBefore->m_pRecHdrPrev;
	pRecHdrInsertBefore->m_pRecHdrPrev = pRecHdr;
	pRecHdr->m_pRecHdrPrev->m_pRecHdrNext = pRecHdr;

	// Our bucket should point to us
	m_pBucket[iBucket].m_pRecHdrFirst = pRecHdr;
}


//-----------------------------------------------------------------------------
// Purpose: Removes the specified entry from the table
// Input:	pvRemove -		Pointer to the entry to remove
//-----------------------------------------------------------------------------
template<class Data, class I>
void CTHash<Data,I>::RemoveFromHash( Data * pvRemove )
{
	// Find our RecHdr
	RecHdr_t *pRecHdr = PRecHdrFromPvRecord( pvRemove );

	// If our bucket points to us, point it to the next record (or else NULL)
	int iBucket = IBucket( pRecHdr->m_unKey );
	if ( pRecHdr == m_pBucket[iBucket].m_pRecHdrFirst )
	{
		if ( pRecHdr->m_pRecHdrNext->m_iBucket == iBucket )
			m_pBucket[iBucket].m_pRecHdrFirst = pRecHdr->m_pRecHdrNext;
		else
			m_pBucket[iBucket].m_pRecHdrFirst = NULL;
	}

	// Remove us from the linked list
	pRecHdr->m_pRecHdrPrev->m_pRecHdrNext = pRecHdr->m_pRecHdrNext;
	pRecHdr->m_pRecHdrNext->m_pRecHdrPrev = pRecHdr->m_pRecHdrPrev;

	// Are we the next record to run?
	if ( pRecHdr == m_pRecHdrRunNext )
		m_pRecHdrRunNext = pRecHdr->m_pRecHdrNext;

	m_cRecordInUse--;
}

#endif // THASH_H