ViennaCL - The Vienna Computing Library  1.6.0
Free open-source GPU-accelerated linear algebra and solver library.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
scalar_operations.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_LINALG_OPENCL_SCALAR_OPERATIONS_HPP_
2 #define VIENNACL_LINALG_OPENCL_SCALAR_OPERATIONS_HPP_
3 
4 /* =========================================================================
5  Copyright (c) 2010-2014, Institute for Microelectronics,
6  Institute for Analysis and Scientific Computing,
7  TU Wien.
8  Portions of this software are copyright by UChicago Argonne, LLC.
9 
10  -----------------
11  ViennaCL - The Vienna Computing Library
12  -----------------
13 
14  Project Head: Karl Rupp rupp@iue.tuwien.ac.at
15 
16  (A list of authors and contributors can be found in the PDF manual)
17 
18  License: MIT (X11), see file LICENSE in the base directory
19 ============================================================================= */
20 
25 #include "viennacl/forwards.h"
26 #include "viennacl/ocl/device.hpp"
27 #include "viennacl/ocl/handle.hpp"
28 #include "viennacl/ocl/kernel.hpp"
29 #include "viennacl/tools/tools.hpp"
35 #include "viennacl/traits/size.hpp"
39 
40 namespace viennacl
41 {
42 namespace linalg
43 {
44 namespace opencl
45 {
46 
47 template<typename ScalarT1,
48  typename ScalarT2, typename NumericT>
52  >::type
53 as(ScalarT1 & s1,
54  ScalarT2 const & s2, NumericT const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
55 {
56  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
57 
58  typedef typename viennacl::result_of::cpu_value_type<ScalarT1>::type value_type;
59  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
61 
62  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
63 
66  k.local_work_size(0, 1);
67  k.global_work_size(0, 1);
68  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
69  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
70  options_alpha,
71  viennacl::traits::opencl_handle(s2) )
72  );
73 }
74 
75 
76 template<typename ScalarT1,
77  typename ScalarT2, typename NumericT2,
78  typename ScalarT3, typename NumericT3>
84  >::type
85 asbs(ScalarT1 & s1,
86  ScalarT2 const & s2, NumericT2 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
87  ScalarT3 const & s3, NumericT3 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
88 {
89  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
90  assert( &viennacl::traits::opencl_handle(s2).context() == &viennacl::traits::opencl_handle(s3).context() && bool("Operands not in the same OpenCL context!"));
91 
92  typedef typename viennacl::result_of::cpu_value_type<ScalarT1>::type value_type;
93  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
95 
96  std::string kernel_name;
99  if (is_cpu_2 && is_cpu_3)
100  kernel_name = "asbs_cpu_cpu";
101  else if (is_cpu_2 && !is_cpu_3)
102  kernel_name = "asbs_cpu_gpu";
103  else if (!is_cpu_2 && is_cpu_3)
104  kernel_name = "asbs_gpu_cpu";
105  else
106  kernel_name = "asbs_gpu_gpu";
107 
108  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
109  cl_uint options_beta = detail::make_options(len_beta, reciprocal_beta, flip_sign_beta);
110 
112  k.local_work_size(0, 1);
113  k.global_work_size(0, 1);
114  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
115  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
116  options_alpha,
117  viennacl::traits::opencl_handle(s2),
118  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(beta)),
119  options_beta,
120  viennacl::traits::opencl_handle(s3) )
121  );
122 }
123 
124 
125 template<typename ScalarT1,
126  typename ScalarT2, typename NumericT2,
127  typename ScalarT3, typename NumericT3>
133  >::type
134 asbs_s(ScalarT1 & s1,
135  ScalarT2 const & s2, NumericT2 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
136  ScalarT3 const & s3, NumericT3 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
137 {
138  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
139  assert( &viennacl::traits::opencl_handle(s2).context() == &viennacl::traits::opencl_handle(s3).context() && bool("Operands not in the same OpenCL context!"));
140 
141  typedef typename viennacl::result_of::cpu_value_type<ScalarT1>::type value_type;
142  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
144 
145  std::string kernel_name;
147  kernel_name = "asbs_s_cpu_cpu";
149  kernel_name = "asbs_s_cpu_gpu";
151  kernel_name = "asbs_s_gpu_cpu";
152  else
153  kernel_name = "asbs_s_gpu_gpu";
154 
155  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
156  cl_uint options_beta = detail::make_options(len_beta, reciprocal_beta, flip_sign_beta);
157 
159  k.local_work_size(0, 1);
160  k.global_work_size(0, 1);
161  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
162  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
163  options_alpha,
164  viennacl::traits::opencl_handle(s2),
165  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(beta)),
166  options_beta,
167  viennacl::traits::opencl_handle(s3) )
168  );
169 }
170 
171 
177 template<typename ScalarT1, typename ScalarT2>
180  >::type
181 swap(ScalarT1 & s1, ScalarT2 & s2)
182 {
183  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
184 
185  typedef typename viennacl::result_of::cpu_value_type<ScalarT1>::type value_type;
186  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
188 
190  k.local_work_size(0, 1);
191  k.global_work_size(0, 1);
192  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
193  viennacl::traits::opencl_handle(s2))
194  );
195 }
196 
197 
198 
199 } //namespace opencl
200 } //namespace linalg
201 } //namespace viennacl
202 
203 
204 #endif
Simple enable-if variant that uses the SFINAE pattern.
Definition: enable_if.hpp:30
Represents an OpenCL device within ViennaCL.
OpenCL kernel file for scalar operations.
Generic size and resize functionality for different vector and matrix types.
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value >::type swap(ScalarT1 &s1, ScalarT2 &s2)
Swaps the contents of two scalars, data is copied.
Represents an OpenCL kernel within ViennaCL.
Definition: kernel.hpp:58
Extracts the underlying OpenCL start index handle from a vector, a matrix, an expression etc...
Various little tools used here and there in ViennaCL.
size_type local_work_size(int index=0) const
Returns the local work size at the respective dimension.
Definition: kernel.hpp:742
Manages an OpenCL context and provides the respective convenience functions for creating buffers...
Definition: context.hpp:54
This file provides the forward declarations for the main types used within ViennaCL.
Determines row and column increments for matrices and matrix proxies.
viennacl::scalar< int > s2
viennacl::scalar< float > s1
Common implementations shared by OpenCL-based operations.
Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<>.
Definition: scalar.hpp:226
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value &&viennacl::is_scalar< ScalarT3 >::value &&viennacl::is_any_scalar< NumericT2 >::value &&viennacl::is_any_scalar< NumericT3 >::value >::type asbs_s(ScalarT1 &s1, ScalarT2 const &s2, NumericT2 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, ScalarT3 const &s3, NumericT3 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Helper struct for checking whether a type is a host scalar type (e.g. float, double) ...
Definition: forwards.h:447
viennacl::ocl::kernel & get_kernel(std::string const &program_name, std::string const &kernel_name)
Convenience function for retrieving the kernel of a program directly from the context.
Definition: context.hpp:607
static void init(viennacl::ocl::context &ctx)
Definition: scalar.hpp:233
Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
Definition: forwards.h:468
Implementation of a smart-pointer-like class for handling OpenCL handles.
cl_uint make_options(vcl_size_t length, bool reciprocal, bool flip_sign)
Definition: common.hpp:63
std::size_t vcl_size_t
Definition: forwards.h:74
T::ERROR_CANNOT_DEDUCE_CPU_SCALAR_TYPE_FOR_T type
Definition: result_of.hpp:238
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value &&viennacl::is_scalar< ScalarT3 >::value &&viennacl::is_any_scalar< NumericT2 >::value &&viennacl::is_any_scalar< NumericT3 >::value >::type asbs(ScalarT1 &s1, ScalarT2 const &s2, NumericT2 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, ScalarT3 const &s3, NumericT3 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value &&viennacl::is_any_scalar< NumericT >::value >::type as(ScalarT1 &s1, ScalarT2 const &s2, NumericT const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
All the predicates used within ViennaCL. Checks for expressions to be vectors, etc.
Helper struct for checking whether a type is a viennacl::scalar<>
Definition: forwards.h:454
viennacl::context context(T const &t)
Returns an ID for the currently active memory domain of an object.
Definition: context.hpp:40
void enqueue(KernelType &k, viennacl::ocl::command_queue const &queue)
Enqueues a kernel in the provided queue.
Definition: enqueue.hpp:50
Representation of an OpenCL kernel in ViennaCL.
size_type global_work_size(int index=0) const
Returns the global work size at the respective dimension.
Definition: kernel.hpp:751
Extracts the underlying OpenCL handle from a vector, a matrix, an expression etc. ...
A collection of compile time type deductions.
Simple enable-if variant that uses the SFINAE pattern.