ViennaCL - The Vienna Computing Library  1.5.2
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  template <typename S1,
47  typename S2, typename ScalarType1>
51  >::type
52  as(S1 & s1,
53  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
54  {
55  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
56 
57  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
58  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
60 
61  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
62 
64  (viennacl::is_cpu_scalar<ScalarType1>::value ? "as_cpu" : "as_gpu"));
65  k.local_work_size(0, 1);
66  k.global_work_size(0, 1);
67  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
68  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
69  options_alpha,
70  viennacl::traits::opencl_handle(s2) )
71  );
72  }
73 
74 
75  template <typename S1,
76  typename S2, typename ScalarType1,
77  typename S3, typename ScalarType2>
83  >::type
84  asbs(S1 & s1,
85  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
86  S3 const & s3, ScalarType2 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
87  {
88  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
89  assert( &viennacl::traits::opencl_handle(s2).context() == &viennacl::traits::opencl_handle(s3).context() && bool("Operands not in the same OpenCL context!"));
90 
91  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
92  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
94 
95  std::string kernel_name;
97  kernel_name = "asbs_cpu_cpu";
99  kernel_name = "asbs_cpu_gpu";
101  kernel_name = "asbs_gpu_cpu";
102  else
103  kernel_name = "asbs_gpu_gpu";
104 
105  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
106  cl_uint options_beta = detail::make_options(len_beta, reciprocal_beta, flip_sign_beta);
107 
109  k.local_work_size(0, 1);
110  k.global_work_size(0, 1);
111  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
112  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
113  options_alpha,
114  viennacl::traits::opencl_handle(s2),
115  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(beta)),
116  options_beta,
117  viennacl::traits::opencl_handle(s3) )
118  );
119  }
120 
121 
122  template <typename S1,
123  typename S2, typename ScalarType1,
124  typename S3, typename ScalarType2>
130  >::type
131  asbs_s(S1 & s1,
132  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
133  S3 const & s3, ScalarType2 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
134  {
135  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
136  assert( &viennacl::traits::opencl_handle(s2).context() == &viennacl::traits::opencl_handle(s3).context() && bool("Operands not in the same OpenCL context!"));
137 
138  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
139  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
141 
142  std::string kernel_name;
144  kernel_name = "asbs_s_cpu_cpu";
146  kernel_name = "asbs_s_cpu_gpu";
148  kernel_name = "asbs_s_gpu_cpu";
149  else
150  kernel_name = "asbs_s_gpu_gpu";
151 
152  cl_uint options_alpha = detail::make_options(len_alpha, reciprocal_alpha, flip_sign_alpha);
153  cl_uint options_beta = detail::make_options(len_beta, reciprocal_beta, flip_sign_beta);
154 
156  k.local_work_size(0, 1);
157  k.global_work_size(0, 1);
158  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
159  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(alpha)),
160  options_alpha,
161  viennacl::traits::opencl_handle(s2),
162  viennacl::traits::opencl_handle(viennacl::tools::promote_if_host_scalar<value_type>(beta)),
163  options_beta,
164  viennacl::traits::opencl_handle(s3) )
165  );
166  }
167 
168 
174  template <typename S1, typename S2>
177  >::type
178  swap(S1 & s1, S2 & s2)
179  {
180  assert( &viennacl::traits::opencl_handle(s1).context() == &viennacl::traits::opencl_handle(s2).context() && bool("Operands not in the same OpenCL context!"));
181 
182  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
183  viennacl::ocl::context & ctx = const_cast<viennacl::ocl::context &>(viennacl::traits::opencl_handle(s1).context());
185 
187  k.local_work_size(0, 1);
188  k.global_work_size(0, 1);
189  viennacl::ocl::enqueue(k(viennacl::traits::opencl_handle(s1),
190  viennacl::traits::opencl_handle(s2))
191  );
192  }
193 
194 
195 
196  } //namespace opencl
197  } //namespace linalg
198 } //namespace viennacl
199 
200 
201 #endif
Simple enable-if variant that uses the SFINAE pattern.
Definition: enable_if.hpp:29
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:470
std::size_t vcl_size_t
Definition: forwards.h:58
Represents an OpenCL device within ViennaCL.
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_scalar< S3 >::value &&viennacl::is_any_scalar< ScalarType1 >::value &&viennacl::is_any_scalar< ScalarType2 >::value >::type asbs_s(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:131
OpenCL kernel file for scalar operations.
Common implementations shared by OpenCL-based operations.
Generic size and resize functionality for different vector and matrix types.
Represents an OpenCL kernel within ViennaCL.
Definition: kernel.hpp:59
Extracts the underlying OpenCL start index handle from a vector, a matrix, an expression etc...
Various little tools used here and there in ViennaCL.
Manages an OpenCL context and provides the respective convenience functions for creating buffers...
Definition: context.hpp:51
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value >::type swap(S1 &s1, S2 &s2)
Swaps the contents of two scalars, data is copied.
Definition: scalar_operations.hpp:178
This file provides the forward declarations for the main types used within ViennaCL.
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_any_scalar< ScalarType1 >::value >::type as(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
Definition: scalar_operations.hpp:52
Determines row and column increments for matrices and matrix proxies.
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_scalar< S3 >::value &&viennacl::is_any_scalar< ScalarType1 >::value &&viennacl::is_any_scalar< ScalarType2 >::value >::type asbs(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:84
Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
Definition: cpu_ram.hpp:29
Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<>.
Definition: scalar.hpp:226
void enqueue(KernelType &k, viennacl::ocl::command_queue const &queue)
Enqueues a kernel in the provided queue.
Definition: enqueue.hpp:48
Helper struct for checking whether a type is a host scalar type (e.g. float, double) ...
Definition: forwards.h:363
Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
Definition: forwards.h:384
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:39
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:370
viennacl::context context(T const &t)
Returns an ID for the currently active memory domain of an object.
Definition: context.hpp:41
static void init(viennacl::ocl::context &ctx)
Definition: scalar.hpp:233
Representation of an OpenCL kernel in ViennaCL.
T::ERROR_CANNOT_DEDUCE_CPU_SCALAR_TYPE_FOR_T type
Definition: result_of.hpp:276
size_type global_work_size(int index=0) const
Returns the global work size at the respective dimension.
Definition: kernel.hpp:759
Extracts the underlying OpenCL handle from a vector, a matrix, an expression etc. ...
size_type local_work_size(int index=0) const
Returns the local work size at the respective dimension.
Definition: kernel.hpp:750
A collection of compile time type deductions.
Simple enable-if variant that uses the SFINAE pattern.