CacheImpl.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/cache/CacheImpl.h#20 $
// 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_CacheImpl_Included
#define Fennel_CacheImpl_Included

#include "fennel/cache/Cache.h"
#include "fennel/cache/CacheStats.h"
#include "fennel/common/IntrusiveList.h"
#include "fennel/common/AtomicCounter.h"
#include "fennel/synch/SXMutex.h"
#include "fennel/synch/TimerThread.h"
#include "fennel/cache/CacheAllocator.h"
#include "fennel/device/DeviceAccessScheduler.h"
#include "fennel/cache/CachePage.h"
#include "fennel/cache/PageBucket.h"
#include "fennel/cache/MappedPageListener.h"
#include "fennel/cache/PagePredicate.h"
#include "fennel/common/FileStatsTarget.h"

#include <vector>
#include <algorithm>
#include <boost/scoped_ptr.hpp>

FENNEL_BEGIN_NAMESPACE

template <class PageT,class VictimPolicyT>
class CacheImpl : public Cache, private TimerThreadClient
{
    // convenience typedef
    typedef PageBucket<PageT> PageBucketT;
    typedef typename PageBucketT::PageListIter PageBucketIter;
    typedef typename PageBucketT::PageListMutator PageBucketMutator;

    std::vector<SharedRandomAccessDevice> deviceTable;

    PageBucketT unmappedBucket;

    PageBucketT unallocatedBucket;

    std::vector<PageBucketT *> pageTable;

    uint dirtyHighWaterPercent;

    uint dirtyLowWaterPercent;

    uint dirtyHighWaterMark;

    uint dirtyLowWaterMark;

    bool inFlushMode;

    AtomicCounter nCacheHits;

    AtomicCounter nCacheRequests;

    AtomicCounter nVictimizations;

    AtomicCounter nDirtyPages;

    AtomicCounter nPageReads;

    AtomicCounter nPageWrites;

    AtomicCounter nRejectedCachePrefetches;

    AtomicCounter nIoRetries;

    AtomicCounter nSuccessfulCachePrefetches;

    AtomicCounter nLazyWrites;

    AtomicCounter nLazyWriteCalls;

    AtomicCounter nVictimizationWrites;

    AtomicCounter nCheckpointWrites;

    CacheStats statsSinceInit;

    StrictMutex freePageMutex;

    LocalCondition freePageCondition;

    std::vector<PageT *> pages;

    DeviceAccessScheduler *pDeviceAccessScheduler;

    CacheAllocator &bufferAllocator;

    boost::scoped_ptr<CacheAllocator> pBufferAllocator;

    VictimPolicyT victimPolicy;

    TimerThread timerThread;

    uint idleFlushInterval;

    uint prefetchPagesMax;

    uint prefetchThrottleRate;

    enum FlushPhase {
        phaseSkip, phaseInitiate, phaseWait
    };

    // A class used as VictimPolicyT is required to define nested types
    // PageIterator and SharedGuard via which CacheImpl can safely iterate
    // over victim candidates.  Within CacheImpl code, these are referred to
    // via private typedefs for brevity.
    typedef typename VictimPolicyT::PageIterator VictimPageIterator;
    typedef typename VictimPolicyT::DirtyPageIterator DirtyVictimPageIterator;
    typedef typename VictimPolicyT::SharedGuard VictimSharedGuard;
    typedef typename VictimPolicyT::ExclusiveGuard VictimExclusiveGuard;

// ----------------------------------------------------------------------
// CacheImpl internal helper methods
// ----------------------------------------------------------------------

    PageT *lookupPage(PageBucketT &bucket,BlockId blockId,bool pin);

    PageT *findFreePage();

    void flushSomePages();

    bool transferPageAsync(PageT &page);

    bool readPageAsync(PageT &page);

    bool writePageAsync(PageT &page);

    FileSize getPageOffset(BlockId const &blockId);

    PageBucketT &getHashBucket(BlockId const &blockId);

    void assertCorrectBucket(PageBucketT &bucket,BlockId const &blockId);

    void unmapPage(PageT &page,StrictMutexGuard &guard,bool discard);

    void unmapAndFreeDiscardedPage(
        PageT &page,
        StrictMutexGuard &guard);

    PageT &mapPage(
        PageBucketT &bucket,PageT &newPage,BlockId blockId,
        MappedPageListener *pMappedPageListener,
        bool bPendingRead = true,bool bIncRef = true);

    void freePage(PageT &page);

    bool canVictimizePage(PageT &page);

    void incrementCounter(AtomicCounter &x);

    void decrementCounter(AtomicCounter &x);

    void incrementStatsCounter(AtomicCounter &x);

    void decrementStatsCounter(AtomicCounter &x);

    void initializeStats();

    void allocatePages(CacheParams const &params);

    void successfulPrefetch();

    void rejectedPrefetch();

    void ioRetry();

    void calcDirtyThreshholds(uint nCachePages);

// ----------------------------------------------------------------------
// Implementation of private Cache interface (q.v.)
// ----------------------------------------------------------------------

    void markPageDirty(CachePage &page);
    void notifyTransferCompletion(CachePage &,bool);

// ----------------------------------------------------------------------
// Implementation of TimerThreadClient interface (q.v.)
// ----------------------------------------------------------------------

    virtual uint getTimerIntervalMillis();
    virtual void onTimerInterval();

protected:
    void closeImpl();

public:
// ----------------------------------------------------------------------
// Implementation of public Cache interface (q.v.)
// ----------------------------------------------------------------------
    CacheImpl(
        CacheParams const &,
        CacheAllocator * = NULL);
    virtual void setAllocatedPageCount(uint nMemPages);
    virtual uint getAllocatedPageCount();
    virtual uint getMaxAllocatedPageCount();
    virtual PageT *lockPage(
        BlockId blockId,LockMode lockMode,bool readIfUnmapped,
        MappedPageListener *pMappedPageListener,TxnId txnId);
    virtual PageT &lockScratchPage(BlockNum blockNum);
    virtual void discardPage(BlockId blockId);
    virtual uint checkpointPages(
        PagePredicate &pagePredicate,CheckpointType checkpointType);
    virtual void collectStats(CacheStats &stats);
    virtual void registerDevice(
        DeviceId deviceId,SharedRandomAccessDevice pDevice);
    virtual void unregisterDevice(DeviceId deviceId);
    virtual SharedRandomAccessDevice &getDevice(DeviceId deviceId);
    virtual bool prefetchPage(
        BlockId blockId,MappedPageListener *pMappedPageListener);
    virtual void prefetchBatch(
        BlockId blockId,uint nPages,MappedPageListener *pMappedPageListener);
    virtual void flushPage(CachePage &page,bool async);
    virtual void unlockPage(CachePage &page,LockMode lockMode,TxnId txnId);
    virtual void nicePage(CachePage &page);
    virtual bool isPageMapped(BlockId blockId);
    virtual CacheAllocator &getAllocator() const;
    virtual void getPrefetchParams(
        uint &prefetchPagesMax,
        uint &prefetchThrottleRate);
    virtual DeviceAccessScheduler &getDeviceAccessScheduler(
        RandomAccessDevice &)
    {
        return *pDeviceAccessScheduler;
    }

};

FENNEL_END_NAMESPACE

#include "fennel/cache/CacheMethodsImpl.h"

#endif

// End CacheImpl.h

---