Fennel: VersionedRandomAllocationSegment Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

VersionedRandomAllocationSegment refines RandomAllocationSegmentBase, defining a VersionedExtentAllocationNode where each page entry within the segment is versioned. More...

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

Inheritance diagram for VersionedRandomAllocationSegment:

List of all members.

Detailed Description

VersionedRandomAllocationSegment refines RandomAllocationSegmentBase, defining a VersionedExtentAllocationNode where each page entry within the segment is versioned.

When modifications are made to either VersionedExtentAllocationNodes or SegmentAllocationNodes, the changes are reflected in pages originating from a temporary segment. The changes are only copied back to the permanent segment when a transaction commits; changes are thrown away on a rollback.

Page deallocations are handled differently. Deallocated pages are not actually deallocated, but instead are marked as deallocation-deferred. This makes the page unusable but not yet available for re-allocation. A deallocation-deferred page is deallocated by calling the methods getOldPageIds() and deallocateOldPages(). The former finds pages that need to be deallocated, while the latter does the actual deallocation. When the deallocations are done, the modifications are made directly in the permanent segment. The two methods should be called in a loop, one after the other, until getOldPageIds() can no longer find any old pages.

Definition at line 138 of file VersionedRandomAllocationSegment.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

Member Function Documentation

template

Retrieves the pageId in the temporary segment of the page corresponding to an allocation node page.

If the page doesn't yet exist in the temporary segment, creates it.

Assumes that the pageEntry will be updated. Therefore, it also increments the update count corresponding to the pageEntry.

Parameters:

Returns:

pageId of node in the temporary segment

Definition at line 82 of file VersionedRandomAllocationSegmentImpl.h.

References allocationNodeMap, Segment::getTracingSegment(), mapMutex, Segment::pCache, and pTempSegment.

00085 { 00086 SXMutexExclusiveGuard mapGuard(mapMutex); 00087 00088 PageId tempNodePageId; 00089 SharedModifiedAllocationNode pModAllocNode; 00090 00091
00092
00093
00094
00095 NodeMapConstIter iter = allocationNodeMap.find(origNodePageId); 00096 if (iter == allocationNodeMap.end()) { 00097
00098
00099 SegmentAccessor tempAccessor(pTempSegment, pCache); 00100 AllocationLockT tempAllocLock(tempAccessor); 00101 tempNodePageId = tempAllocLock.allocatePage(); 00102 00103 SegmentAccessor selfAccessor(getTracingSegment(), pCache); 00104 AllocationLockT allocLock(selfAccessor); 00105 allocLock.lockShared(origNodePageId); 00106 00107 memcpy( 00108 tempAllocLock.getPage().getWritableData(), 00109 allocLock.getPage().getReadableData(), 00110 pTempSegment->getUsablePageSize()); 00111 00112
00113 pModAllocNode = 00114 SharedModifiedAllocationNode(new ModifiedAllocationNode()); 00115 pModAllocNode->tempPageId = tempNodePageId; 00116 pModAllocNode->updateCount = 0; 00117 pModAllocNode->isSegAllocNode = isSegAllocNode; 00118 } else { 00119 pModAllocNode = iter->second; 00120 tempNodePageId = pModAllocNode->tempPageId; 00121 } 00122 00123
00124 pModAllocNode->updateCount++; 00125 00126 if (iter == allocationNodeMap.end()) { 00127 allocationNodeMap.insert( 00128 ModifiedAllocationNodeMap::value_type( 00129 origNodePageId, 00130 pModAllocNode)); 00131 } 00132 00133 return tempNodePageId; 00134 }

Determines whether an allocation node page has been modified.

If it has been, passes back the temporary pageId corresponding to the page. Otherwise, the original pageId is passed back.

This method assumes that the caller has already acquired a shared mutex on allocationNodeMap.

Parameters:

Returns:

the pageId of the node in the temp segment if the page has been modified; otherwise, the original pageId

Definition at line 107 of file VersionedRandomAllocationSegment.cpp.

References allocationNodeMap, Segment::getTracingSegment(), SXMutex::isLocked(), LOCKMODE_S, mapMutex, and pTempSegment.

Referenced by getExtAllocPageIdForRead(), and getSegAllocPageIdForRead().

Marks a page entry as deallocation deferred in the temporary segment.

Once the txn commits, the permanent entry will also be marked so it can then be deallocated by an ALTER SYSTEM DEALLOCATE OLD statement.

Parameters:

Definition at line 183 of file VersionedRandomAllocationSegment.cpp.

References getExtAllocPageIdForWrite(), SegNodeLock< Node >::getNodeForWrite(), VersionedExtentAllocationNode::getPageEntry(), isDeallocatedPageOwnerId(), SegPageLock::lockExclusive(), makeDeallocatedPageOwnerId(), PageEntry::ownerId, Segment::pCache, pTempSegment, RandomAllocationSegmentBase::splitPageId(), and UNALLOCATED_PAGE_OWNER_ID.

Referenced by deallocatePageRange().

Updates an extent entry corresponding to either a commit or rollback action of page allocations and/or deallocations.

In the case of a commit, the permanent extent entry is updated. In the case of a rollback, the changes made in the temporary extent entry are thrown away.

This method assumes that the caller has already acquired an exclusive mutex on allocationNodeMap.

Parameters:

Definition at line 559 of file VersionedRandomAllocationSegment.cpp.

References allocationNodeMap, SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForWrite(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), SXMutex::isLocked(), SegPageLock::lockExclusive(), LOCKMODE_X, mapMutex, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, and pTempSegment.

Referenced by updateAllocNodes().

Allocates a new SegmentAllocationNode and VersionedExtentAllocationNodes if they haven't been allocated yet.

Also recursively allocates predecessor SegmentAllocationNodes, as needed.

Parameters:

Definition at line 605 of file VersionedRandomAllocationSegment.cpp.

References allocateExtAllocNodes(), SegNodeLock< Node >::checkMagicNumber(), SegNodeLock< Node >::getNodeForWrite(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), SegPageLock::lockExclusive(), SegmentAllocationNode::nExtents, SegmentAllocationNode::nextSegAllocPageId, RandomAllocationSegmentBase::nPagesPerExtent, SegmentAllocationNode::nPagesPerExtent, NULL_PAGE_ID, Segment::pCache, and SegNodeLock< Node >::setMagicNumber().

Referenced by updateAllocNodes().

Updates a page entry by either copying a page entry from the temporary segment to the permanent one if we're committing the page entry, or the reverse if we're rolling it back.

This method assumes that the caller has already acquired an exclusive mutex on allocationNodeMap.

Parameters:

Definition at line 455 of file VersionedRandomAllocationSegment.cpp.

References ModifiedPageEntry::ALLOCATED, allocationNodeMap, copyPageEntryFromTemp(), copyPageEntryToTemp(), RandomAllocationSegmentBase::getExtentAllocPageId(), SXMutex::isLocked(), LOCKMODE_X, mapMutex, and Segment::pCache.

Referenced by updateAllocNodes().

Copies a page entry from the temporary segment to the permanent one.

Parameters:

Definition at line 496 of file VersionedRandomAllocationSegment.cpp.

References ModifiedPageEntry::ALLOCATED, VersionedPageEntry::allocationCsn, ModifiedPageEntry::DEALLOCATED, SegNodeLock< Node >::getNodeForWrite(), VersionedExtentAllocationNode::getPageEntry(), Segment::getTracingSegment(), isDeallocatedPageOwnerId(), SegPageLock::lockExclusive(), makeDeallocatedPageOwnerId(), PageEntry::ownerId, Segment::pCache, pTempSegment, and UNCOMMITTED_PAGE_OWNER_ID.

Referenced by updatePageEntry().

Sanity checks the unallocated page count in a SegmentAllocationNode against the pages marked as unallocated in the corresponding VersionedExtentAllocationNode.

Parameters:

Returns:

true if the counts match

Definition at line 670 of file VersionedRandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForRead(), VersionedExtentAllocationNode::getPageEntry(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), SegPageLock::lockExclusive(), SegPageLock::lockShared(), RandomAllocationSegmentBase::nExtentsPerSegAlloc, RandomAllocationSegmentBase::nPagesPerExtent, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, RandomAllocationSegmentBase::splitPageId(), and UNALLOCATED_PAGE_OWNER_ID.

Determines the txnId corresponding to the oldest pageId in a page chain that can be deallocated, provided there are pages that can be deallocated.

If pages in the chain are marked deallocation-deferred and are no longer being referenced, then set the flag indicating that the entire page chain should be deallocated.

Parameters:

Returns:

the txnId one larger than the commit sequence number on the oldest page that can be deallocated or NULL_TXN_ID if the page chain should be left as is (either because there's nothing to deallocate, or the page chain contains deallocation-deferred pages)

Definition at line 849 of file VersionedRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, getDeallocatedTxnId(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegNodeLock< Node >::getNodeForRead(), VersionedExtentAllocationNode::getPageEntry(), Segment::getTracingSegment(), isDeallocatedPageOwnerId(), isPageIdAllocateCommitted(), SegPageLock::lockShared(), NULL_PAGE_ID, NULL_TXN_ID, PageEntry::ownerId, Segment::pCache, skipDeferredDeallocations(), RandomAllocationSegmentBase::splitPageId(), UNCOMMITTED_PAGE_OWNER_ID, and VersionedPageEntry::versionChainPageId.

Referenced by deallocateOldPages().

Deallocates a single page and also discards it from the cache.

This method assumes that the caller has already acquired an exclusive mutex on allocationNodeMap.

Parameters:

Definition at line 985 of file VersionedRandomAllocationSegment.cpp.

References allocationNodeMap, copyPageEntryToTemp(), RandomAllocationSegmentBase::deallocatePageRange(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForWrite(), RandomAllocationSegmentBase::getSegAllocPageId(), SXMutex::isLocked(), SegPageLock::lockExclusive(), LOCKMODE_X, mapMutex, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, pTempSegment, and RandomAllocationSegmentBase::splitPageId().

Referenced by deallocateEntirePageChain(), and deallocatePageChain().

Deallocates all old pages in a page chain.

Parameters:

Definition at line 1029 of file VersionedRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, chainPageEntries(), deallocateSinglePage(), getCommittedPageEntryCopy(), isDeallocatedPageOwnerId(), NULL_PAGE_ID, PageEntry::ownerId, UNALLOCATED_PAGE_OWNER_ID, uncommittedDeallocation(), updateTempPageEntry(), and VersionedPageEntry::versionChainPageId.

Referenced by deallocateOldPages().

Determines if a page chain is in the process of being marked deallocation-deferred and has not yet been committed.

This method assumes that the caller has already acquired an exclusive mutex on allocationNodeMap.

Parameters:

Returns:

true if the anchor page entry is marked as deallocation-deferred in its temporary page entry

Definition at line 1092 of file VersionedRandomAllocationSegment.cpp.

References allocationNodeMap, getDeallocatedTxnId(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegNodeLock< Node >::getNodeForRead(), VersionedExtentAllocationNode::getPageEntry(), isDeallocatedPageOwnerId(), SXMutex::isLocked(), LOCKMODE_X, SegPageLock::lockShared(), mapMutex, PageEntry::ownerId, Segment::pCache, pTempSegment, skipDeferredDeallocations(), and RandomAllocationSegmentBase::splitPageId().

Referenced by deallocatePageChain().

Updates a page entry in the temporary segment, if it exists.

This method assumes that the caller has already acquired an exclusive mutex on allocationNodeMap.

Parameters:

Definition at line 1165 of file VersionedRandomAllocationSegment.cpp.

References allocationNodeMap, RandomAllocationSegmentBase::getExtentAllocPageId(), SegNodeLock< Node >::getNodeForWrite(), VersionedExtentAllocationNode::getPageEntry(), SXMutex::isLocked(), SegPageLock::lockExclusive(), LOCKMODE_X, mapMutex, Segment::pCache, pTempSegment, and RandomAllocationSegmentBase::splitPageId().

Referenced by deallocatePageChain().

Chains one page to another, updating either the corresponding permanent page entry or the temporary one.

Also may set the successorId of the first page.

Parameters:

Definition at line 352 of file VersionedRandomAllocationSegment.cpp.

References getExtAllocPageIdForWrite(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegNodeLock< Node >::getNodeForWrite(), VersionedExtentAllocationNode::getPageEntry(), Segment::getTracingSegment(), isPageIdAllocated(), SegPageLock::lockExclusive(), NULL_PAGE_ID, Segment::pCache, pTempSegment, RandomAllocationSegmentBase::splitPageId(), PageEntry::successorId, and VersionedPageEntry::versionChainPageId.

Referenced by chainPageEntries(), SnapshotRandomAllocationSegment::chainPageEntries(), and deallocatePageChain().

Definition at line 1298 of file VersionedRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, checkAbort(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), Segment::getFullPageSize(), Segment::getLinearPageId(), SegNodeLock< Node >::getNodeForRead(), SegPageLock::getPage(), VersionedExtentAllocationNode::getPageEntry(), CachePage::getReadableData(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), SegPageLock::lockShared(), RandomAllocationSegmentBase::makePageNum(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, NULL_TXN_ID, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, PageEntry::ownerId, Segment::pCache, RandomAllocationSegmentBase::translatePageId(), UNALLOCATED_PAGE_OWNER_ID, and SegPageLock::unlock().

Referenced by backupDataPages(), and restoreFromBackup().

Determines whether a pageOwnerId corresponds to a deallocation-deferred page.

Parameters:

Returns:

true if the pageOwnerId corresponds to a deallocation-deferred page

Definition at line 143 of file VersionedRandomAllocationSegmentImpl.h.

References ANON_PAGE_OWNER_ID, DEALLOCATED_PAGE_OWNER_ID_MASK, and opaqueToInt().

Referenced by copyPageEntryFromTemp(), deallocateEntirePageChain(), deallocatePageChain(), deferDeallocation(), getDeallocatedTxnId(), getOldestTxnId(), getOldPageIds(), skipDeferredDeallocations(), and uncommittedDeallocation().

Retrieves the ownerId corresponding to a page entry.

See also:

getPageOwnerIdTemplate()

Parameters:

Returns:

ownerId

Implements RandomAllocationSegmentBase.

Definition at line 271 of file VersionedRandomAllocationSegment.cpp.

00274 { 00275 return getPageOwnerIdTemplate(pageId, thisSegment); 00276 }

Initializes the versioning fields in a pageEntry for a specified page.

Parameters:

Definition at line 317 of file VersionedRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, getExtAllocPageIdForWrite(), SegNodeLock< Node >::getNodeForWrite(), VersionedExtentAllocationNode::getPageEntry(), isPageIdAllocated(), SegPageLock::lockExclusive(), NULL_TXN_ID, PageEntry::ownerId, Segment::pCache, pTempSegment, RandomAllocationSegmentBase::splitPageId(), UNALLOCATED_PAGE_OWNER_ID, and VersionedPageEntry::versionChainPageId.

Referenced by SnapshotRandomAllocationSegment::allocatePageId().

Chains one page to another, updating the corresponding page entry in the temp segment page.

Also may set the successorId of the first page.

Parameters:

Definition at line 344 of file VersionedRandomAllocationSegment.cpp.

References chainPageEntries().

00348 { 00349 chainPageEntries(pageId, versionChainId, successorId, false); 00350 }

Updates the permanent allocation nodes to reflect changes currently in the temporary segment, or vice versa if the updates correspond to a rollback.

Parameters:

Definition at line 389 of file VersionedRandomAllocationSegment.cpp.

References allocateAllocNodes(), ModifiedPageEntry::ALLOCATED, allocationNodeMap, ModifiedPageEntry::DEALLOCATED, freeTempPage(), isPageIdAllocated(), mapMutex, NULL_PAGE_ID, RandomAllocationSegmentBase::splitPageId(), updateExtentEntry(), and updatePageEntry().

Referenced by SnapshotRandomAllocationSegment::commitChanges(), and SnapshotRandomAllocationSegment::rollbackChanges().

00394 { 00395 SXMutexExclusiveGuard mapGuard(mapMutex); 00396 00397 for (ModifiedPageEntryMapIter iter = modifiedPageEntryMap.begin(); 00398 iter != modifiedPageEntryMap.end(); 00399 iter++) 00400 { 00401 PageId pageId = iter->first; 00402 SharedModifiedPageEntry pModEntry = iter->second; 00403 00404 assert(isPageIdAllocated(pageId)); 00405 00406 ExtentNum extentNum; 00407 BlockNum iPageInExtent; 00408 uint iSegAlloc; 00409 splitPageId(pageId, iSegAlloc, extentNum, iPageInExtent); 00410 assert(iPageInExtent); 00411 00412
00413
00414 allocateAllocNodes(iSegAlloc, NULL_PAGE_ID, extentNum); 00415 00416
00417
00418
00419 if ((pModEntry->lastModType == ModifiedPageEntry::ALLOCATED) || 00420 (pModEntry->lastModType == ModifiedPageEntry::DEALLOCATED)) 00421 { 00422 updateExtentEntry( 00423 iSegAlloc, 00424 extentNum, 00425 pModEntry->allocationCount, 00426 commit); 00427 } 00428 updatePageEntry( 00429 pageId, 00430 extentNum, 00431 iPageInExtent, 00432 pModEntry, 00433 commitCsn, 00434 commit, 00435 pOrigSegment); 00436 } 00437 00438
00439
00440
00441
00442 ModifiedAllocationNodeMap::iterator iter = allocationNodeMap.begin(); 00443 while (iter != allocationNodeMap.end()) { 00444 SharedModifiedAllocationNode pModNode = iter->second; 00445 if (pModNode->updateCount == 0 && !pModNode->isSegAllocNode) { 00446 PageId pageId = iter->first; 00447 iter++; 00448 freeTempPage(pageId, pModNode->tempPageId); 00449 } else { 00450 iter++; 00451 } 00452 } 00453 }

| SXMutex & VersionedRandomAllocationSegment::getDeallocationMutex | ( | | ) | | ------------------------------------------------------------------------------------- | - | | - |

Retrieves a batch of pageIds corresponding either to old snapshot pages that are no longer being referenced or pages marked for deallocation.

The number of pageIds returned must be at least some value as specified by an input parameter, unless there are no more pages left to deallocate. The old pages are located starting at a location specified by the index of a SegmentAllocationNode and the offset of an extent within that node. Upon exit, those parameters are replaced with the location where the search should be resumed the next time the method is called.

Once a batch of pages have been identified, deallocateOldPages() should then be called. After deallocating that set of pages, getOldPageIds() should be called again to identify the next set of old pages.

Parameters:

Returns:

true if additional pages need to be searched; false if reached end of search

Definition at line 714 of file VersionedRandomAllocationSegment.cpp.

References getDeallocatedTxnId(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), Segment::getLinearPageId(), SegNodeLock< Node >::getNodeForRead(), VersionedExtentAllocationNode::getPageEntry(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), isDeallocatedPageOwnerId(), SegPageLock::lockShared(), RandomAllocationSegmentBase::makePageNum(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, and UNALLOCATED_PAGE_OWNER_ID.

Referenced by SnapshotSegmentTest::deallocateOldPages(), and Database::deallocateOldPages().

Deallocates an old set of pages and updates the version chain that the pages may be a part of.

Old pages are identified by calling getOldPageIds().

The actual deallocation of pages is in a separate method to minimize the duration the deallocation mutex is held.

Parameters:

Definition at line 794 of file VersionedRandomAllocationSegment.cpp.

References deallocateEntirePageChain(), deallocatePageChain(), deallocationMutex, getOldestTxnId(), isPageIdAllocateCommitted(), mapMutex, and NULL_TXN_ID.

Referenced by SnapshotSegmentTest::deallocateOldPages(), and Database::deallocateOldPages().

00797 { 00798 SXMutexExclusiveGuard deallocationGuard(deallocationMutex); 00799 SXMutexExclusiveGuard mapGuard(mapMutex); 00800 00801 std::hash_set deallocatedPageSet; 00802 for (PageSetConstIter pageIter = oldPageSet.begin(); 00803 pageIter != oldPageSet.end(); pageIter++) 00804 { 00805 PageId pageId = *pageIter; 00806 00807
00808
00809 if (deallocatedPageSet.find(pageId) != deallocatedPageSet.end()) { 00810 continue; 00811 } 00812
00813
00814 if ((pageId)) { 00815 deallocatedPageSet.insert(pageId); 00816 continue; 00817 } 00818 00819
00820
00821
00822
00823 PageId anchorPageId; 00824 bool deallocateChain; 00825 TxnId deallocationCsn = 00826 getOldestTxnId( 00827 pageId, 00828 oldestActiveTxnId, 00829 anchorPageId, 00830 deallocatedPageSet, 00831 deallocateChain); 00832 if (deallocateChain) { 00833 deallocateEntirePageChain( 00834 pageId, 00835 oldestActiveTxnId, 00836 deallocatedPageSet); 00837 continue; 00838 } 00839 if (deallocationCsn == NULL_TXN_ID) { 00840 continue; 00841 } 00842 00843
00844
00845 deallocatePageChain(anchorPageId, deallocationCsn, deallocatedPageSet); 00846 } 00847 }

| void VersionedRandomAllocationSegment::freeTempPages | ( | | ) | | ---------------------------------------------------- | - | | - |

Writes all the segment and extent allocation pages from this segment sequentially to a backup file.

If requested, also counts the number of data pages that will need to be backed up later, based on pages whose allocationCsn's are within a lower and upper bound. If the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive. There must always be an upper bound and it is inclusive.

Parameters:

Returns:

number of data pages that will be backed up if countDataPages is true; otherwise, returns 0

Definition at line 1213 of file VersionedRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, checkAbort(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForRead(), SegPageLock::getPage(), VersionedExtentAllocationNode::getPageEntry(), CachePage::getReadableData(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), SegPageLock::lockShared(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, NULL_TXN_ID, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, PageEntry::ownerId, Segment::pCache, and UNALLOCATED_PAGE_OWNER_ID.

Referenced by BackupRestoreTest::backup().

Walks through all page entries in this segment and locates the ones that have allocationCsn's in between a lower and upper bound.

If the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive. There must always be an upper bound and it is inclusive.

Parameters:

Definition at line 1284 of file VersionedRandomAllocationSegment.cpp.

References locateDataPages().

Referenced by BackupRestoreTest::backup(), and Database::completeBackup().

01289 { 01290 locateDataPages( 01291 pBackupDevice, 01292 lowerBoundCsn, 01293 upperBoundCsn, 01294 true, 01295 abortFlag); 01296 }

Restores the segment and extent allocation node pages and data pages for this segment from a backup file.

The data pages in the backup file correspond to pages with allocationCsn's in between a lower and upper bound. If the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive. There must always be an upper bound and it is inclusive.

Parameters:

Definition at line 1399 of file VersionedRandomAllocationSegment.cpp.

References checkAbort(), DelegatingSegment::ensureAllocatedSize(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForRead(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), locateDataPages(), SegPageLock::lockShared(), RandomAllocationSegmentBase::makePageNum(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, Segment::pCache, and RandomAllocationSegmentBase::translatePageId().

Referenced by BackupRestoreTest::restore(), and Database::restoreFromBackup().

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 RandomAllocationSegmentBase.

Definition at line 159 of file VersionedRandomAllocationSegment.cpp.

References deallocationMutex, deferDeallocation(), RandomAllocationSegmentBase::format(), and NULL_PAGE_ID.

| void VersionedRandomAllocationSegment::initForUse | ( | | ) | [virtual] | | ------------------------------------------------- | - | | - | ----------- |

Calculates the PageId of a particular SegmentAllocationNode.

Parameters:

Returns:

corresponding PageId

Definition at line 104 of file RandomAllocationSegmentBaseImpl.h.

References Segment::getLinearPageId(), and RandomAllocationSegmentBase::nPagesPerSegAlloc.

Referenced by allocateAllocNodes(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), backupAllocationNodes(), RandomAllocationSegmentBase::deallocatePageId(), deallocateSinglePage(), RandomAllocationSegmentBase::format(), getOldPageIds(), locateDataPages(), restoreFromBackup(), updateExtentEntry(), and validateFreePageCount().

Calculates the PageId of a particular extent allocation node.

Parameters:

Returns:

corresponding PageId

Definition at line 118 of file RandomAllocationSegmentBaseImpl.h.

References Segment::getLinearPageId(), and RandomAllocationSegmentBase::makePageNum().

Referenced by backupAllocationNodes(), chainPageEntries(), deallocateSinglePage(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), RandomAllocationSegmentBase::freePageEntryTemplate(), getExtAllocPageIdForRead(), RandomAllocationSegment::getExtAllocPageIdForRead(), getExtAllocPageIdForWrite(), RandomAllocationSegment::getExtAllocPageIdForWrite(), getOldestTxnId(), getOldPageIds(), RandomAllocationSegmentBase::getPageEntryCopyTemplate(), locateDataPages(), restoreFromBackup(), uncommittedDeallocation(), updatePageEntry(), updateTempPageEntry(), and validateFreePageCount().

Maps a linear PageId from this segment into the corresponding SegmentAllocationNode, extent allocation node, and extent-relative page index.

Parameters:

Definition at line 279 of file RandomAllocationSegmentBase.cpp.

References Segment::getLinearBlockNum(), MAXU, RandomAllocationSegmentBase::nExtentsPerSegAlloc, RandomAllocationSegmentBase::nPagesPerExtent, and RandomAllocationSegmentBase::nPagesPerSegAlloc.

Referenced by chainPageEntries(), RandomAllocationSegmentBase::deallocatePageId(), deallocateSinglePage(), deferDeallocation(), getOldestTxnId(), RandomAllocationSegmentBase::getPageEntryCopyTemplate(), initPageEntry(), RandomAllocationSegmentBase::setPageSuccessorTemplate(), RandomAllocationSegmentBase::testPageId(), uncommittedDeallocation(), updateAllocNodes(), updateTempPageEntry(), and validateFreePageCount().

template

Retrieves the ownerId corresponding to a page entry.

This template method allows the caller to specify different page entry types.

Parameters:

Returns:

ownerId

Definition at line 262 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getPageEntryCopy().

00265 { 00266 PageEntryT pageEntry; 00267 00268 getPageEntryCopy(pageId, pageEntry, false, thisSegment); 00269 return pageEntry.ownerId; 00270 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

| PageId RandomAllocationSegmentBase::getFirstSegAllocPageId | ( | | ) | const [inline, protected, inherited] | | ---------------------------------------------------------- | - | | - | -------------------------------------- |

| uint RandomAllocationSegmentBase::inferSegAllocCount | ( | | ) | [protected, inherited] | | ----------------------------------------------------------------------------------------------------------------- | - | | - | ------------------------ |

| void RandomAllocationSegmentBase::format | ( | | ) | [protected, inherited] | | ---------------------------------------- | - | | - | ------------------------ |

Formats allocation pages based on current size of underlying segment, marking all pages as deallocated.

Definition at line 67 of file RandomAllocationSegmentBase.cpp.

References DelegatingSegment::ensureAllocatedSize(), RandomAllocationSegmentBase::formatPageExtents(), DelegatingSegment::getAllocatedSizeInPages(), SegNodeLock< Node >::getNodeForWrite(), RandomAllocationSegmentBase::getSegAllocPageId(), Segment::getTracingSegment(), RandomAllocationSegmentBase::inferSegAllocCount(), SegPageLock::lockExclusive(), min(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, SegmentAllocationNode::nPagesPerExtent, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, Segment::pCache, and SegNodeLock< Node >::setMagicNumber().

Referenced by deallocatePageRange(), and RandomAllocationSegmentBase::deallocatePageRange().

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

Formats each of the extents within a segment allocation node.

This template method allows the caller to specify different extent allocation node types.

Parameters:

Definition at line 146 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::formatExtentTemplate(), RandomAllocationSegmentBase::getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), Segment::getTracingSegment(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, RandomAllocationSegmentBase::nPagesPerExtent, and Segment::pCache.

Referenced by allocateExtAllocNodes(), formatPageExtents(), and RandomAllocationSegment::formatPageExtents().

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

Allocates a page without locking it into memory.

The allocation nodes originate from a specified segment.

Parameters:

Returns:

the PageId of the allocated page, or NULL_PAGE_ID if none could be allocated

Definition at line 151 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::allocateFromExtent(), RandomAllocationSegmentBase::allocateFromNewExtent(), DelegatingSegment::ensureAllocatedSize(), SegmentAllocationNode::getExtentEntry(), RandomAllocationSegmentBase::getFirstSegAllocPageId(), SegNodeLock< Node >::getNodeForRead(), SegNodeLock< Node >::getNodeForWrite(), RandomAllocationSegmentBase::getSegAllocPageId(), RandomAllocationSegmentBase::getSegAllocPageIdForWrite(), RandomAllocationSegmentBase::incrementPageCounters(), RandomAllocationSegmentBase::incrementPagesOccupiedCounter(), SegPageLock::lockExclusive(), RandomAllocationSegmentBase::makePageNum(), SegmentAllocationNode::nExtents, RandomAllocationSegmentBase::nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, SegmentAllocationNode::nPagesPerExtent, RandomAllocationSegmentBase::nPagesPerExtent, NULL_PAGE_ID, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, SegNodeLock< Node >::setMagicNumber(), RandomAllocationSegmentBase::undoSegAllocPageWrite(), and SegPageLock::unlock().

Referenced by allocatePageId(), and RandomAllocationSegment::allocatePageId().

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

Allocates a page from a new extent allocation node.

The extent is specified by the absolute extent number and the segment where the extent allocation node originates from.

This template method allows the caller to specify different extent allocation node types.

Parameters:

Returns:

allocated PageId

Definition at line 183 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getExtAllocPageIdForWrite(), and Segment::pCache.

Referenced by allocateFromNewExtent(), and RandomAllocationSegment::allocateFromNewExtent().

00187 { 00188 SegmentAccessor segAccessor(allocNodeSegment, pCache); 00189 ExtentAllocLockT extentAllocLock(segAccessor); 00190 extentAllocLock.lockExclusive(getExtAllocPageIdForWrite(extentNum)); 00191 extentAllocLock.setMagicNumber(); 00192 ExtentAllocationNodeT &extentNode = extentAllocLock.getNodeForWrite(); 00193 formatExtentTemplate<ExtentAllocationNodeT, ExtentAllocLockT, PageEntryT>( 00194 extentNode); 00195 return 00196 allocateFromLockedExtentTemplate<ExtentAllocationNodeT, PageEntryT>( 00197 extentNode, 00198 extentNum, 00199 ownerId); 00200 }

template<class ExtentAllocationNodeT, class PageEntryT>

template<class ExtentAllocationNodeT, class ExtentAllocLockT>

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

Retrieves a copy of the page entry for a specified page.

This template method allows the caller to specify different extent allocation node and page entry types.

Parameters:

Definition at line 273 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getExtAllocPageIdForRead(), RandomAllocationSegmentBase::getExtentAllocPageId(), Segment::getTracingSegment(), Segment::pCache, RandomAllocationSegmentBase::splitPageId(), and RandomAllocationSegmentBase::testPageId().

Referenced by getPageEntryCopy().

00278 { 00279 if (isAllocated) { 00280 assert(testPageId(pageId, true, thisSegment)); 00281 } 00282 00283 ExtentNum extentNum; 00284 BlockNum iPageInExtent; 00285 uint iSegAlloc; 00286 splitPageId(pageId, iSegAlloc, extentNum, iPageInExtent); 00287 assert(iPageInExtent); 00288 00289 SharedSegment allocNodeSegment; 00290 PageId extentPageId; 00291 if (thisSegment) { 00292 allocNodeSegment = getTracingSegment(); 00293 extentPageId = getExtentAllocPageId(extentNum); 00294 } else { 00295 extentPageId = getExtAllocPageIdForRead(extentNum, allocNodeSegment); 00296 } 00297 00298 SegmentAccessor segAccessor(allocNodeSegment, pCache); 00299 ExtentAllocLockT extentAllocLock(segAccessor); 00300 extentAllocLock.lockShared(extentPageId); 00301 ExtentAllocationNodeT const &extentNode = 00302 extentAllocLock.getNodeForRead(); 00303 00304 PageEntryT const &pageEntry = 00305 extentNode.getPageEntry(iPageInExtent); 00306 00307 pageEntryCopy = pageEntry; 00308 }

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

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

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

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

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

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

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 MappedPageListener.

Reimplemented in SnapshotRandomAllocationSegment, TracingSegment, VersionedSegment, and WALSegment.

Definition at line 122 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by WALSegment::notifyPageDirty(), VersionedSegment::notifyPageDirty(), TracingSegment::notifyPageDirty(), and SnapshotRandomAllocationSegment::notifyPageDirty().

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

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

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

| uint Segment::getUsablePageSize | ( | | ) | const [inline, 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 allocateAllocNodes(), RandomAllocationSegment::allocateFromExtent(), RandomAllocationSegment::allocateFromNewExtent(), RandomAllocationSegment::allocatePageId(), backupAllocationNodes(), chainPageEntries(), SnapshotRandomAllocationSegment::commitChanges(), copyPageEntryFromTemp(), copyPageEntryToTemp(), RandomAllocationSegmentBase::deallocatePageId(), findAllocPageIdForRead(), RandomAllocationSegmentBase::format(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), RandomAllocationSegmentBase::freePageEntryTemplate(), RandomAllocationSegment::getExtAllocPageIdForRead(), getOldestTxnId(), getOldPageIds(), RandomAllocationSegmentBase::getPageEntryCopyTemplate(), RandomAllocationSegment::getSegAllocPageIdForRead(), getTempAllocNodePage(), Segment::getTracingListener(), locateDataPages(), restoreFromBackup(), SnapshotRandomAllocationSegment::rollbackChanges(), RandomAllocationSegment::setPageSuccessor(), updateExtentEntry(), and 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(), getOldPageIds(), RandomAllocationSegmentBase::getSegAllocPageId(), Database::init(), 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

Maps allocation node pages to the modified copy of the node that contains uncommitted page modifications.

Definition at line 150 of file VersionedRandomAllocationSegment.h.

Referenced by deallocateSinglePage(), findAllocPageIdForRead(), freeTempPage(), freeTempPages(), getTempAllocNodePage(), uncommittedDeallocation(), undoSegAllocPageWrite(), updateAllocNodes(), updateExtentEntry(), updatePageEntry(), and updateTempPageEntry().

Mutex used to protect allocationNodeMap.

Multiple readers are allowed but only a single writer.

In the case where both mapMutex and deallocationMutex need to be acquired, acquire deallocationMutex first.

Definition at line 159 of file VersionedRandomAllocationSegment.h.

Referenced by deallocateOldPages(), deallocateSinglePage(), findAllocPageIdForRead(), freeTempPage(), freeTempPages(), getPageEntryCopy(), getTempAllocNodePage(), initForUse(), uncommittedDeallocation(), undoSegAllocPageWrite(), updateAllocNodes(), updateExtentEntry(), updatePageEntry(), and updateTempPageEntry().

Segment used to allocate pages to store uncommitted modifications to segment and extent allocation node pages.

Definition at line 173 of file VersionedRandomAllocationSegment.h.

Referenced by allocateFromExtent(), allocateFromNewExtent(), allocatePageId(), chainPageEntries(), copyPageEntryFromTemp(), copyPageEntryToTemp(), deallocateSinglePage(), deferDeallocation(), findAllocPageIdForRead(), freeTempPage(), getTempAllocNodePage(), initPageEntry(), setPageSuccessor(), uncommittedDeallocation(), updateExtentEntry(), updateTempPageEntry(), and VersionedRandomAllocationSegment().

Number of pages in one extent, including the extent allocation node itself (so actual data capacity per extent is one less).

This is immutable.

Definition at line 147 of file RandomAllocationSegmentBase.h.

Referenced by allocateAllocNodes(), RandomAllocationSegmentBase::allocateFromLockedExtentTemplate(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), backupAllocationNodes(), RandomAllocationSegmentBase::deallocatePageId(), RandomAllocationSegmentBase::format(), RandomAllocationSegmentBase::formatExtentTemplate(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), getOldPageIds(), locateDataPages(), RandomAllocationSegmentBase::makePageNum(), RandomAllocationSegment::RandomAllocationSegment(), restoreFromBackup(), RandomAllocationSegmentBase::splitPageId(), RandomAllocationSegmentBase::tallySegAllocNodePages(), validateFreePageCount(), and VersionedRandomAllocationSegment().

Number of extents mapped by a full SegmentAllocationNode.

This is immutable.

Definition at line 159 of file RandomAllocationSegmentBase.h.

Referenced by allocateExtAllocNodes(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), backupAllocationNodes(), RandomAllocationSegmentBase::deallocatePageId(), deallocateSinglePage(), RandomAllocationSegmentBase::format(), RandomAllocationSegmentBase::formatPageExtentsTemplate(), getOldPageIds(), locateDataPages(), RandomAllocationSegmentBase::makePageNum(), RandomAllocationSegment::RandomAllocationSegment(), RandomAllocationSegmentBase::RandomAllocationSegmentBase(), restoreFromBackup(), RandomAllocationSegmentBase::splitPageId(), updateExtentEntry(), validateFreePageCount(), and VersionedRandomAllocationSegment().

Cache managing pages of this segment.

Definition at line 62 of file Segment.h.

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

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

• /home/pub/open/dev/fennel/segment/VersionedRandomAllocationSegment.h
• /home/pub/open/dev/fennel/segment/VersionedRandomAllocationSegment.cpp
• /home/pub/open/dev/fennel/segment/VersionedRandomAllocationSegmentImpl.h

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