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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/* $Id$ */
/** @file yapf_costcache.hpp */
#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; ///< the pathfinder class (derived from THIS class)
typedef typename Types::NodeList::Titem Node; ///< this will be our node type
/** Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used */
FORCEINLINE bool PfNodeCacheFetch(Node& n)
{
return false;
};
/** Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. */
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; ///< the pathfinder class (derived from THIS class)
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;
/// to access inherited path finder
FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}
public:
/** Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used */
FORCEINLINE bool PfNodeCacheFetch(Node& n)
{
CacheKey key(n.GetKey());
Yapf().ConnectNodeToCachedData(n, *new (&m_local_cache.AddNC()) CachedData(key));
return false;
};
/** Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. */
FORCEINLINE void PfNodeCacheFlush(Node& n)
{
};
};
/** Base class for segment cost cache providers. Contains global counter
* of track layout changes and static notification function called whenever
* the track layout changes. It is implemented as base class because it needs
* to be shared between all rail YAPF types (one shared counter, one notification
* function. */
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() {}
/** flush (clear) the cache */
FORCEINLINE void Flush() {m_map.Clear(); m_heap.Clear();};
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; ///< the pathfinder class (derived from THIS class)
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()) {};
/// to access inherited path finder
FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}
FORCEINLINE static Cache& stGetGlobalCache()
{
static int last_rail_change_counter = 0;
static Date last_date = 0;
static Cache C;
// some statistics
if (last_date != _date) {
last_date = _date;
DEBUG(yapf, 2, "Pf time today: %5d ms", _total_pf_time_us / 1000);
_total_pf_time_us = 0;
}
// delete the cache sometimes...
if (last_rail_change_counter != Cache::s_rail_change_counter) {
last_rail_change_counter = Cache::s_rail_change_counter;
C.Flush();
}
return C;
}
public:
/** Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used */
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;
};
/** Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. */
FORCEINLINE void PfNodeCacheFlush(Node& n)
{
};
};
#endif /* YAPF_COSTCACHE_HPP */
|
