SnapshotRandomAllocationSegment.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/segment/SnapshotRandomAllocationSegment.h#13 $
// 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_SnapshotRandomAllocationSegment_Included
#define Fennel_SnapshotRandomAllocationSegment_Included

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

#include <boost/shared_ptr.hpp>

FENNEL_BEGIN_NAMESPACE

class FENNEL_SEGMENT_EXPORT SnapshotRandomAllocationSegment
    : public DelegatingSegment
{
    ModifiedPageEntryMap modPageEntriesMap;

    PageMap snapshotPageMap;

    // NOTE jvs 23-Oct-2007: Both of these mutexes could become hotspots for
    // read-only access in a parallel query executor.  May need a C++
    // equivalent for ConcurrentHashMap.  Note that even SXMutex requires
    // briefly taking a StrictMutex under the covers.  Alternatively,
    // we could keep this class unchanged and then arrange for each
    // thread to get its own instance (maintaining its own private cache).

    SXMutex modPageMapMutex;

    StrictMutex snapshotPageMapMutex;

    VersionedRandomAllocationSegment *pVersionedRandomSegment;

    TxnId snapshotCsn;

    bool readOnlyCommittedData;

    bool needPageFlush;

    bool forceCacheUnmap;

    PageId getSnapshotId(PageId pageId);

    void incrPageUpdateCount(
        PageId pageId,
        PageOwnerId ownerId,
        ModifiedPageEntry::ModType modType);

    PageId getAnchorPageId(PageId snapshotId);

    bool isPageNewlyAllocated(PageId pageId);

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

public:
    explicit SnapshotRandomAllocationSegment(
        SharedSegment delegateSegment,
        SharedSegment versionedSegment,
        TxnId snapshotCsnInit,
        bool readOnlyCommittedData);

    TxnId getSnapshotCsn();

    void commitChanges(TxnId commitCsn);

    void rollbackChanges();

    void versionPage(PageId destAnchorPageId, PageId srcAnchorPageId);

    void setForceCacheUnmap();

    // implementation of Segment interface
    virtual BlockId translatePageId(PageId pageId);
    virtual PageId getPageSuccessor(PageId pageId);
    virtual void setPageSuccessor(PageId pageId, PageId successorId);
    virtual PageId allocatePageId(PageOwnerId ownerId);
    virtual void deallocatePageRange(PageId startPageId, PageId endPageId);
    virtual PageId updatePage(PageId pageId, bool needsTranslation = false);
    virtual MappedPageListener *getMappedPageListener(BlockId blockId);
    virtual void delegatedCheckpoint(
        Segment &delegatingSegment,
        CheckpointType checkpointType);
    virtual MappedPageListener *notifyAfterPageCheckpointFlush(CachePage &page);
    virtual bool canFlushPage(CachePage &page);
    virtual void notifyPageDirty(CachePage &page, bool bDataValid);
    virtual bool isWriteVersioned();
};

FENNEL_END_NAMESPACE

#endif

// End SnapshotRandomAllocationSegment.h

---