able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/query/cindex/partn.cxx

914 lines
25 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 2001.
//
// File: PARTN.CXX
//
// Contents: Content Index Partition
//
// Classes: CPartition
//
// History: 22-Mar-91 BartoszM Created.
//
// Notes: Unique index ID is created from byte sized per partition
// index ID and Partition ID shifted left by 8.
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <rwex.hxx>
#include <cifailte.hxx>
#include "partn.hxx"
#include "pindex.hxx"
#include "indxact.hxx"
#include "mmerglog.hxx"
#include "mindex.hxx"
#include "resman.hxx"
//+---------------------------------------------------------------------------
//
// Member: CPartition::CPartition, public
//
// Synopsis: Constructor for partition
//
// Arguments:
// [wid] -- wid used for the change log
// [partId] -- partition id
// [storage] -- used to create files
// [frmwrkParams] -- registry params to use
//
// History: 3-Apr-91 BartoszM Created.
//
//----------------------------------------------------------------------------
CPartition::CPartition (
WORKID wid,
PARTITIONID partID,
PStorage& storage,
CCiFrameworkParams & frmwrkParams )
: _sigPartition(eSigPartition),
_frmwrkParams( frmwrkParams ),
_id ( partID ), _queryCount(0), _changes( wid, storage, frmwrkParams ),
_widMasterLog(widInvalid),
_widNewMaster(widInvalid),
_widCurrentMaster(widInvalid),
_widChangeLog(wid),
_iidNewMasterIndex(CIndexId( iidInvalid, partidInvalid ) ),
_pRWStore(0),
_pOldMasterIndex(0),
_pMMergeIndSnap(0),
_storage(storage),
_fCleaningUp(FALSE)
{
// Fill the set of available index id's
_setPersIid.Fill();
_setPersIid.Remove( iidInvalid );
_wlid = MAX_PERS_ID + 1;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::~CPartition, public
//
// Synopsis: Destructor for partition
//
// History: 4-Apr-91 BartoszM Created.
//
//----------------------------------------------------------------------------
CPartition::~CPartition ()
{
delete _pRWStore;
delete _pMMergeIndSnap;
CIndex* pIndex;
//
// If a MasterMerge is in progress, the master index has an indexsnap
// shot with references to participating indexes. That must be deleted
// first.
//
pIndex = GetCurrentMasterIndex();
if ( 0 != pIndex )
{
_idxlst.Remove( pIndex->GetId() );
delete pIndex;
}
while ( (pIndex = _idxlst.RemoveTop()) != 0 )
{
delete pIndex;
}
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokEmpty, public
//
// Synopsis: Initialize a empty partition
//
// History: 14-Nov-94 DwightKr Created.
//
//----------------------------------------------------------------------------
void CPartition::LokEmpty()
{
_widMasterLog = widInvalid;
_widNewMaster = widInvalid;
_widCurrentMaster = widInvalid;
_iidNewMasterIndex = CIndexId( iidInvalid, partidInvalid );
delete _pRWStore;
_pRWStore = NULL;
_pOldMasterIndex = NULL;
delete _pMMergeIndSnap;
_pMMergeIndSnap = NULL;
_changes.LokEmpty();
}
#define _CompUL(x,y) ((*(x)) > (*(y)) ? 1 : (*(x)) == (*(y)) ? 0 : -1)
#define _SwapUL(x,y) { ULONG _t = *(x); *(x) = *(y); *(y) = _t; }
inline static void _AddRootUL(ULONG x,ULONG n,ULONG *p)
{
ULONG _x = x;
ULONG _j = (2 * (_x + 1)) - 1;
while (_j < n)
{
if (((_j + 1) < n) &&
(_CompUL(p + _j,p + _j + 1) < 0))
_j++;
if (_CompUL(p + _x,p + _j) < 0)
{
_SwapUL(p + _x,p + _j);
_x = _j;
_j = (2 * (_j + 1)) - 1;
}
else break;
}
} //_AddRootUL
void SortULongArray(ULONG *pulItems,ULONG cItems)
{
if (cItems == 0)
return;
long z;
for (z = (((long) cItems + 1) / 2) - 1; z >= 0; z--)
{
_AddRootUL(z,cItems,pulItems);
}
for (z = cItems - 1; z != 0; z--)
{
_SwapUL(pulItems,pulItems + z);
_AddRootUL(0,(ULONG) z,pulItems);
}
} //_SortULongArray
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokQueryMergeIndexes, public
//
// Arguments: [count] -- returns count of indexes in the array
// [mt] -- type of merge
//
// Returns: Array of indexes to be merged
//
// History: 4-Apr-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
CIndex** CPartition::LokQueryMergeIndexes ( unsigned& count, MergeType mt )
{
ciDebugOut (( DEB_ITRACE, "Query %s (%d)\n",
(mt == mtWordlist) ? "wordlists" : "merge indexes",
_idxlst.Count() ));
int cInd = _idxlst.Count();
ciDebugOut (( DEB_ITRACE, " Merge indexes: " ));
CIndex** indexes = new CIndex* [ cInd ];
SByteArray sapIndex( indexes );
unsigned cIndSoFar = 0;
CForIndexIter iter(_idxlst);
if ( mtMaster == mt )
{
//
// Don't include wordlists in a master merge. Must use only
// persistent indexes.
//
for ( ; !_idxlst.AtEnd(iter); _idxlst.Advance(iter) )
{
CIndexId iid = iter->GetId();
if ( iid.IsPersistent() && !iter->IsZombie() )
{
ciDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME, "%lx, ",
iter->GetId() ));
iter->Reference();
indexes[cIndSoFar++] = iter.GetIndex();
}
}
}
else
{
Win4Assert( mtShadow == mt || mtWordlist == mt || mtAnnealing == mt || mtIncrBackup || mtDeletes == mt );
// Get the sizes of all persistent indexes that might be in the merge
ULONG aSizes[ MAX_PERS_ID ];
ULONG cPersistent = 0;
{
CForIndexIter iterSize( _idxlst );
for ( ; !_idxlst.AtEnd( iterSize ); _idxlst.Advance( iterSize ) )
{
if ( !iterSize->IsMaster() && !iterSize->InMasterMerge() )
{
CIndexId iid = iterSize->GetId();
if ( iid.IsPersistent() )
{
ULONG cp = iterSize->Size();
//DbgPrint( " pers index %d is size %#x pages\n", cPersistent, cp );
aSizes[ cPersistent++ ] = cp;
}
}
}
}
// Find the size of the index with 1/3 smaller and 2/3 larger indexes
ULONG aMedian[ MAX_PERS_ID ];
RtlCopyMemory( &aMedian, &aSizes, cPersistent * sizeof ULONG );
SortULongArray( (ULONG *) &aMedian, cPersistent );
ULONG cpAtOneThird = aMedian[ cPersistent / 3 ];
// Wordlists come first in the iteration. Add them all to the merge.
for ( ; !_idxlst.AtEnd(iter); _idxlst.Advance(iter) )
{
CIndexId iid = iter->GetId();
if ( iid.IsPersistent() )
break;
ciDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME, "%lx, ",
iter->GetId() ));
Win4Assert ( !iter->IsZombie() );
iter->Reference();
indexes[cIndSoFar++] = iter.GetIndex();
}
//
// If we are doing a shadow merge, we must not have more than the maximum
// allowed count of indexes - so merge as to have at most that number.
//
if ( mtShadow == mt || mtAnnealing == mt || mtIncrBackup == mt || mtDeletes == mt )
{
unsigned cMaxRemaining;
//
// Count is decremented by 1 to account for the new index that will
// be created.
//
BOOL fAnyPersistent = TRUE;
if ( mtDeletes == mt )
{
cMaxRemaining = _frmwrkParams.GetMaxIndexes() - 1;
}
else if ( mtShadow == mt )
{
cMaxRemaining = 0;
// Don't use any persistent indexes in the merge if
// there are free slots available.
if ( cPersistent < _frmwrkParams.GetMaxIndexes() )
fAnyPersistent = FALSE;
}
else if ( mtAnnealing == mt )
{
cMaxRemaining = _frmwrkParams.GetMaxIdealIndexes() - 1;
}
else
{
cMaxRemaining = 0;
}
ULONG cSoFar = 0;
if ( fAnyPersistent )
{
while ( !_idxlst.AtEnd(iter) && (cInd - cIndSoFar > cMaxRemaining) )
{
CIndexId iid = iter->GetId();
ciDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME, "pers: %lx, ",
iter->GetId() ));
Win4Assert ( !iter->IsZombie() );
if ( !iter->IsMaster() && !iter->InMasterMerge() )
{
//
// We should skip over the master index and indexes
// participating in a master merge for a shadow merge.
// Also skip indexes > 4 times the size of the 1/3 median.
//
if ( ( mtShadow != mt ) ||
( aSizes[cSoFar] < ( 4 * cpAtOneThird) ) )
{
iter->Reference();
indexes[cIndSoFar++] = iter.GetIndex();
}
cSoFar++;
}
else
{
#if DBG==1
if ( iter->InMasterMerge() )
{
ciDebugOut(( DEB_ITRACE,
"ShadowMergeSet:Skipping over 0x%X - Already in MMergeSet\n",
iter->GetId() ));
}
#endif // DBG==1
}
_idxlst.Advance(iter);
}
}
}
}
count = cIndSoFar;
ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME, "\n" ));
sapIndex.Acquire();
return indexes;
} //LokQueryMergeIndexes
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokQueryIndexesForBackup
//
// Synopsis: Snaps persistent indexes for backup. For a full backup, all
// persistent indexes are returned. For an incremental backup,
// only the shadow indexes are returned.
//
// Arguments: [count] - on output, count of indexes
// [fFull] - Flag indicating if it is a full backup.
//
// Returns: Array of pointers to refcounted indexes.
//
// History: 3-18-97 srikants Created
//
//----------------------------------------------------------------------------
CIndex** CPartition::LokQueryIndexesForBackup ( unsigned& count, BOOL fFull )
{
ciDebugOut (( DEB_ITRACE, "LokQueryIndexesForBackup (%s)\n",
fFull ? "Full" : "Incremental" ));
int cInd = _idxlst.Count();
ciDebugOut (( DEB_ITRACE, " Backup indexes: " ));
CIndex** indexes = new CIndex* [ cInd ];
SByteArray sapIndex( indexes );
unsigned cIndSoFar = 0;
CForIndexIter iter(_idxlst);
//
// Don't include wordlists . Must use only persistent indexes.
//
for ( ; !_idxlst.AtEnd(iter); _idxlst.Advance(iter) )
{
CIndexId iid = iter->GetId();
if ( iid.IsPersistent() && !iter->IsZombie() )
{
if ( !fFull && iter.GetIndex()->IsMaster() )
{
//
// For an incremental backup, skip the master index.
//
continue;
}
//
// We should never have an in-progress merge while doing the
// save.
//
Win4Assert( ! iter.GetIndex()->IsMasterMergeIndex() );
ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME, "%lx, ",
iter->GetId() ));
iter->Reference();
indexes[cIndSoFar++] = iter.GetIndex();
}
}
count = cIndSoFar;
ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME, "\n" ));
sapIndex.Acquire();
return indexes;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokCheckMerge, public
//
// Synopsis: Checks if there is need to merge
//
// Arguments: [mt] -- type of merge
// History: 4-Apr-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
BOOL CPartition::LokCheckMerge( MergeType mt )
{
if ( mt == mtShadow )
{
ciDebugOut (( DEB_ITRACE, "Partition: check shadow merge\n" ));
if ( _idxlst.CountWlist() >= _frmwrkParams.GetMaxWordlists() )
{
ciDebugOut (( DEB_ITRACE | DEB_PENDING,
"Shadow merge, reason: wordlists %d >= %d \n",
_idxlst.CountWlist(), _frmwrkParams.GetMaxWordlists() ));
return TRUE;
}
if ( LokCheckWordlistMerge() )
{
ciDebugOut(( DEB_ITRACE | DEB_PENDING,
"Shadow merge, reason: wordlist size > %d\n",
_frmwrkParams.GetMinSizeMergeWordlist() ));
return TRUE;
}
}
else if ( mt == mtAnnealing )
{
ciDebugOut (( DEB_ITRACE, "Partition: check annealing merge\n" ));
if ( _idxlst.Count() > _frmwrkParams.GetMaxIdealIndexes() ||
_idxlst.CountWlist() > 0 )
{
ciDebugOut (( DEB_ITRACE | DEB_PENDING,
"Annealing merge, reason: too many indices %d >= %d, %d wordlists \n",
_idxlst.Count(), _frmwrkParams.GetMaxIdealIndexes(), _idxlst.CountWlist() ));
return TRUE;
}
}
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokCheckWordlistMerge, public
//
// Synopsis: Checks if there is need to merge due to excessive wordlist
// memory consumption.
//
// History: 12-Jan-1999 KyleP Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
BOOL CPartition::LokCheckWordlistMerge()
{
unsigned size = 0;
for ( CForIndexIter iter (_idxlst);
!_idxlst.AtEnd(iter);
_idxlst.Advance(iter) )
{
CIndexId iid = iter->GetId();
if ( iid.IsPersistent() )
break;
Win4Assert( !iter->IsZombie() );
size += iter.GetIndex()->Size();
}
return ( size > _frmwrkParams.GetMinSizeMergeWordlist() );
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokGetIndexes, public
//
// Synopsis: Returns an array of index pointers
//
// Arguments: [cInd] -- count of returned indexes
//
// History: 07-Oct-91 BartoszM Created
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
unsigned CPartition::LokGetIndexes ( CIndex** apIndex )
{
ciDebugOut (( DEB_ITRACE, "CPartition::GetIndexes\n" ));
if ( _idxlst.Count() == 0 )
return 0;
unsigned cInd = 0;
for (CForIndexIter iter (_idxlst); !_idxlst.AtEnd(iter); _idxlst.Advance(iter))
{
Win4Assert ( !iter->IsZombie() );
iter->Reference();
apIndex[cInd] = iter.GetIndex();
cInd++ ;
}
return cInd;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokMakeWlstId, public
//
// Synopsis: Return unique volatile index id
//
// History: 12-Apr-91 BartoszM Created.
//
//----------------------------------------------------------------------------
INDEXID CPartition::LokMakeWlstId ()
{
Win4Assert ( _wlid > MAX_PERS_ID );
ULONG hint = _wlid;
CIndexId iid;
for(;;)
{
iid = CIndexId ( hint, _id );
for ( CForIndexIter iter = _idxlst;
!_idxlst.AtEnd(iter);
_idxlst.Advance(iter) )
{
if ( iter->GetId() == iid )
break;
}
hint++;
// wrap around
if ( hint >= MAX_VOL_ID )
hint = MAX_PERS_ID + 1;
Win4Assert ( hint != _wlid );
if (_idxlst.AtEnd(iter) )
break;
}
_wlid = hint;
return iid;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokMakePersId, public
//
// Synopsis: Return unique persistent index id
//
// History: 12-Apr-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
INDEXID CPartition::LokMakePersId ()
{
int piid = _setPersIid.FirstElement();
if ( piid == EOS )
{
Win4Assert ( piid != EOS );
return iidInvalid;
}
_setPersIid.Remove ( piid );
ciDebugOut (( DEB_ITRACE, "New pers index id %x\n", piid ));
CIndexId iid ( piid, _id );
#if CIDBG==1
//
// There musn't be an index already with the same iid.
//
Win4Assert( 0 == LokGetIndex(iid) && "Adding Duplicate Index" );
#endif // CIDBG==1
return iid;
}
void CPartition::RegisterId ( CIndexId iid )
{
int persid = iid.PersId();
_setPersIid.Remove ( persid );
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::FreeIndexId, public
//
// Synopsis: Recycle index id
//
// History: 08-Oct-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
void CPartition::FreeIndexId ( CIndexId iid )
{
ciDebugOut (( DEB_ITRACE, "Free index id %lx\n", iid ));
if ( iid.IsPersistent() )
{
int persid = iid.PersId();
_setPersIid.Add ( persid );
}
}
#if CIDBG==1
CIndex * CPartition::LokGetIndex( CIndexId iid)
{
CForIndexIter iter(_idxlst);
for ( ; !_idxlst.AtEnd(iter); _idxlst.Advance(iter) )
{
CIndexId iidCurr = iter->GetId();
if ( iidCurr == iid )
{
return iter.GetIndex();
}
}
return 0;
}
#endif // CIDBG==1
//+---------------------------------------------------------------------------
//
// Member: CPartition::AddIndex, public
//
// Synopsis: Add a newly created index (wordlist)
//
// Arguments: [pIndex] -- index to be added
//
// History: 26-Apr-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
void CPartition::AddIndex ( CIndex* pIndex )
{
ciDebugOut (( DEB_ITRACE, "Partition: Adding index %lx\n", pIndex->GetId() ));
#if CIDBG==1
//
// This index must not already exist in the list.
//
CIndexId iid = pIndex->GetId();
Win4Assert( 0 == LokGetIndex( iid ) && "Adding Duplicate Index" );
#endif // CIDBG==1
_idxlst.Add ( pIndex );
#ifdef CI_FAILTEST
NTSTATUS status = CI_CORRUPT_DATABASE ;
ciFAILTEST( status );
#endif // CI_FAILTEST
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::Swap, public
//
// Synopsis: Replace old indexes with a new one (after merge)
// Old indexes are removed from the list
// and marked 'deleted' for later deletion
//
// Arguments: [xact] -- transaction
// [pIndexNew] -- index to be added
// [cInd] -- count of indexes to be removed
// [aiidOld] -- indexes to be removed
//
// History: 26-Apr-91 BartoszM Created.
//
// Notes: ResMan LOCKED
//
//----------------------------------------------------------------------------
void CPartition::Swap (
CMergeTrans& xact,
CIndex * pIndexNew,
unsigned cInd,
INDEXID aIidOld[] )
{
ciDebugOut (( DEB_ITRACE, "Partition: Swap in %lx for \n",
pIndexNew->GetId() ));
// Indexes will be deleted when transaction commits
for ( unsigned i = 0; i < cInd; i++ )
{
_idxlst.Remove ( aIidOld[i] );
xact.LogSwap ();
}
//
// The master index was added to the index list at the BEGINNING of the
// master merge. Hence we don't need to add it here.
//
if ( !pIndexNew->IsMaster() )
{
#if CIDBG==1
//
// This index must not already exist in the list.
//
CIndexId iid = pIndexNew->GetId();
Win4Assert( 0 == LokGetIndex( iid ) && "Adding Duplicate Index" );
#endif // CIDBG==1
_idxlst.Add ( pIndexNew );
}
_changes.LokRemoveIndexes ( xact, cInd, aIidOld );
}
//+---------------------------------------------------------------------------
//
// Function: LokQueryMMergeIndexes
//
// Synopsis: Gets the list on indexes participating in the master merge
// based on the list of indexes stored in the master merge log.
//
// Arguments: [count] -- Will have the number of participating
// indexes.
// [objMMLog] -- The Recoverable Storage Object for the master
// merge log.
//
// History: 4-01-94 srikants Created
//
// Notes: The indexes are NOT reference counted here because they
// are expected to have been reference counted during startup.
//
//----------------------------------------------------------------------------
CIndex ** CPartition::LokQueryMMergeIndexes( unsigned & count,
PRcovStorageObj & objMMLog )
{
//
// Iterator for the master log.
//
CMMergeIdxListIter iterMMLog( objMMLog );
count = iterMMLog.Count();
Win4Assert( 0 != count );
CIndex** indexes = new CIndex* [ count ];
SByteArray sapIndex(indexes);
ULONG cIndSoFar = 0;
for ( CForIndexIter iter(_idxlst) ;
!_idxlst.AtEnd(iter); _idxlst.Advance(iter) )
{
CIndexId iid = iter->GetId();
if ( iid.IsPersistent() && iterMMLog.Found( iid) )
{
ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME, "%lx, ",
iter->GetId() ));
Win4Assert ( !iter->IsZombie() );
indexes[cIndSoFar++] = iter.GetIndex();
iter->Reference();
iter->SetInMasterMerge();
}
}
Win4Assert( cIndSoFar == count );
sapIndex.Acquire();
return(indexes);
}
void CPartition::SerializeMMergeIndexes( unsigned count,
const CIndex * aIndexes[], PRcovStorageObj & objMMLog )
{
CNewMMergeLog mmLog ( objMMLog );
for ( unsigned i = 0; i < count; i++ )
{
const CIndex * pIndex = aIndexes[i];
Win4Assert( pIndex->IsPersistent() );
CIndexId iid(pIndex->GetId());
mmLog.AddPersistentIndex( iid );
}
mmLog.Commit();
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::GetCurrentMasterIndex, public
//
// Synopsis: Returns the current master index for this partition.
//
// History: 13-Apr-94 DwightKr Created.
//
//----------------------------------------------------------------------------
CPersIndex * CPartition::GetCurrentMasterIndex()
{
for (CForIndexIter iter(_idxlst);
!_idxlst.AtEnd(iter);
_idxlst.Advance(iter)
)
{
if ( iter->IsMaster() )
{
Win4Assert( iter->IsPersistent() );
return (CPersIndex*) iter.GetIndex();
}
}
return 0;
}
//+---------------------------------------------------------------------------
//
// Member: CPartition::LokZombify, public
//
// Synopsis: Zombify all indexes, and delete the MMlog, if any. Ownership
// of the indexes is transferred to the caller.
//
// History: 13-Apr-94 DwightKr Created.
//
//----------------------------------------------------------------------------
CIndex ** CPartition::LokZombify(unsigned & cInd )
{
//
// Get list of current indexes
//
CIndex ** paIndex = new CIndex *[ _idxlst.Count() ];
cInd = LokGetIndexes( paIndex );
//
// Zombify each index, and remove it from the in-memory index list
//
for (unsigned i=0; i<cInd; i++)
{
paIndex[i]->Zombify();
_idxlst.Remove( paIndex[i]->GetId() );
}
return paIndex;
}
Reference in a new issue Copy permalink