A class representing the MapOverlap skeleton. More...

#include <mapoverlap.h>

Collaboration diagram for skepu::MapOverlap< MapOverlapFunc >:

Public Member Functions
	MapOverlap (MapOverlapFunc *mapOverlapFunc)
	~MapOverlap ()
template<typename T >
void	operator() (Vector< T > &input, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator >
void	operator() (InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	operator() (Vector< T > &input, Vector< T > &output, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator , typename OutputIterator >
void	operator() (InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	CPU (Vector< T > &input, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator >
void	CPU (InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	CPU (Vector< T > &input, Vector< T > &output, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator , typename OutputIterator >
void	CPU (InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	OMP (Vector< T > &input, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator >
void	OMP (InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	OMP (Vector< T > &input, Vector< T > &output, EdgePolicy poly=CONSTANT, T pad=T())
template<typename InputIterator , typename OutputIterator >
void	OMP (InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type())
template<typename T >
void	CU (Vector< T > &input, EdgePolicy poly=CONSTANT, T pad=T(), int useNumGPU=1)
template<typename InputIterator >
void	CU (InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type(), int useNumGPU=1)
template<typename T >
void	CU (Vector< T > &input, Vector< T > &output, EdgePolicy poly=CONSTANT, T pad=T(), int useNumGPU=1)
template<typename InputIterator , typename OutputIterator >
void	CU (InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type(), int useNumGPU=1)
template<typename T >
void	CL (Vector< T > &input, EdgePolicy poly=CONSTANT, T pad=T(), int useNumGPU=1)
template<typename InputIterator >
void	CL (InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type(), int useNumGPU=1)
template<typename T >
void	CL (Vector< T > &input, Vector< T > &output, EdgePolicy poly=CONSTANT, T pad=T(), int useNumGPU=1)
template<typename InputIterator , typename OutputIterator >
void	CL (InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly=CONSTANT, typename InputIterator::value_type pad=typename InputIterator::value_type(), int useNumGPU=1)

Detailed Description

template<typename MapOverlapFunc>
class skepu::MapOverlap< MapOverlapFunc >

A class representing the MapOverlap skeleton.

Author:: Johan Enmyren

Version:: 0.6

This class defines the MapOverlap skeleton which is similar to a Map, but each element of the result vector is a function of several adjacent elements of one input vector that reside at a certain constant maximum distance from each other. Once instantiated, it is meant to be used as a function and therefore overloading operator(). There are a few overloaded variants of this operator depending on if a seperate output vector is provided or if vectors or iterators are used as parameters.

If a certain backend is to be used, functions with the same interface as operator() but by the names CPU, CU, CL, OMP exists for CPU, CUDA, OpenCL and OpenMP respectively.

The MapOverlap skeleton also includes a pointer to an Environment which includes the devices available to execute on.

Constructor & Destructor Documentation

template<typename MapOverlapFunc >

skepu::MapOverlap< MapOverlapFunc >::MapOverlap ( MapOverlapFunc * mapOverlapFunc )

When creating an instance of the MapOverlap skeleton, a pointer to an overlap user function must be provided. Also the environment is set and if SKEPU_OPENCL is defined, the appropriate OpenCL program and kernel are created. Also creates a default execution plan which the skeleton will use if no other is specified.

Parameters:

mapOverlapFunc

A pointer to a valid overlap user function. Will be deleted in the destructor.

template<typename MapOverlapFunc >

skepu::MapOverlap< MapOverlapFunc >::~MapOverlap ( )

When the MapOverlap skeleton is destroyed, it deletes the user function it was created with.

Member Function Documentation

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CL	(	Vector< T > &	input,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a whole Vector. With itself as output. A wrapper for CL(InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly, typename InputIterator::value_type pad, int useNumGPU). Using CUDA as backend.

Parameters:

	input	A vector which the mapping will be performed on. It will be overwritten with the result.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), and skepu::Vector< T >::end().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CL	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a range of elements. With the same range as output. Since a seperate output is needed, a temporary output vector is created and copied to the input vector at the end. This is rather inefficient and the two functions using a seperated output explicitly should be used instead. Using CUDA as backend.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::Vector< T >::clear(), and skepu::Vector< T >::resize().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CL	(	Vector< T > &	input,
		Vector< T > &	output,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a whole Vector. With a seperate output vector. Wrapper for CL(InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly, typename InputIterator::value_type pad, int useNumGPU). Using OpenCL as backend.

Parameters:

	input	A vector which the mapping will be performed on.
	output	The result vector, will be overwritten with the result and resized if needed.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::Vector< T >::clear(), skepu::Vector< T >::end(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator , typename OutputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CL	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		OutputIterator	outputBegin,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a range of elements. With a seperate output range. The function decides whether to perform the MapOverlap on one device, calling mapOverlapSingle_CL or on multiple devices, calling mapOverlapNumDevices_CL. Using OpenCL as backend.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	outputBegin	A Vector::iterator to the first element of the output range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

template<typename MapOverlapFunc >

template<typename InputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CPU	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements on the CPU with the same range as output. Since a seperate output is needed, a temporary output vector is created and copied to the input vector at the end. This is rather inefficient and the two functions using a seperated output explicitly should be used instead.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::MapOverlap< MapOverlapFunc >::CPU(), and skepu::Vector< T >::resize().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CPU	(	Vector< T > &	input,
		Vector< T > &	output,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector on the CPU with a seperate output vector. Wrapper for CPU(InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly, typename InputIterator::value_type pad).

Parameters:

	input	A vector which the mapping will be performed on.
	output	The result vector, will be overwritten with the result and resized if needed.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::MapOverlap< MapOverlapFunc >::CPU(), skepu::Vector< T >::end(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator , typename OutputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CPU	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		OutputIterator	outputBegin,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements on the CPU with a seperate output range.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	outputBegin	A Vector::iterator to the first element of the output range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CPU	(	Vector< T > &	input,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector on the CPU with itself as output. A wrapper for CPU(InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly, typename InputIterator::value_type pad).

Parameters:

	input	A vector which the mapping will be performed on. It will be overwritten with the result.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), and skepu::Vector< T >::end().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CU	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a range of elements. With the same range as output. Since a seperate output is needed, a temporary output vector is created and copied to the input vector at the end. This is rather inefficient and the two functions using a seperated output explicitly should be used instead. Using CUDA as backend.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::MapOverlap< MapOverlapFunc >::CU(), and skepu::Vector< T >::resize().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CU	(	Vector< T > &	input,
		Vector< T > &	output,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a whole Vector. With a seperate output vector. Wrapper for CU(InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly, typename InputIterator::value_type pad, int useNumGPU). Using CUDA as backend.

Parameters:

	input	A vector which the mapping will be performed on.
	output	The result vector, will be overwritten with the result and resized if needed.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::MapOverlap< MapOverlapFunc >::CU(), skepu::Vector< T >::end(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator , typename OutputIterator >

void skepu::MapOverlap< MapOverlapFunc >::CU	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		OutputIterator	outputBegin,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a range of elements. With a seperate output range. Decides whether to use one device and mapOverlapSingleThread_CU or multiple devices and create new threads which calls mapOverlapThreadFunc_CU. In the case of several devices the input range is divided evenly among the threads created. Using CUDA as backend.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	outputBegin	A Vector::iterator to the first element of the output range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Threads::fork(), and skepu::Threads::join().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::CU	(	Vector< T > &	input,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`,
		int	useNumGPU = `1`
	)

Performs the MapOverlap on a whole Vector. With itself as output. A wrapper for CU(InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly, typename InputIterator::value_type pad, int useNumGPU). Using CUDA as backend.

Parameters:

	input	A vector which the mapping will be performed on. It will be overwritten with the result.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.
	useNumGPU	Integer specifying how many devices to use. 0 = Implementation decides.

References skepu::Vector< T >::begin(), and skepu::Vector< T >::end().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::OMP	(	Vector< T > &	input,
		Vector< T > &	output,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector using OpenMP as backend and a seperate output vector. Wrapper for OMP(InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, EdgePolicy poly, typename InputIterator::value_type pad).

Parameters:

	input	A vector which the mapping will be performed on.
	output	The result vector, will be overwritten with the result and resized if needed.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::Vector< T >::end(), skepu::MapOverlap< MapOverlapFunc >::OMP(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator , typename OutputIterator >

void skepu::MapOverlap< MapOverlapFunc >::OMP	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		OutputIterator	outputBegin,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements using OpenMP as backend and a seperate output range.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	outputBegin	A Vector::iterator to the first element of the output range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::OMP	(	Vector< T > &	input,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector using OpenMP as backend and itself as output. A wrapper for OMP(InputIterator inputBegin, InputIterator inputEnd, EdgePolicy poly, typename InputIterator::value_type pad).

Parameters:

	input	A vector which the mapping will be performed on. It will be overwritten with the result.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), and skepu::Vector< T >::end().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator >

void skepu::MapOverlap< MapOverlapFunc >::OMP	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements using OpenMP as backend and the same range as output. Since a seperate output is needed, a temporary output vector is created and copied to the input vector at the end. This is rather inefficient and the two functions using a seperated output explicitly should be used instead.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::Vector< T >::begin(), skepu::Vector< T >::clear(), skepu::MapOverlap< MapOverlapFunc >::OMP(), and skepu::Vector< T >::resize().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::operator()	(	Vector< T > &	input,
		Vector< T > &	output,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector. With a seperate Vector as output.

Depending on which backend was used, different versions of the skeleton is called. If SKEPU_CUDA is defined, the CUDA backend is used, similarly if SKEPU_OPENCL or SKEPU_OPENMP are defined then the OpenCL or OpenMP backend is used. As a fallback there is always a CPU version.

Parameters:

	input	A vector which the mapping will be performed on.
	output	The result vector, will be overwritten with the result and resized if needed.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::MapOverlap< MapOverlapFunc >::CPU(), skepu::MapOverlap< MapOverlapFunc >::CU(), skepu::MapOverlap< MapOverlapFunc >::OMP(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename T >

void skepu::MapOverlap< MapOverlapFunc >::operator()	(	Vector< T > &	input,
		EdgePolicy	poly = `CONSTANT`,
		T	pad = `T()`
	)

Performs the MapOverlap on a whole Vector. With itself as output.

Depending on which backend was used, different versions of the skeleton is called. If SKEPU_CUDA is defined, the CUDA backend is used, similarly if SKEPU_OPENCL or SKEPU_OPENMP are defined then the OpenCL or OpenMP backend is used. As a fallback there is always a CPU version.

Parameters:

	input	A vector which the mapping will be performed on. It will be overwritten with the result.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::MapOverlap< MapOverlapFunc >::CPU(), skepu::MapOverlap< MapOverlapFunc >::CU(), skepu::MapOverlap< MapOverlapFunc >::OMP(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator >

void skepu::MapOverlap< MapOverlapFunc >::operator()	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements. With the same range as output.

Depending on which backend was used, different versions of the skeleton is called. If SKEPU_CUDA is defined, the CUDA backend is used, similarly if SKEPU_OPENCL or SKEPU_OPENMP are defined then the OpenCL or OpenMP backend is used. As a fallback there is always a CPU version.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::MapOverlap< MapOverlapFunc >::CPU(), skepu::MapOverlap< MapOverlapFunc >::CU(), and skepu::MapOverlap< MapOverlapFunc >::OMP().

Here is the call graph for this function:

template<typename MapOverlapFunc >

template<typename InputIterator , typename OutputIterator >

void skepu::MapOverlap< MapOverlapFunc >::operator()	(	InputIterator	inputBegin,
		InputIterator	inputEnd,
		OutputIterator	outputBegin,
		EdgePolicy	poly = `CONSTANT`,
		typename InputIterator::value_type	pad = `typename InputIterator::value_type()`
	)

Performs the MapOverlap on a range of elements. With a seperate output range.

Depending on which backend was used, different versions of the skeleton is called. If SKEPU_CUDA is defined, the CUDA backend is used, similarly if SKEPU_OPENCL or SKEPU_OPENMP are defined then the OpenCL or OpenMP backend is used. As a fallback there is always a CPU version.

Parameters:

	inputBegin	A Vector::iterator to the first element in the range.
	inputEnd	A Vector::iterator to the last element of the range.
	outputBegin	A Vector::iterator to the first element of the output range.
	poly	Edge policy for the calculation, either CONSTANT or CYCLIC.
	pad	If CONSTANT edge policy, this is the value to pad with.

References skepu::MapOverlap< MapOverlapFunc >::CL(), skepu::MapOverlap< MapOverlapFunc >::CPU(), skepu::MapOverlap< MapOverlapFunc >::CU(), and skepu::MapOverlap< MapOverlapFunc >::OMP().

Here is the call graph for this function:

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

include/skepu/mapoverlap.h
include/skepu/src/mapoverlap.inl
include/skepu/src/mapoverlap_cl.inl
include/skepu/src/mapoverlap_cpu.inl
include/skepu/src/mapoverlap_cu.inl
include/skepu/src/mapoverlap_omp.inl

skepu::MapOverlap< MapOverlapFunc > Class Template Reference [Skeletons]

Public Member Functions

Detailed Description

template<typename MapOverlapFunc> class skepu::MapOverlap< MapOverlapFunc >

Constructor & Destructor Documentation

Member Function Documentation

skepu::MapOverlap< MapOverlapFunc > Class Template Reference
[Skeletons]

template<typename MapOverlapFunc>
class skepu::MapOverlap< MapOverlapFunc >