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 */
|