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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP
#define BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP
#include <algorithm>
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <boost/compute/config.hpp>
#include <boost/compute/device.hpp>
#include <boost/compute/detail/global_static.hpp>
#include <boost/compute/version.hpp>
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
#include <boost/algorithm/string/trim.hpp>
#include <boost/compute/detail/path.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
namespace boost {
namespace compute {
namespace detail {
class parameter_cache : boost::noncopyable
{
public:
parameter_cache(const device &device)
: m_dirty(false),
m_device_name(device.name())
{
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
// get offline cache file name (e.g. /home/user/.boost_compute/tune/device.json)
m_file_name = make_file_name();
// load parameters from offline cache file (if it exists)
if(boost::filesystem::exists(m_file_name)){
read_from_disk();
}
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
}
~parameter_cache()
{
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
write_to_disk();
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
}
void set(const std::string &object, const std::string ¶meter, uint_ value)
{
m_cache[std::make_pair(object, parameter)] = value;
// set the dirty flag to true. this will cause the updated parameters
// to be stored to disk.
m_dirty = true;
}
uint_ get(const std::string &object, const std::string ¶meter, uint_ default_value)
{
std::map<std::pair<std::string, std::string>, uint_>::iterator
iter = m_cache.find(std::make_pair(object, parameter));
if(iter != m_cache.end()){
return iter->second;
}
else {
return default_value;
}
}
static boost::shared_ptr<parameter_cache> get_global_cache(const device &device)
{
// device name -> parameter cache
typedef std::map<std::string, boost::shared_ptr<parameter_cache> > cache_map;
BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(cache_map, caches, ((std::less<std::string>())));
cache_map::iterator iter = caches.find(device.name());
if(iter == caches.end()){
boost::shared_ptr<parameter_cache> cache =
boost::make_shared<parameter_cache>(device);
caches.insert(iter, std::make_pair(device.name(), cache));
return cache;
}
else {
return iter->second;
}
}
private:
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
// returns a string containing a cannoical device name
static std::string cannonical_device_name(std::string name)
{
boost::algorithm::trim(name);
std::replace(name.begin(), name.end(), ' ', '_');
std::replace(name.begin(), name.end(), '(', '_');
std::replace(name.begin(), name.end(), ')', '_');
return name;
}
// returns the boost.compute version string
static std::string version_string()
{
char buf[32];
std::snprintf(buf, sizeof(buf), "%d.%d.%d", BOOST_COMPUTE_VERSION_MAJOR,
BOOST_COMPUTE_VERSION_MINOR,
BOOST_COMPUTE_VERSION_PATCH);
return buf;
}
// returns the file path for the cached parameters
std::string make_file_name() const
{
return detail::parameter_cache_path(true) + cannonical_device_name(m_device_name) + ".json";
}
// store current parameters to disk
void write_to_disk()
{
BOOST_ASSERT(!m_file_name.empty());
if(m_dirty){
// save current parameters to disk
boost::property_tree::ptree pt;
pt.put("header.device", m_device_name);
pt.put("header.version", version_string());
typedef std::map<std::pair<std::string, std::string>, uint_> map_type;
for(map_type::const_iterator iter = m_cache.begin(); iter != m_cache.end(); ++iter){
const std::pair<std::string, std::string> &key = iter->first;
pt.add(key.first + "." + key.second, iter->second);
}
write_json(m_file_name, pt);
m_dirty = false;
}
}
// load stored parameters from disk
void read_from_disk()
{
BOOST_ASSERT(!m_file_name.empty());
m_cache.clear();
boost::property_tree::ptree pt;
try {
read_json(m_file_name, pt);
}
catch(boost::property_tree::json_parser::json_parser_error&){
// no saved cache file, ignore
return;
}
std::string stored_device;
try {
stored_device = pt.get<std::string>("header.device");
}
catch(boost::property_tree::ptree_bad_path&){
return;
}
std::string stored_version;
try {
stored_version = pt.get<std::string>("header.version");
}
catch(boost::property_tree::ptree_bad_path&){
return;
}
if(stored_device == m_device_name && stored_version == version_string()){
typedef boost::property_tree::ptree::const_iterator pt_iter;
for(pt_iter iter = pt.begin(); iter != pt.end(); ++iter){
if(iter->first == "header"){
// skip header
continue;
}
boost::property_tree::ptree child_pt = pt.get_child(iter->first);
for(pt_iter child_iter = child_pt.begin(); child_iter != child_pt.end(); ++child_iter){
set(iter->first, child_iter->first, boost::lexical_cast<uint_>(child_iter->second.data()));
}
}
}
m_dirty = false;
}
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
private:
bool m_dirty;
std::string m_device_name;
std::string m_file_name;
std::map<std::pair<std::string, std::string>, uint_> m_cache;
};
} // end detail namespace
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP
|
