www.pudn.com > tristripper-1.1.0-beta-5.zip > cache_simulator.h

// 
// 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  
#include  
#include  
 
 
 
 
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 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::max()); 
} 
 
 
inline void cache_simulator::reset() 
{ 
	std::fill(m_Cache.begin(), m_Cache.end(), std::numeric_limits::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