summaryrefslogtreecommitdiff
path: root/yapf/yapf_costcache.hpp
blob: 4947e6cefdf7099d5572216a48c3eecf74a1fe0b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/* $Id$ */
#ifndef  YAPF_COSTCACHE_HPP
#define  YAPF_COSTCACHE_HPP


/** CYapfSegmentCostCacheNoneT - the formal only yapf cost cache provider that implements
PfNodeCacheFetch() and PfNodeCacheFlush() callbacks. Used when nodes don't have CachedData
defined (they don't count with any segment cost caching).
*/
template <class Types>
class CYapfSegmentCostCacheNoneT
{
public:
	typedef typename Types::Tpf Tpf;
	typedef typename Types::NodeList::Titem Node; ///< this will be our node type

	FORCEINLINE bool PfNodeCacheFetch(Node& n)
	{
		return false;
	};

	FORCEINLINE void PfNodeCacheFlush(Node& n)
	{
	};
};


/** CYapfSegmentCostCacheLocalT - the yapf cost cache provider that implements fake segment
cost caching functionality for yapf. Used when node needs caching, but you don't want to
cache the segment costs.
*/
template <class Types>
class CYapfSegmentCostCacheLocalT
{
public:
	typedef typename Types::Tpf Tpf;
	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
	typedef typename Node::Key Key;    ///< key to hash tables
	typedef typename Node::CachedData CachedData;
	typedef typename CachedData::Key CacheKey;
	typedef CArrayT<CachedData> LocalCache;

protected:
	LocalCache      m_local_cache;

	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}

public:
	FORCEINLINE bool PfNodeCacheFetch(Node& n)
	{
		CacheKey key(n.GetKey());
		Yapf().ConnectNodeToCachedData(n, *new (&m_local_cache.AddNC()) CachedData(key));
		return false;
	};

	FORCEINLINE void PfNodeCacheFlush(Node& n)
	{
	};
};



struct CSegmentCostCacheBase
{
	static int   s_rail_change_counter;

	static void NotifyTrackLayoutChange(TileIndex tile, Track track) {s_rail_change_counter++;}
};


/** CSegmentCostCacheT - template class providing hash-map and storage (heap)
    of Tsegment structures. Each rail node contains pointer to the segment
    that contains cached (or non-cached) segment cost information. Nodes can
    differ by key type, but they use the same segment type. Segment key should
    be always the same (TileIndex + DiagDirection) that represent the beginning
    of the segment (origin tile and exit-dir from this tile).
    Different CYapfCachedCostT types can share the same type of CSegmentCostCacheT.
    Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */

template <class Tsegment>
struct CSegmentCostCacheT
	: public CSegmentCostCacheBase
{
	enum {c_hash_bits = 14};

	typedef CHashTableT<Tsegment, c_hash_bits> HashTable;
	typedef CArrayT<Tsegment> Heap;
	typedef typename Tsegment::Key Key;    ///< key to hash table

	HashTable    m_map;
	Heap         m_heap;

	FORCEINLINE CSegmentCostCacheT() {}

	FORCEINLINE Tsegment& Get(Key& key, bool *found)
	{
		Tsegment* item = &m_map.Find(key);
		if (item == NULL) {
			*found = false;
			item = new (&m_heap.AddNC()) Tsegment(key);
			m_map.Push(*item);
		} else {
			*found = true;
		}
		return *item;
	}
};

/** CYapfSegmentCostCacheGlobalT - the yapf cost cache provider that adds the segment cost
    caching functionality to yapf. Using this class as base of your will provide the global
		segment cost caching services for your Nodes.
*/
template <class Types>
class CYapfSegmentCostCacheGlobalT
	: public CYapfSegmentCostCacheLocalT<Types>
{
public:
	typedef CYapfSegmentCostCacheLocalT<Types> Tlocal;
	typedef typename Types::Tpf Tpf;
	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
	typedef typename Node::Key Key;    ///< key to hash tables
	typedef typename Node::CachedData CachedData;
	typedef typename CachedData::Key CacheKey;
	typedef CSegmentCostCacheT<CachedData> Cache;

protected:
	Cache&      m_global_cache;

	FORCEINLINE CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};

	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}

	FORCEINLINE static Cache*& stGlobalCachePtr() {static Cache* pC = NULL; return pC;}

	FORCEINLINE static Cache& stGetGlobalCache()
	{
		static int last_rail_change_counter = 0;
		static uint32 last_day = 0;

		// some statistics
		if (last_day != _date) {
			last_day = _date;
			DEBUG(yapf, 1)("pf time today:%5d ms\n", _total_pf_time_us / 1000);
			_total_pf_time_us = 0;
		}

		Cache*& pC = stGlobalCachePtr();

		// delete the cache sometimes...
		if (pC != NULL && last_rail_change_counter != Cache::s_rail_change_counter) {
			last_rail_change_counter = Cache::s_rail_change_counter;
			delete pC;
			pC = NULL;
		}

		if (pC == NULL)
			pC = new Cache();
		return *pC;
	}

public:
	FORCEINLINE bool PfNodeCacheFetch(Node& n)
	{
		if (!Yapf().CanUseGlobalCache(n)) {
			return Tlocal::PfNodeCacheFetch(n);
		}
		CacheKey key(n.GetKey());
		bool found;
		CachedData& item = m_global_cache.Get(key, &found);
		Yapf().ConnectNodeToCachedData(n, item);
		return found;
	};

	FORCEINLINE void PfNodeCacheFlush(Node& n)
	{
	};

};




#endif /* YAPF_COSTCACHE_HPP */