1 #ifndef VIENNACL_IO_KERNEL_PARAMETERS_HPP
2 #define VIENNACL_IO_KERNEL_PARAMETERS_HPP
26 #include "pugixml/src/pugixml.hpp"
34 static std::string root =
"parameters";
35 static std::string devices =
"devices";
36 static std::string device =
"device";
37 static std::string name =
"name";
38 static std::string driver =
"driver";
39 static std::string compun =
"computeunits";
40 static std::string workgrp =
"workgroupsize";
41 static std::string tests =
"tests";
42 static std::string test =
"test";
43 static std::string numeric =
"numeric";
44 static std::string kernels =
"kernels";
45 static std::string kernel =
"kernel";
46 static std::string params =
"params";
47 static std::string param =
"param";
48 static std::string value =
"value";
49 static std::string alignment =
"alignment";
53 static std::string globsize =
"globalsize";
54 static std::string locsize =
"localsize";
55 static std::string vec =
"vector";
56 static std::string
matrix =
"matrix";
57 static std::string compmat =
"compressed_matrix";
58 static std::string fl =
"float";
59 static std::string dbl =
"double";
68 root.set_name(tag::root.c_str());
83 dev.set_name(tag::device.c_str());
88 devices.set_name(tag::devices.c_str());
91 dev.set_name(tag::device.c_str());
103 test =
tests.append_child();
104 test.set_name(tag::test.c_str());
109 tests.set_name(tag::tests.c_str());
111 test =
tests.append_child();
112 test.set_name(tag::test.c_str());
128 kern.set_name(tag::kernel.c_str());
133 kernels.set_name(tag::kernels.c_str());
136 kern.set_name(tag::kernel.c_str());
154 para.set_name(tag::param.c_str());
162 para.set_name(tag::param.c_str());
169 template<
typename ValueT>
172 std::stringstream ss;
179 pugi::xml_node node =
last.append_child();
181 if(tagstr == tag::name)
182 node.set_name(tag::name.c_str());
183 else if(tagstr == tag::driver)
184 node.set_name(tag::driver.c_str());
185 else if(tagstr == tag::numeric)
186 node.set_name(tag::numeric.c_str());
187 else if(tagstr == tag::alignment)
188 node.set_name(tag::alignment.c_str());
189 else if(tagstr == tag::value)
190 node.set_name(tag::value.c_str());
191 else if(tagstr == tag::compun)
192 node.set_name(tag::compun.c_str());
193 else if(tagstr == tag::workgrp)
194 node.set_name(tag::workgrp.c_str());
196 std::cout <<
"# Error adding data node: node tag not recognized .." << std::endl;
197 node.append_child(pugi::node_pcdata).set_value(data.c_str());
200 void load(std::string filename)
202 doc.load_file(filename.c_str());
205 void dump(std::string filename)
207 std::ofstream outstream(filename.c_str());
208 this->
dump(outstream);
212 void dump(std::ostream& stream = std::cout)
214 doc.save(stream,
" ");
233 template <
typename T>
242 static char get() {
return 'f'; }
248 static char get() {
return 'd'; }
251 template <
typename T>
254 static std::string
get();
257 template <
typename T,
unsigned int ALIGNMENT>
260 static std::string
get()
262 std::stringstream ss;
263 ss << first_letter_of_type<T>::get() <<
"_vector_" << ALIGNMENT;
268 template <
typename T,
unsigned int ALIGNMENT>
271 static std::string
get()
273 std::stringstream ss;
274 ss << first_letter_of_type<T>::get() <<
"_matrix_row_" << ALIGNMENT;
279 template <
typename T,
unsigned int ALIGNMENT>
282 static std::string
get()
284 std::stringstream ss;
285 ss << first_letter_of_type<T>::get() <<
"_matrix_col_" << ALIGNMENT;
290 template <
typename T,
unsigned int ALIGNMENT>
293 static std::string
get()
295 std::stringstream ss;
296 ss << first_letter_of_type<T>::get() <<
"_compressed_matrix_" << ALIGNMENT;
301 template<
typename SCALARTYPE,
unsigned int ALIGNMENT>
303 std::string kernel_name,
315 template<
typename VclBasicType>
318 typedef typename VclBasicType::value_type::value_type SCALARTYPE;
324 std::string kernel_str = parent+
"/kernels/kernel/name/text()";
325 pugi::xpath_node_set kernel_res = paras.
doc.select_nodes(kernel_str.c_str());
327 typedef std::vector<std::string> kernels_type;
328 kernels_type kernels;
329 std::cout <<
"Retrieving kernels..." << std::endl;
330 for (pugi::xpath_node_set::const_iterator it = kernel_res.begin(); it != kernel_res.end(); ++it)
332 std::stringstream ss;
333 it->node().print(ss,
" ");
334 std::string kern(ss.str());
335 kern.erase(std::remove(kern.begin(), kern.end(),
'\n'), kern.end());
336 kernels.push_back(kern);
340 std::cout <<
"Retrieving actual parameters..." << std::endl;
341 for(
typename kernels_type::iterator iter = kernels.begin();
342 iter != kernels.end(); iter++)
345 std::string wg_str = parent+
"/kernels/kernel[name='"+*iter+
"']/params/param[name='"+val::globsize+
"']/value/text()";
346 pugi::xpath_node_set wg_res = paras.
doc.select_nodes(wg_str.c_str());
348 unsigned int global_size(0);
350 std::stringstream ss;
351 ss << wg_res[0].node().value();
355 std::string lw_str = parent+
"/kernels/kernel[name='"+*iter+
"']/params/param[name='"+val::locsize+
"']/value/text()";
356 pugi::xpath_node_set lw_res = paras.
doc.select_nodes(lw_str.c_str());
358 unsigned int local_workers(0);
361 ss << lw_res[0].node().value();
374 template <
typename T>
380 static std::string
get() {
return "float"; }
386 static std::string
get() {
return "double"; }
394 template<
typename VclBasicType>
397 typedef typename VclBasicType::value_type::value_type SCALARTYPE;
400 paras.
load(filename);
405 std::string device_str =
"/parameters/devices/device[name='"+devname+
"']";
406 pugi::xpath_node_set device_res = paras.
doc.select_nodes(device_str.c_str());
408 if(device_res.size() == 0)
410 std::cout <<
"Tuner: There are no parameters for this device present!" << std::endl;
416 pugi::xpath_node_set numeric_res = paras.
doc.select_nodes(numeric_str.c_str());
418 if(numeric_res.size() > 0)
420 tune_impl<VclBasicType>(paras, numeric_str);
424 std::cout <<
"Tuner: There are no parameters for numeric type float present!" << std::endl;