diff options
Diffstat (limited to 'boost/compute/detail/device_ptr.hpp')
-rw-r--r-- | boost/compute/detail/device_ptr.hpp | 215 |
1 files changed, 215 insertions, 0 deletions
diff --git a/boost/compute/detail/device_ptr.hpp b/boost/compute/detail/device_ptr.hpp new file mode 100644 index 0000000000..29ecd13631 --- /dev/null +++ b/boost/compute/detail/device_ptr.hpp @@ -0,0 +1,215 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// 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 +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef BOOST_COMPUTE_DEVICE_PTR_HPP +#define BOOST_COMPUTE_DEVICE_PTR_HPP + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/buffer.hpp> +#include <boost/compute/config.hpp> +#include <boost/compute/detail/is_buffer_iterator.hpp> +#include <boost/compute/detail/read_write_single_value.hpp> +#include <boost/compute/type_traits/is_device_iterator.hpp> + +namespace boost { +namespace compute { +namespace detail { + +template<class T, class IndexExpr> +struct device_ptr_index_expr +{ + typedef T result_type; + + device_ptr_index_expr(const buffer &buffer, + uint_ index, + const IndexExpr &expr) + : m_buffer(buffer), + m_index(index), + m_expr(expr) + { + } + + operator T() const + { + BOOST_STATIC_ASSERT_MSG(boost::is_integral<IndexExpr>::value, + "Index expression must be integral"); + + BOOST_ASSERT(m_buffer.get()); + + const context &context = m_buffer.get_context(); + const device &device = context.get_device(); + command_queue queue(context, device); + + return detail::read_single_value<T>(m_buffer, m_expr, queue); + } + + const buffer &m_buffer; + uint_ m_index; + IndexExpr m_expr; +}; + +template<class T> +class device_ptr +{ +public: + typedef T value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + typedef T* pointer; + typedef T& reference; + + device_ptr() + : m_index(0) + { + } + + device_ptr(const buffer &buffer, size_t index = 0) + : m_buffer(buffer.get(), false), + m_index(index) + { + } + + device_ptr(const device_ptr<T> &other) + : m_buffer(other.m_buffer.get(), false), + m_index(other.m_index) + { + } + + device_ptr<T>& operator=(const device_ptr<T> &other) + { + if(this != &other){ + m_buffer.get() = other.m_buffer.get(); + m_index = other.m_index; + } + + return *this; + } + + #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES + device_ptr(device_ptr<T>&& other) BOOST_NOEXCEPT + : m_buffer(other.m_buffer.get(), false), + m_index(other.m_index) + { + other.m_buffer.get() = 0; + } + + device_ptr<T>& operator=(device_ptr<T>&& other) BOOST_NOEXCEPT + { + m_buffer.get() = other.m_buffer.get(); + m_index = other.m_index; + + other.m_buffer.get() = 0; + + return *this; + } + #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES + + ~device_ptr() + { + // set buffer to null so that its reference count will + // not be decremented when its destructor is called + m_buffer.get() = 0; + } + + size_type get_index() const + { + return m_index; + } + + const buffer& get_buffer() const + { + return m_buffer; + } + + template<class OT> + device_ptr<OT> cast() const + { + return device_ptr<OT>(m_buffer, m_index); + } + + device_ptr<T> operator+(difference_type n) const + { + return device_ptr<T>(m_buffer, m_index + n); + } + + device_ptr<T> operator+(const device_ptr<T> &other) const + { + return device_ptr<T>(m_buffer, m_index + other.m_index); + } + + device_ptr<T>& operator+=(difference_type n) + { + m_index += static_cast<size_t>(n); + return *this; + } + + difference_type operator-(const device_ptr<T> &other) const + { + return static_cast<difference_type>(m_index - other.m_index); + } + + device_ptr<T>& operator-=(difference_type n) + { + m_index -= n; + return *this; + } + + bool operator==(const device_ptr<T> &other) const + { + return m_buffer.get() == other.m_buffer.get() && + m_index == other.m_index; + } + + bool operator!=(const device_ptr<T> &other) const + { + return !(*this == other); + } + + template<class Expr> + detail::device_ptr_index_expr<T, Expr> + operator[](const Expr &expr) const + { + BOOST_ASSERT(m_buffer.get()); + + return detail::device_ptr_index_expr<T, Expr>(m_buffer, + uint_(m_index), + expr); + } + +private: + const buffer m_buffer; + size_t m_index; +}; + +// is_buffer_iterator specialization for device_ptr +template<class Iterator> +struct is_buffer_iterator< + Iterator, + typename boost::enable_if< + boost::is_same< + device_ptr<typename Iterator::value_type>, + typename boost::remove_const<Iterator>::type + > + >::type +> : public boost::true_type {}; + +} // end detail namespace + +// is_device_iterator specialization for device_ptr +template<class T> +struct is_device_iterator<detail::device_ptr<T> > : boost::true_type {}; + +} // end compute namespace +} // end boost namespace + +#endif // BOOST_COMPUTE_DEVICE_PTR_HPP |