source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/detail/cache_simulator.h @ 774

//
// Copyright (C) 2004 Tanguy Fautré.
// For conditions of distribution and use,
// see copyright notice in tri_stripper.h
//
//////////////////////////////////////////////////////////////////////
// SVN: $Id: cache_simulator.h 86 2005-06-08 17:47:27Z gpsnoopy $
//////////////////////////////////////////////////////////////////////

#ifndef TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H
#define TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H

#include <algorithm>
#include <limits>
#include <deque>




namespace triangle_stripper {

        namespace detail {




class cache_simulator
{
public:
        cache_simulator();

        void clear();
        void resize(size_t Size);
        void reset();
        void push_cache_hits(bool Enabled = true);
        size_t size() const;

        void push(index i, bool CountCacheHit = false);
        void merge(const cache_simulator & Backward, size_t PossibleOverlap);

        void reset_hitcount();
        size_t hitcount() const;

protected:
        typedef std::deque<index> indices_deque;

        indices_deque   m_Cache;
        size_t                  m_NbHits;
        bool                    m_PushHits;
};





//////////////////////////////////////////////////////////////////////////
// cache_simulator inline functions
//////////////////////////////////////////////////////////////////////////

inline cache_simulator::cache_simulator()
        : m_NbHits(0),
          m_PushHits(true)
{

}


inline void cache_simulator::clear()
{
        reset_hitcount();
        m_Cache.clear();
}


inline void cache_simulator::resize(const size_t Size)
{
        m_Cache.resize(Size, std::numeric_limits<index>::max());
}


inline void cache_simulator::reset()
{
        std::fill(m_Cache.begin(), m_Cache.end(), std::numeric_limits<index>::max());
        reset_hitcount();
}


inline void cache_simulator::push_cache_hits(bool Enabled)
{
        m_PushHits = Enabled;
}


inline size_t cache_simulator::size() const
{
        return m_Cache.size();
}


inline void cache_simulator::push(const index i, const bool CountCacheHit)
{
        if (CountCacheHit || m_PushHits) {

                if (std::find(m_Cache.begin(), m_Cache.end(), i) != m_Cache.end()) {

                        // Should we count the cache hits?
                        if (CountCacheHit)
                                ++m_NbHits;
                        
                        // Should we not push the index into the cache if it's a cache hit?
                        if (! m_PushHits)
                                return;
                }
        }
            
        // Manage the indices cache as a FIFO structure
        m_Cache.push_front(i);
        m_Cache.pop_back();
}


inline void cache_simulator::merge(const cache_simulator & Backward, const size_t PossibleOverlap)
{
        const size_t Overlap = std::min(PossibleOverlap, size());

        for (size_t i = 0; i < Overlap; ++i)
                push(Backward.m_Cache[i], true);

        m_NbHits += Backward.m_NbHits;
}


inline void cache_simulator::reset_hitcount()
{
        m_NbHits = 0;
}


inline size_t cache_simulator::hitcount() const
{
        return m_NbHits;
}




        } // namespace detail

} // namespace triangle_stripper




#endif // TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H