RandomAllocationSegment Class Reference

RandomAllocationSegment refines RandomAllocationSegmentBase, defining an ExtentAllocationNode where each page entry within the segment is unversioned. More...

#include <RandomAllocationSegment.h>

Inheritance diagram for RandomAllocationSegment:

List of all members.


Public Types
enum	AllocationOrder { RANDOM_ALLOCATION, ASCENDING_ALLOCATION, CONSECUTIVE_ALLOCATION, LINEAR_ALLOCATION }
	Enumeration of the possible orderings of PageIds returned from allocatePageId. More...
Public Member Functions
	RandomAllocationSegment (SharedSegment delegateSegment)
virtual PageId	allocatePageId (PageOwnerId ownerId)
	Allocates a page without locking it into memory.
virtual PageId	getPageSuccessor (PageId pageId)
	Determines the successor of a given PageId.
virtual void	setPageSuccessor (PageId pageId, PageId successorId)
	Sets the successor of a given PageId.
virtual BlockId	translatePageId (PageId)
	Maps from a PageId in this segment to a BlockId.
virtual bool	isPageIdAllocated (PageId pageId)
	Tests whether a PageId is allocated.
virtual AllocationOrder	getAllocationOrder () const
	Returns: the AllocationOrder for this segment
virtual BlockNum	getAllocatedSizeInPages ()
	Returns: number of pages allocated from this segment
virtual BlockNum	getNumPagesOccupiedHighWater ()
	Returns the max number of pages occupied by this segment instance.
virtual void	deallocatePageRange (PageId startPageId, PageId endPageId)
	Deallocates a range of pages allocated from this segment.
virtual void	initForUse ()
	Performs additional initialization required on the segment after it has been properly formatted.
SharedSegment const &	getDelegateSegment () const
virtual BlockNum	getNumPagesExtended ()
	Returns: the number of incremental pages added to this instance of the segment
virtual PageId	translateBlockId (BlockId)
	Maps from a BlockId to a PageId in this segment.
virtual bool	ensureAllocatedSize (BlockNum nPages)
	Allocates pages as needed to make getAllocatedSizeInPages() meet a lower bound.
virtual void	delegatedCheckpoint (Segment &delegatingSegment, CheckpointType checkpointType)
	Helper for DelegatingSegment.
virtual PageId	updatePage (PageId pageId, bool needsTranslation=false)
	Determines whether a page can be updated in-place, and if so, prepares the page for update.
virtual void	notifyPageMap (CachePage &page)
	Receives notification from CacheImpl as soon as a page is mapped, before any I/O is initiated to retrieve the page contents.
virtual void	notifyPageUnmap (CachePage &page)
	Receives notification from CacheImpl just before a page is unmapped.
virtual void	notifyAfterPageRead (CachePage &page)
	Receives notification from CacheImpl after a page read completes.
virtual void	notifyPageDirty (CachePage &page, bool bDataValid)
	Receives notification from CacheImpl the first time a page becomes dirty after it has been mapped (but before the contents have changed).
virtual void	notifyBeforePageFlush (CachePage &page)
	Receives notification from CacheImpl just before a dirty page is flushed to disk.
virtual void	notifyAfterPageFlush (CachePage &page)
	Receives notification from CacheImpl when a page flush completes successfully.
virtual bool	canFlushPage (CachePage &page)
	Informs CacheImpl whether a dirty page can safely be flushed to disk.
SharedCache	getCache () const
	Returns: the Cache for this Segment
uint	getFullPageSize () const
	Returns: the full size of pages stored in this segment; this is the same as the size of underlying cache pages
uint	getUsablePageSize () const
	Returns: the full size of pages stored in this segment minus the size for any footer information stored at the end of each page
SharedSegment	getTracingSegment ()
	Returns: tracing segment associated with this segment if tracing is turned on; otherwise, returns the segment itself
void	setTracingSegment (WeakSegment pTracingSegmentInit)
	Sets the tracing segment associated with this segment.
void	checkpoint (CheckpointType checkpointType=CHECKPOINT_FLUSH_ALL)
	Checkpoints this segment.
virtual MappedPageListener *	getMappedPageListener (BlockId blockId)
	Returns the mapped page listener corresponding to a page.
virtual bool	isWriteVersioned ()
	Returns: true if the segment supports versioning
virtual MappedPageListener *	getTracingListener ()
	Retrieves the tracing wrapper corresponding to this listener if tracing is turned on.
virtual MappedPageListener *	notifyAfterPageCheckpointFlush (CachePage &page)
	Receives notification that a page has been flushed during a checkpoint.
bool	isClosed () const
	Returns: whether the object has been closed
void	close ()
	Closes this object, releasing any unallocated resources.
Static Public Member Functions
static PageId	getLinearPageId (BlockNum iPage)
	Constructs a linear PageId based on a linear page number.
static BlockNum	getLinearBlockNum (PageId pageId)
	Obtains the linear page number from a linear PageId.
Protected Types
typedef std::hash_map< PageId, PageId >	PageMap
typedef PageMap::const_iterator	PageMapConstIter
Protected Member Functions
PageId	getSegAllocPageId (uint iSegPage) const
	Calculates the PageId of a particular SegmentAllocationNode.
PageId	getExtentAllocPageId (ExtentNum extentNum) const
	Calculates the PageId of a particular extent allocation node.
BlockNum	makePageNum (ExtentNum extentNum, BlockNum iPageInExtent) const
	Calculates a linear page number.
void	splitPageId (PageId pageId, uint &iSegAlloc, ExtentNum &extentNum, BlockNum &iPageInExtent) const
	Maps a linear PageId from this segment into the corresponding SegmentAllocationNode, extent allocation node, and extent-relative page index.
virtual bool	isPageIdValid (PageId pageId)
	Tests whether the given PageId has valid contents (either an allocated data page or an allocation map page).
bool	testPageId (PageId pageId, bool testAllocation, bool thisSegment)
	Common implementation for isPageIdValid and isPageIdAllocated.
template<class PageEntryT>
PageOwnerId	getPageOwnerIdTemplate (PageId pageId, bool thisSegment)
	Retrieves the ownerId corresponding to a page entry.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
void	freePageEntryTemplate (ExtentNum extentNum, BlockNum iPageInExtent)
	Marks the page entry corresponding to a deallocated page as unallocated.
virtual void	markPageEntryUnused (PageEntry &pageEntry)
	Marks a page entry as unused.
PageId	getFirstSegAllocPageId () const
	Returns: the PageId of the first SegmentAllocationNode
uint	inferSegAllocCount ()
	Infers the number of SegmentAllocationNodes from the size of the underlying segment.
void	format ()
	Formats allocation pages based on current size of underlying segment, marking all pages as deallocated.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
void	formatPageExtentsTemplate (SegmentAllocationNode &segAllocNode, ExtentNum &extentNum)
	Formats each of the extents within a segment allocation node.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
void	formatExtentTemplate (ExtentAllocationNodeT &extentNode)
	Formats one extent allocation.
PageId	allocatePageIdFromSegment (PageOwnerId ownerId, SharedSegment allocNodeSegment)
	Allocates a page without locking it into memory.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
PageId	allocateFromExtentTemplate (ExtentNum extentNum, PageOwnerId ownerId, SharedSegment allocNodeSegment)
	Allocates a new page from an extent known to have space.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
PageId	allocateFromNewExtentTemplate (ExtentNum extentNum, PageOwnerId ownerId, SharedSegment allocNodeSegment)
	Allocates a page from a new extent allocation node.
template<class ExtentAllocationNodeT, class PageEntryT>
PageId	allocateFromLockedExtentTemplate (ExtentAllocationNodeT &extentNode, ExtentNum extentNum, PageOwnerId ownerId)
	Allocates a new page from an extent known to have space, with the extent allocation node already locked.
template<class ExtentAllocationNodeT, class ExtentAllocLockT>
void	setPageSuccessorTemplate (PageId pageId, PageId successorId, SharedSegment allocNodeSegment)
	Sets the successor pageId for a page.
template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>
void	getPageEntryCopyTemplate (PageId pageId, PageEntryT &pageEntryCopy, bool isAllocated, bool thisSegment)
	Retrieves a copy of the page entry for a specified page.
void	setUsablePageSize (uint)
PConstBuffer	getReadableFooter (CachePage &page)
PBuffer	getWritableFooter (CachePage &page)
PageId	getLinearPageSuccessor (PageId pageId)
	An implementation of getPageSuccessor suitable for LINEAR_ALLOCATION.
void	setLinearPageSuccessor (PageId pageId, PageId successorId)
	An implementation of setPageSuccessor suitable for LINEAR_ALLOCATION.
bool	isLinearPageIdAllocated (PageId pageId)
	An implementation of isPageIdAllocated suitable for LINEAR_ALLOCATION when deallocation holes are disallowed.
Protected Attributes
BlockNum	nPagesPerExtent
	Number of pages in one extent, including the extent allocation node itself (so actual data capacity per extent is one less).
BlockNum	nPagesPerSegAlloc
	Number of pages mapped by one SegmentAllocationNode, including the SegmentAllocationNode itself.
ExtentNum	nExtentsPerSegAlloc
	Number of extents mapped by a full SegmentAllocationNode.
SharedCache	pCache
	Cache managing pages of this segment.
WeakSegment	pTracingSegment
	The tracing segment associated with this segment, if tracing is turned on.
bool	needsClose
Private Member Functions
virtual PageId	getSegAllocPageIdForWrite (PageId origSegAllocPageId)
	Retrieves the pageId of the SegmentAllocationNode that should be updated when updates are made to that node.
virtual void	undoSegAllocPageWrite (PageId segAllocPageId)
	Indicates that no new pages were allocated from extents within a SegmentAllocationNode.
virtual PageId	getExtAllocPageIdForWrite (ExtentNum extentNum)
	Retrieves the pageId of the extent allocation node that should be updated when updates are made to that node.
virtual PageId	allocateFromExtent (ExtentNum extentNum, PageOwnerId ownerId)
	Allocates a new page from an extent known to have space.
virtual void	formatPageExtents (SegmentAllocationNode &segAllocNode, ExtentNum &extentNum)
	Formats each of the extents within a segment allocation node.
virtual PageId	allocateFromNewExtent (ExtentNum extentNum, PageOwnerId ownerId)
	Allocates a page from a new extent allocation node.
virtual void	freePageEntry (ExtentNum extentNum, BlockNum iPageInExtent)
	Marks the page entry corresponding to a deallocated page as unallocated.
virtual PageOwnerId	getPageOwnerId (PageId pageId, bool thisSegment)
	Retrieves the ownerId corresponding to a page entry.
virtual PageId	getSegAllocPageIdForRead (PageId origSegAllocPageId, SharedSegment &allocNodeSegment)
	Retrieves the actual pageId corresponding to the SegmentAllocationNode that should be accessed when reading from the node.
virtual PageId	getExtAllocPageIdForRead (ExtentNum extentNum, SharedSegment &allocNodeSegment)
	Retrieves the actual pageId corresponding to the extent allocation node that should be accessed when reading from the node.
virtual void	getPageEntryCopy (PageId pageId, PageEntry &pageEntryCopy, bool isAllocated, bool thisSegment)
	Retrieves a copy of the page entry for a specified page.
Friends
class	SegmentFactory

Detailed Description

RandomAllocationSegment refines RandomAllocationSegmentBase, defining an ExtentAllocationNode where each page entry within the segment is unversioned.

The ExtentAllocationNodes are stored in the segment itself.

Definition at line 38 of file RandomAllocationSegment.h.

Member Typedef Documentation

typedef std::hash_map<PageId,PageId> Segment::PageMap [protected, inherited]

Definition at line 56 of file Segment.h.

typedef PageMap::const_iterator Segment::PageMapConstIter [protected, inherited]

Definition at line 57 of file Segment.h.

Member Enumeration Documentation

enum Segment::AllocationOrder [inherited]

Enumeration of the possible orderings of PageIds returned from allocatePageId.

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

Enumerator:

RANDOM_ALLOCATION	Random order.
ASCENDING_ALLOCATION	Later calls always return greater PageIds, but not necessarily consecutively.
CONSECUTIVE_ALLOCATION	PageIds are returned in consecutive ascending order of BlockNum; the DeviceId is always the same.
LINEAR_ALLOCATION	PageIds are returned in consecutive ascending order starting with 0; all bytes of the PageId are used (no division into DeviceId/BlockNum), yielding maximum range.

Definition at line 105 of file Segment.h.

00105                          {
00109         RANDOM_ALLOCATION,
00110 
00115         ASCENDING_ALLOCATION,
00116 
00121         CONSECUTIVE_ALLOCATION,
00122 
00128         LINEAR_ALLOCATION
00129     };

Constructor & Destructor Documentation

RandomAllocationSegment::RandomAllocationSegment ( SharedSegment delegateSegment ) [explicit]

Definition at line 30 of file RandomAllocationSegment.cpp.

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

00032     : RandomAllocationSegmentBase(delegateSegment)
00033 {
00034     nPagesPerExtent = (getUsablePageSize() - sizeof(ExtentAllocationNode))
00035         / sizeof(PageEntry);
00036 
00037     // + 1 is for SegAllocNode itself
00038     nPagesPerSegAlloc = nPagesPerExtent*nExtentsPerSegAlloc + 1;
00039 }

Member Function Documentation

PageId RandomAllocationSegment::getSegAllocPageIdForWrite ( PageId origSegAllocPageId ) [private, virtual]

Retrieves the pageId of the SegmentAllocationNode that should be updated when updates are made to that node.

Parameters:

origSegAllocPageId

original SegmentAllocationNode pageId

Returns:: pageId of the SegmentAllocationNode to be updated

Implements RandomAllocationSegmentBase.

Definition at line 58 of file RandomAllocationSegment.cpp.

00060 {
00061     return origSegAllocPageId;
00062 }

void RandomAllocationSegment::undoSegAllocPageWrite ( PageId segAllocPageId ) [private, virtual]

Indicates that no new pages were allocated from extents within a SegmentAllocationNode.

Parameters:

segAllocPageId

SegmentAllocationNode pageId

Implements RandomAllocationSegmentBase.

Definition at line 64 of file RandomAllocationSegment.cpp.

00065 {
00066 }

PageId RandomAllocationSegment::getExtAllocPageIdForWrite ( ExtentNum extentNum ) [private, virtual]

Retrieves the pageId of the extent allocation node that should be updated when updates are made to that node.

Parameters:

extentNum

absolute 0-based extent number

Returns:: pageId of the extent allocation to be updated

Implements RandomAllocationSegmentBase.

Definition at line 68 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::getExtentAllocPageId().

00069 {
00070     return getExtentAllocPageId(extentNum);
00071 }

PageId RandomAllocationSegment::allocateFromExtent	(	ExtentNum	extentNum,
		PageOwnerId	ownerId
	)			`[private, virtual]`

Allocates a new page from an extent known to have space.

See also:: allocateFromExtentTemplate()

Parameters:

	extentNum	absolute 0-based extent number from which to allocate
	ownerId	PageOwnerId of owning object

Returns:: allocated PageId

Implements RandomAllocationSegmentBase.

Definition at line 116 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::allocateFromExtentTemplate(), and Segment::getTracingSegment().

00119 {
00120     return
00121         allocateFromExtentTemplate<
00122                 ExtentAllocationNode,
00123                 ExtentAllocLock,
00124                 PageEntry>(
00125             extentNum,
00126             ownerId,
00127             getTracingSegment());
00128 }

void RandomAllocationSegment::formatPageExtents	(	SegmentAllocationNode &	segAllocNode,
		ExtentNum &	extentNum
	)			`[private, virtual]`

Formats each of the extents within a segment allocation node.

See also:: formatPageExtentsTemplate()

Parameters:

`[in]`	segAllocNode	locked segment allocation node
`[in,out]`	extentNum	on input, the initial absolute 0-based extent number that needs to be formatted; on output, the last extent number formatted + 1

Implements RandomAllocationSegmentBase.

Definition at line 41 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::formatPageExtentsTemplate().

00044 {
00045     formatPageExtentsTemplate<
00046             ExtentAllocationNode,
00047             ExtentAllocLock,
00048             PageEntry>(
00049         segAllocNode,
00050         extentNum);
00051 }

PageId RandomAllocationSegment::allocateFromNewExtent	(	ExtentNum	extentNum,
		PageOwnerId	ownerId
	)			`[private, virtual]`

Allocates a page from a new extent allocation node.

See also:: allocateFromNewExtentTemplate()

Parameters:

	extentNum	absolute extent number from which to allocate
	ownerId	PageOwnerId of owning object

Returns:: allocated PageId

Implements RandomAllocationSegmentBase.

Definition at line 102 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::allocateFromNewExtentTemplate(), and Segment::getTracingSegment().

00105 {
00106     return
00107         allocateFromNewExtentTemplate<
00108                 ExtentAllocationNode,
00109                 ExtentAllocLock,
00110                 PageEntry>(
00111             extentNum,
00112             ownerId,
00113             getTracingSegment());
00114 }

void RandomAllocationSegment::freePageEntry	(	ExtentNum	extentNum,
		BlockNum	iPageInExtent
	)			`[private, virtual]`

Marks the page entry corresponding to a deallocated page as unallocated.

See also:: freePageEntryTemplate()

Parameters:

	extentNum	absolute 0-based extent number
	iPageInExtent	0-based index of page in extent

Implements RandomAllocationSegmentBase.

Definition at line 130 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::freePageEntryTemplate().

00133 {
00134     freePageEntryTemplate<
00135             ExtentAllocationNode,
00136             ExtentAllocLock,
00137             PageEntry>(
00138         extentNum,
00139         iPageInExtent);
00140 }

PageOwnerId RandomAllocationSegment::getPageOwnerId	(	PageId	pageId,
		bool	thisSegment
	)			`[private, virtual]`

Retrieves the ownerId corresponding to a page entry.

See also:: getPageOwnerIdTemplate()

Parameters:

	pageId	PageId of the page whose owner we are retrieving
	thisSegment	if true, retrieve page entry from this segment; otherwise, retrieve it from an alternative segment

Returns:: ownerId

Implements RandomAllocationSegmentBase.

Definition at line 160 of file RandomAllocationSegment.cpp.

00163 {
00164     return getPageOwnerIdTemplate<PageEntry>(pageId, thisSegment);
00165 }

PageId RandomAllocationSegment::getSegAllocPageIdForRead	(	PageId	origSegAllocPageId,
		SharedSegment &	allocNodeSegment
	)			`[private, virtual]`

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

Parameters:

	origSegAllocPageId	original SegmentAllocationNode pageId
`[out]`	allocNodeSegment	segment from which the allocation node to be read originates

Returns:: pageId to be read

Implements RandomAllocationSegmentBase.

Definition at line 73 of file RandomAllocationSegment.cpp.

References Segment::getTracingSegment().

00076 {
00077     allocNodeSegment = getTracingSegment();
00078     return origSegAllocPageId;
00079 }

PageId RandomAllocationSegment::getExtAllocPageIdForRead	(	ExtentNum	extentNum,
		SharedSegment &	allocNodeSegment
	)			`[private, virtual]`

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

Parameters:

	extentNum	absolute 0-based extent number
`[out]`	allocNodeSegment	segment from which the allocation node to be read originates

Returns:: pageId to be read

Implements RandomAllocationSegmentBase.

Definition at line 81 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::getExtentAllocPageId(), and Segment::getTracingSegment().

00084 {
00085     allocNodeSegment = getTracingSegment();
00086     return getExtentAllocPageId(extentNum);
00087 }

void RandomAllocationSegment::getPageEntryCopy	(	PageId	pageId,
		PageEntry &	pageEntryCopy,
		bool	isAllocated,
		bool	thisSegment
	)			`[private, virtual]`

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

See also:: getPageEntryCopyTemplate()

Parameters:

	pageId	pageId of the page whose page entry data we are retrieving
`[out]`	pageEntryCopy	copy of page entry retrieved
	isAllocated	if true, assert that the page is allocated
	thisSegment	if true, retrieve page entry from this segment; otherwise, retrieve it from an alternative segment

Implements RandomAllocationSegmentBase.

Definition at line 89 of file RandomAllocationSegment.cpp.

Referenced by getPageSuccessor().

00094 {
00095     getPageEntryCopyTemplate<ExtentAllocationNode, ExtentAllocLock, PageEntry>(
00096         pageId,
00097         pageEntryCopy,
00098         isAllocated,
00099         thisSegment);
00100 }

PageId RandomAllocationSegment::allocatePageId ( PageOwnerId ownerId ) [virtual]

Allocates a page without locking it into memory.

Parameters:

ownerId

the PageOwnerId of the object which will own this page, or ANON_PAGE_OWNER_ID for pages unassociated with an owner

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

Reimplemented from DelegatingSegment.

Definition at line 53 of file RandomAllocationSegment.cpp.

References RandomAllocationSegmentBase::allocatePageIdFromSegment(), and Segment::getTracingSegment().

00054 {
00055     return allocatePageIdFromSegment(ownerId, getTracingSegment());
00056 }

PageId RandomAllocationSegment::getPageSuccessor ( PageId pageId ) [virtual]

Determines the successor of a given PageId.

This is an optional interface only supported by segments with some concept of page ordering.

Parameters:

pageId

PageId for which the successor is to be found

Returns:: successor PageId

Reimplemented from DelegatingSegment.

Definition at line 142 of file RandomAllocationSegment.cpp.

References getPageEntryCopy(), and PageEntry::successorId.

00143 {
00144     PageEntry pageEntry;
00145 
00146     getPageEntryCopy(pageId, pageEntry, true, true);
00147     return pageEntry.successorId;
00148 }

void RandomAllocationSegment::setPageSuccessor	(	PageId	pageId,
		PageId	successorId
	)			`[virtual]`

Sets the successor of a given PageId.

This is an optional interface only supported by segments with some concept of modifiable ordering.

Parameters:

	pageId	PageId for which the successor is to be set
	successorId	PageId of successor

Reimplemented from DelegatingSegment.

Definition at line 150 of file RandomAllocationSegment.cpp.

References Segment::getTracingSegment().

00153 {
00154     setPageSuccessorTemplate<ExtentAllocationNode, ExtentAllocLock>(
00155         pageId,
00156         successorId,
00157         getTracingSegment());
00158 }

PageId RandomAllocationSegmentBase::getSegAllocPageId ( uint iSegPage ) const [inline, protected, inherited]

Calculates the PageId of a particular SegmentAllocationNode.

Parameters:

iSegPage

0-based index of desired SegmentAllocationNode

Returns:: corresponding PageId

Definition at line 104 of file RandomAllocationSegmentBaseImpl.h.

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

00106 {
00107     return getLinearPageId(nPagesPerSegAlloc*iSegPage);
00108 }

PageId RandomAllocationSegmentBase::getExtentAllocPageId ( ExtentNum extentNum ) const [inline, protected, inherited]

Calculates the PageId of a particular extent allocation node.

Parameters:

extentNum

absolute 0-based extent number

Returns:: corresponding PageId

Definition at line 118 of file RandomAllocationSegmentBaseImpl.h.

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

00120 {
00121     return getLinearPageId(makePageNum(extentNum,0));
00122 }

BlockNum RandomAllocationSegmentBase::makePageNum	(	ExtentNum	extentNum,
		BlockNum	iPageInExtent
	)			const `[inline, protected, inherited]`

Calculates a linear page number.

Parameters:

	extentNum	absolute 0-based extent number of extent containing desired page
	iPageInExtent	0-based index of page in extent

Returns:: BlockNum corresponding to a linear PageId in this segment

Definition at line 110 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::nExtentsPerSegAlloc, and RandomAllocationSegmentBase::nPagesPerExtent.

Referenced by RandomAllocationSegmentBase::allocateFromLockedExtentTemplate(), RandomAllocationSegmentBase::allocatePageIdFromSegment(), RandomAllocationSegmentBase::getExtentAllocPageId(), VersionedRandomAllocationSegment::getOldPageIds(), VersionedRandomAllocationSegment::locateDataPages(), and VersionedRandomAllocationSegment::restoreFromBackup().

00112 {
00113     // weird calculation to take into account interspersal of SegAllocNodes
00114     uint nSegPages = extentNum / nExtentsPerSegAlloc + 1;
00115     return iPageInExtent + extentNum*nPagesPerExtent + nSegPages;
00116 }

void RandomAllocationSegmentBase::splitPageId	(	PageId	pageId,
		uint &	iSegAlloc,
		ExtentNum &	extentNum,
		BlockNum &	iPageInExtent
	)			const `[protected, inherited]`

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

Parameters:

	pageId	input PageId
`[out]`	iSegAlloc	0-based index of containing SegmentAllocationNode
`[out]`	extentNum	absolute 0-based extent number of containing extent allocation node
`[out]`	iPageInExtent	0-based index of page in extent

Definition at line 279 of file RandomAllocationSegmentBase.cpp.

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

00282 {
00283     // calculate block number relative to containing SegAllocNode
00284     BlockNum iPageInSegAlloc = getLinearBlockNum(pageId) % nPagesPerSegAlloc;
00285     iSegAlloc = getLinearBlockNum(pageId) / nPagesPerSegAlloc;
00286     if (!iPageInSegAlloc) {
00287         // this is the SegAllocNode itself!
00288         extentNum = MAXU;
00289         iPageInExtent = 0;
00290     } else {
00291         // account for the SegAllocNode
00292         --iPageInSegAlloc;
00293         extentNum =
00294             iPageInSegAlloc / nPagesPerExtent + nExtentsPerSegAlloc * iSegAlloc;
00295         iPageInExtent = iPageInSegAlloc % nPagesPerExtent;
00296     }
00297 }

bool RandomAllocationSegmentBase::isPageIdValid ( PageId pageId ) [protected, virtual, inherited]

Tests whether the given PageId has valid contents (either an allocated data page or an allocation map page).

Parameters:

pageId

the PageId to test

Returns:: true iff pageId is valid

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 412 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::testPageId().

Referenced by RandomAllocationSegmentBase::translatePageId().

00413 {
00414     return testPageId(pageId,false,true);
00415 }

bool RandomAllocationSegmentBase::testPageId	(	PageId	pageId,
		bool	testAllocation,
		bool	thisSegment
	)			`[protected, inherited]`

Common implementation for isPageIdValid and isPageIdAllocated.

Definition at line 385 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::getPageOwnerId(), DelegatingSegment::isPageIdAllocated(), RandomAllocationSegmentBase::splitPageId(), and UNALLOCATED_PAGE_OWNER_ID.

Referenced by RandomAllocationSegmentBase::getPageEntryCopyTemplate(), VersionedRandomAllocationSegment::isPageIdAllocateCommitted(), VersionedRandomAllocationSegment::isPageIdAllocated(), RandomAllocationSegmentBase::isPageIdAllocated(), VersionedRandomAllocationSegment::isPageIdValid(), and RandomAllocationSegmentBase::isPageIdValid().

00389 {
00390     if (!DelegatingSegment::isPageIdAllocated(pageId)) {
00391         return false;
00392     }
00393 
00394     uint iSegAlloc;
00395     ExtentNum extentNum;
00396     BlockNum iPageInExtent;
00397     splitPageId(pageId,iSegAlloc,extentNum,iPageInExtent);
00398     if (!iPageInExtent) {
00399         // header pages are valid but not allocated (from the
00400         // perspective of the RandomAllocationSegment, not the
00401         // underlying linear segment)
00402         if (testAllocation) {
00403             return false;
00404         } else {
00405             return true;
00406         }
00407     }
00408     PageOwnerId ownerId = getPageOwnerId(pageId, thisSegment);
00409     return (ownerId != UNALLOCATED_PAGE_OWNER_ID);
00410 }

template<class PageEntryT>

PageOwnerId RandomAllocationSegmentBase::getPageOwnerIdTemplate	(	PageId	pageId,
		bool	thisSegment
	)			`[protected, inherited]`

Retrieves the ownerId corresponding to a page entry.

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

Parameters:

	pageId	PageId of the page whose owner we are retrieving
	thisSegment	if true, retrieve page entry from this segment; otherwise, retrieve it from an alternative segment

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>

void RandomAllocationSegmentBase::freePageEntryTemplate	(	ExtentNum	extentNum,
		BlockNum	iPageInExtent
	)			`[protected, inherited]`

Marks the page entry corresponding to a deallocated page as unallocated.

The extent is specified by the the extentNum, the index of the page in the extent, and the segment where the extent allocation node originates from.

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

Parameters:

	extentNum	absolute 0-based extent number
	iPageInExtent	0-based index of deallocated page in extent

Definition at line 225 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getExtentAllocPageId(), Segment::getTracingSegment(), RandomAllocationSegmentBase::markPageEntryUnused(), Segment::pCache, and UNALLOCATED_PAGE_OWNER_ID.

Referenced by VersionedRandomAllocationSegment::freePageEntry(), and freePageEntry().

00228 {
00229     SegmentAccessor segAccessor(getTracingSegment(), pCache);
00230     ExtentAllocLockT extentAllocLock(segAccessor);
00231 
00232     extentAllocLock.lockExclusive(getExtentAllocPageId(extentNum));
00233     ExtentAllocationNodeT &extentNode = extentAllocLock.getNodeForWrite();
00234     PageEntryT &pageEntry = extentNode.getPageEntry(iPageInExtent);
00235     permAssert(pageEntry.ownerId != UNALLOCATED_PAGE_OWNER_ID);
00236     markPageEntryUnused(pageEntry);
00237 }

void RandomAllocationSegmentBase::markPageEntryUnused ( PageEntry & pageEntry ) [protected, virtual, inherited]

Marks a page entry as unused.

Parameters:

[in,out] pageEntry entry to be marked

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 136 of file RandomAllocationSegmentBase.cpp.

References NULL_PAGE_ID, PageEntry::ownerId, PageEntry::successorId, and UNALLOCATED_PAGE_OWNER_ID.

Referenced by RandomAllocationSegmentBase::formatExtentTemplate(), RandomAllocationSegmentBase::freePageEntryTemplate(), and VersionedRandomAllocationSegment::markPageEntryUnused().

00138 {
00139     pageEntry.ownerId = UNALLOCATED_PAGE_OWNER_ID;
00140     pageEntry.successorId = NULL_PAGE_ID;
00141 }

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

Returns:: the PageId of the first SegmentAllocationNode

Definition at line 99 of file RandomAllocationSegmentBaseImpl.h.

References FIRST_LINEAR_PAGE_ID.

Referenced by RandomAllocationSegmentBase::allocatePageIdFromSegment(), and RandomAllocationSegmentBase::countAllocatedPages().

00100 {
00101     return FIRST_LINEAR_PAGE_ID;
00102 }

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

Infers the number of SegmentAllocationNodes from the size of the underlying segment.

Definition at line 143 of file RandomAllocationSegmentBase.cpp.

References DelegatingSegment::getAllocatedSizeInPages(), and RandomAllocationSegmentBase::nPagesPerSegAlloc.

Referenced by RandomAllocationSegmentBase::format().

00144 {
00145     BlockNum nPages = DelegatingSegment::getAllocatedSizeInPages();
00146     // round up
00147     return nPages / nPagesPerSegAlloc +
00148         (nPages % nPagesPerSegAlloc ? 1 : 0);
00149 }

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 VersionedRandomAllocationSegment::deallocatePageRange(), and RandomAllocationSegmentBase::deallocatePageRange().

00068 {
00069     // calculate number of SegAllocNodes based on current segment size
00070     uint nSegAllocPages = inferSegAllocCount();
00071 
00072     // calculate number of extents in all but last SegAllocNode
00073     ExtentNum nExtents = (nSegAllocPages-1)*nExtentsPerSegAlloc;
00074 
00075     // calculate number of pages in last SegAllocNode
00076     BlockNum nRemainderPages = DelegatingSegment::getAllocatedSizeInPages();
00077     nRemainderPages -= (nExtents*nPagesPerExtent+nSegAllocPages);
00078 
00079     if (nRemainderPages) {
00080         // last SegAllocNode is not full; add number of remainder extents,
00081         // rounding down
00082         nExtents += nRemainderPages / nPagesPerExtent;
00083     } else {
00084         // last SegAllocNode is full
00085         nExtents += nExtentsPerSegAlloc;
00086     }
00087 
00088     // always format at least one extent; this is somewhat arbitrary, but helps
00089     // to avoid spurious problems with tiny segments in test cases
00090     if (!nExtents) {
00091         nSegAllocPages = 1;
00092         nExtents = 1;
00093     }
00094 
00095     // make sure underlying segment is big enough
00096     bool bigEnough = DelegatingSegment::ensureAllocatedSize(
00097         nExtents*nPagesPerExtent + nSegAllocPages);
00098     permAssert(bigEnough);
00099 
00100     // format each SegAllocNode
00101 
00102     ExtentNum extentNum = 0;
00103     SegmentAccessor selfAccessor(getTracingSegment(), pCache);
00104     SegAllocLock segAllocLock(selfAccessor);
00105     for (uint iSegAlloc = 0; iSegAlloc < nSegAllocPages; iSegAlloc++) {
00106         PageId segAllocPageId = getSegAllocPageId(iSegAlloc);
00107         segAllocLock.lockExclusive(segAllocPageId);
00108 
00109         // REVIEW: have to do setMagicNumber() explicitly since we skipped
00110         // allocation.  Should figure out a way to indicate allocation of a
00111         // specific PageId.
00112         segAllocLock.setMagicNumber();
00113         SegmentAllocationNode &segAllocNode = segAllocLock.getNodeForWrite();
00114 
00115         uint iNextSegAlloc = iSegAlloc + 1;
00116         if (iNextSegAlloc < nSegAllocPages) {
00117             // set up SegAllocNode chain
00118             segAllocNode.nextSegAllocPageId = getSegAllocPageId(iNextSegAlloc);
00119         } else {
00120             // terminate SegAllocNode chain at last node
00121             segAllocNode.nextSegAllocPageId = NULL_PAGE_ID;
00122         }
00123 
00124         // format extent array
00125         segAllocNode.nPagesPerExtent = nPagesPerExtent;
00126         segAllocNode.nExtents = std::min(nExtents,nExtentsPerSegAlloc);
00127         nExtents -= segAllocNode.nExtents;
00128 
00129         // format each extent node within the page
00130         formatPageExtents(segAllocNode, extentNum);
00131     }
00132 
00133     permAssert(!nExtents);
00134 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

void RandomAllocationSegmentBase::formatPageExtentsTemplate	(	SegmentAllocationNode &	segAllocNode,
		ExtentNum &	extentNum
	)			`[protected, inherited]`

Formats each of the extents within a segment allocation node.

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

Parameters:

`[in]`	segAllocNode	locked segment allocation node
`[in,out]`	extentNum	on input, the initial absolute 0-based extent number that needs to be formatted; on output, the last extent number formatted + 1

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 VersionedRandomAllocationSegment::allocateExtAllocNodes(), VersionedRandomAllocationSegment::formatPageExtents(), and formatPageExtents().

00149 {
00150     SegmentAccessor selfAccessor(getTracingSegment(), pCache);
00151     ExtentAllocLockT extentAllocLock(selfAccessor);
00152     uint startOffset = extentNum % nExtentsPerSegAlloc;
00153     for (uint i = startOffset; i < segAllocNode.nExtents; ++i, ++extentNum) {
00154         // -1 for the extent allocation node itself
00155         segAllocNode.getExtentEntry(i).nUnallocatedPages =
00156             nPagesPerExtent - 1;
00157         extentAllocLock.lockExclusive(getExtentAllocPageId(extentNum));
00158         extentAllocLock.setMagicNumber();
00159         formatExtentTemplate<
00160                 ExtentAllocationNodeT,
00161                 ExtentAllocLockT,
00162                 PageEntryT>(
00163             extentAllocLock.getNodeForWrite());
00164     }
00165 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

void RandomAllocationSegmentBase::formatExtentTemplate ( ExtentAllocationNodeT & extentNode ) [protected, inherited]

Formats one extent allocation.

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

Parameters:

[in] extentNode locked extent allocation node

Definition at line 168 of file RandomAllocationSegmentBaseImpl.h.

References ANON_PAGE_OWNER_ID, RandomAllocationSegmentBase::markPageEntryUnused(), and RandomAllocationSegmentBase::nPagesPerExtent.

Referenced by RandomAllocationSegmentBase::formatPageExtentsTemplate().

00170 {
00171     // mark all pages as free
00172     for (uint i = 0; i < nPagesPerExtent; i++) {
00173         PageEntryT &pageEntry = extentNode.getPageEntry(i);
00174         markPageEntryUnused(pageEntry);
00175     }
00176 
00177     // mark the first entry representing the extent allocation node itself
00178     // as permanently allocated
00179     extentNode.getPageEntry(0).ownerId = ANON_PAGE_OWNER_ID;
00180 }

PageId RandomAllocationSegmentBase::allocatePageIdFromSegment	(	PageOwnerId	ownerId,
		SharedSegment	allocNodeSegment
	)			`[protected, inherited]`

Allocates a page without locking it into memory.

The allocation nodes originate from a specified segment.

Parameters:

	ownerId	the PageOwnerId of the object which will own this page, or ANON_PAGE_OWNER_ID for pages unassociated with an owner
	allocNodeSegment	segment from which the allocation nodes originate

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

Definition at line 151 of file RandomAllocationSegmentBase.cpp.

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

00154 {
00155     ExtentNum extentNum = 0;
00156     SegmentAccessor segAccessor(allocNodeSegment, pCache);
00157     SegAllocLock segAllocLock(segAccessor);
00158 
00159     // find a SegAllocNode with free space
00160     PageId origSegAllocPageId = getFirstSegAllocPageId();
00161     PageId segAllocPageId = getSegAllocPageIdForWrite(origSegAllocPageId);
00162     for (uint iSegAlloc = 0; ; ++iSegAlloc) {
00163         // Initially access the node for read because we may not actually
00164         // update it if all extents in the node are full.  Once we need
00165         // to update the node, we'll acquire a writable node.
00166         segAllocLock.lockExclusive(segAllocPageId);
00167         SegmentAllocationNode const &readOnlySegAllocNode =
00168             segAllocLock.getNodeForRead();
00169 
00170         // check each extent
00171         for (uint i = 0; i < readOnlySegAllocNode.nExtents; ++i, ++extentNum) {
00172             SegmentAllocationNode::ExtentEntry const &readOnlyExtentEntry =
00173                 readOnlySegAllocNode.getExtentEntry(i);
00174             if (readOnlyExtentEntry.nUnallocatedPages) {
00175                 // found one, so get a writable node
00176                 SegmentAllocationNode &writableSegAllocNode =
00177                     segAllocLock.getNodeForWrite();
00178                 SegmentAllocationNode::ExtentEntry &writableExtentEntry =
00179                     writableSegAllocNode.getExtentEntry(i);
00180                 writableExtentEntry.nUnallocatedPages--;
00181                 // explicit unlock to minimize contention window and avoid
00182                 // deadlock with deallocatePageId; this is like a Southwest
00183                 // airlines reservation: we've got a flight reserved, not a
00184                 // particular seat on that flight, but we're guaranteed to find
00185                 // a seat when we get on
00186                 segAllocLock.unlock();
00187                 incrementPageCounters();
00188                 return allocateFromExtent(extentNum,ownerId);
00189             }
00190         }
00191 
00192         if (readOnlySegAllocNode.nextSegAllocPageId != NULL_PAGE_ID) {
00193             // since there's no space on the current SegAllocNode, indicate
00194             // that we haven't allocated any new pages from it
00195             undoSegAllocPageWrite(origSegAllocPageId);
00196 
00197             // try next SegAllocNode
00198             origSegAllocPageId = readOnlySegAllocNode.nextSegAllocPageId;
00199             segAllocPageId = getSegAllocPageIdForWrite(origSegAllocPageId);
00200             continue;
00201         }
00202 
00203         // We have to extend the underlying segment, so we need to prevent
00204         // anyone else from trying to do the same thing at the same time.  So
00205         // hold onto segAllocLock during this process.
00206 
00207         if (readOnlySegAllocNode.nExtents < nExtentsPerSegAlloc) {
00208             // Try to allocate a new extent.  The parameters to makePageNum
00209             // request just enough space to fit one more extent within the
00210             // current SegAllocNode.
00211             try {
00212                 if (!DelegatingSegment::ensureAllocatedSize(
00213                         makePageNum(extentNum,nPagesPerExtent)))
00214                 {
00215                     // couldn't grow
00216                     undoSegAllocPageWrite(origSegAllocPageId);
00217                     return NULL_PAGE_ID;
00218                 }
00219             } catch (...) {
00220                 undoSegAllocPageWrite(origSegAllocPageId);
00221                 throw;
00222             }
00223 
00224             // acquire a writable node now that we're actually updating it
00225             SegmentAllocationNode &writableSegAllocNode =
00226                 segAllocLock.getNodeForWrite();
00227             writableSegAllocNode.nExtents++;
00228             SegmentAllocationNode::ExtentEntry &writableExtentEntry =
00229                 writableSegAllocNode.getExtentEntry(
00230                     writableSegAllocNode.nExtents - 1);
00231 
00232             // -2 = -1 for extent allocation node, -1 for page we're
00233             // about to allocate
00234             writableExtentEntry.nUnallocatedPages = nPagesPerExtent - 2;
00235 
00236             incrementPageCounters();
00237             // another increment for the extent page
00238             incrementPagesOccupiedCounter();
00239             return allocateFromNewExtent(extentNum, ownerId);
00240         }
00241 
00242         // since there's no space on the current SegAllocNode, indicate
00243         // that we haven't allocated any pages from its extents
00244         undoSegAllocPageWrite(origSegAllocPageId);
00245 
00246         // Have to allocate a whole new SegAllocNode.  The parameters to
00247         // makePageNum request enough space to fit the first extent of a new
00248         // SegAllocNode.
00249         if (!DelegatingSegment::ensureAllocatedSize(
00250                 makePageNum(extentNum + 1,0)))
00251         {
00252             // couldn't grow
00253             return NULL_PAGE_ID;
00254         }
00255 
00256         SegAllocLock newSegAllocLock(segAccessor);
00257         origSegAllocPageId = getSegAllocPageId(iSegAlloc + 1);
00258         segAllocPageId = getSegAllocPageIdForWrite(origSegAllocPageId);
00259         newSegAllocLock.lockExclusive(segAllocPageId);
00260         newSegAllocLock.setMagicNumber();
00261         SegmentAllocationNode &newNode = newSegAllocLock.getNodeForWrite();
00262         newNode.nPagesPerExtent = nPagesPerExtent;
00263         newNode.nExtents = 0;
00264         newNode.nextSegAllocPageId = NULL_PAGE_ID;
00265         // increment for the segment allocation node
00266         incrementPagesOccupiedCounter();
00267 
00268         // acquire a writable node to update the next page pointer
00269         SegmentAllocationNode &writableSegAllocNode =
00270             segAllocLock.getNodeForWrite();
00271         writableSegAllocNode.nextSegAllocPageId = origSegAllocPageId;
00272 
00273         // Carry on with the loop.  We'll unlock and relock the node just
00274         // allocated, but that's not a big deal since allocating a new
00275         // SegAllocNode is very rare.
00276     }
00277 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

PageId RandomAllocationSegmentBase::allocateFromExtentTemplate	(	ExtentNum	extentNum,
		PageOwnerId	ownerId,
		SharedSegment	allocNodeSegment
	)			`[protected, inherited]`

Allocates a new page from an extent known to have space.

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:

	extentNum	absolute 0-based extent number from which to allocate
	ownerId	PageOwnerId of owning object
	allocNodeSegment	segment that the allocation node page originates from

Returns:: allocated PageId

Definition at line 127 of file RandomAllocationSegmentBaseImpl.h.

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

Referenced by VersionedRandomAllocationSegment::allocateFromExtent(), and allocateFromExtent().

00131 {
00132     permAssert(ownerId != UNALLOCATED_PAGE_OWNER_ID);
00133 
00134     SegmentAccessor segAccessor(allocNodeSegment, pCache);
00135     ExtentAllocLockT extentAllocLock(segAccessor);
00136     extentAllocLock.lockExclusive(getExtAllocPageIdForWrite(extentNum));
00137     ExtentAllocationNodeT &node = extentAllocLock.getNodeForWrite();
00138     return
00139         allocateFromLockedExtentTemplate<ExtentAllocationNodeT, PageEntryT>(
00140             node,
00141             extentNum,
00142             ownerId);
00143 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

PageId RandomAllocationSegmentBase::allocateFromNewExtentTemplate	(	ExtentNum	extentNum,
		PageOwnerId	ownerId,
		SharedSegment	allocNodeSegment
	)			`[protected, inherited]`

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:

	extentNum	absolute 0-based extent number from which to allocate
	ownerId	PageOwnerId of owning object
	allocNodeSegment	segment that the allocation node page originates from

Returns:: allocated PageId

Definition at line 183 of file RandomAllocationSegmentBaseImpl.h.

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

Referenced by VersionedRandomAllocationSegment::allocateFromNewExtent(), and 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>

PageId RandomAllocationSegmentBase::allocateFromLockedExtentTemplate	(	ExtentAllocationNodeT &	extentNode,
		ExtentNum	extentNum,
		PageOwnerId	ownerId
	)			`[protected, inherited]`

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:

`[in]`	extentNode	locked extent allocation node corresponding to extentNum
	extentNum	absolute extent number from which to allocate
	ownerId	PageOwnerId of owning object

Returns:: allocated PageId

Definition at line 203 of file RandomAllocationSegmentBaseImpl.h.

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

00205 {
00206     // find a free page
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                 // entry 0 is the extent allocation node itself so it
00212                 // should never be marked as unallocated
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>

void RandomAllocationSegmentBase::setPageSuccessorTemplate	(	PageId	pageId,
		PageId	successorId,
		SharedSegment	allocNodeSegment
	)			`[protected, inherited]`

Sets the successor pageId for a page.

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

Parameters:

	pageId	pageId of the page whose successor will be set
	successorId	successor pageId
	allocNodeSegment	segment that the allocation node page originates from

Definition at line 240 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getExtAllocPageIdForWrite(), RandomAllocationSegmentBase::isPageIdAllocated(), NULL_PAGE_ID, Segment::pCache, and RandomAllocationSegmentBase::splitPageId().

Referenced by VersionedRandomAllocationSegment::setPageSuccessor().

00244 {
00245     assert(isPageIdAllocated(pageId));
00246     assert((successorId == NULL_PAGE_ID) || isPageIdAllocated(successorId));
00247 
00248     uint iSegAlloc;
00249     ExtentNum extentNum;
00250     BlockNum iPageInExtent;
00251     splitPageId(pageId, iSegAlloc, extentNum, iPageInExtent);
00252     permAssert(iPageInExtent);
00253 
00254     SegmentAccessor segAccessor(allocNodeSegment, pCache);
00255     ExtentAllocLockT extentAllocLock(segAccessor);
00256     extentAllocLock.lockExclusive(getExtAllocPageIdForWrite(extentNum));
00257     ExtentAllocationNodeT &node = extentAllocLock.getNodeForWrite();
00258     node.getPageEntry(iPageInExtent).successorId = successorId;
00259 }

template<class ExtentAllocationNodeT, class ExtentAllocLockT, class PageEntryT>

void RandomAllocationSegmentBase::getPageEntryCopyTemplate	(	PageId	pageId,
		PageEntryT &	pageEntryCopy,
		bool	isAllocated,
		bool	thisSegment
	)			`[protected, inherited]`

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:

	pageId	pageId of the page whose page entry data we are retrieving
`[out]`	pageEntryCopy	copy of page entry retrieved
	isAllocated	if true, assert that the page is allocated
	thisSegment	if true, retrieve page entry from this segment; otherwise, retrieve it from an alternative segment

Definition at line 273 of file RandomAllocationSegmentBaseImpl.h.

References RandomAllocationSegmentBase::getExtAllocPageIdForRead(), RandomAllocationSegmentBase::getExtentAllocPageId(), Segment::getTracingSegment(), Segment::pCache, RandomAllocationSegmentBase::splitPageId(), and RandomAllocationSegmentBase::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, inherited]

Maps from a PageId in this segment to a BlockId.

Reimplemented from DelegatingSegment.

Definition at line 377 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::isPageIdValid(), and DelegatingSegment::translatePageId().

Referenced by VersionedRandomAllocationSegment::locateDataPages(), and VersionedRandomAllocationSegment::restoreFromBackup().

00378 {
00379     assert(
00380         const_cast<RandomAllocationSegmentBase *>(this)->isPageIdValid(pageId));
00381 
00382     return DelegatingSegment::translatePageId(pageId);
00383 }

bool RandomAllocationSegmentBase::isPageIdAllocated ( PageId pageId ) [virtual, inherited]

Tests whether a PageId is allocated.

Parameters:

pageId

the PageId of interest

Returns:: true iff the PageId is currently allocated in this segment

Reimplemented from DelegatingSegment.

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 417 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::testPageId().

Referenced by RandomAllocationSegmentBase::deallocatePageId(), and RandomAllocationSegmentBase::setPageSuccessorTemplate().

00418 {
00419     return testPageId(pageId,true,true);
00420 }

Segment::AllocationOrder RandomAllocationSegmentBase::getAllocationOrder ( ) const [virtual, inherited]

Returns:: the AllocationOrder for this segment

Reimplemented from DelegatingSegment.

Definition at line 372 of file RandomAllocationSegmentBase.cpp.

References Segment::RANDOM_ALLOCATION.

00373 {
00374     return RANDOM_ALLOCATION;
00375 }

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

Returns:: number of pages allocated from this segment

Reimplemented from DelegatingSegment.

Definition at line 422 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::nPagesAllocated.

Referenced by SnapshotSegmentTest::deallocateOldPages().

00423 {
00424     return nPagesAllocated;
00425 }

BlockNum RandomAllocationSegmentBase::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

Reimplemented from DelegatingSegment.

Definition at line 448 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::nPagesOccupiedHighWater.

00449 {
00450     return nPagesOccupiedHighWater;
00451 }

void RandomAllocationSegmentBase::deallocatePageRange	(	PageId	startPageId,
		PageId	endPageId
	)			`[virtual, inherited]`

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:

	startPageId	inclusive start of PageId range to deallocate, or default NULL_PAGE_ID for beginning of segment
	endPageId	inclusive end of PageId range to deallocate, or default NULL_PAGE_ID for end of segment

Reimplemented from DelegatingSegment.

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 326 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::deallocatePageId(), RandomAllocationSegmentBase::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, inherited]

Performs additional initialization required on the segment after it has been properly formatted.

Reimplemented from Segment.

Reimplemented in VersionedRandomAllocationSegment.

Definition at line 62 of file RandomAllocationSegmentBase.cpp.

References RandomAllocationSegmentBase::countAllocatedPages().

Referenced by VersionedRandomAllocationSegment::initForUse().

00063 {
00064     countAllocatedPages();
00065 }

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

Definition at line 53 of file DelegatingSegment.h.

Referenced by SegmentFactory::dynamicCast(), TracingSegment::getMappedPageListener(), TracingSegment::isWriteVersioned(), and TracingSegment::notifyAfterPageCheckpointFlush().

00054     {
00055         return pDelegateSegment;
00056     }

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

Returns:: the number of incremental pages added to this instance of the segment

Implements Segment.

Definition at line 57 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

00058 {
00059     return pDelegateSegment->getNumPagesExtended();
00060 }

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

Maps from a BlockId to a PageId in this segment.

Implements Segment.

Reimplemented in CircularSegment, LinearViewSegment, and TracingSegment.

Definition at line 77 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by VersionedSegment::canFlushPage(), SnapshotRandomAllocationSegment::getMappedPageListener(), WALSegment::notifyAfterPageFlush(), WALSegment::notifyPageDirty(), VersionedSegment::notifyPageDirty(), TracingSegment::translateBlockId(), LinearViewSegment::translateBlockId(), and CircularSegment::translateBlockId().

00078 {
00079     return pDelegateSegment->translateBlockId(blockId);
00080 }

bool DelegatingSegment::ensureAllocatedSize ( BlockNum nPages ) [virtual, inherited]

Allocates pages as needed to make getAllocatedSizeInPages() meet a lower bound.

The PageId's of the allocated pages are not returned, so this is mostly only meaningful for linear segments.

Parameters:

nPages

lower bound for getAllocatedSizeInPages()

Returns:: true if enough pages could be allocated; false if not

Reimplemented from Segment.

Reimplemented in TracingSegment.

Definition at line 87 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by RandomAllocationSegmentBase::allocatePageIdFromSegment(), TracingSegment::ensureAllocatedSize(), RandomAllocationSegmentBase::format(), and VersionedRandomAllocationSegment::restoreFromBackup().

00088 {
00089     return pDelegateSegment->ensureAllocatedSize(nPages);
00090 }

void DelegatingSegment::delegatedCheckpoint	(	Segment &	delegatingSegment,
		CheckpointType	checkpointType
	)			`[virtual, inherited]`

Helper for DelegatingSegment.

Parameters:

	delegatingSegment	the Segment on which checkpoint was originally called
	checkpointType	type of checkpoint requested

Reimplemented from Segment.

Reimplemented in SnapshotRandomAllocationSegment, TracingSegment, and VersionedSegment.

Definition at line 142 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by VersionedSegment::delegatedCheckpoint(), and TracingSegment::delegatedCheckpoint().

00144 {
00145     pDelegateSegment->delegatedCheckpoint(delegatingSegment,checkpointType);
00146 }

PageId DelegatingSegment::updatePage	(	PageId	pageId,
		bool	needsTranslation = `false`
	)			`[virtual, inherited]`

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

Parameters:

	pageId	pageId of the page being modified
	needsTranslation	true if the pageId needs to be mapped to the appropriate update page; defaults to false

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

Reimplemented in LinearViewSegment, and SnapshotRandomAllocationSegment.

Definition at line 148 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by LinearViewSegment::updatePage().

00149 {
00150     return pDelegateSegment->updatePage(pageId, needsTranslation);
00151 }

void DelegatingSegment::notifyPageMap ( CachePage & page ) [virtual, inherited]

Receives notification from CacheImpl as soon as a page is mapped, before any I/O is initiated to retrieve the page contents.

Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page being mapped

Reimplemented from MappedPageListener.

Reimplemented in TracingSegment.

Definition at line 107 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by TracingSegment::notifyPageMap().

00108 {
00109     pDelegateSegment->notifyPageMap(page);
00110 }

void DelegatingSegment::notifyPageUnmap ( CachePage & page ) [virtual, inherited]

Receives notification from CacheImpl just before a page is unmapped.

Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page being unmapped

Reimplemented from MappedPageListener.

Reimplemented in TracingSegment, and WALSegment.

Definition at line 112 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by TracingSegment::notifyPageUnmap().

00113 {
00114     pDelegateSegment->notifyPageUnmap(page);
00115 }

void DelegatingSegment::notifyAfterPageRead ( CachePage & page ) [virtual, inherited]

Receives notification from CacheImpl after a page read completes.

Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page read

Reimplemented from MappedPageListener.

Reimplemented in TracingSegment.

Definition at line 117 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by TracingSegment::notifyAfterPageRead().

00118 {
00119     pDelegateSegment->notifyAfterPageRead(page);
00120 }

void DelegatingSegment::notifyPageDirty	(	CachePage &	page,
		bool	bDataValid
	)			`[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:

	page	the page being modified
	bDataValid	if true, the page data was already valid; if false, the data was invalid, but has now been marked valid since it's about to be written

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

00123 {
00124     pDelegateSegment->notifyPageDirty(page,bDataValid);
00125 }

void DelegatingSegment::notifyBeforePageFlush ( CachePage & page ) [virtual, inherited]

Receives notification from CacheImpl just before a dirty page is flushed to disk.

Allows some logging action to be taken; for example, flushing corresponding write-ahead log pages, or storing a checksum in the page header. Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page to be flushed

Reimplemented from MappedPageListener.

Reimplemented in TracingSegment.

Definition at line 127 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by TracingSegment::notifyBeforePageFlush().

00128 {
00129     pDelegateSegment->notifyBeforePageFlush(page);
00130 }

void DelegatingSegment::notifyAfterPageFlush ( CachePage & page ) [virtual, inherited]

Receives notification from CacheImpl when a page flush completes successfully.

Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page that was flushed

Reimplemented from MappedPageListener.

Reimplemented in TracingSegment, and WALSegment.

Definition at line 132 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by WALSegment::notifyAfterPageFlush(), and TracingSegment::notifyAfterPageFlush().

00133 {
00134     pDelegateSegment->notifyAfterPageFlush(page);
00135 }

bool DelegatingSegment::canFlushPage ( CachePage & page ) [virtual, inherited]

Informs CacheImpl whether a dirty page can safely be flushed to disk.

Called with the page mutex held, so the implementation must take care to avoid deadlock.

Parameters:

page

the page to be flushed

Reimplemented from MappedPageListener.

Reimplemented in SnapshotRandomAllocationSegment, and VersionedSegment.

Definition at line 137 of file DelegatingSegment.cpp.

References DelegatingSegment::pDelegateSegment.

Referenced by VersionedSegment::canFlushPage().

00138 {
00139     return pDelegateSegment->canFlushPage(page);
00140 }

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

Definition at line 70 of file Segment.cpp.

References Segment::cbUsablePerPage.

Referenced by DelegatingSegment::DelegatingSegment(), DynamicDelegatingSegment::DynamicDelegatingSegment(), Segment::Segment(), and VersionedSegment::VersionedSegment().

00071 {
00072     cbUsablePerPage = cb;
00073 }

PConstBuffer Segment::getReadableFooter ( CachePage & page ) [protected, inherited]

Definition at line 75 of file Segment.cpp.

References CachePage::getReadableData(), and Segment::getUsablePageSize().

Referenced by VersionedSegment::getPageVersion(), and VersionedSegment::recover().

00076 {
00077     return page.getReadableData() + getUsablePageSize();
00078 }

PBuffer Segment::getWritableFooter ( CachePage & page ) [protected, inherited]

Definition at line 80 of file Segment.cpp.

References Segment::getUsablePageSize(), and CachePage::getWritableData().

Referenced by VersionedSegment::notifyPageDirty().

00081 {
00082     return page.getWritableData() + getUsablePageSize();
00083 }

PageId Segment::getLinearPageSuccessor ( PageId pageId ) [protected, inherited]

An implementation of getPageSuccessor suitable for LINEAR_ALLOCATION.

Definition at line 85 of file Segment.cpp.

References Segment::isPageIdAllocated(), and NULL_PAGE_ID.

Referenced by ScratchSegment::getPageSuccessor(), LinearViewSegment::getPageSuccessor(), LinearDeviceSegment::getPageSuccessor(), and CircularSegment::getPageSuccessor().

00086 {
00087     assert(isPageIdAllocated(pageId));
00088     ++pageId;
00089     if (!isPageIdAllocated(pageId)) {
00090         return NULL_PAGE_ID;
00091     }
00092     return pageId;
00093 }

void Segment::setLinearPageSuccessor	(	PageId	pageId,
		PageId	successorId
	)			`[protected, inherited]`

An implementation of setPageSuccessor suitable for LINEAR_ALLOCATION.

Definition at line 95 of file Segment.cpp.

References Segment::getLinearBlockNum(), and Segment::isPageIdAllocated().

Referenced by ScratchSegment::setPageSuccessor(), LinearViewSegment::setPageSuccessor(), LinearDeviceSegment::setPageSuccessor(), and CircularSegment::setPageSuccessor().

00096 {
00097     assert(isPageIdAllocated(pageId));
00098     assert(isPageIdAllocated(successorId));
00099     assert(getLinearBlockNum(successorId)
00100            == getLinearBlockNum(pageId) + 1);
00101 }

bool Segment::isLinearPageIdAllocated ( PageId pageId ) [protected, inherited]

An implementation of isPageIdAllocated suitable for LINEAR_ALLOCATION when deallocation holes are disallowed.

Definition at line 103 of file Segment.cpp.

References Segment::getAllocatedSizeInPages(), and Segment::getLinearBlockNum().

Referenced by ScratchSegment::isPageIdAllocated(), LinearViewSegment::isPageIdAllocated(), and LinearDeviceSegment::isPageIdAllocated().

00104 {
00105     if (getLinearBlockNum(pageId) >= getAllocatedSizeInPages()) {
00106         return false;
00107     }
00108     return true;
00109 }

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

Returns:: the Cache for this Segment

Definition at line 358 of file Segment.h.

References Segment::pCache.

Referenced by ScratchSegment::getCache(), and TempSegDestructor::operator()().

00359 {
00360     return pCache;
00361 }

uint Segment::getFullPageSize ( ) const [inherited]

Returns:: the full size of pages stored in this segment; this is the same as the size of underlying cache pages

Definition at line 133 of file Segment.cpp.

References Segment::pCache.

Referenced by LinearDeviceSegment::ensureAllocatedSize(), LinearDeviceSegment::getAvailableDevicePages(), LinearDeviceSegment::LinearDeviceSegment(), VersionedRandomAllocationSegment::locateDataPages(), VersionedSegment::recover(), Segment::Segment(), and SegPageLock::swapBuffers().

00134 {
00135     return pCache->getPageSize();
00136 }

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

Returns:: the full size of pages stored in this segment minus the size for any footer information stored at the end of each page

Definition at line 363 of file Segment.h.

References Segment::cbUsablePerPage.

Referenced by VersionedSegment::computeChecksum(), DynamicDelegatingSegment::DynamicDelegatingSegment(), Segment::getReadableFooter(), Segment::getWritableFooter(), VersionedSegment::notifyPageDirty(), RandomAllocationSegment(), RandomAllocationSegmentBase::RandomAllocationSegmentBase(), SegPageLock::swapBuffers(), VersionedRandomAllocationSegment::VersionedRandomAllocationSegment(), and VersionedSegment::VersionedSegment().

00364 {
00365     return cbUsablePerPage;
00366 }

SharedSegment Segment::getTracingSegment ( ) [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.

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

void Segment::setTracingSegment ( WeakSegment pTracingSegmentInit ) [inherited]

Sets the tracing segment associated with this segment.

Parameters:

pTracingSegmentInit

the tracing segment

Definition at line 60 of file Segment.cpp.

References Segment::pTracingSegment.

00061 {
00062     pTracingSegment = pTracingSegmentInit;
00063 }

void Segment::checkpoint ( CheckpointType checkpointType = CHECKPOINT_FLUSH_ALL ) [inherited]

Checkpoints this segment.

Parameters:

checkpointType

type of checkpoint to execute

Definition at line 111 of file Segment.cpp.

References Segment::delegatedCheckpoint(), and Segment::pTracingSegment.

Referenced by Segment::closeImpl(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), and LcsClusterReplaceExecStreamTest::testClusterReplace().

00112 {
00113     // Note that we can't use getTracingSegment() here because that method
00114     // references the shared ptr associated with this segment, and the
00115     // shared segment may have already been freed during shutdown by the
00116     // time this method is called.
00117     SharedSegment sharedPtr = pTracingSegment.lock();
00118     if (sharedPtr && sharedPtr.get()) {
00119         delegatedCheckpoint(*(sharedPtr.get()),checkpointType);
00120     } else {
00121         delegatedCheckpoint(*this,checkpointType);
00122     }
00123 }

MappedPageListener * Segment::getMappedPageListener ( BlockId blockId ) [virtual, inherited]

Returns the mapped page listener corresponding to a page.

Parameters:

blockId

blockId of the page whose page listener we are returning

Returns:: segment corresponding to mapped page listener

Reimplemented in DynamicDelegatingSegment, SnapshotRandomAllocationSegment, and TracingSegment.

Definition at line 153 of file Segment.cpp.

00154 {
00155     return this;
00156 }

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

Returns:: true if the segment supports versioning

Reimplemented in DynamicDelegatingSegment, SnapshotRandomAllocationSegment, and TracingSegment.

Definition at line 158 of file Segment.cpp.

00159 {
00160     return false;
00161 }

PageId Segment::getLinearPageId ( BlockNum iPage ) [inline, static, inherited]

Constructs a linear PageId based on a linear page number.

Definition at line 348 of file Segment.h.

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

00349 {
00350     return PageId(iPage);
00351 }

BlockNum Segment::getLinearBlockNum ( PageId pageId ) [inline, static, inherited]

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

00354 {
00355     return opaqueToInt(pageId);
00356 }

MappedPageListener * Segment::getTracingListener ( ) [virtual, inherited]

Retrieves the tracing wrapper corresponding to this listener if tracing is turned on.

Otherwise, returns this listener itself.

Returns:: tracing segment corresponding to a listener

Implements MappedPageListener.

Definition at line 65 of file Segment.cpp.

References Segment::getTracingSegment().

00066 {
00067     return getTracingSegment().get();
00068 }

MappedPageListener * MappedPageListener::notifyAfterPageCheckpointFlush ( CachePage & page ) [virtual, inherited]

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:

page

the page that was flushed

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.

00059     {
00060         return !needsClose;
00061     }

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

00040 {
00041     if (!needsClose) {
00042         return;
00043     }
00044     needsClose = false;
00045     closeImpl();
00046 }

Friends And Related Function Documentation

friend class SegmentFactory [friend, inherited]

Definition at line 140 of file RandomAllocationSegmentBase.h.

Member Data Documentation

BlockNum RandomAllocationSegmentBase::nPagesPerExtent [protected, inherited]

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.

BlockNum RandomAllocationSegmentBase::nPagesPerSegAlloc [protected, inherited]

Number of pages mapped by one SegmentAllocationNode, including the SegmentAllocationNode itself.

This is immutable.

Definition at line 153 of file RandomAllocationSegmentBase.h.

Referenced by RandomAllocationSegmentBase::getSegAllocPageId(), RandomAllocationSegmentBase::inferSegAllocCount(), RandomAllocationSegment(), RandomAllocationSegmentBase::splitPageId(), and VersionedRandomAllocationSegment::VersionedRandomAllocationSegment().

ExtentNum RandomAllocationSegmentBase::nExtentsPerSegAlloc [protected, inherited]

Number of extents mapped by a full SegmentAllocationNode.

This is immutable.

Definition at line 159 of file RandomAllocationSegmentBase.h.

SharedCache Segment::pCache [protected, inherited]

Cache managing pages of this segment.

Definition at line 62 of file Segment.h.

WeakSegment Segment::pTracingSegment [protected, inherited]

The tracing segment associated with this segment, if tracing is turned on.

A weak_ptr is used due to the circular shared pointers between this segment and its tracing segment.

Definition at line 69 of file Segment.h.

Referenced by Segment::checkpoint(), Segment::getTracingSegment(), and Segment::setTracingSegment().

bool ClosableObject::needsClose [protected, inherited]

Definition at line 44 of file ClosableObject.h.

Referenced by SegStreamAllocation::beginWrite(), ExecStreamGraphImpl::clear(), ClosableObject::ClosableObject(), ClosableObject::close(), FlatFileBuffer::open(), ExecStreamGraphImpl::open(), ExecStream::open(), and ClosableObject::~ClosableObject().

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

/home/pub/open/dev/fennel/segment/RandomAllocationSegment.h
/home/pub/open/dev/fennel/segment/RandomAllocationSegment.cpp

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

1.5.1

RandomAllocationSegment Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation