Repository navigation
Expand file tree
/
Copy pathNNCache.h
More file actions
117 lines (87 loc) · 3.2 KB
/
Copy pathNNCache.h
File metadata and controls
117 lines (87 loc) · 3.2 KB
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
/*
This file is part of Leela Zero.
Copyright (C) 2017-2019 Michael O and contributors
Leela Zero is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Leela Zero is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Leela Zero. If not, see <http://www.gnu.org/licenses/>.
Additional permission under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with NVIDIA Corporation's libraries from the
NVIDIA CUDA Toolkit and/or the NVIDIA CUDA Deep Neural
Network library and/or the NVIDIA TensorRT inference library
(or a modified version of those libraries), containing parts covered
by the terms of the respective license agreement, the licensors of
this Program grant you additional permission to convey the resulting
work.
*/
#ifndef NNCACHE_H_INCLUDED
#define NNCACHE_H_INCLUDED
#include "config.h"
#include <array>
#include <deque>
#include <memory>
#include <mutex>
#include <unordered_map>
class NNCache {
public:
// Maximum size of the cache in number of items.
static constexpr int MAX_CACHE_COUNT = 150'000;
// Minimum size of the cache in number of items.
static constexpr int MIN_CACHE_COUNT = 6'000;
struct Netresult {
// 19x19 board positions
std::array<float, NUM_INTERSECTIONS> policy;
// pass
float policy_pass;
// winrate
float winrate;
Netresult() : policy_pass(0.0f), winrate(0.0f) {
policy.fill(0.0f);
}
};
static constexpr size_t ENTRY_SIZE =
sizeof(Netresult)
+ sizeof(std::uint64_t)
+ sizeof(std::unique_ptr<Netresult>);
NNCache(int size = MAX_CACHE_COUNT); // ~ 208MiB
// Set a reasonable size gives max number of playouts
void set_size_from_playouts(int max_playouts);
// Resize NNCache
void resize(int size);
// Try and find an existing entry.
bool lookup(std::uint64_t hash, Netresult & result);
// Insert a
5031
new entry.
void insert(std::uint64_t hash,
const Netresult& result);
// Return the hit rate ratio.
std::pair<int, int> hit_rate() const {
return {m_hits, m_lookups};
}
void dump_stats();
// Return the estimated memory consumption of the cache.
size_t get_estimated_size();
private:
std::mutex m_mutex;
size_t m_size;
// Statistics
int m_hits{0};
int m_lookups{0};
int m_inserts{0};
struct Entry {
Entry(const Netresult& r)
: result(r) {}
Netresult result; // ~ 1.4KiB
};
// Map from hash to {features, result}
std::unordered_map<std::uint64_t, std::unique_ptr<const Entry>> m_cache;
// Order entries were added to the map.
std::deque<size_t> m_order;
};
#endif