Fennel: VersionedSegment Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

VersionedSegment provides versioned updates to an underlying data segment by keeping before-images of modified pages in a separate write-ahead log segment. More...

#include <[VersionedSegment.h](VersionedSegment%5F8h-source.html)>

Inheritance diagram for VersionedSegment:

List of all members.

Detailed Description

VersionedSegment provides versioned updates to an underlying data segment by keeping before-images of modified pages in a separate write-ahead log segment.

See the design docs for more detail.

Definition at line 44 of file VersionedSegment.h.

Member Typedef Documentation

Member Enumeration Documentation

Enumeration of the possible orderings of PageIds returned from allocatePageId.

The enumeration is from weakest to strongest ordering, and should not be changed.

Enumerator:

Definition at line 105 of file Segment.h.

Constructor & Destructor Documentation

Definition at line 68 of file VersionedSegment.cpp.

References Segment::getUsablePageSize(), inRecovery, lastCheckpointLogPageId, logSegment, newestLogPageId, NULL_PAGE_ID, oldestLogPageId, onlineUuid, pWALSegment, Segment::setUsablePageSize(), and versionNumber.

| VersionedSegment::~VersionedSegment | ( | | ) | [virtual] | | ------------------------------------ | - | | - | ----------- |

Member Function Documentation

Recovers to a specific version from the log.

Parameters:

Definition at line 284 of file VersionedSegment.cpp.

References VersionedPageFooter::checksum, computeChecksum(), VersionedPageFooter::dataPageId, dataToLogMap, Segment::getFullPageSize(), WALSegment::getMinDirtyPageId(), SegPageLock::getPage(), Segment::getReadableFooter(), CachePage::getWritableData(), inRecovery, isMAXU(), SegPageLock::lockExclusive(), logSegment, NULL_PAGE_ID, onlineUuid, VersionedPageFooter::onlineUuid, Segment::pCache, pWALSegment, VersionedPageFooter::versionNumber, and versionNumber.

Referenced by recover(), Database::recoverPhysical(), Database::restoreFromBackup(), and VersionedSegmentTest::testRecovery().

00288 { 00289 assert(dataToLogMap.empty()); 00290 assert(pWALSegment->getMinDirtyPageId() == NULL_PAGE_ID); 00291 00292 inRecovery = true; 00293 00294 if ((versionNumberInit)) { 00295 versionNumber = versionNumberInit; 00296 } 00297 00298
00299
00300
00301
00302
00303 std::hash_set recoveredPageSet; 00304 00305
00306 00307
00308
00309 SegmentAccessor logSegmentAccessor(logSegment,pCache); 00310 SegmentAccessor dataSegmentAccessor(pDelegatingSegment,pCache); 00311 for (; firstLogPageId != NULL_PAGE_ID; 00312 firstLogPageId = logSegment->getPageSuccessor(firstLogPageId)) 00313 { 00314 SegPageLock logPageLock(logSegmentAccessor); 00315 logPageLock.lockShared(firstLogPageId); 00316 if (!logPageLock.getPage().isDataValid()) { 00317 break; 00318 } 00319 PConstBuffer pLogPageBuffer = logPageLock.getPage().getReadableData(); 00320 VersionedPageFooter const *pLogFooter = 00321 reinterpret_cast<VersionedPageFooter const *>( 00322 getReadableFooter(logPageLock.getPage())); 00323 if (pLogFooter->checksum != computeChecksum(pLogPageBuffer)) { 00324 break; 00325 } 00326 if (pLogFooter->onlineUuid != onlineUuid) { 00327 break; 00328 } 00329 assert(pLogFooter->versionNumber < (versionNumber + 2)); 00330 if (pLogFooter->versionNumber < versionNumber) { 00331 continue; 00332 } 00333 if (recoveredPageSet.find(pLogFooter->dataPageId) 00334 != recoveredPageSet.end()) 00335 { 00336 assert(pLogFooter->versionNumber > versionNumber); 00337 continue; 00338 } 00339 00340 SegPageLock dataPageLock(dataSegmentAccessor); 00341 dataPageLock.lockExclusive(pLogFooter->dataPageId); 00342 memcpy( 00343 dataPageLock.getPage().getWritableData(), 00344 pLogPageBuffer, 00345 getFullPageSize()); 00346 recoveredPageSet.insert(pLogFooter->dataPageId); 00347 } 00348 00349 inRecovery = false; 00350 }

Recovers to a specific version from the log and resets the online uuid.

Parameters:

Definition at line 274 of file VersionedSegment.cpp.

References onlineUuid, and recover().

00279 { 00280 onlineUuid = onlineUuidInit; 00281 recover(pDelegatingSegment, firstLogPageId, versionNumberInit); 00282 }

| void VersionedSegment::prepareOnlineRecovery | ( | | ) | | -------------------------------------------- | - | | - |

| PageId VersionedSegment::getRecoveryPageId | ( | | ) | const | | ------------------------------------------ | - | | - | ----- |

| PageId VersionedSegment::getOnlineRecoveryPageId | ( | | ) | const | | ------------------------------------------------ | - | | - | ----- |

Deallocates a range of pages allocated from this segment.

Some segment implementations may impose restrictions on the range (e.g. individual pages only, entire segment truncation only, start-ranges, or end-ranges). The interpretation of the range may also vary by segment (e.g. for a LINEAR_ALLOCATION segment, it's a simple linear PageId range, while for a RANDOM_ALLOCATION segment, successors could be used).

Depending on the circumstances, it may be the responsibility of the segment to discard the corresponding blocks from the cache. The details vary by segment implementation.

Parameters:

Reimplemented from DelegatingSegment.

Definition at line 152 of file VersionedSegment.cpp.

References DelegatingSegment::deallocatePageRange(), and NULL_PAGE_ID.

Helper for DelegatingSegment.

Parameters:

Reimplemented from DelegatingSegment.

Definition at line 99 of file VersionedSegment.cpp.

References CHECKPOINT_DISCARD, CHECKPOINT_FLUSH_FUZZY, FuzzyCheckpointSet::clear(), dataToLogMap, DelegatingSegment::delegatedCheckpoint(), FuzzyCheckpointSet::finishCheckpoint(), fuzzyCheckpointSet, WALSegment::getMinDirtyPageId(), lastCheckpointLogPageId, logSegment, mutex, NULL_PAGE_ID, oldestLogPageId, Segment::pCache, pWALSegment, FuzzyCheckpointSet::setDelegatePagePredicate(), and versionNumber.

Receives notification from CacheImpl the first time a page becomes dirty after it has been mapped (but before the contents have changed).

Allows some logging action to be taken; for example, making a backup copy of the unmodified page contents. Note that when called for a newly allocated page, the page contents are invalid. Because it is implied that the calling thread already has an exclusive lock on the page, no cache locks are held when called.

Parameters:

Reimplemented from DelegatingSegment.

Definition at line 163 of file VersionedSegment.cpp.

References SegPageLock::allocatePage(), VersionedPageFooter::checksum, computeChecksum(), VersionedPageFooter::dataPageId, dataToLogMap, PseudoUuid::generateInvalid(), CachePage::getBlockId(), SegPageLock::getPage(), CachePage::getReadableData(), Segment::getUsablePageSize(), CachePage::getWritableData(), Segment::getWritableFooter(), inRecovery, logSegment, mutex, newestLogPageId, DelegatingSegment::notifyPageDirty(), NULL_PAGE_ID, oldestLogPageId, onlineUuid, VersionedPageFooter::onlineUuid, Segment::pCache, DelegatingSegment::translateBlockId(), versionNumber, and VersionedPageFooter::versionNumber.

| SharedSegment const& DelegatingSegment::getDelegateSegment | ( | | ) | const [inline, inherited] | | -------------------------------------------------------------------------------------------------------------------- | - | | - | --------------------------- |

| BlockNum DelegatingSegment::getAllocatedSizeInPages | ( | | ) | [virtual, inherited] | | ------------------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

| BlockNum DelegatingSegment::getNumPagesOccupiedHighWater | ( | | ) | [virtual, inherited] | | ------------------------------------------------------------------------------------------------------------ | - | | - | ---------------------- |

Returns the max number of pages occupied by this segment instance.

In other words, pages that are allocated but subsequently deallocated, are included in this count. Also, the count includes all pages used by the segment, including metadata pages.

Returns:

the max number of pages occupied by a segment

Implements Segment.

Reimplemented in RandomAllocationSegmentBase.

Definition at line 52 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

| BlockNum DelegatingSegment::getNumPagesExtended | ( | | ) | [virtual, inherited] | | --------------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

| BlockId DelegatingSegment::translatePageId | ( | PageId | | ) | [virtual, inherited] | | ------------------------------------------ | - | ------ | | - | ---------------------- |

| PageId DelegatingSegment::translateBlockId | ( | BlockId | | ) | [virtual, inherited] | | ------------------------------------------ | - | ------- | | - | ---------------------- |

| void Segment::setUsablePageSize | ( | uint | | ) | [protected, inherited] | | ------------------------------- | - | ----------------------------------------------------------------- | | - | ------------------------ |

| SharedCache Segment::getCache | ( | | ) | const [inline, inherited] | | --------------------------------------------------------------------------------------- | - | | - | --------------------------- |

| uint Segment::getFullPageSize | ( | | ) | const [inherited] | | ------------------------------------------------------------------------------------------ | - | | - | ------------------- |

| uint Segment::getUsablePageSize | ( | | ) | const [inline, inherited] | | -------------------------------------------------------------------------------------------- | - | | - | --------------------------- |

| void Segment::initForUse | ( | | ) | [virtual, inherited] | | ------------------------ | - | | - | ---------------------- |

Returns:

tracing segment associated with this segment if tracing is turned on; otherwise, returns the segment itself

Definition at line 50 of file Segment.cpp.

References Segment::pTracingSegment.

Referenced by VersionedRandomAllocationSegment::allocateAllocNodes(), RandomAllocationSegment::allocateFromExtent(), RandomAllocationSegment::allocateFromNewExtent(), RandomAllocationSegment::allocatePageId(), VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::chainPageEntries(), SnapshotRandomAllocationSegment::commitChanges(), VersionedRandomAllocationSegment::copyPageEntryFromTemp(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), RandomAllocationSegmentBase::deallocatePageId(), VersionedRandomAllocationSegment::findAllocPageIdForRead(), RandomAllocationSegmentBase::format(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), RandomAllocationSegmentBase::freePageEntryTemplate(), RandomAllocationSegment::getExtAllocPageIdForRead(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), RandomAllocationSegmentBase::getPageEntryCopyTemplate(), RandomAllocationSegment::getSegAllocPageIdForRead(), VersionedRandomAllocationSegment::getTempAllocNodePage(), Segment::getTracingListener(), VersionedRandomAllocationSegment::locateDataPages(), VersionedRandomAllocationSegment::restoreFromBackup(), SnapshotRandomAllocationSegment::rollbackChanges(), RandomAllocationSegment::setPageSuccessor(), VersionedRandomAllocationSegment::updateExtentEntry(), and VersionedRandomAllocationSegment::validateFreePageCount().

00051 { 00052 SharedSegment sharedPtr = pTracingSegment.lock(); 00053 if (sharedPtr && sharedPtr.get()) { 00054 return sharedPtr; 00055 } else { 00056 return shared_from_this(); 00057 } 00058 }

Sets the tracing segment associated with this segment.

Parameters:

Definition at line 60 of file Segment.cpp.

References Segment::pTracingSegment.

| bool Segment::isWriteVersioned | ( | | ) | [virtual, inherited] | | ------------------------------ | - | | - | ---------------------- |

Constructs a linear PageId based on a linear page number.

Definition at line 348 of file Segment.h.

Referenced by RandomAllocationSegmentBase::allocateFromLockedExtentTemplate(), ScratchSegment::allocatePageId(), LinearViewSegment::allocatePageId(), LinearDeviceSegment::allocatePageId(), CircularSegment::allocatePageId(), RandomAllocationSegmentBase::getExtentAllocPageId(), VersionedRandomAllocationSegment::getOldPageIds(), RandomAllocationSegmentBase::getSegAllocPageId(), Database::init(), VersionedRandomAllocationSegment::locateDataPages(), SegmentTestBase::lockPage(), SegmentTestBase::prefetchPage(), SegPageIterTest::testBoundedIter(), SegPageEntryIterTest::testBoundedIter(), ScratchSegment::translateBlockId(), LinearViewSegment::translateBlockId(), LinearDeviceSegment::translateBlockId(), CircularSegment::translateBlockId(), and CircularSegment::translatePageId().

00349 { 00350 return PageId(iPage); 00351 }

Obtains the linear page number from a linear PageId.

Definition at line 353 of file Segment.h.

References opaqueToInt().

Referenced by CircularSegment::CircularSegment(), LinearDeviceSegment::deallocatePageRange(), CircularSegment::deallocatePageRange(), Segment::isLinearPageIdAllocated(), CircularSegment::isPageIdAllocated(), SegmentTestBase::lockPage(), SegInputStream::readPrevBuffer(), Segment::setLinearPageSuccessor(), RandomAllocationSegmentBase::splitPageId(), CircularSegment::translateBlockId(), ScratchSegment::translatePageId(), LinearViewSegment::translatePageId(), LinearDeviceSegment::translatePageId(), CircularSegment::translatePageId(), and LinearViewSegment::updatePage().

Receives notification that a page has been flushed during a checkpoint.

Also determines if the listener on the page needs to be reset.

Note that if the page listener is reset, that page may not be unmapped during a CHECKPOINT_FLUSH_AND_UNMAP checkpoint call.

This method should be called immediately after the page flush has completed while the checkpoint is still in progress.

Parameters:

Returns:

NULL if the listener on the page does not need to be reset; otherwise, returns the listener that the page should be reset to

Reimplemented in SnapshotRandomAllocationSegment, and TracingSegment.

Definition at line 62 of file MappedPageListener.cpp.

00064 { 00065 return NULL; 00066 }

| bool ClosableObject::isClosed | ( | | ) | const [inline, inherited] | | ----------------------------- | - | | - | --------------------------- |

Returns:

whether the object has been closed

Definition at line 58 of file ClosableObject.h.

| void ClosableObject::close | ( | | ) | [inherited] | | -------------------------- | - | | - | ------------- |

Closes this object, releasing any unallocated resources.

Reimplemented in CollectExecStream, CorrelationJoinExecStream, LcsClusterAppendExecStream, and LcsClusterReplaceExecStream.

Definition at line 39 of file ClosableObject.cpp.

References ClosableObject::closeImpl(), and ClosableObject::needsClose.

Referenced by CacheImpl< PageT, VictimPolicyT >::allocatePages(), LcsRowScanBaseExecStream::closeImpl(), ExecStreamGraphImpl::closeImpl(), FlatFileBuffer::open(), ClosableObjectDestructor::operator()(), and Segment::~Segment().

Friends And Related Function Documentation

Member Data Documentation

Cache managing pages of this segment.

Definition at line 62 of file Segment.h.

Referenced by VersionedRandomAllocationSegment::allocateAllocNodes(), RandomAllocationSegmentBase::allocateFromExtentTemplate(), RandomAllocationSegmentBase::allocateFromNewExtentTemplate(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::chainPageEntries(), VersionedRandomAllocationSegment::copyPageEntryFromTemp(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), RandomAllocationSegmentBase::deallocatePageId(), VersionedRandomAllocationSegment::deallocateSinglePage(), VersionedRandomAllocationSegment::deferDeallocation(), delegatedCheckpoint(), SnapshotRandomAllocationSegment::delegatedCheckpoint(), Segment::delegatedCheckpoint(), RandomAllocationSegmentBase::format(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), RandomAllocationSegmentBase::freePageEntryTemplate(), Segment::getCache(), Segment::getFullPageSize(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), RandomAllocationSegmentBase::getPageEntryCopyTemplate(), VersionedRandomAllocationSegment::getTempAllocNodePage(), VersionedRandomAllocationSegment::initPageEntry(), VersionedRandomAllocationSegment::locateDataPages(), notifyPageDirty(), recover(), VersionedRandomAllocationSegment::restoreFromBackup(), RandomAllocationSegmentBase::setPageSuccessorTemplate(), RandomAllocationSegmentBase::tallySegAllocNodePages(), VersionedRandomAllocationSegment::uncommittedDeallocation(), VersionedRandomAllocationSegment::updateExtentEntry(), VersionedRandomAllocationSegment::updatePageEntry(), VersionedRandomAllocationSegment::updateTempPageEntry(), and VersionedRandomAllocationSegment::validateFreePageCount().

The documentation for this class was generated from the following files:

• /home/pub/open/dev/fennel/segment/VersionedSegment.h
• /home/pub/open/dev/fennel/segment/VersionedSegment.cpp

Generated on Mon Jun 22 04:00:49 2009 for Fennel by 1.5.1