ViennaCL - The Vienna Computing Library  1.2.0
vector_kernels.h
Go to the documentation of this file.
1 #ifndef _VIENNACL_VECTOR_KERNELS_HPP_
2 #define _VIENNACL_VECTOR_KERNELS_HPP_
6 #include "viennacl/ocl/utils.hpp"
8 
9 //Automatically generated file from aux-directory, do not edit manually!
10 namespace viennacl
11 {
12  namespace linalg
13  {
14  namespace kernels
15  {
16  template<class TYPE, unsigned int alignment>
17  struct vector;
18 
19 
21  template <>
22  struct vector<float, 4>
23  {
24  static std::string program_name()
25  {
26  return "f_vector_4";
27  }
28  static void init()
29  {
31  static std::map<cl_context, bool> init_done;
33  if (!init_done[context_.handle()])
34  {
35  std::string source;
36  source.append(vector_align1_inplace_divide);
37  source.append(vector_align4_inplace_div_sub);
38  source.append(vector_align1_vmax);
39  source.append(vector_align1_index_norm_inf);
40  source.append(vector_align1_sub);
41  source.append(vector_align4_mul_add);
42  source.append(vector_align1_inplace_sub);
43  source.append(vector_align1_inner_prod);
44  source.append(vector_align1_mult);
45  source.append(vector_align1_diag_precond);
46  source.append(vector_align4_inplace_mul_add);
47  source.append(vector_align1_norm_1);
48  source.append(vector_align1_divide);
49  source.append(vector_align1_swap);
50  source.append(vector_align1_norm_inf);
51  source.append(vector_align4_inplace_div_add);
52  source.append(vector_align1_sqrt_sum);
53  source.append(vector_align1_inplace_add);
54  source.append(vector_align1_mul_sub);
55  source.append(vector_align1_sum);
56  source.append(vector_align4_cpu_mul_add);
57  source.append(vector_align1_cpu_mult);
58  source.append(vector_align4_cpu_inplace_mul_add);
59  source.append(vector_align1_cpu_inplace_mult);
60  source.append(vector_align1_plane_rotation);
61  source.append(vector_align1_clear);
62  source.append(vector_align1_inplace_mult);
63  source.append(vector_align4_inplace_mul_sub);
64  source.append(vector_align1_norm_2);
65  source.append(vector_align1_add);
66  std::string prog_name = program_name();
67  #ifdef VIENNACL_BUILD_INFO
68  std::cout << "Creating program " << prog_name << std::endl;
69  #endif
70  context_.add_program(source, prog_name);
71  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
72  prog_.add_kernel("inplace_divide");
73  prog_.add_kernel("inplace_div_sub");
74  prog_.add_kernel("vmax");
75  prog_.add_kernel("index_norm_inf");
76  prog_.add_kernel("sub");
77  prog_.add_kernel("mul_add");
78  prog_.add_kernel("inplace_sub");
79  prog_.add_kernel("inner_prod");
80  prog_.add_kernel("mult");
81  prog_.add_kernel("diag_precond");
82  prog_.add_kernel("inplace_mul_add");
83  prog_.add_kernel("norm_1");
84  prog_.add_kernel("divide");
85  prog_.add_kernel("swap");
86  prog_.add_kernel("norm_inf");
87  prog_.add_kernel("inplace_div_add");
88  prog_.add_kernel("sqrt_sum");
89  prog_.add_kernel("inplace_add");
90  prog_.add_kernel("mul_sub");
91  prog_.add_kernel("sum");
92  prog_.add_kernel("cpu_mul_add");
93  prog_.add_kernel("cpu_mult");
94  prog_.add_kernel("cpu_inplace_mul_add");
95  prog_.add_kernel("cpu_inplace_mult");
96  prog_.add_kernel("plane_rotation");
97  prog_.add_kernel("clear");
98  prog_.add_kernel("inplace_mult");
99  prog_.add_kernel("inplace_mul_sub");
100  prog_.add_kernel("norm_2");
101  prog_.add_kernel("add");
102  init_done[context_.handle()] = true;
103  } //if
104  } //init
105  }; // struct
106 
107  template <>
108  struct vector<float, 1>
109  {
110  static std::string program_name()
111  {
112  return "f_vector_1";
113  }
114  static void init()
115  {
117  static std::map<cl_context, bool> init_done;
119  if (!init_done[context_.handle()])
120  {
121  std::string source;
122  source.append(vector_align1_inplace_divide);
123  source.append(vector_align1_inplace_div_sub);
124  source.append(vector_align1_vmax);
125  source.append(vector_align1_index_norm_inf);
126  source.append(vector_align1_sub);
127  source.append(vector_align1_mul_add);
128  source.append(vector_align1_inplace_sub);
129  source.append(vector_align1_inner_prod);
130  source.append(vector_align1_mult);
131  source.append(vector_align1_diag_precond);
132  source.append(vector_align1_inplace_mul_add);
133  source.append(vector_align1_norm_1);
134  source.append(vector_align1_divide);
135  source.append(vector_align1_swap);
136  source.append(vector_align1_norm_inf);
137  source.append(vector_align1_inplace_div_add);
138  source.append(vector_align1_sqrt_sum);
139  source.append(vector_align1_inplace_add);
140  source.append(vector_align1_mul_sub);
141  source.append(vector_align1_sum);
142  source.append(vector_align1_cpu_mul_add);
143  source.append(vector_align1_cpu_mult);
144  source.append(vector_align1_cpu_inplace_mul_add);
145  source.append(vector_align1_cpu_inplace_mult);
146  source.append(vector_align1_plane_rotation);
147  source.append(vector_align1_clear);
148  source.append(vector_align1_inplace_mult);
149  source.append(vector_align1_inplace_mul_sub);
150  source.append(vector_align1_norm_2);
151  source.append(vector_align1_add);
152  std::string prog_name = program_name();
153  #ifdef VIENNACL_BUILD_INFO
154  std::cout << "Creating program " << prog_name << std::endl;
155  #endif
156  context_.add_program(source, prog_name);
157  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
158  prog_.add_kernel("inplace_divide");
159  prog_.add_kernel("inplace_div_sub");
160  prog_.add_kernel("vmax");
161  prog_.add_kernel("index_norm_inf");
162  prog_.add_kernel("sub");
163  prog_.add_kernel("mul_add");
164  prog_.add_kernel("inplace_sub");
165  prog_.add_kernel("inner_prod");
166  prog_.add_kernel("mult");
167  prog_.add_kernel("diag_precond");
168  prog_.add_kernel("inplace_mul_add");
169  prog_.add_kernel("norm_1");
170  prog_.add_kernel("divide");
171  prog_.add_kernel("swap");
172  prog_.add_kernel("norm_inf");
173  prog_.add_kernel("inplace_div_add");
174  prog_.add_kernel("sqrt_sum");
175  prog_.add_kernel("inplace_add");
176  prog_.add_kernel("mul_sub");
177  prog_.add_kernel("sum");
178  prog_.add_kernel("cpu_mul_add");
179  prog_.add_kernel("cpu_mult");
180  prog_.add_kernel("cpu_inplace_mul_add");
181  prog_.add_kernel("cpu_inplace_mult");
182  prog_.add_kernel("plane_rotation");
183  prog_.add_kernel("clear");
184  prog_.add_kernel("inplace_mult");
185  prog_.add_kernel("inplace_mul_sub");
186  prog_.add_kernel("norm_2");
187  prog_.add_kernel("add");
188  init_done[context_.handle()] = true;
189  } //if
190  } //init
191  }; // struct
192 
193  template <>
194  struct vector<float, 16>
195  {
196  static std::string program_name()
197  {
198  return "f_vector_16";
199  }
200  static void init()
201  {
203  static std::map<cl_context, bool> init_done;
205  if (!init_done[context_.handle()])
206  {
207  std::string source;
208  source.append(vector_align16_inplace_divide);
209  source.append(vector_align4_inplace_div_sub);
210  source.append(vector_align1_vmax);
211  source.append(vector_align1_index_norm_inf);
212  source.append(vector_align16_sub);
213  source.append(vector_align4_mul_add);
214  source.append(vector_align16_inplace_sub);
215  source.append(vector_align1_inner_prod);
216  source.append(vector_align16_mult);
217  source.append(vector_align1_diag_precond);
218  source.append(vector_align4_inplace_mul_add);
219  source.append(vector_align1_norm_1);
220  source.append(vector_align16_divide);
221  source.append(vector_align1_swap);
222  source.append(vector_align1_norm_inf);
223  source.append(vector_align4_inplace_div_add);
224  source.append(vector_align1_sqrt_sum);
225  source.append(vector_align16_inplace_add);
226  source.append(vector_align1_mul_sub);
227  source.append(vector_align1_sum);
228  source.append(vector_align4_cpu_mul_add);
229  source.append(vector_align16_cpu_mult);
230  source.append(vector_align4_cpu_inplace_mul_add);
231  source.append(vector_align1_cpu_inplace_mult);
232  source.append(vector_align1_plane_rotation);
233  source.append(vector_align1_clear);
234  source.append(vector_align16_inplace_mult);
235  source.append(vector_align4_inplace_mul_sub);
236  source.append(vector_align1_norm_2);
237  source.append(vector_align16_add);
238  std::string prog_name = program_name();
239  #ifdef VIENNACL_BUILD_INFO
240  std::cout << "Creating program " << prog_name << std::endl;
241  #endif
242  context_.add_program(source, prog_name);
243  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
244  prog_.add_kernel("inplace_divide");
245  prog_.add_kernel("inplace_div_sub");
246  prog_.add_kernel("vmax");
247  prog_.add_kernel("index_norm_inf");
248  prog_.add_kernel("sub");
249  prog_.add_kernel("mul_add");
250  prog_.add_kernel("inplace_sub");
251  prog_.add_kernel("inner_prod");
252  prog_.add_kernel("mult");
253  prog_.add_kernel("diag_precond");
254  prog_.add_kernel("inplace_mul_add");
255  prog_.add_kernel("norm_1");
256  prog_.add_kernel("divide");
257  prog_.add_kernel("swap");
258  prog_.add_kernel("norm_inf");
259  prog_.add_kernel("inplace_div_add");
260  prog_.add_kernel("sqrt_sum");
261  prog_.add_kernel("inplace_add");
262  prog_.add_kernel("mul_sub");
263  prog_.add_kernel("sum");
264  prog_.add_kernel("cpu_mul_add");
265  prog_.add_kernel("cpu_mult");
266  prog_.add_kernel("cpu_inplace_mul_add");
267  prog_.add_kernel("cpu_inplace_mult");
268  prog_.add_kernel("plane_rotation");
269  prog_.add_kernel("clear");
270  prog_.add_kernel("inplace_mult");
271  prog_.add_kernel("inplace_mul_sub");
272  prog_.add_kernel("norm_2");
273  prog_.add_kernel("add");
274  init_done[context_.handle()] = true;
275  } //if
276  } //init
277  }; // struct
278 
279 
280 
282  template <>
283  struct vector<double, 4>
284  {
285  static std::string program_name()
286  {
287  return "d_vector_4";
288  }
289  static void init()
290  {
292  static std::map<cl_context, bool> init_done;
294  if (!init_done[context_.handle()])
295  {
296  std::string source;
297  std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
302  source.append(viennacl::tools::make_double_kernel(vector_align1_sub, fp64_ext));
317  source.append(viennacl::tools::make_double_kernel(vector_align1_sum, fp64_ext));
327  source.append(viennacl::tools::make_double_kernel(vector_align1_add, fp64_ext));
328  std::string prog_name = program_name();
329  #ifdef VIENNACL_BUILD_INFO
330  std::cout << "Creating program " << prog_name << std::endl;
331  #endif
332  context_.add_program(source, prog_name);
333  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
334  prog_.add_kernel("inplace_divide");
335  prog_.add_kernel("inplace_div_sub");
336  prog_.add_kernel("vmax");
337  prog_.add_kernel("index_norm_inf");
338  prog_.add_kernel("sub");
339  prog_.add_kernel("mul_add");
340  prog_.add_kernel("inplace_sub");
341  prog_.add_kernel("inner_prod");
342  prog_.add_kernel("mult");
343  prog_.add_kernel("diag_precond");
344  prog_.add_kernel("inplace_mul_add");
345  prog_.add_kernel("norm_1");
346  prog_.add_kernel("divide");
347  prog_.add_kernel("swap");
348  prog_.add_kernel("norm_inf");
349  prog_.add_kernel("inplace_div_add");
350  prog_.add_kernel("sqrt_sum");
351  prog_.add_kernel("inplace_add");
352  prog_.add_kernel("mul_sub");
353  prog_.add_kernel("sum");
354  prog_.add_kernel("cpu_mul_add");
355  prog_.add_kernel("cpu_mult");
356  prog_.add_kernel("cpu_inplace_mul_add");
357  prog_.add_kernel("cpu_inplace_mult");
358  prog_.add_kernel("plane_rotation");
359  prog_.add_kernel("clear");
360  prog_.add_kernel("inplace_mult");
361  prog_.add_kernel("inplace_mul_sub");
362  prog_.add_kernel("norm_2");
363  prog_.add_kernel("add");
364  init_done[context_.handle()] = true;
365  } //if
366  } //init
367  }; // struct
368 
369  template <>
370  struct vector<double, 1>
371  {
372  static std::string program_name()
373  {
374  return "d_vector_1";
375  }
376  static void init()
377  {
379  static std::map<cl_context, bool> init_done;
381  if (!init_done[context_.handle()])
382  {
383  std::string source;
384  std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
389  source.append(viennacl::tools::make_double_kernel(vector_align1_sub, fp64_ext));
404  source.append(viennacl::tools::make_double_kernel(vector_align1_sum, fp64_ext));
414  source.append(viennacl::tools::make_double_kernel(vector_align1_add, fp64_ext));
415  std::string prog_name = program_name();
416  #ifdef VIENNACL_BUILD_INFO
417  std::cout << "Creating program " << prog_name << std::endl;
418  #endif
419  context_.add_program(source, prog_name);
420  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
421  prog_.add_kernel("inplace_divide");
422  prog_.add_kernel("inplace_div_sub");
423  prog_.add_kernel("vmax");
424  prog_.add_kernel("index_norm_inf");
425  prog_.add_kernel("sub");
426  prog_.add_kernel("mul_add");
427  prog_.add_kernel("inplace_sub");
428  prog_.add_kernel("inner_prod");
429  prog_.add_kernel("mult");
430  prog_.add_kernel("diag_precond");
431  prog_.add_kernel("inplace_mul_add");
432  prog_.add_kernel("norm_1");
433  prog_.add_kernel("divide");
434  prog_.add_kernel("swap");
435  prog_.add_kernel("norm_inf");
436  prog_.add_kernel("inplace_div_add");
437  prog_.add_kernel("sqrt_sum");
438  prog_.add_kernel("inplace_add");
439  prog_.add_kernel("mul_sub");
440  prog_.add_kernel("sum");
441  prog_.add_kernel("cpu_mul_add");
442  prog_.add_kernel("cpu_mult");
443  prog_.add_kernel("cpu_inplace_mul_add");
444  prog_.add_kernel("cpu_inplace_mult");
445  prog_.add_kernel("plane_rotation");
446  prog_.add_kernel("clear");
447  prog_.add_kernel("inplace_mult");
448  prog_.add_kernel("inplace_mul_sub");
449  prog_.add_kernel("norm_2");
450  prog_.add_kernel("add");
451  init_done[context_.handle()] = true;
452  } //if
453  } //init
454  }; // struct
455 
456  template <>
457  struct vector<double, 16>
458  {
459  static std::string program_name()
460  {
461  return "d_vector_16";
462  }
463  static void init()
464  {
466  static std::map<cl_context, bool> init_done;
468  if (!init_done[context_.handle()])
469  {
470  std::string source;
471  std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
491  source.append(viennacl::tools::make_double_kernel(vector_align1_sum, fp64_ext));
502  std::string prog_name = program_name();
503  #ifdef VIENNACL_BUILD_INFO
504  std::cout << "Creating program " << prog_name << std::endl;
505  #endif
506  context_.add_program(source, prog_name);
507  viennacl::ocl::program & prog_ = context_.get_program(prog_name);
508  prog_.add_kernel("inplace_divide");
509  prog_.add_kernel("inplace_div_sub");
510  prog_.add_kernel("vmax");
511  prog_.add_kernel("index_norm_inf");
512  prog_.add_kernel("sub");
513  prog_.add_kernel("mul_add");
514  prog_.add_kernel("inplace_sub");
515  prog_.add_kernel("inner_prod");
516  prog_.add_kernel("mult");
517  prog_.add_kernel("diag_precond");
518  prog_.add_kernel("inplace_mul_add");
519  prog_.add_kernel("norm_1");
520  prog_.add_kernel("divide");
521  prog_.add_kernel("swap");
522  prog_.add_kernel("norm_inf");
523  prog_.add_kernel("inplace_div_add");
524  prog_.add_kernel("sqrt_sum");
525  prog_.add_kernel("inplace_add");
526  prog_.add_kernel("mul_sub");
527  prog_.add_kernel("sum");
528  prog_.add_kernel("cpu_mul_add");
529  prog_.add_kernel("cpu_mult");
530  prog_.add_kernel("cpu_inplace_mul_add");
531  prog_.add_kernel("cpu_inplace_mult");
532  prog_.add_kernel("plane_rotation");
533  prog_.add_kernel("clear");
534  prog_.add_kernel("inplace_mult");
535  prog_.add_kernel("inplace_mul_sub");
536  prog_.add_kernel("norm_2");
537  prog_.add_kernel("add");
538  init_done[context_.handle()] = true;
539  } //if
540  } //init
541  }; // struct
542 
543 
544  } //namespace kernels
545  } //namespace linalg
546 } //namespace viennacl
547 #endif