Fennel: SnapshotRandomAllocationSegment Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

SnapshotRandomAllocationSegment implements a random allocation segment that provides a consistent view of the data in the segment based on a specified point in time. More...

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

Inheritance diagram for SnapshotRandomAllocationSegment:

List of all members.

Detailed Description

SnapshotRandomAllocationSegment implements a random allocation segment that provides a consistent view of the data in the segment based on a specified point in time.

All pages read are as of that specified point in time. If a page is updated, and this is the first time the page is being updated, a new copy of the page is created and used for the remaining lifetime of the segment.

This segment delegates much of its work to its underlying VersionedRandomAllocationSegment. That segment is responsible for the actual underlying data storage.

Definition at line 48 of file SnapshotRandomAllocationSegment.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

Retrieves the pageId corresponding to this segment's snapshot of a specified page.

Parameters:

Returns:

snapshot pageId corresponding to the desired pageId

Definition at line 61 of file SnapshotRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, getAnchorPageId(), VersionedRandomAllocationSegment::getLatestPageEntryCopy(), PageEntry::ownerId, pVersionedRandomSegment, readOnlyCommittedData, snapshotCsn, snapshotPageMap, snapshotPageMapMutex, UNCOMMITTED_PAGE_OWNER_ID, and VersionedPageEntry::versionChainPageId.

Referenced by getPageSuccessor(), setPageSuccessor(), translatePageId(), and updatePage().

Increments the counters that keep track of the number of modifications made to a page entry as well as allocations/deallocations.

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

Parameters:

Definition at line 131 of file SnapshotRandomAllocationSegment.cpp.

References ModifiedPageEntry::ALLOCATED, ModifiedPageEntry::DEALLOCATED, SXMutex::isLocked(), LOCKMODE_X, modPageEntriesMap, modPageMapMutex, and needPageFlush.

Referenced by allocatePageId(), chainPageEntries(), deallocatePageRange(), and setPageSuccessor().

| TxnId SnapshotRandomAllocationSegment::getSnapshotCsn | ( | | ) | | ----------------------------------------------------- | - | | - |

Commits page entry changes.

Parameters:

Definition at line 355 of file SnapshotRandomAllocationSegment.cpp.

References Segment::getTracingSegment(), modPageEntriesMap, modPageMapMutex, pVersionedRandomSegment, readOnlyCommittedData, snapshotPageMap, and VersionedRandomAllocationSegment::updateAllocNodes().

Referenced by SnapshotSegmentTestBase::commitChanges(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), LcsClusterReplaceExecStreamTest::testClusterReplace(), and CmdInterpreter::visit().

| void SnapshotRandomAllocationSegment::rollbackChanges | ( | | ) | | ----------------------------------------------------- | - | | - |

Adds a source page chain into a destination page chain.

All pages in the source chain must be newer than the pages in the destination chain.

Parameters:

Definition at line 453 of file SnapshotRandomAllocationSegment.cpp.

References VersionedPageEntry::allocationCsn, chainPageEntries(), getAnchorPageId(), VersionedRandomAllocationSegment::getLatestPageEntryCopy(), modPageMapMutex, NULL_PAGE_ID, pVersionedRandomSegment, readOnlyCommittedData, snapshotPageMap, snapshotPageMapMutex, and VersionedPageEntry::versionChainPageId.

Referenced by LbmSplicerExecStream::execute(), and LcsClusterReplaceExecStream::getTupleForLoad().

| void SnapshotRandomAllocationSegment::setForceCacheUnmap | ( | | ) | | -------------------------------------------------------- | - | | - |

Allocates a page without locking it into memory.

Parameters:

Returns:

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

Reimplemented from DelegatingSegment.

Definition at line 202 of file SnapshotRandomAllocationSegment.cpp.

References ModifiedPageEntry::ALLOCATED, DelegatingSegment::allocatePageId(), ANON_PAGE_OWNER_ID, incrPageUpdateCount(), VersionedRandomAllocationSegment::initPageEntry(), ModifiedPageEntry::MODIFIED, modPageMapMutex, pVersionedRandomSegment, readOnlyCommittedData, snapshotCsn, and UNCOMMITTED_PAGE_OWNER_ID.

Referenced by updatePage().

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 221 of file SnapshotRandomAllocationSegment.cpp.

References ANON_PAGE_OWNER_ID, ModifiedPageEntry::DEALLOCATED, DelegatingSegment::deallocatePageRange(), VersionedRandomAllocationSegment::getLatestPageEntryCopy(), incrPageUpdateCount(), modPageMapMutex, NULL_PAGE_ID, pVersionedRandomSegment, readOnlyCommittedData, snapshotPageMap, snapshotPageMapMutex, and VersionedPageEntry::versionChainPageId.

Determines whether a page can be updated in-place, and if so, prepares the page for update.

Parameters:

Returns:

NULL_PAGE_ID if the page can be updated in place; otherwise, the pageId of the page that should be used when updates are made to the page

Reimplemented from DelegatingSegment.

Definition at line 256 of file SnapshotRandomAllocationSegment.cpp.

References allocatePageId(), chainPageEntries(), getAnchorPageId(), VersionedRandomAllocationSegment::getLatestPageEntryCopy(), getSnapshotId(), isPageNewlyAllocated(), modPageMapMutex, NULL_PAGE_ID, PageEntry::ownerId, pVersionedRandomSegment, readOnlyCommittedData, snapshotPageMap, snapshotPageMapMutex, PageEntry::successorId, and VersionedPageEntry::versionChainPageId.

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

Definition at line 419 of file SnapshotRandomAllocationSegment.cpp.

References pVersionedRandomSegment, and readOnlyCommittedData.

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 436 of file SnapshotRandomAllocationSegment.cpp.

References DelegatingSegment::notifyPageDirty(), and readOnlyCommittedData.

| bool SnapshotRandomAllocationSegment::isWriteVersioned | ( | | ) | [virtual] | | ------------------------------------------------------ | - | | - | ----------- |

| 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] | | --------------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

| 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(), 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(), 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.

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().

| 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().

Member Data Documentation

Underlying segment that provides versioning of pages.

Definition at line 93 of file SnapshotRandomAllocationSegment.h.

Referenced by allocatePageId(), chainPageEntries(), commitChanges(), deallocatePageRange(), getAnchorPageId(), getMappedPageListener(), getSnapshotId(), notifyAfterPageCheckpointFlush(), rollbackChanges(), SnapshotRandomAllocationSegment(), updatePage(), and versionPage().

True if only committed data should be read by the segment.

This includes not reading uncommitted data created by the current transaction.

Definition at line 105 of file SnapshotRandomAllocationSegment.h.

Referenced by allocatePageId(), canFlushPage(), commitChanges(), deallocatePageRange(), getSnapshotId(), notifyAfterPageCheckpointFlush(), notifyPageDirty(), rollbackChanges(), setPageSuccessor(), SnapshotRandomAllocationSegment(), updatePage(), and versionPage().

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(), VersionedSegment::delegatedCheckpoint(), 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(), VersionedSegment::notifyPageDirty(), VersionedSegment::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/SnapshotRandomAllocationSegment.h
• /home/pub/open/dev/fennel/segment/SnapshotRandomAllocationSegment.cpp

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