A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!! More...

#include <vector.hpp>

Inheritance diagram for const_vector_iterator< SCALARTYPE, ALIGNMENT >:

Public Types
typedef scalar< SCALARTYPE >	value_type
typedef long	difference_type
Public Member Functions
	const_vector_iterator ()
	const_vector_iterator (vector< SCALARTYPE, ALIGNMENT > const &vec, cl_uint index)
	Constructor.
	const_vector_iterator (viennacl::ocl::handle< cl_mem > const &elements, cl_uint index)
value_type	operator* (void) const
self_type	operator++ (void)
self_type	operator++ (int)
bool	operator== (self_type const &other) const
bool	operator!= (self_type const &other) const
difference_type	operator- (self_type const &other) const
self_type	operator+ (difference_type diff) const
std::size_t	index () const
viennacl::ocl::handle< cl_mem > const &	handle () const
Protected Attributes
viennacl::ocl::handle< cl_mem >	elements_
	The index of the entry the iterator is currently pointing to.
std::size_t	index_

Detailed Description

template<class SCALARTYPE, unsigned int ALIGNMENT>
class viennacl::const_vector_iterator< SCALARTYPE, ALIGNMENT >

A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!!

Every dereference operation initiates a transfer from the GPU to the CPU. The overhead of such a transfer is around 50us, so 20.000 dereferences take one second. This is four orders of magnitude slower than similar dereferences on the CPU. However, increments and comparisons of iterators is as fast as for CPU types. If you need a fast iterator, copy the whole vector to the CPU first and iterate over the CPU object, e.g. std::vector<float> temp; copy(gpu_vector, temp); for (std::vector<float>::const_iterator iter = temp.begin(); iter != temp.end(); ++iter) { //do something } Note that you may obtain inconsistent data if entries of gpu_vector are manipulated elsewhere in the meanwhile.

Template Parameters:

	SCALARTYPE	The underlying floating point type (either float or double)
	ALIGNMENT	Alignment of the underlying vector,

See also:: vector

Member Typedef Documentation

typedef long difference_type

typedef scalar<SCALARTYPE> value_type

Constructor & Destructor Documentation

const_vector_iterator ( ) [inline]

const_vector_iterator	(	vector< SCALARTYPE, ALIGNMENT > const &	vec,
		cl_uint	index
	)			`[inline]`

Constructor.

Parameters:

	vec	The vector over which to iterate
	index	The starting index of the iterator

const_vector_iterator	(	viennacl::ocl::handle< cl_mem > const &	elements,
		cl_uint	index
	)			`[inline]`

Member Function Documentation

viennacl::ocl::handle<cl_mem> const& handle ( ) const [inline]

std::size_t index ( ) const [inline]

bool operator!= ( self_type const & other ) const [inline]

value_type operator* ( void ) const [inline]

self_type operator+ ( difference_type diff ) const [inline]

self_type operator++ ( void ) [inline]

self_type operator++ ( int ) [inline]

difference_type operator- ( self_type const & other ) const [inline]

bool operator== ( self_type const & other ) const [inline]

Field Documentation

viennacl::ocl::handle<cl_mem> elements_ [protected]

The index of the entry the iterator is currently pointing to.

std::size_t index_ [protected]

The documentation for this class was generated from the following file:

/data/development/ViennaCL/dev/viennacl/vector.hpp

const_vector_iterator< SCALARTYPE, ALIGNMENT > Class Template Reference

Public Types

Public Member Functions