SegPageLock Class Reference

A SegPageLock is associated with a single segment, and starts out in the unlocked state. More...

#include <SegPageLock.h>

Inheritance diagram for SegPageLock:

SegNodeLock< Node > List of all members.

Public Member Functions

 SegPageLock ()
 SegPageLock (SegmentAccessor const &segmentAccessor)
 ~SegPageLock ()
void accessSegment (SegmentAccessor const &segmentAccessorInit)
bool isLocked () const
CachePage & getPage () const
PageId allocatePage (PageOwnerId ownerId=ANON_PAGE_OWNER_ID)
PageId tryAllocatePage (PageOwnerId ownerId=ANON_PAGE_OWNER_ID)
void deallocateLockedPage ()
void deallocateUnlockedPage (PageId pageId)
void unlock ()
void dontUnlock ()
void lockPage (PageId pageId, LockMode lockModeInit, bool readIfUnmapped=true)
void lockPageWithCoupling (PageId pageId, LockMode lockModeInit)
void lockShared (PageId pageId)
void lockExclusive (PageId pageId)
void lockSharedNoWait (PageId pageId)
void lockExclusiveNoWait (PageId pageId)
void updatePage ()
void lockUpdatePage (PageId updatePageId)
PageId getPageId ()
void flushPage (bool async)
void swapBuffers (SegPageLock &other)
bool tryUpgrade ()
SharedCacheAccessor getCacheAccessor () const

Private Member Functions

void resetPage ()
LockMode getLockMode (LockMode origLockMode)
void initialize ()

Private Attributes

SegmentAccessor segmentAccessor
CachePage * pPage
LockMode lockMode
PageId lockedPageId
bool newPage
bool isWriteVersioned

Detailed Description

A SegPageLock is associated with a single segment, and starts out in the unlocked state.

It serves a function similar to a boost::scoped_lock, but for locking Cache pages rather than synchronization objects. The lockShared or lockExclusive methods can be used to access a page of the segment by its ID; the destructor for the SegPageLock will then unlock the page automatically, unless the dontUnlock method is invoked first.

Definition at line 50 of file SegPageLock.h.

Constructor & Destructor Documentation

SegPageLock::SegPageLock (  )  [inline, explicit]

Definition at line 100 of file SegPageLock.h.

00101     {
00102         initialize();
00103         resetPage();
00104     }

SegPageLock::SegPageLock ( SegmentAccessor const &  segmentAccessor  )  [inline, explicit]

Definition at line 106 of file SegPageLock.h.

00108     {
00109         initialize();
00110         resetPage();
00111         accessSegment(segmentAccessor);
00112     }

SegPageLock::~SegPageLock (  )  [inline]

Definition at line 114 of file SegPageLock.h.

00115     {
00116         unlock();
00117     }

Member Function Documentation

void SegPageLock::resetPage (  )  [inline, private]

Definition at line 64 of file SegPageLock.h.

References NULL_PAGE_ID.

00065     {
00066         pPage = NULL;
00067         lockedPageId = NULL_PAGE_ID;
00068         newPage = false;
00069     }

LockMode SegPageLock::getLockMode ( LockMode  origLockMode  )  [inline, private]

Definition at line 71 of file SegPageLock.h.

References LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, and LOCKMODE_X_NOWAIT.

00072     {
00073         // If writes are versioned, then there's no need to apply an
00074         // exclusive lock on the current version of the page.  When
00075         // we need to modify the page, we'll create a new version of the
00076         // page, which we'll exclusively lock.
00077         if (isWriteVersioned) {
00078             if (origLockMode == LOCKMODE_X
00079                 || origLockMode == LOCKMODE_X_NOWAIT)
00080             {
00081                 return
00082                     (origLockMode == LOCKMODE_X) ?
00083                         LOCKMODE_S : LOCKMODE_S_NOWAIT;
00084             }
00085         }
00086 
00087         return origLockMode;
00088     }

void SegPageLock::initialize (  )  [inline, private]

Definition at line 90 of file SegPageLock.h.

References LOCKMODE_X.

00091     {
00092         // this is a dummy to keep happy optimizing compilers which are too
00093         // smart for their own good
00094         lockMode = LOCKMODE_X;
00095         isWriteVersioned = false;
00096     }

void SegPageLock::accessSegment ( SegmentAccessor const &  segmentAccessorInit  )  [inline]

Definition at line 119 of file SegPageLock.h.

References SegmentAccessor::pCacheAccessor, and SegmentAccessor::pSegment.

Referenced by BTreeBuildLevel::allocateAndLinkNewNode(), BTreeBuildLevel::BTreeBuildLevel(), BTreeReader::BTreeReader(), BTreeWriter::BTreeWriter(), BTreeBuilder::createEmptyRoot(), ExternalSortRunLoader::ExternalSortRunLoader(), SegPageBackupRestoreDevice::init(), LhxHashTable::init(), LcsClusterAccessBase::LcsClusterAccessBase(), LcsClusterNodeWriter::LcsClusterNodeWriter(), LcsClusterAppendExecStream::prepare(), LbmUnionExecStream::prepare(), LbmGeneratorExecStream::prepare(), LbmChopperExecStream::prepare(), BTreePrefetchSearchExecStream::prepare(), FlatFileExecStreamImpl::prepare(), ScratchBufferExecStream::prepare(), MockResourceExecStream::prepare(), DoubleBufferExecStream::prepare(), SpillOutputStream::SpillOutputStream(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmEntryTest::testMergeEntry(), LbmEntryTest::testZeroBytes(), BTreeBuilder::truncate(), BTreeBuilder::truncateChildren(), BTreeBuilder::truncateExternal(), and BTreeVerifier::verifyNode().

00121     {
00122         assert(!pPage);
00123         assert(segmentAccessorInit.pSegment);
00124         assert(segmentAccessorInit.pCacheAccessor);
00125         segmentAccessor = segmentAccessorInit;
00126         isWriteVersioned = segmentAccessor.pSegment->isWriteVersioned();
00127     }

bool SegPageLock::isLocked (  )  const [inline]

Definition at line 129 of file SegPageLock.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterNodeWriter::close(), SpillOutputStream::closeImpl(), BTreeWriter::compactNode(), BTreeWriter::deleteCurrent(), SpillOutputStream::flushBuffer(), SegOutputStream::flushBuffer(), SpillOutputStream::getInputStream(), BTreeReader::isPositioned(), BTreeNonLeafReader::isPositionedOnInfinityKey(), SegmentTestBase::lockPage(), ScratchBufferExecStream::open(), DoubleBufferExecStream::open(), SegInputStream::readNextBuffer(), BTreeReader::searchNext(), BTreeNonLeafReader::searchNext(), BTreeLeafReader::searchNext(), swapBuffers(), BTreeWriter::updateCurrent(), and SegOutputStream::updatePage().

00130     {
00131         return pPage ? true : false;
00132     }

CachePage& SegPageLock::getPage (  )  const [inline]

Definition at line 134 of file SegPageLock.h.

Referenced by LcsClusterNodeWriter::allocArrays(), BTreeBuildLevel::allocateAndLinkNewNode(), LbmEntryTest::allocateBuf(), ExternalSortRunLoader::allocateBuffer(), BTreePrefetchSearchExecStream::allocateScratchPages(), LhxHashTable::allocBlock(), VersionedRandomAllocationSegment::backupAllocationNodes(), SegNodeLock< Node >::checkMagicNumber(), DoubleBufferExecStream::execute(), SegOutputStream::flushBuffer(), SpillOutputStream::getInputStream(), SegNodeLock< Node >::getNodeForRead(), SegNodeLock< Node >::getNodeForWrite(), LbmGeneratorExecStream::initBitmapTable(), LcsClusterAppendExecStream::initLoad(), SegPageBackupRestoreDevice::initScratchPages(), SegNodeLock< Node >::isMagicNumberValid(), VersionedRandomAllocationSegment::locateDataPages(), CrcSegInputStream::lockBufferParanoid(), SegmentTestBase::lockPage(), VersionedSegment::notifyPageDirty(), LbmUnionExecStream::open(), LbmChopperExecStream::open(), FlatFileExecStreamImpl::open(), ScratchBufferExecStream::open(), DoubleBufferExecStream::open(), VersionedSegment::recover(), SpillOutputStream::spill(), SpillOutputStream::SpillOutputStream(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), and Database::writeHeader().

00135     {
00136         assert(isLocked());
00137         return *pPage;
00138     }

PageId SegPageLock::allocatePage ( PageOwnerId  ownerId = ANON_PAGE_OWNER_ID  )  [inline]

Reimplemented in SegNodeLock< Node >.

Definition at line 140 of file SegPageLock.h.

References NULL_PAGE_ID.

Referenced by LbmEntryTest::allocateBuf(), ExternalSortRunLoader::allocateBuffer(), SegNodeLock< Node >::allocatePage(), LhxHashTable::allocBlock(), MockResourceExecStream::execute(), SegPageBackupRestoreDevice::initScratchPages(), SegmentTestBase::lockPage(), VersionedSegment::notifyPageDirty(), LbmUnionExecStream::open(), LbmChopperExecStream::open(), FlatFileExecStreamImpl::open(), ScratchBufferExecStream::open(), DoubleBufferExecStream::open(), SpillOutputStream::SpillOutputStream(), and RandomAllocationSegmentTest::testAllocateAndDeallocate().

00141     {
00142         PageId pageId = tryAllocatePage(ownerId);
00143         permAssert(pageId != NULL_PAGE_ID);
00144         return pageId;
00145     }

PageId SegPageLock::tryAllocatePage ( PageOwnerId  ownerId = ANON_PAGE_OWNER_ID  )  [inline]

Reimplemented in SegNodeLock< Node >.

Definition at line 147 of file SegPageLock.h.

References LOCKMODE_X, and NULL_PAGE_ID.

Referenced by SegmentTestBase::testAllocate(), and SegNodeLock< Node >::tryAllocatePage().

00148     {
00149         unlock();
00150         PageId pageId = segmentAccessor.pSegment->allocatePageId(ownerId);
00151         if (pageId == NULL_PAGE_ID) {
00152             return pageId;
00153         }
00154         lockPage(pageId,LOCKMODE_X,false);
00155         newPage = true;
00156         return pageId;
00157     }

void SegPageLock::deallocateLockedPage (  )  [inline]

Definition at line 159 of file SegPageLock.h.

Referenced by SegInputStream::readNextBuffer(), BTreeBuilder::swapRoot(), SegmentTestBase::testDeallocate(), and BTreeBuilder::truncate().

00160     {
00161         assert(isLocked());
00162         BlockId blockId = pPage->getBlockId();
00163         unlock();
00164         PageId pageId = segmentAccessor.pSegment->translateBlockId(blockId);
00165         // we rely on the segment to decide whether to discard the block
00166         // from cache
00167         segmentAccessor.pSegment->deallocatePageRange(pageId,pageId);
00168     }

void SegPageLock::deallocateUnlockedPage ( PageId  pageId  )  [inline]

Definition at line 170 of file SegPageLock.h.

References NULL_PAGE_ID.

Referenced by SegInputStream::closeImpl(), BTreeBuilder::truncateChildren(), and BTreeBuilder::truncateExternal().

00171     {
00172         assert(pageId != NULL_PAGE_ID);
00173         BlockId blockId = segmentAccessor.pSegment->translatePageId(pageId);
00174         // we rely on the segment to decide whether to discard the block
00175         // from cache
00176         segmentAccessor.pSegment->deallocatePageRange(pageId,pageId);
00177     }

void SegPageLock::unlock (  )  [inline]

Definition at line 179 of file SegPageLock.h.

Referenced by BTreeReader::adjustRootLockMode(), LcsClusterNodeWriter::allocArrays(), LbmEntryTest::allocateBuf(), ExternalSortRunLoader::allocateBuffer(), Database::allocateHeader(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), LhxHashTable::allocBlock(), LcsClusterNodeWriter::close(), SpillOutputStream::closeImpl(), SegStream::closeImpl(), SegInputStream::closeImpl(), ScratchBufferExecStream::closeImpl(), DoubleBufferExecStream::closeImpl(), BackupRestoreTest::createSnapshotData(), BTreeReader::endSearch(), BackupRestoreTest::executeSnapshotTxn(), SegOutputStream::flushBuffer(), BTreeWriter::grow(), LcsClusterAppendExecStream::initLoad(), BTreeNonLeafReader::isRootOnly(), VersionedRandomAllocationSegment::locateDataPages(), CrcSegInputStream::lockBuffer(), BTreeWriter::lockParentPage(), LbmUnionExecStream::open(), SegInputStream::readNextBuffer(), BTreeWriter::releaseScratchBuffers(), BTreeReader::searchForKeyTemplate(), SpillOutputStream::spill(), BTreeWriter::splitCurrentNode(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), BTreeBuilder::truncateChildren(), and LcsClusterAccessBase::unlockClusterPage().

00180     {
00181         if (pPage) {
00182             segmentAccessor.pCacheAccessor->unlockPage(
00183                 *pPage,
00184                 lockMode);
00185             resetPage();
00186         }
00187     }

void SegPageLock::dontUnlock (  )  [inline]

Definition at line 189 of file SegPageLock.h.

Referenced by SegmentTestBase::lockPage().

00190     {
00191         resetPage();
00192     }

void SegPageLock::lockPage ( PageId  pageId,
LockMode  lockModeInit,
bool  readIfUnmapped = true 
) [inline]

Definition at line 194 of file SegPageLock.h.

Referenced by BTreeNonLeafReader::isRootOnly(), SegmentTestBase::lockPage(), BTreeLeafReader::searchExtreme(), BTreeReader::searchExtremeInternal(), BTreeReader::searchForKeyTemplate(), and BTreeReader::searchNextInternal().

00197     {
00198         // if the page we want to lock is already locked in the desired
00199         // mode, nothing needs to be done
00200         if (isLocked() && pageId == lockedPageId && lockMode == lockModeInit) {
00201             return;
00202         }
00203         unlock();
00204         lockMode = getLockMode(lockModeInit);
00205         BlockId blockId = segmentAccessor.pSegment->translatePageId(pageId);
00206         pPage = segmentAccessor.pCacheAccessor->lockPage(
00207             blockId,
00208             lockMode,
00209             readIfUnmapped,
00210             segmentAccessor.pSegment->getMappedPageListener(blockId));
00211         lockedPageId = pageId;
00212     }

void SegPageLock::lockPageWithCoupling ( PageId  pageId,
LockMode  lockModeInit 
) [inline]

Definition at line 214 of file SegPageLock.h.

References LOCKMODE_S_NOWAIT.

Referenced by BTreeWriter::lockParentPage(), and BTreeReader::searchForKeyTemplate().

00216     {
00217         assert(lockModeInit < LOCKMODE_S_NOWAIT);
00218         BlockId blockId = segmentAccessor.pSegment->translatePageId(pageId);
00219         LockMode newLockMode = getLockMode(lockModeInit);
00220         CachePage *pNewPage = segmentAccessor.pCacheAccessor->lockPage(
00221             blockId,
00222             newLockMode,
00223             true,
00224             segmentAccessor.pSegment->getMappedPageListener(blockId));
00225         assert(pNewPage);
00226         unlock();
00227         lockMode = newLockMode;
00228         pPage = pNewPage;
00229         lockedPageId = pageId;
00230     }

void SegPageLock::lockShared ( PageId  pageId  )  [inline]

Definition at line 232 of file SegPageLock.h.

References LOCKMODE_S.

Referenced by VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), BTreeAccessBase::getFirstChild(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), Database::loadHeader(), VersionedRandomAllocationSegment::locateDataPages(), SegInputStream::lockBuffer(), CrcSegInputStream::lockBufferParanoid(), LcsClusterReader::moveToBlock(), LcsClusterReader::moveToBlockWithRid(), LcsClusterReader::readClusterPage(), VersionedRandomAllocationSegment::restoreFromBackup(), SegmentTestBase::testDeallocate(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), VersionedRandomAllocationSegment::uncommittedDeallocation(), VersionedRandomAllocationSegment::validateFreePageCount(), BTreeVerifier::verifyNode(), and BackupRestoreTest::verifySnapshotData().

00233     {
00234         lockPage(pageId,LOCKMODE_S);
00235     }

void SegPageLock::lockExclusive ( PageId  pageId  )  [inline]

Definition at line 237 of file SegPageLock.h.

References LOCKMODE_X.

Referenced by VersionedRandomAllocationSegment::allocateAllocNodes(), BTreeBuildLevel::allocateAndLinkNewNode(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), BTreeBuilder::buildBalanced(), VersionedRandomAllocationSegment::chainPageEntries(), VersionedRandomAllocationSegment::copyPageEntryFromTemp(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), RandomAllocationSegmentBase::deallocatePageId(), VersionedRandomAllocationSegment::deallocateSinglePage(), VersionedRandomAllocationSegment::deferDeallocation(), BackupRestoreTest::executeSnapshotTxn(), RandomAllocationSegmentBase::format(), LcsClusterNodeWriter::getLastClusterPageForWrite(), VersionedRandomAllocationSegment::initPageEntry(), VersionedSegment::recover(), BTreeBuilder::swapRoot(), RandomAllocationSegmentBase::tallySegAllocNodePages(), BTreeBuilder::truncate(), BTreeBuilder::truncateChildren(), VersionedRandomAllocationSegment::updateExtentEntry(), VersionedRandomAllocationSegment::updateTempPageEntry(), VersionedRandomAllocationSegment::validateFreePageCount(), and Database::writeHeader().

00238     {
00239         lockPage(pageId,LOCKMODE_X);
00240     }

void SegPageLock::lockSharedNoWait ( PageId  pageId  )  [inline]

Definition at line 242 of file SegPageLock.h.

References LOCKMODE_S, and LOCKMODE_S_NOWAIT.

00243     {
00244         lockPage(pageId,LOCKMODE_S_NOWAIT);
00245         lockMode = LOCKMODE_S;
00246     }

void SegPageLock::lockExclusiveNoWait ( PageId  pageId  )  [inline]

Definition at line 248 of file SegPageLock.h.

References LOCKMODE_X, and LOCKMODE_X_NOWAIT.

00249     {
00250         lockPage(pageId,LOCKMODE_X_NOWAIT);
00251         lockMode = LOCKMODE_X;
00252     }

void SegPageLock::updatePage (  )  [inline]

Definition at line 254 of file SegPageLock.h.

References LOCKMODE_S, LOCKMODE_X, and NULL_PAGE_ID.

Referenced by SegNodeLock< Node >::getNodeForWrite(), and swapBuffers().

00255     {
00256         assert(isLocked());
00257 
00258         // If the page is not newly allocated and can't be updated in-place,
00259         // lock the page that will be updated
00260         if (!newPage) {
00261             PageId origPageId =
00262                 segmentAccessor.pSegment->translateBlockId(getPage().
00263                     getBlockId());
00264             PageId updatePageId =
00265                 segmentAccessor.pSegment->updatePage(origPageId);
00266             if (updatePageId != NULL_PAGE_ID) {
00267                 lockUpdatePage(updatePageId);
00268                 return;
00269             }
00270         }
00271 
00272         // Either the page is new or the page can be updated in-place.
00273         // If we haven't locked the page exclusively yet, upgrade the
00274         // shared lock, forcing the upgrade to wait for pending IOs.
00275         if (lockMode == LOCKMODE_S) {
00276             assert(isWriteVersioned);
00277             TxnId txnId = segmentAccessor.pCacheAccessor->getTxnId();
00278             pPage->upgrade(txnId);
00279             lockMode = LOCKMODE_X;
00280         }
00281     }

void SegPageLock::lockUpdatePage ( PageId  updatePageId  )  [inline]

Definition at line 283 of file SegPageLock.h.

References LOCKMODE_S, and LOCKMODE_X.

00284     {
00285         assert(isWriteVersioned);
00286         BlockId blockId =
00287             segmentAccessor.pSegment->translatePageId(updatePageId);
00288         assert(lockMode == LOCKMODE_S);
00289         CachePage *pNewPage = segmentAccessor.pCacheAccessor->lockPage(
00290             blockId,
00291             LOCKMODE_X,
00292             true,
00293             segmentAccessor.pSegment->getMappedPageListener(blockId));
00294         assert(pNewPage);
00295         // copy the original page while we have both the original and new
00296         // pages locked
00297         memcpy(
00298             pNewPage->getWritableData(),
00299             pPage->getReadableData(),
00300             segmentAccessor.pSegment->getUsablePageSize());
00301         PageId origPageId = lockedPageId;
00302         unlock();
00303         lockMode = LOCKMODE_X;
00304         pPage = pNewPage;
00305         newPage = true;
00306         // keep track of the locked page based on the original pageId
00307         // requested
00308         lockedPageId = origPageId;
00309     }

PageId SegPageLock::getPageId (  )  [inline]

Definition at line 311 of file SegPageLock.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage().

00312     {
00313         // note that lockedPageId may not be the same as
00314         // segmentAccessor.pSegment->translateBlockId(getPage().getBlockId())
00315         // if the page is versioned
00316         return lockedPageId;
00317     }

void SegPageLock::flushPage ( bool  async  )  [inline]

Definition at line 319 of file SegPageLock.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterNodeWriter::close(), BTreeWriter::grow(), and BTreeWriter::splitCurrentNode().

00320     {
00321         assert(isLocked());
00322         segmentAccessor.pCacheAccessor->flushPage(getPage(), true);
00323     }

void SegPageLock::swapBuffers ( SegPageLock &  other  )  [inline]

Definition at line 326 of file SegPageLock.h.

References Segment::getFullPageSize(), Segment::getUsablePageSize(), CachePage::getWritableData(), isLocked(), lockMode, LOCKMODE_X, pPage, and updatePage().

Referenced by BTreeWriter::compactNode(), and BTreeBuilder::swapRoot().

00327     {
00328         // TODO:  assert magic numbers the same?
00329         assert(isLocked());
00330         assert(other.isLocked());
00331         assert(lockMode == LOCKMODE_X);
00332         assert(other.lockMode == LOCKMODE_X);
00333         assert(pPage != other.pPage);
00334 
00335         // since we're copying new data into other, treat it as an update
00336         other.updatePage();
00337 
00338         // both pages will end up with this page's footer, on the assumption
00339         // that other was a scratch page
00340         // TODO:  correctly swap footers as well?
00341         Segment &segment = *(segmentAccessor.pSegment);
00342         memcpy(
00343             other.pPage->getWritableData() + segment.getUsablePageSize(),
00344             pPage->getReadableData() +  segment.getUsablePageSize(),
00345             segment.getFullPageSize() - segment.getUsablePageSize());
00346         pPage->swapBuffers(*other.pPage);
00347     }

bool SegPageLock::tryUpgrade (  )  [inline]

Definition at line 349 of file SegPageLock.h.

References LOCKMODE_S, and LOCKMODE_X.

Referenced by BTreeReader::adjustRootLockMode().

00350     {
00351         assert(isLocked());
00352         assert(lockMode == LOCKMODE_S);
00353         // REVIEW jvs 31-Dec-2005:  This should really go through
00354         // the CacheAccessor interface.
00355         TxnId txnId = segmentAccessor.pCacheAccessor->getTxnId();
00356 
00357         // If we're versioning, defer upgrading the lock until
00358         // we're actually going to be update the page.
00359         if (isWriteVersioned) {
00360             return true;
00361         } else {
00362             if (pPage->tryUpgrade(txnId)) {
00363                 lockMode = LOCKMODE_X;
00364                 return true;
00365             }
00366             return false;
00367         }
00368     }

SharedCacheAccessor SegPageLock::getCacheAccessor (  )  const [inline]

Definition at line 370 of file SegPageLock.h.

Referenced by SegOutputStream::flushBuffer(), and SpillOutputStream::spill().

00371     {
00372         return segmentAccessor.pCacheAccessor;
00373     }

Member Data Documentation

SegmentAccessor SegPageLock::segmentAccessor [private]

Definition at line 57 of file SegPageLock.h.

CachePage* SegPageLock::pPage [private]

Definition at line 58 of file SegPageLock.h.

Referenced by swapBuffers().

LockMode SegPageLock::lockMode [private]

Definition at line 59 of file SegPageLock.h.

Referenced by swapBuffers().

PageId SegPageLock::lockedPageId [private]

Definition at line 60 of file SegPageLock.h.

bool SegPageLock::newPage [private]

Definition at line 61 of file SegPageLock.h.

bool SegPageLock::isWriteVersioned [private]

Definition at line 62 of file SegPageLock.h.

The documentation for this class was generated from the following file:
Generated on Mon Jun 22 04:00:46 2009 for Fennel by  doxygen 1.5.1