Public Member Functions

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

A class representing the MapOverlap skeleton. More...

#include <mapoverlap.h>

Collaboration diagram for skepu::MapOverlap< MapOverlapFunc >:
Collaboration graph
[legend]

List of all members.

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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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:
 All Classes Namespaces Files Functions Enumerations Friends Defines