LRUVictimPolicy.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/cache/LRUVictimPolicy.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_LRUVictimPolicy_Included
#define Fennel_LRUVictimPolicy_Included

#include "fennel/common/IntrusiveDList.h"

FENNEL_BEGIN_NAMESPACE

class FENNEL_CACHE_EXPORT LRUVictim
    : public IntrusiveDListNode
{
    // no data; base IntrusiveDListNode is used to order LRUVictims in an
    // intrusive doubly-linked list.
};

template <class PageT>
class LRUVictimPolicy
{
    SXMutex mutex;

    PageT *pageLRU;

    PageT *pageMRU;

public:

    typedef IntrusiveDListIter<PageT> PageIterator;

    typedef IntrusiveDListIter<PageT> DirtyPageIterator;

    typedef SXMutexSharedGuard SharedGuard;

    typedef SXMutexExclusiveGuard ExclusiveGuard;

    LRUVictimPolicy()
    {
        pageLRU = NULL;
        pageMRU = NULL;
    }

    LRUVictimPolicy(const CacheParams &params)
    {
        pageLRU = NULL;
        pageMRU = NULL;
    }

    void setAllocatedPageCount(uint nCachePages)
    {
    }

    void registerPage(PageT &page)
    {
        // TODO:  use a DList container to avoid this edge case
        ExclusiveGuard exclusiveGuard(mutex);
        if (!pageLRU) {
            pageLRU = &page;
        } else {
            page.IntrusiveDListNode::insertAfter(*pageMRU);
        }
        pageMRU = &page;
    }

    void unregisterPage(PageT &page)
    {
        ExclusiveGuard exclusiveGuard(mutex);
        if (&page == pageLRU) {
            pageLRU = (PageT *) (page.getNext());
        }
        if (&page == pageMRU) {
            pageMRU = (PageT *) (page.getPrev());
        }
        page.IntrusiveDListNode::detach();
    }

    void notifyPageAccess(PageT &page, bool pin)
    {
        ExclusiveGuard exclusiveGuard(mutex);
        if (&page == pageMRU) {
            return;
        }
        if (&page == pageLRU) {
            pageLRU = (PageT *) (page.getNext());
        }
        page.IntrusiveDListNode::detach();
        page.IntrusiveDListNode::insertAfter(*pageMRU);
        pageMRU = &page;
    }

    void notifyPageNice(PageT &page)
    {
        ExclusiveGuard exclusiveGuard(mutex);
        if (&page == pageLRU) {
            return;
        }
        if (&page == pageMRU) {
            pageMRU = (PageT *) (page.getPrev());
        }
        page.IntrusiveDListNode::detach();
        page.IntrusiveDListNode::insertBefore(*pageLRU);
        pageLRU = &page;
    }

    void notifyPageMap(PageT &page, bool pin)
    {
        // first access for a newly mapped page will not get a corresponding
        // call to notifyPageAccess, so do it now
        notifyPageAccess(page, pin);
    }

    void notifyPageUnmap(PageT &page, bool discard)
    {
        // move the unmapped page to the MRU position so that it will not be
        // treated as a candidate for flush
        notifyPageAccess(page, false);
    }

    void notifyPageUnpin(PageT &page)
    {
    }

    void notifyPageDirty(PageT &page)
    {
    }

    void notifyPageClean(PageT &page)
    {
    }

    void notifyPageDiscard(BlockId blockId)
    {
    }

    SXMutex &getMutex()
    {
        return mutex;
    }

    std::pair<PageIterator,PageIterator> getVictimRange()
    {
        return std::pair<PageIterator,PageIterator>(
            PageIterator(pageLRU),PageIterator());
    }

    std::pair<DirtyPageIterator,DirtyPageIterator> getDirtyVictimRange()
    {
        return
            static_cast<std::pair<DirtyPageIterator,DirtyPageIterator> >(
                getVictimRange());
    }
};

FENNEL_END_NAMESPACE

#endif

// End LRUVictimPolicy.h

---