VersionedRandomAllocationSegment.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/segment/VersionedRandomAllocationSegment.h#14 $
// 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_VersionedRandomAllocationSegment_Included
#define Fennel_VersionedRandomAllocationSegment_Included

#include "fennel/synch/SXMutex.h"
#include "fennel/segment/RandomAllocationSegmentBase.h"
#include "fennel/segment/SegPageBackupRestoreDevice.h"

#include <hash_set>
#include <hash_map>
#include <boost/shared_ptr.hpp>

FENNEL_BEGIN_NAMESPACE

struct VersionedExtentAllocationNode;
struct ModifiedAllocationNode;

typedef boost::shared_ptr<ModifiedAllocationNode> SharedModifiedAllocationNode;

struct FENNEL_SEGMENT_EXPORT VersionedPageEntry
    : PageEntry
{
    TxnId allocationCsn;

    PageId versionChainPageId;
};

struct FENNEL_SEGMENT_EXPORT ModifiedPageEntry
{
    enum ModType {
        ALLOCATED,
        DEALLOCATED,
        MODIFIED
    };

    uint updateCount;

    uint allocationCount;

    ModType lastModType;

    PageOwnerId ownerId;
};

typedef boost::shared_ptr<ModifiedPageEntry> SharedModifiedPageEntry;

// Use a shared pointer because the structure is dynamically allocated.
typedef std::hash_map<PageId, SharedModifiedPageEntry> ModifiedPageEntryMap;
typedef ModifiedPageEntryMap::const_iterator ModifiedPageEntryMapIter;

static const PageOwnerId UNCOMMITTED_PAGE_OWNER_ID = PageOwnerId(1);

static const uint64_t DEALLOCATED_PAGE_OWNER_ID_MASK = 0x8000000000000000LL;

class FENNEL_SEGMENT_EXPORT VersionedRandomAllocationSegment
    : public RandomAllocationSegmentBase
{
    typedef std::hash_map<PageId, SharedModifiedAllocationNode>
        ModifiedAllocationNodeMap;

    typedef ModifiedAllocationNodeMap::const_iterator NodeMapConstIter;

    ModifiedAllocationNodeMap allocationNodeMap;

    SXMutex mapMutex;

    SXMutex deallocationMutex;

    SharedSegment pTempSegment;

    template <class AllocationLockT>
    PageId getTempAllocNodePage(PageId origNodePageId, bool isSegAllocNode);

    PageId findAllocPageIdForRead(
        PageId origAllocNodePageId,
        SharedSegment &allocNodeSegment);

    void deferDeallocation(PageId pageId);

    void updateExtentEntry(
        uint iSegAlloc,
        ExtentNum extentNum,
        uint allocationCount,
        bool commit);

    void allocateAllocNodes(
        uint iSegAlloc,
        PageId nextPageId,
        ExtentNum extentNum);

    void allocateExtAllocNodes(
        SegmentAllocationNode &segAllocNode,
        uint iSegAlloc,
        ExtentNum extentNum);

    void updatePageEntry(
        PageId pageId,
        ExtentNum extentNum,
        uint iPageInExtent,
        SharedModifiedPageEntry pModEntry,
        TxnId commitCsn,
        bool commit,
        SharedSegment pOrigSegment);

    void copyPageEntryFromTemp(
        PageId pageId,
        PageId origPageId,
        PageId tempPageId,
        BlockNum iPageInExtent,
        ModifiedPageEntry::ModType lastModType,
        TxnId commitCsn,
        PageOwnerId ownerId);

    void copyPageEntryToTemp(
        PageId origPageId,
        PageId tempPageId,
        BlockNum iPageInExtent);

    bool validateFreePageCount(PageId pageId);

    void freeTempPage(PageId origAllocNodePageId, PageId tempAllocNodePageId);

    TxnId getOldestTxnId(
        PageId pageId,
        TxnId oldestActiveTxnId,
        PageId &anchorPageId,
        std::hash_set<PageId> &deallocatedPageSet,
        bool &deallocateChain);

    void deallocateEntirePageChain(
        PageId pageId,
        TxnId oldestActiveTxnId,
        std::hash_set<PageId> &deallocatedPageSet);

    void deallocateSinglePage(
        PageId pageId,
        std::hash_set<PageId> &deallocatedPageSet);

    void deallocatePageChain(
        PageId anchorPageId,
        TxnId deallocationCsn,
        std::hash_set<PageId> &deallocatedPageSet);

    bool validatePageChain(PageId anchorPageId);

    bool uncommittedDeallocation(
        PageId anchorPageId,
        std::hash_set<PageId> &deallocatedPageSet);

    void skipDeferredDeallocations(
        PageId pageId,
        std::hash_set<PageId> &deallocatedPageSet);

    void updateTempPageEntry(
        PageId pageId,
        VersionedPageEntry const &pageEntry);

    void getCommittedPageEntryCopy(
        PageId pageId,
        VersionedPageEntry &pageEntryCopy);

    bool isPageIdAllocateCommitted(PageId pageId);

    void chainPageEntries(
        PageId pageId,
        PageId versionChainId,
        PageId successorId,
        bool thisSegment);

    /*
     * Locates data pages relevant to a backup or restore based on the
     * csn boundaries passed in, and then either backs up or restores the
     * pages identified.
     *
     * @param pBackupDevice device that carries out I/O for the backup or
     * restore
     * @param lowerBoundCsn the lower bound allocation csn
     * @param upperBoundCsn the upper bound allocation csn
     * @param isBackup if true, relevant pages are backed up; otherwise,
     * they are restored
     * @param [in] abortFlag reference to a flag indicating whether the backup
     * or restore should be aborted
     */
    void locateDataPages(
        SharedSegPageBackupRestoreDevice pBackupDevice,
        TxnId lowerBoundCsn,
        TxnId upperBoundCsn,
        bool isBackup,
        bool volatile const &abortFlag);

    void checkAbort(bool volatile const &abortFlag);

    inline PageOwnerId makeDeallocatedPageOwnerId(TxnId txnId);

    inline bool isDeallocatedPageOwnerId(PageOwnerId pageOwnerId);

    inline TxnId getDeallocatedTxnId(PageOwnerId pageOwnerId);

    // implement RandomAllocationSegmentBase
    virtual bool isPageIdValid(PageId pageId);
    virtual PageId getSegAllocPageIdForWrite(PageId origSegAllocPageId);
    virtual void undoSegAllocPageWrite(PageId segAllocPageId);
    virtual PageId getExtAllocPageIdForWrite(ExtentNum extentNum);
    virtual PageId allocateFromExtent(ExtentNum extentNum, PageOwnerId ownerId);
    virtual void formatPageExtents(
        SegmentAllocationNode &segAllocNode,
        ExtentNum &extentNum);
    virtual PageId allocateFromNewExtent(
        ExtentNum extentNum,
        PageOwnerId ownerId);
    virtual void freePageEntry(ExtentNum extentNum, BlockNum iPageInExtent);
    virtual void markPageEntryUnused(PageEntry &pageEntry);
    virtual PageOwnerId getPageOwnerId(PageId pageId, bool thisSegment);
    virtual PageId getSegAllocPageIdForRead(
        PageId origSegAllocPageId,
        SharedSegment &allocNodeSegment);
    virtual PageId getExtAllocPageIdForRead(
        ExtentNum extentNum,
        SharedSegment &allocNodeSegment);
    virtual void getPageEntryCopy(
        PageId pageId,
        PageEntry &pageEntryCopy,
        bool isAllocated,
        bool thisSegment);

public:
    explicit VersionedRandomAllocationSegment(
        SharedSegment delegateSegment,
        SharedSegment pTempSegmentInit);

    void getLatestPageEntryCopy(
        PageId pageId,
        VersionedPageEntry &pageEntryCopy);

    void initPageEntry(
        PageId pageId,
        PageId versionChainId,
        TxnId allocationCsn);

    void chainPageEntries(
        PageId pageId,
        PageId versionChainId,
        PageId successorId);

    void updateAllocNodes(
        ModifiedPageEntryMap const &modifiedPageEntryMap,
        TxnId commitCsn,
        bool commit,
        SharedSegment pOrigSegment);

    SXMutex &getDeallocationMutex();

    bool getOldPageIds(
        uint &iSegAlloc,
        ExtentNum &extentNum,
        TxnId oldestActiveTxnId,
        uint numPages,
        PageSet &oldPageSet);

    void deallocateOldPages(PageSet const &oldPageSet, TxnId oldestActiveTxnId);

    void freeTempPages();

    BlockNum backupAllocationNodes(
        SharedSegPageBackupRestoreDevice pBackupDevice,
        bool countDataPages,
        TxnId lowerBoundCsn,
        TxnId upperBoundCsn,
        bool volatile const &abortFlag);

    void backupDataPages(
        SharedSegPageBackupRestoreDevice pBackupDevice,
        TxnId lowerBoundCsn,
        TxnId upperBoundCsn,
        bool volatile const &abortFlag);

    void restoreFromBackup(
        SharedSegPageBackupRestoreDevice pBackupDevice,
        TxnId lowerBoundCsn,
        TxnId upperBoundCsn,
        bool volatile const &abortFlag);

    // implementation of Segment interface
    virtual bool isPageIdAllocated(PageId pageId);
    virtual PageId allocatePageId(PageOwnerId ownerId);
    virtual PageId getPageSuccessor(PageId pageId);
    virtual void setPageSuccessor(PageId pageId, PageId successorId);
    virtual void deallocatePageRange(PageId startPageId, PageId endPageId);
    virtual void initForUse();
};

FENNEL_END_NAMESPACE

#endif

// End VersionedRandomAllocationSegment.h

---