boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/ublas/opencl/elementwise.hpp

@@ -0,0 +1,508 @@
+// Boost.uBLAS
+//
+// Copyright (c) 2018 Fady Essam
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_elementwise_hpp_
+#define boost_numeric_ublas_opencl_elementwise_hpp_
+
+#include <boost/numeric/ublas/opencl/library.hpp>
+#include <boost/numeric/ublas/opencl/vector.hpp>
+#include <boost/numeric/ublas/opencl/matrix.hpp>
+
+namespace boost { namespace numeric { namespace ublas { namespace opencl {
+
+namespace compute = boost::compute;
+namespace lambda = boost::compute::lambda;
+
+template <typename T, typename L1, typename L2, typename L3, class O>
+void element_wise(ublas::matrix<T, L1, opencl::storage> const &a,
+		  ublas::matrix<T, L2, opencl::storage> const &b,
+		  ublas::matrix<T, L3, opencl::storage> &result,
+		  O op, compute::command_queue& queue)
+{
+  assert(a.device() == b.device() &&
+	 a.device() == result.device() &&
+	 a.device() == queue.get_device());
+  assert(a.size1() == b.size1() && a.size2() == b.size2());
+
+  compute::transform(a.begin(),
+		     a.end(),
+		     b.begin(),
+		     result.begin(),
+		     op,
+		     queue);
+  queue.finish();
+}
+
+template <typename T, typename L1, typename L2, typename L3, typename A, class O>
+void element_wise(ublas::matrix<T, L1, A> const &a,
+		  ublas::matrix<T, L2, A> const &b,
+		  ublas::matrix<T, L3, A> &result,
+		  O op,
+		  compute::command_queue &queue)
+{
+  ublas::matrix<T, L1, opencl::storage> adev(a, queue);
+  ublas::matrix<T, L2, opencl::storage> bdev(b, queue);
+  ublas::matrix<T, L3, opencl::storage> rdev(a.size1(), b.size2(), queue.get_context());
+  element_wise(adev, bdev, rdev, op, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename L1, typename L2, typename A, typename O>
+ublas::matrix<T, L1, A> element_wise(ublas::matrix<T, L1, A> const &a,
+				     ublas::matrix<T, L2, A> const &b,
+				     O op,
+				     compute::command_queue &queue)
+{
+  ublas::matrix<T, L1, A> result(a.size1(), b.size2());
+  element_wise(a, b, result, op, queue);
+  return result;
+}
+
+template <typename T, typename O>
+void element_wise(ublas::vector<T, opencl::storage> const &a,
+		  ublas::vector<T, opencl::storage> const &b,
+		  ublas::vector<T, opencl::storage> &result,
+		  O op,
+		  compute::command_queue& queue)
+{
+  assert(a.device() == b.device() &&
+	 a.device() == result.device() &&
+	 a.device() == queue.get_device());
+  assert(a.size() == b.size());
+  compute::transform(a.begin(),
+		     a.end(),
+		     b.begin(),
+		     result.begin(),
+		     op,
+		     queue);
+  queue.finish();
+}
+
+template <typename T, typename A, typename O>
+void element_wise(ublas::vector<T, A> const &a,
+		  ublas::vector<T, A> const &b,
+		  ublas::vector<T, A>& result,
+		  O op,
+		  compute::command_queue &queue)
+{
+  ublas::vector<T, opencl::storage> adev(a, queue);
+  ublas::vector<T, opencl::storage> bdev(b, queue);
+  ublas::vector<T, opencl::storage> rdev(a.size(), queue.get_context());
+  element_wise(adev, bdev, rdev, op, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename A, typename O>
+ublas::vector<T, A> element_wise(ublas::vector<T, A> const &a,
+				 ublas::vector<T, A> const &b,
+				 O op,
+				 compute::command_queue &queue)
+{
+  ublas::vector<T, A> result(a.size());
+  element_wise(a, b, result, op, queue);
+  return result;
+}
+
+template <typename T, typename L1, typename L2, typename L3>
+void element_add(ublas::matrix<T, L1, opencl::storage> const &a,
+		 ublas::matrix<T, L2, opencl::storage> const &b,
+		 ublas::matrix<T, L3, opencl::storage> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::plus<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename L3, typename A>
+void element_add(ublas::matrix<T, L1, A> const &a,
+		 ublas::matrix<T, L2, A> const &b,
+		 ublas::matrix<T, L3, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::plus<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename A>
+ublas::matrix<T, L1, A> element_add(ublas::matrix<T, L1, A> const &a,
+				    ublas::matrix<T, L2, A> const &b,
+				    compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::plus<T>(), queue);
+}
+
+template <typename T>
+void element_add(ublas::vector<T, opencl::storage> const &a,
+		 ublas::vector<T, opencl::storage> const &b,
+		 ublas::vector<T, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::plus<T>(), queue);
+}
+
+template <typename T, typename A>
+void element_add(ublas::vector<T, A> const &a,
+		 ublas::vector<T, A> const &b,
+		 ublas::vector<T, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::plus<T>(), queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_add(ublas::vector<T, A> const &a,
+				ublas::vector<T, A> const &b,
+				compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::plus<T>(), queue);
+}
+
+template<typename T, typename L>
+void element_add(ublas::matrix<T, L, opencl::storage> const &m, T value,
+		 ublas::matrix<T, L, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  assert(m.device() == result.device() && m.device() == queue.get_device());
+  assert(m.size1() == result.size1() && m.size2() == result.size2());
+  compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 + value, queue);
+  queue.finish();
+}
+
+template<typename T, typename L, typename A>
+void element_add(ublas::matrix<T, L, A> const &m, T value,
+		 ublas::matrix<T, L, A> &result,
+		 compute::command_queue& queue)
+{
+  ublas::matrix<T, L, opencl::storage> mdev(m, queue);
+  ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
+  element_add(mdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template<typename T, typename L, typename A>
+ublas::matrix<T, L, A> element_add(ublas::matrix<T, L, A> const &m, T value,
+				   compute::command_queue& queue)
+{
+  ublas::matrix<T, L, A> result(m.size1(), m.size2());
+  element_add(m, value, result, queue);
+  return result;
+}
+
+template<typename T>
+void element_add(ublas::vector<T, opencl::storage> const &v, T value,
+		 ublas::vector<T, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  assert(v.device() == result.device() && v.device() == queue.get_device());
+  assert(v.size() == result.size());
+  compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 + value, queue);
+  queue.finish();
+}
+
+template<typename T, typename A>
+void element_add(ublas::vector<T, A> const &v, T value,
+		 ublas::vector<T, A> &result,
+		 compute::command_queue& queue)
+{
+  ublas::vector<T, opencl::storage> vdev(v, queue);
+  ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
+  element_add(vdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_add(ublas::vector<T, A> const &v, T value,
+				compute::command_queue& queue)
+{
+  ublas::vector<T, A> result(v.size());
+  element_add(v, value, result, queue);
+  return result;
+}
+
+template <typename T, typename L1, typename L2, typename L3>
+void element_sub(ublas::matrix<T, L1, opencl::storage> const &a,
+		 ublas::matrix<T, L2, opencl::storage> const &b,
+		 ublas::matrix<T, L3, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  element_wise(a, b, compute::minus<T>(), result, queue);
+}
+
+template <typename T, typename L1, typename L2, typename L3, typename A>
+void element_sub(ublas::matrix<T, L1, A> const &a,
+		 ublas::matrix<T, L2, A> const &b,
+		 ublas::matrix<T, L3, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::minus<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename A>
+ublas::matrix<T, L1, A> element_sub(ublas::matrix<T, L1, A> const &a,
+				    ublas::matrix<T, L2, A> const &b,
+				    compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::minus<T>(), queue);
+}
+
+template <typename T>
+void element_sub(ublas::vector<T, opencl::storage> const &a,
+		 ublas::vector<T, opencl::storage> const &b,
+		 ublas::vector<T, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::minus<T>(), queue);
+}
+
+template <typename T, typename A>
+void element_sub(ublas::vector<T, A> const &a,
+		 ublas::vector<T, A> const &b,
+		 ublas::vector<T, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::minus<T>(), queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_sub(ublas::vector<T, A> const &a,
+				ublas::vector<T, A> const &b,
+				compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::minus<T>(), queue);
+}
+
+template <typename T, typename L>
+void element_sub(ublas::matrix<T, L, opencl::storage> const &m, T value,
+		 ublas::matrix<T, L, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  assert(m.device() == result.device() && m.device() == queue.get_device());
+  assert(m.size1() == result.size1() && m.size2() == result.size2());
+  compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 - value, queue);
+  queue.finish();
+}
+
+template <typename T, typename L, typename A>
+void element_sub(ublas::matrix<T, L, A> const &m, T value,
+		 ublas::matrix<T, L, A> &result,
+		 compute::command_queue& queue)
+{
+  ublas::matrix<T, L, opencl::storage> mdev(m, queue);
+  ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
+  element_sub(mdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename L, typename A>
+ublas::matrix<T, L, A> element_sub(ublas::matrix<T, L, A> const &m, T value,
+				   compute::command_queue& queue)
+{
+  ublas::matrix<T, L, A> result(m.size1(), m.size2());
+  element_sub(m, value, result, queue);
+  return result;
+}
+
+template <typename T>
+void element_sub(ublas::vector<T, opencl::storage> const &v, T value,
+		 ublas::vector<T, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  assert(v.device() == result.device() && v.device() == queue.get_device());
+  assert(v.size() == result.size());
+  compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 - value, queue);
+  queue.finish();
+}
+
+template <typename T, typename A>
+void element_sub(ublas::vector<T, A> const &v, T value,
+		 ublas::vector<T, A> &result,
+		 compute::command_queue& queue)
+{
+  ublas::vector<T, opencl::storage> vdev(v, queue);
+  ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
+  element_sub(vdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_sub(ublas::vector<T, A> const &v, T value,
+				compute::command_queue& queue)
+{
+  ublas::vector<T, A> result(v.size());
+  element_sub(v, value, result, queue);
+  return result;
+}
+
+template <typename T, typename L1, typename L2, typename L3>
+void element_prod(ublas::matrix<T, L1, opencl::storage> const &a,
+		  ublas::matrix<T, L2, opencl::storage> const &b,
+		  ublas::matrix<T, L3, opencl::storage> &result,
+		  compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::multiplies<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename L3, typename A>
+void element_prod(ublas::matrix<T, L1, A> const &a,
+		  ublas::matrix<T, L2, A> const &b,
+		  ublas::matrix<T, L3, A> &result,
+		  compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::multiplies<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename A>
+ublas::matrix<T, L1, A> element_prod(ublas::matrix<T, L1, A> const &a,
+				     ublas::matrix<T, L2, A> const &b,
+				     compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::multiplies<T>(), queue);
+}
+
+template <typename T>
+void element_prod(ublas::vector<T, opencl::storage> const &a,
+		  ublas::vector<T, opencl::storage> const &b,
+		  ublas::vector<T, opencl::storage> &result,
+		  compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::multiplies<T>(), queue);
+}
+
+template <typename T, typename A>
+void element_prod(ublas::vector<T, A> const &a,
+		  ublas::vector<T, A> const &b,
+		  ublas::vector<T, A> &result,
+		  compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::multiplies<T>(), queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_prod(ublas::vector<T, A> const &a,
+				 ublas::vector<T, A> const &b,
+				 compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::multiplies<T>(), queue);
+}
+
+template <typename T, typename L>
+void element_scale(ublas::matrix<T, L, opencl::storage> const &m, T value,
+		   ublas::matrix<T, L, opencl::storage> &result,
+		   compute::command_queue& queue)
+{
+  assert(m.device() == result.device() && m.device() == queue.get_device());
+  assert(m.size1() == result.size1() && m.size2() == result.size2());
+  compute::transform(m.begin(), m.end(), result.begin(), lambda::_1 * value, queue);
+  queue.finish();
+}
+
+template <typename T, typename L, typename A>
+void element_scale(ublas::matrix<T, L, A> const &m, T value,
+		   ublas::matrix<T, L, A> &result,
+		   compute::command_queue& queue)
+{
+  ublas::matrix<T, L, opencl::storage> mdev(m, queue);
+  ublas::matrix<T, L, opencl::storage> rdev(result.size1(), result.size2(), queue.get_context());
+  element_scale(mdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename L, typename A>
+ublas::matrix<T, L, A>  element_scale(ublas::matrix<T, L, A> const &m, T value,
+				      compute::command_queue& queue)
+{
+  ublas::matrix<T, L, A> result(m.size1(), m.size2());
+  element_scale(m, value, result, queue);
+  return result;
+}
+
+template <typename T>
+void element_scale(ublas::vector<T, opencl::storage> const &v, T value,
+		   ublas::vector<T, opencl::storage> &result,
+		   compute::command_queue& queue)
+{
+  assert(v.device() == result.device() && v.device() == queue.get_device());
+  assert(v.size() == result.size());
+  compute::transform(v.begin(), v.end(), result.begin(), lambda::_1 * value, queue);
+  queue.finish();
+}
+
+template <typename T, typename A>
+void element_scale(ublas::vector<T, A> const &v, T value,
+		   ublas::vector<T, A> & result,
+		   compute::command_queue& queue)
+{
+  ublas::vector<T, opencl::storage> vdev(v, queue);
+  ublas::vector<T, opencl::storage> rdev(v.size(), queue.get_context());
+  element_scale(vdev, value, rdev, queue);
+  rdev.to_host(result, queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T,A> element_scale(ublas::vector<T, A> const &v, T value,
+				 compute::command_queue& queue)
+{
+  ublas::vector<T, A> result(v.size());
+  element_scale(v, value, result, queue);
+  return result;
+}
+
+template <typename T, typename L1, typename L2, typename L3>
+void element_div(ublas::matrix<T, L1, opencl::storage> const &a,
+		 ublas::matrix<T, L2, opencl::storage> const &b,
+		 ublas::matrix<T, L3, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::divides<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename L3, typename A>
+void element_div(ublas::matrix<T, L1, A> const &a,
+		 ublas::matrix<T, L2, A> const &b,
+		 ublas::matrix<T, L3, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::divides<T>(), queue);
+}
+
+template <typename T, typename L1, typename L2, typename A>
+ublas::matrix<T, L1, A> element_div(ublas::matrix<T, L1, A> const &a,
+				    ublas::matrix<T, L2, A> const &b,
+				    compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::divides<T>(), queue);
+}
+
+template <typename T>
+void element_div(ublas::vector<T, opencl::storage> const &a,
+		 ublas::vector<T, opencl::storage> const &b,
+		 ublas::vector<T, opencl::storage> &result,
+		 compute::command_queue& queue)
+{
+  element_wise(a, b, result, compute::divides<T>(), queue);
+}
+
+template <typename T, typename A>
+void element_div(ublas::vector<T, A> const &a,
+		 ublas::vector<T, A> const &b,
+		 ublas::vector<T, A> &result,
+		 compute::command_queue &queue)
+{
+  element_wise(a, b, result, compute::divides<T>(), queue);
+}
+
+template <typename T, typename A>
+ublas::vector<T, A> element_div(ublas::vector<T, A> const &a,
+				ublas::vector<T, A> const &b,
+				compute::command_queue &queue)
+{
+  return element_wise(a, b, compute::divides<T>(), queue);
+}
+
+}}}}
+
+#endif 

package/boost/numeric/ublas/opencl/library.hpp

@@ -0,0 +1,38 @@
+// Boost.uBLAS
+//
+// Copyright (c) 2018 Fady Essam
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_library_hpp_
+#define boost_numeric_ublas_opencl_library_hpp_
+
+#include <clBLAS.h>
+#include <type_traits>
+#include <complex>
+
+namespace boost { namespace numeric { namespace ublas { namespace opencl {
+
+class library
+{
+public:
+  library() { clblasSetup();}
+  ~library() { clblasTeardown();}
+};
+
+template <typename T>
+struct is_numeric
+{
+  static bool const value =
+    std::is_same<T, float>::value |
+    std::is_same<T, double>::value |
+    std::is_same<T, std::complex<float>>::value |
+    std::is_same<T, std::complex<double>>::value;
+};
+	
+}}}}
+
+#endif

package/boost/numeric/ublas/opencl/matrix.hpp

@@ -0,0 +1,123 @@
+// Boost.uBLAS
+//
+// Copyright (c) 2018 Fady Essam
+// Copyright (c) 2018 Stefan Seefeld
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef boost_numeric_ublas_opencl_matrix_hpp_
+#define boost_numeric_ublas_opencl_matrix_hpp_
+
+#include <boost/numeric/ublas/opencl/library.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/functional.hpp>
+#include <boost/compute/core.hpp>
+#include <boost/compute/algorithm.hpp>
+#include <boost/compute/buffer.hpp>
+
+namespace boost { namespace numeric { namespace ublas { namespace opencl {
+
+class storage;
+
+namespace compute = boost::compute;
+
+} // namespace opencl
+	
+template<class T, class L>
+class matrix<T, L, opencl::storage> : public matrix_container<matrix<T, L, opencl::storage> >
+{
+  typedef typename boost::compute::buffer_allocator<T>::size_type size_type;
+  typedef L layout_type;
+  typedef matrix<T, L, opencl::storage> self_type;
+public:
+  matrix()
+    : matrix_container<self_type>(),
+      size1_(0), size2_(0), data_() , device_()
+  {}
+
+  matrix(size_type size1, size_type size2, compute::context c)
+    : matrix_container<self_type>(),
+      size1_(size1), size2_(size2), device_(c.get_device())
+  {
+    compute::buffer_allocator<T> allocator(c);
+    data_ = allocator.allocate(layout_type::storage_size(size1, size2)).get_buffer();
+  }
+
+  matrix(size_type size1, size_type size2, T const &value, compute::command_queue &q)
+    : matrix_container<self_type>(),
+      size1_(size1), size2_(size2), device_(q.get_device())
+  {
+    compute::buffer_allocator<T> allocator(q.get_context());
+    data_ = allocator.allocate(layout_type::storage_size(size1, size2)).get_buffer();
+    compute::fill(this->begin(), this->end(), value, q);
+    q.finish();
+  }
+
+  template <typename A>
+  matrix(matrix<T, L, A> const &m, compute::command_queue &queue)
+    : matrix(m.size1(), m.size2(), queue.get_context())
+  {
+    this->from_host(m, queue);
+  }
+  
+  size_type size1() const { return size1_;}
+  size_type size2() const { return size2_;}
+
+  const compute::buffer_iterator<T> begin() const { return compute::make_buffer_iterator<T>(data_);}
+  compute::buffer_iterator<T> begin() { return compute::make_buffer_iterator<T>(data_);}
+
+  compute::buffer_iterator<T> end() { return compute::make_buffer_iterator<T>(data_, layout_type::storage_size(size1_, size2_));}
+  const compute::buffer_iterator<T> end() const { return compute::make_buffer_iterator<T>(data_, layout_type::storage_size(size1_, size2_));}
+
+  const compute::device &device() const { return device_;}
+  compute::device &device() { return device_;}
+
+  void fill(T value, compute::command_queue &queue)
+  {
+    assert(device_ == queue.get_device());
+    compute::fill(this->begin(), this->end(), value, queue);
+    queue.finish();
+  }
+
+  /** Copies a matrix to a device
+  * \param m is a matrix that is not on the device _device and it is copied to it
+  * \param queue is the command queue that will execute the operation
+  */
+  template<class A>
+  void from_host(ublas::matrix<T, L, A> const &m, compute::command_queue &queue)
+  {
+    assert(device_ == queue.get_device());
+    compute::copy(m.data().begin(),
+		  m.data().end(),
+		  this->begin(),
+		  queue);
+    queue.finish();
+  }
+
+  /** Copies a matrix from a device
+  * \param m is a matrix that will be reized to (size1_,size2) and the values of (*this) will be copied in it
+  * \param queue is the command queue that will execute the operation
+  */
+  template<class A>
+  void to_host(ublas::matrix<T, L, A> &m, compute::command_queue &queue) const
+  {
+    assert(device_ == queue.get_device());
+    compute::copy(this->begin(),
+		  this->end(),
+		  m.data().begin(),
+		  queue);
+    queue.finish();
+  }
+
+private:
+  size_type size1_;
+  size_type size2_;
+  compute::buffer data_;
+  compute::device device_;
+};
+
+}}}
+
+#endif