RandomAllocationSegmentBase.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/segment/RandomAllocationSegmentBase.h#11 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 1999-2009 John V. Sichi
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_RandomAllocationSegmentBase_Included
#define Fennel_RandomAllocationSegmentBase_Included

#include "fennel/synch/SynchObj.h"
#include "fennel/segment/DelegatingSegment.h"

FENNEL_BEGIN_NAMESPACE

struct SegmentAllocationNode;

struct FENNEL_SEGMENT_EXPORT PageEntry
{
    PageOwnerId ownerId;

    PageId successorId;
};

class FENNEL_SEGMENT_EXPORT RandomAllocationSegmentBase
    : public DelegatingSegment
{
    BlockNum nPagesOccupiedHighWater;

    BlockNum nPagesAllocated;

    BlockNum netDeallocations;

    StrictMutex pageCounterMutex;

    void incrementPageCounters();

    void incrementPagesOccupiedCounter();

    void decrementPageCounters();

    void countAllocatedPages();

    void tallySegAllocNodePages(
        PageId segAllocPageId,
        SharedSegment allocNodeSegment,
        PageId &nextSegAllocPageId);

    void deallocatePageId(PageId pageId);

protected:
    friend class SegmentFactory;

    BlockNum nPagesPerExtent;

    BlockNum nPagesPerSegAlloc;

    ExtentNum nExtentsPerSegAlloc;

    explicit RandomAllocationSegmentBase(
        SharedSegment delegateSegment);

    inline PageId getSegAllocPageId(uint iSegPage) const;

    virtual PageId getSegAllocPageIdForWrite(PageId origSegAllocPageId) = 0;

    virtual void undoSegAllocPageWrite(PageId segAllocPageId) = 0;

    inline PageId getExtentAllocPageId(ExtentNum extentNum) const;

    virtual PageId getExtAllocPageIdForWrite(ExtentNum extentNum) = 0;

    inline BlockNum makePageNum(
        ExtentNum extentNum,BlockNum iPageInExtent) const;

    void splitPageId(
        PageId pageId,uint &iSegAlloc,
        ExtentNum &extentNum,BlockNum &iPageInExtent) const;

    virtual bool isPageIdValid(PageId pageId);

    bool testPageId(PageId pageId,bool testAllocation,bool thisSegment);

    virtual PageOwnerId getPageOwnerId(PageId pageId, bool thisSegment) = 0;

    template <class PageEntryT>
    PageOwnerId getPageOwnerIdTemplate(PageId pageId, bool thisSegment);

    virtual void freePageEntry(
        ExtentNum extentNum,
        BlockNum iPageInExtent) = 0;

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    void freePageEntryTemplate(ExtentNum extentNum, BlockNum iPageInExtent);

    virtual void markPageEntryUnused(PageEntry &pageEntry);

    inline PageId getFirstSegAllocPageId() const;

    uint inferSegAllocCount();

    void format();

    virtual void formatPageExtents(
        SegmentAllocationNode &segAllocNode,
        ExtentNum &extentNum) = 0;

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    void formatPageExtentsTemplate(
        SegmentAllocationNode &segAllocNode,
        ExtentNum &extentNum);

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    void formatExtentTemplate(ExtentAllocationNodeT &extentNode);

    PageId allocatePageIdFromSegment(
        PageOwnerId ownerId,
        SharedSegment allocNodeSegment);

    virtual PageId allocateFromExtent(
        ExtentNum extentNum,
        PageOwnerId ownerId) = 0;

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    PageId allocateFromExtentTemplate(
        ExtentNum extentNum,
        PageOwnerId ownerId,
        SharedSegment allocNodeSegment);

    virtual PageId allocateFromNewExtent(
        ExtentNum extentNum,
        PageOwnerId ownerId) = 0;

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    PageId allocateFromNewExtentTemplate(
        ExtentNum extentNum,
        PageOwnerId ownerId,
        SharedSegment allocNodeSegment);

    template <class ExtentAllocationNodeT, class PageEntryT>
    PageId allocateFromLockedExtentTemplate(
         ExtentAllocationNodeT &extentNode,
         ExtentNum extentNum,
         PageOwnerId ownerId);

    template <class ExtentAllocationNodeT, class ExtentAllocLockT>
    void setPageSuccessorTemplate(
        PageId pageId,
        PageId successorId,
        SharedSegment allocNodeSegment);

    virtual PageId getSegAllocPageIdForRead(
        PageId origSegAllocPageId,
        SharedSegment &allocNodeSegment) = 0;

    virtual PageId getExtAllocPageIdForRead(
        ExtentNum extentNum,
        SharedSegment &allocNodeSegment) = 0;

    virtual void getPageEntryCopy(
        PageId pageId,
        PageEntry &pageEntryCopy,
        bool isAllocated,
        bool thisSegment) = 0;

    template <
        class ExtentAllocationNodeT,
        class ExtentAllocLockT,
        class PageEntryT>
    void getPageEntryCopyTemplate(
         PageId pageId,
         PageEntryT &pageEntryCopy,
         bool isAllocated,
         bool thisSegment);

public:
    virtual ~RandomAllocationSegmentBase();

    // implementation of Segment interface
    virtual BlockId translatePageId(PageId);
    virtual bool isPageIdAllocated(PageId pageId);
    virtual AllocationOrder getAllocationOrder() const;
    virtual BlockNum getAllocatedSizeInPages();
    virtual BlockNum getNumPagesOccupiedHighWater();
    virtual void deallocatePageRange(PageId startPageId, PageId endPageId);
    virtual void initForUse();
};

FENNEL_END_NAMESPACE

#endif

// End RandomAllocationSegmentBase.h

---