CachePage.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/cache/CachePage.h#16 $
// 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_CachePage_Included
#define Fennel_CachePage_Included

#include "fennel/synch/SynchObj.h"
#include "fennel/synch/SXMutex.h"
#include "fennel/device/RandomAccessRequest.h"
#include "fennel/cache/Cache.h"
#include "fennel/cache/CacheAllocator.h"
#include "fennel/common/SysCallExcn.h"

FENNEL_BEGIN_NAMESPACE

class Cache;
class MappedPageListener;

template <class PageT,class VictimPolicyT>
class CacheImpl;

class FENNEL_CACHE_EXPORT PageBucketListNode
    : public IntrusiveListNode
{
};

class FENNEL_CACHE_EXPORT CachePage
    : public PageBucketListNode, private RandomAccessRequestBinding
{
public:
    enum DataStatus {
        DATA_INVALID,

        DATA_ERROR,

        DATA_CLEAN,

        DATA_DIRTY,

        DATA_WRITE,

        DATA_READ
    };

private:
    template <class PageT,class VictimPolicyT>
    friend class CacheImpl;

// ----------------------------------------------------------------------
// State variables
// ----------------------------------------------------------------------
    Cache &cache;

    StrictMutex mutex;

    SXMutex lock;

    PBuffer pBuffer;

    // NOTE: the data members below should only be accessed while the
    // page mutex is held.  This includes indirect access via accessors such as
    // getBlockId().

    BlockId blockId;

    uint nReferences;

    LocalCondition ioCompletionCondition;

    MappedPageListener *pMappedPageListener;

    DataStatus dataStatus;

// ----------------------------------------------------------------------
// Methods internal to CacheImpl
// ----------------------------------------------------------------------
    bool hasBlockId() const
    {
        return blockId != NULL_BLOCK_ID;
    }

    void waitForPendingIO(StrictMutexGuard &guard)
    {
        ioCompletionCondition.wait(guard);
    }

    bool isExclusiveLockHeld() const
    {
        // REVIEW:  should make sure lock is held by this thread?
        return isScratchLocked() || lock.isLocked(LOCKMODE_X);
    }

// ----------------------------------------------------------------------
// Implementation of RandomAccessRequestBinding interface (q.v.)
// ----------------------------------------------------------------------
    virtual void notifyTransferCompletion(bool bSuccess);
    virtual PBuffer getBuffer() const;
    virtual uint getBufferSize() const;

public:
    explicit CachePage(Cache &,PBuffer);
    virtual ~CachePage();

    Cache &getCache()
    {
        return cache;
    }

    bool isDirty() const
    {
        return dataStatus == DATA_DIRTY;
    }

    bool isTransferInProgress() const
    {
        return (dataStatus >= DATA_WRITE);
    }

    bool isDataValid() const
    {
        return (dataStatus >= DATA_CLEAN) && (dataStatus <= DATA_WRITE);
    }

    bool isDataError() const
    {
        return (dataStatus == DATA_ERROR);
    }

    BlockId getBlockId() const
    {
        return blockId;
    }

    PConstBuffer getReadableData() const
    {
        assert(isDataValid());
        assert(lock.isLocked(LOCKMODE_S) || isExclusiveLockHeld());
        return pBuffer;
    }

    PBuffer getWritableData()
    {
        assert(isExclusiveLockHeld());
        assert(!isDataError());
        assert(!isTransferInProgress());
        // REVIEW:  is thread-safety ever an issue here?  If so, it's also an
        // issue for the previous assertions.
        if (!isDirty()) {
            getCache().markPageDirty(*this);
        }
        return pBuffer;
    }

    bool isScratchLocked() const;

    MappedPageListener *getMappedPageListener() const
    {
        assert(hasBlockId());
        return pMappedPageListener;
    }

    bool tryUpgrade(TxnId txnId)
    {
        StrictMutexGuard pageGuard(mutex);
        if (isTransferInProgress()) {
            return false;
        }
#ifdef DEBUG
        int errorCode;
        if (getCache().getAllocator().setProtection(
                pBuffer, getCache().getPageSize(), false, &errorCode))
        {
            throw SysCallExcn("memory protection failed", errorCode);
        }
#endif
        return lock.tryUpgrade(txnId);
    }

    void upgrade(TxnId txnId)
    {
        StrictMutexGuard pageGuard(mutex);
        while (isTransferInProgress()) {
            waitForPendingIO(pageGuard);
        }
#ifdef DEBUG
        int errorCode;
        if (getCache().getAllocator().setProtection(
                pBuffer, getCache().getPageSize(), false, &errorCode))
        {
            throw SysCallExcn("memory protection failed", errorCode);
        }
#endif
        bool rc = lock.tryUpgrade(txnId);
        assert(rc);
    }

    void swapBuffers(CachePage &other);
};

FENNEL_END_NAMESPACE

#endif

// End CachePage.h

---