ViennaCL - The Vienna Computing Library: examples/tutorial/multithreaded.cpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
multithreaded.cpp
Go to the documentation of this file.
1 /* =========================================================================
2 Copyright (c) 2010-2016, Institute for Microelectronics,
3 Institute for Analysis and Scientific Computing,
4 TU Wien.
5 Portions of this software are copyright by UChicago Argonne, LLC.
6
7 -----------------
8 ViennaCL - The Vienna Computing Library
9 -----------------
10
11 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
12
13 (A list of authors and contributors can be found in the PDF manual)
14
15 License: MIT (X11), see file LICENSE in the base directory
16 ============================================================================= */
17
28 #ifndef VIENNACL_WITH_OPENCL
29 #define VIENNACL_WITH_OPENCL
30 #endif
31
32 // include necessary system headers
33 #include <iostream>
34
35 //include basic scalar and vector types of ViennaCL
36 #include "viennacl/scalar.hpp"
37 #include "viennacl/vector.hpp"
38 #include "viennacl/matrix.hpp"
39
40 #include "viennacl/ocl/device.hpp"
41 #include "viennacl/ocl/platform.hpp"
42 #include "viennacl/ocl/backend.hpp"
43
44 //include the generic inner product functions of ViennaCL
45 #include "viennacl/linalg/norm_2.hpp"
46
47
48 #include <boost/thread.hpp>
49
50
55 template<typename NumericT>
56 class worker
57 {
58 public:
59 worker(std::size_t tid) : thread_id_(tid) {}
60
61 void operator()()
62 {
63 std::size_t N = 6;
64
65 viennacl::context ctx(viennacl::ocl::get_context(static_cast<long>(thread_id_)));
66 viennacl::vector<NumericT> u = viennacl::scalar_vector<NumericT>(N, NumericT(1) * NumericT(thread_id_ + 1), ctx);
67 viennacl::vector<NumericT> v = viennacl::scalar_vector<NumericT>(N, NumericT(2) * NumericT(thread_id_ + 1), ctx);
68 viennacl::matrix<NumericT> A = viennacl::linalg::outer_prod(u, v);
69 viennacl::vector<NumericT> x(u);
70
71 u += v;
72 NumericT result = viennacl::linalg::norm_2(u);
73
74 std::stringstream ss;
75 ss << "Result of thread " << thread_id_ << " on device " << viennacl::ocl::get_context(static_cast<long>(thread_id_)).devices()[0].name() << ": " << result << std::endl;
76 ss << " A: " << A << std::endl;
77 ss << " x: " << x << std::endl;
78 message_ = ss.str();
79 }
80
81 std::string message() const { return message_; }
82
83 private:
84 std::string message_;
85 std::size_t thread_id_;
86 };
87
91 int main()
92 {
93 // Change this type definition to double if your gpu supports that
94 typedef float ScalarType;
95
96 if (viennacl::ocl::get_platforms().size() == 0)
97 {
98 std::cerr << "Error: No platform found!" << std::endl;
99 return EXIT_FAILURE;
100 }
101
105 viennacl::ocl::platform pf = viennacl::ocl::get_platforms()[0];
106 std::vector<viennacl::ocl::device> const & devices = pf.devices();
107
108 // Set first device to first context:
109 viennacl::ocl::setup_context(0, devices[0]);
110
111 // Set second device for second context (use the same device for the second context if only one device available):
112 if (devices.size() > 1)
113 viennacl::ocl::setup_context(1, devices[1]);
114 else
115 viennacl::ocl::setup_context(1, devices[0]);
116
121 worker<ScalarType> work_functor0(0);
122 worker<ScalarType> work_functor1(1);
123 boost::thread worker_thread_0(boost::ref(work_functor0));
124 boost::thread worker_thread_1(boost::ref(work_functor1));
125
126 worker_thread_0.join();
127 worker_thread_1.join();
128
129 std::cout << work_functor0.message() << std::endl;
130 std::cout << work_functor1.message() << std::endl;
131
135 std::cout << "!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!" << std::endl;
136
137 return EXIT_SUCCESS;
138 }
139
viennacl::linalg::norm_2
T norm_2(std::vector< T, A > const &v1)
Definition: norm_2.hpp:96
viennacl::ocl::get_platforms
std::vector< platform > get_platforms()
Definition: platform.hpp:124
norm_2.hpp
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
device.hpp
Represents an OpenCL device within ViennaCL.
platform.hpp
Implements a OpenCL platform within ViennaCL.
viennacl::ocl::platform
Wrapper class for an OpenCL platform.
Definition: platform.hpp:45
matrix.hpp
Implementation of the dense matrix class.
main
int main()
Definition: bisect.cpp:91
viennacl::ocl::platform::devices
std::vector< device > devices(cl_device_type dtype=CL_DEVICE_TYPE_DEFAULT)
Returns the available devices of the supplied device type.
Definition: platform.hpp:91
viennacl::matrix< NumericT >
NumericT
float NumericT
Definition: bisect.cpp:40
viennacl::context
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Definition: context.hpp:39
viennacl::traits::size
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:239
viennacl::vector< NumericT >
backend.hpp
Implementations of the OpenCL backend, where all contexts are stored in.
viennacl::linalg::outer_prod
viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > outer_prod(const vector_base< NumericT > &vec1, const vector_base< NumericT > &vec2)
Returns a proxy class for the operation mat += vec1 * vec2^T, i.e. a rank 1 update.
Definition: matrix_operations.hpp:840
vector.hpp
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
viennacl::scalar_vector
Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initial...
Definition: vector_def.hpp:87
ScalarType
float ScalarType
Definition: fft_1d.cpp:42
viennacl::ocl::get_context
viennacl::ocl::context & get_context(long i)
Convenience function for returning the current context.
Definition: backend.hpp:225
viennacl::ocl::context::devices
std::vector< viennacl::ocl::device > const & devices() const
Returns a vector with all devices in this context.
Definition: context.hpp:106
scalar.hpp
Implementation of the ViennaCL scalar class.
viennacl::ocl::setup_context
void setup_context(long i, std::vector< cl_device_id > const &devices)
Convenience function for setting devices for a context.
Definition: backend.hpp:231