ViennaCL - The Vienna Computing Library  1.6.1
Free open-source GPU-accelerated linear algebra and solver library.
multithreaded_cg.cpp
Go to the documentation of this file.
1 /* =========================================================================
2  Copyright (c) 2010-2014, 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 
25 #ifndef VIENNACL_WITH_OPENCL
26  #define VIENNACL_WITH_OPENCL
27 #endif
28 
29 // include necessary system headers
30 #include <iostream>
31 
32 //
33 // ublas includes
34 //
35 #include <boost/numeric/ublas/io.hpp>
36 #include <boost/numeric/ublas/triangular.hpp>
37 #include <boost/numeric/ublas/matrix_sparse.hpp>
38 #include <boost/numeric/ublas/matrix.hpp>
39 #include <boost/numeric/ublas/matrix_proxy.hpp>
40 #include <boost/numeric/ublas/operation.hpp>
41 #include <boost/numeric/ublas/operation_sparse.hpp>
42 #include <boost/numeric/ublas/io.hpp>
43 #include <boost/numeric/ublas/lu.hpp>
44 
45 // Must be set if you want to use ViennaCL algorithms on ublas objects
46 #define VIENNACL_WITH_UBLAS 1
47 
48 
49 //include basic scalar and vector types of ViennaCL
50 #include "viennacl/scalar.hpp"
51 #include "viennacl/vector.hpp"
54 
55 #include "viennacl/ocl/device.hpp"
57 #include "viennacl/ocl/backend.hpp"
58 
59 //include the generic inner product functions of ViennaCL
61 #include "viennacl/linalg/cg.hpp"
62 
63 // Some helper functions for this tutorial:
64 #include "Random.hpp"
65 #include "vector-io.hpp"
66 
67 using namespace boost::numeric;
68 
72 #include <boost/thread.hpp>
73 
78 template<typename NumericT>
79 class worker
80 {
81 public:
82  worker(std::size_t tid) : thread_id_(tid) {}
83 
87  void operator()()
88  {
92  ublas::vector<NumericT> rhs;
93  ublas::vector<NumericT> ref_result;
94  ublas::compressed_matrix<NumericT> ublas_matrix;
95 
99  if (!viennacl::io::read_matrix_market_file(ublas_matrix, "../examples/testdata/mat65k.mtx"))
100  {
101  std::cout << "Error reading Matrix file" << std::endl;
102  return;
103  }
104 
105  if (!readVectorFromFile("../examples/testdata/rhs65025.txt", rhs))
106  {
107  std::cout << "Error reading RHS file" << std::endl;
108  return;
109  }
110 
111  if (!readVectorFromFile("../examples/testdata/result65025.txt", ref_result))
112  {
113  std::cout << "Error reading Result file" << std::endl;
114  return;
115  }
116 
121  viennacl::context ctx(viennacl::ocl::get_context(static_cast<long>(thread_id_)));
122 
123  std::size_t vcl_size = rhs.size();
124  viennacl::compressed_matrix<NumericT> vcl_compressed_matrix(ctx);
125  viennacl::vector<NumericT> vcl_rhs(vcl_size, ctx);
126  viennacl::vector<NumericT> vcl_ref_result(vcl_size, ctx);
127 
128  viennacl::copy(rhs.begin(), rhs.end(), vcl_rhs.begin());
129  viennacl::copy(ref_result.begin(), ref_result.end(), vcl_ref_result.begin());
130 
131 
135  viennacl::copy(ublas_matrix, vcl_compressed_matrix);
136 
137  viennacl::vector<NumericT> vcl_result = viennacl::linalg::solve(vcl_compressed_matrix, vcl_rhs, viennacl::linalg::cg_tag());
138 
139  std::stringstream ss;
140  ss << "Result of thread " << thread_id_ << " on device " << viennacl::ocl::get_context(static_cast<long>(thread_id_)).devices()[0].name() << ": " << vcl_result[0] << ", should: " << ref_result[0] << std::endl;
141  message_ = ss.str();
142  }
143 
144  std::string message() const { return message_; }
145 
146 private:
147  std::string message_;
148  std::size_t thread_id_;
149 };
150 
154 int main()
155 {
156  //Change this type definition to double if your gpu supports that
157  typedef float ScalarType;
158 
159  if (viennacl::ocl::get_platforms().size() == 0)
160  {
161  std::cerr << "Error: No platform found!" << std::endl;
162  return EXIT_FAILURE;
163  }
164 
169  std::vector<viennacl::ocl::device> const & devices = pf.devices();
170 
171  // Set first device to first context:
172  viennacl::ocl::setup_context(0, devices[0]);
173 
174  // Set second device for second context (use the same device for the second context if only one device available):
175  if (devices.size() > 1)
176  viennacl::ocl::setup_context(1, devices[1]);
177  else
178  viennacl::ocl::setup_context(1, devices[0]);
179 
184  worker<ScalarType> work_functor0(0);
185  worker<ScalarType> work_functor1(1);
186  boost::thread worker_thread_0(boost::ref(work_functor0));
187  boost::thread worker_thread_1(boost::ref(work_functor1));
188 
189  worker_thread_0.join();
190  worker_thread_1.join();
191 
192  std::cout << work_functor0.message() << std::endl;
193  std::cout << work_functor1.message() << std::endl;
194 
198  std::cout << "!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!" << std::endl;
199 
200  return EXIT_SUCCESS;
201 }
202 
A reader and writer for the matrix market format is implemented here.
std::vector< platform > get_platforms()
Definition: platform.hpp:124
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
Represents an OpenCL device within ViennaCL.
Implements a OpenCL platform within ViennaCL.
Wrapper class for an OpenCL platform.
Definition: platform.hpp:45
int main()
Definition: bisect.cpp:160
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
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Definition: context.hpp:39
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:144
Implementation of the compressed_matrix class.
bool readVectorFromFile(const std::string &filename, VectorType &vec)
Definition: vector-io.hpp:104
The conjugate gradient method is implemented here.
Implementations of the OpenCL backend, where all contexts are stored in.
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
float ScalarType
Definition: fft_1d.cpp:42
A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve()...
Definition: cg.hpp:48
long read_matrix_market_file(MatrixT &mat, const char *file, long index_base=1)
Reads a sparse matrix from a file (MatrixMarket format)
viennacl::ocl::context & get_context(long i)
Convenience function for returning the current context.
Definition: backend.hpp:225
std::vector< viennacl::ocl::device > const & devices() const
Returns a vector with all devices in this context.
Definition: context.hpp:105
Implementation of the ViennaCL scalar class.
void setup_context(long i, std::vector< cl_device_id > const &devices)
Convenience function for setting devices for a context.
Definition: backend.hpp:231
viennacl::vector< NumericT > solve(MatrixT const &A, viennacl::vector_base< NumericT > const &rhs, bicgstab_tag const &tag, viennacl::linalg::no_precond)
Implementation of a pipelined stabilized Bi-conjugate gradient solver.
Definition: bicgstab.hpp:88