Fennel: RandomAllocationSegmentBase Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

RandomAllocationSegmentBase is an abstract base class that implements RANDOM_ALLOCATION in terms of an underlying segment supporting LINEAR_ALLOCATION. More...

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

Inheritance diagram for RandomAllocationSegmentBase:

List of all members.

Detailed Description

RandomAllocationSegmentBase is an abstract base class that implements RANDOM_ALLOCATION in terms of an underlying segment supporting LINEAR_ALLOCATION.

See the design docs for more detail.

The segment tracks space allocation using segment allocation nodes and extent allocation nodes. This base class defines the structure of the segment allocation node and a base page entry. It is left to each deriving class to define its own extent allocation node, and further refine the page entry, if necessary.

The allocation nodes may be stored in a separate segment.

Definition at line 68 of file RandomAllocationSegmentBase.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

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

Member Function Documentation

| void RandomAllocationSegmentBase::incrementPageCounters | ( | | ) | [private] | | ------------------------------------------------------- | - | | - | ----------- |

| void RandomAllocationSegmentBase::incrementPagesOccupiedCounter | ( | | ) | [private] | | --------------------------------------------------------------- | - | | - | ----------- |

| void RandomAllocationSegmentBase::decrementPageCounters | ( | | ) | [private] | | ------------------------------------------------------- | - | | - | ----------- |

| void RandomAllocationSegmentBase::countAllocatedPages | ( | | ) | [private] | | ----------------------------------------------------- | - | | - | ----------- |

Deallocates a single page.

Parameters:

Definition at line 338 of file RandomAllocationSegmentBase.cpp.

References decrementPageCounters(), freePageEntry(), SegmentAllocationNode::getExtentEntry(), SegNodeLock< Node >::getNodeForWrite(), getSegAllocPageId(), Segment::getTracingSegment(), isPageIdAllocated(), SegPageLock::lockExclusive(), nExtentsPerSegAlloc, nPagesPerExtent, NULL_PAGE_ID, Segment::pCache, splitPageId(), and DelegatingSegment::translatePageId().

Referenced by deallocatePageRange().

Calculates the PageId of a particular SegmentAllocationNode.

Parameters:

Returns:

corresponding PageId

Definition at line 104 of file RandomAllocationSegmentBaseImpl.h.

References Segment::getLinearPageId(), and nPagesPerSegAlloc.

Referenced by VersionedRandomAllocationSegment::allocateAllocNodes(), allocatePageIdFromSegment(), VersionedRandomAllocationSegment::backupAllocationNodes(), deallocatePageId(), VersionedRandomAllocationSegment::deallocateSinglePage(), format(), VersionedRandomAllocationSegment::getOldPageIds(), VersionedRandomAllocationSegment::locateDataPages(), VersionedRandomAllocationSegment::restoreFromBackup(), VersionedRandomAllocationSegment::updateExtentEntry(), and VersionedRandomAllocationSegment::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 makePageNum().

Referenced by VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::chainPageEntries(), VersionedRandomAllocationSegment::deallocateSinglePage(), formatPageExtentsTemplate(), freePageEntryTemplate(), VersionedRandomAllocationSegment::getExtAllocPageIdForRead(), RandomAllocationSegment::getExtAllocPageIdForRead(), VersionedRandomAllocationSegment::getExtAllocPageIdForWrite(), RandomAllocationSegment::getExtAllocPageIdForWrite(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), getPageEntryCopyTemplate(), VersionedRandomAllocationSegment::locateDataPages(), VersionedRandomAllocationSegment::restoreFromBackup(), VersionedRandomAllocationSegment::uncommittedDeallocation(), VersionedRandomAllocationSegment::updatePageEntry(), VersionedRandomAllocationSegment::updateTempPageEntry(), and VersionedRandomAllocationSegment::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, nExtentsPerSegAlloc, nPagesPerExtent, and nPagesPerSegAlloc.

Referenced by VersionedRandomAllocationSegment::chainPageEntries(), deallocatePageId(), VersionedRandomAllocationSegment::deallocateSinglePage(), VersionedRandomAllocationSegment::deferDeallocation(), VersionedRandomAllocationSegment::getOldestTxnId(), getPageEntryCopyTemplate(), VersionedRandomAllocationSegment::initPageEntry(), setPageSuccessorTemplate(), testPageId(), VersionedRandomAllocationSegment::uncommittedDeallocation(), VersionedRandomAllocationSegment::updateAllocNodes(), VersionedRandomAllocationSegment::updateTempPageEntry(), and VersionedRandomAllocationSegment::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 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] | | ---------------------------------------------------------- | - | | - | --------------------------- |

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

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

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(), formatPageExtents(), DelegatingSegment::getAllocatedSizeInPages(), SegNodeLock< Node >::getNodeForWrite(), getSegAllocPageId(), Segment::getTracingSegment(), inferSegAllocCount(), SegPageLock::lockExclusive(), min(), SegmentAllocationNode::nExtents, nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, SegmentAllocationNode::nPagesPerExtent, nPagesPerExtent, NULL_PAGE_ID, Segment::pCache, and SegNodeLock< Node >::setMagicNumber().

Referenced by VersionedRandomAllocationSegment::deallocatePageRange(), and 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 formatExtentTemplate(), getExtentAllocPageId(), SegmentAllocationNode::getExtentEntry(), Segment::getTracingSegment(), SegmentAllocationNode::nExtents, nExtentsPerSegAlloc, nPagesPerExtent, and Segment::pCache.

Referenced by VersionedRandomAllocationSegment::allocateExtAllocNodes(), VersionedRandomAllocationSegment::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 allocateFromExtent(), allocateFromNewExtent(), DelegatingSegment::ensureAllocatedSize(), SegmentAllocationNode::getExtentEntry(), getFirstSegAllocPageId(), SegNodeLock< Node >::getNodeForRead(), SegNodeLock< Node >::getNodeForWrite(), getSegAllocPageId(), getSegAllocPageIdForWrite(), incrementPageCounters(), incrementPagesOccupiedCounter(), SegPageLock::lockExclusive(), makePageNum(), SegmentAllocationNode::nExtents, nExtentsPerSegAlloc, SegmentAllocationNode::nextSegAllocPageId, SegmentAllocationNode::nPagesPerExtent, nPagesPerExtent, NULL_PAGE_ID, SegmentAllocationNode::ExtentEntry::nUnallocatedPages, Segment::pCache, SegNodeLock< Node >::setMagicNumber(), undoSegAllocPageWrite(), and SegPageLock::unlock().

Referenced by VersionedRandomAllocationSegment::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 getExtAllocPageIdForWrite(), and Segment::pCache.

Referenced by VersionedRandomAllocationSegment::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>

Allocates a new page from an extent known to have space, with the extent allocation node already locked.

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

Parameters:

Returns:

allocated PageId

Definition at line 203 of file RandomAllocationSegmentBaseImpl.h.

References Segment::getLinearPageId(), makePageNum(), nPagesPerExtent, and UNALLOCATED_PAGE_OWNER_ID.

00205 { 00206
00207 for (uint i = 0; i < nPagesPerExtent; i++) { 00208 PageEntryT &pageEntry = node.getPageEntry(i); 00209 if (pageEntry.ownerId == UNALLOCATED_PAGE_OWNER_ID) { 00210 if (i == 0) { 00211
00212
00213 permAssert(false); 00214 } 00215 pageEntry.ownerId = ownerId; 00216 PageId pageId = getLinearPageId(makePageNum(extentNum,i)); 00217 return pageId; 00218 } 00219 } 00220 00221 permAssert(false); 00222 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT>

Retrieves the actual pageId corresponding to the extent allocation node that should be accessed when reading from the node.

Parameters:

Returns:

pageId to be read

Implemented in RandomAllocationSegment, and VersionedRandomAllocationSegment.

Referenced by getPageEntryCopyTemplate().

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 getExtAllocPageIdForRead(), getExtentAllocPageId(), Segment::getTracingSegment(), Segment::pCache, splitPageId(), and testPageId().

Referenced by VersionedRandomAllocationSegment::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] | | ---------------------------------------------------- | - | ------ | | - | ----------- |

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

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

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

Reimplemented from DelegatingSegment.

Definition at line 448 of file RandomAllocationSegmentBase.cpp.

References nPagesOccupiedHighWater.

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.

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 326 of file RandomAllocationSegmentBase.cpp.

References deallocatePageId(), format(), and NULL_PAGE_ID.

Referenced by VersionedRandomAllocationSegment::deallocateSinglePage().

00329 { 00330 permAssert(startPageId == endPageId); 00331 if (startPageId != NULL_PAGE_ID) { 00332 deallocatePageId(startPageId); 00333 } else { 00334 format(); 00335 } 00336 }

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

| 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 VersionedRandomAllocationSegment::allocateAllocNodes(), RandomAllocationSegment::allocateFromExtent(), RandomAllocationSegment::allocateFromNewExtent(), RandomAllocationSegment::allocatePageId(), VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::chainPageEntries(), SnapshotRandomAllocationSegment::commitChanges(), VersionedRandomAllocationSegment::copyPageEntryFromTemp(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), deallocatePageId(), VersionedRandomAllocationSegment::findAllocPageIdForRead(), format(), formatPageExtentsTemplate(), freePageEntryTemplate(), RandomAllocationSegment::getExtAllocPageIdForRead(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), 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 allocateFromLockedExtentTemplate(), ScratchSegment::allocatePageId(), LinearViewSegment::allocatePageId(), LinearDeviceSegment::allocatePageId(), CircularSegment::allocatePageId(), getExtentAllocPageId(), VersionedRandomAllocationSegment::getOldPageIds(), 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(), 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

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 VersionedRandomAllocationSegment::allocateAllocNodes(), allocateFromLockedExtentTemplate(), allocatePageIdFromSegment(), VersionedRandomAllocationSegment::backupAllocationNodes(), deallocatePageId(), format(), formatExtentTemplate(), formatPageExtentsTemplate(), VersionedRandomAllocationSegment::getOldPageIds(), VersionedRandomAllocationSegment::locateDataPages(), makePageNum(), RandomAllocationSegment::RandomAllocationSegment(), VersionedRandomAllocationSegment::restoreFromBackup(), splitPageId(), tallySegAllocNodePages(), VersionedRandomAllocationSegment::validateFreePageCount(), and VersionedRandomAllocationSegment::VersionedRandomAllocationSegment().

Number of extents mapped by a full SegmentAllocationNode.

This is immutable.

Definition at line 159 of file RandomAllocationSegmentBase.h.

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

Cache managing pages of this segment.

Definition at line 62 of file Segment.h.

Referenced by VersionedRandomAllocationSegment::allocateAllocNodes(), allocateFromExtentTemplate(), allocateFromNewExtentTemplate(), allocatePageIdFromSegment(), VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::chainPageEntries(), VersionedRandomAllocationSegment::copyPageEntryFromTemp(), VersionedRandomAllocationSegment::copyPageEntryToTemp(), deallocatePageId(), VersionedRandomAllocationSegment::deallocateSinglePage(), VersionedRandomAllocationSegment::deferDeallocation(), VersionedSegment::delegatedCheckpoint(), SnapshotRandomAllocationSegment::delegatedCheckpoint(), Segment::delegatedCheckpoint(), format(), formatPageExtentsTemplate(), freePageEntryTemplate(), Segment::getCache(), Segment::getFullPageSize(), VersionedRandomAllocationSegment::getOldestTxnId(), VersionedRandomAllocationSegment::getOldPageIds(), getPageEntryCopyTemplate(), VersionedRandomAllocationSegment::getTempAllocNodePage(), VersionedRandomAllocationSegment::initPageEntry(), VersionedRandomAllocationSegment::locateDataPages(), VersionedSegment::notifyPageDirty(), VersionedSegment::recover(), VersionedRandomAllocationSegment::restoreFromBackup(), setPageSuccessorTemplate(), 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/RandomAllocationSegmentBase.h
• /home/pub/open/dev/fennel/segment/RandomAllocationSegmentBase.cpp
• /home/pub/open/dev/fennel/segment/RandomAllocationSegmentBaseImpl.h

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