SkePU(integratedwithStarPU) 0.8
Public Member Functions | Static Public Member Functions
skepu::Map< MapFunc, T, c_type, cont_type > Class Template Reference

A class representing the Map skeleton. More...

#include <map.h>

Inheritance diagram for skepu::Map< MapFunc, T, c_type, cont_type >:
Inheritance graph
[legend]
Collaboration diagram for skepu::Map< MapFunc, T, c_type, cont_type >:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 Map (MapFunc *mapFunc)
 Map (MapFunc *mapFunc, Vector< T > *input, Vector< T > *output, int parts=1)
 ~Map ()
void run_async ()
template<typename U >
void setConstant (U constant1)
void finishAll ()
void operator() (Vector< T > &input)
void operator() (Vector< T > &input, Vector< T > &output)
void operator() (Vector< T > &input, int parts)
void operator() (Vector< T > &input, Vector< T > &output, int parts)
void replaceText (std::string &text, std::string find, std::string replace)
void createOpenCLProgram ()

Static Public Member Functions

static void cpu_func (void *buffers[], void *arg)
static void omp_func (void *buffer[], void *arg)
static void cuda_func (void *buffer[], void *arg)
static void opencl_func (void *buffer[], void *arg)

Detailed Description

template<typename MapFunc, typename T, skepu::FuncType c_type = UNARY, skepu_container_type cont_type = VECTOR>
class skepu::Map< MapFunc, T, c_type, cont_type >

A class representing the Map skeleton.

This class defines the Map skeleton for unary user function and vector container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for binary user function and vector container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for ternary user function and vector container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for unary user function and matrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for binary user function and Matrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for ternary user function and matrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for unary user function and SparseMatrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for binary user function and SparseMatrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.

This class defines the Map skeleton for ternary user function and SparseMatrix container type, a calculation pattern where a user function is applied to each element of an input range. Once the Map object is instantiated, it is meant to be used as a function and therefore overloading operator().

It uses StarPU as a backend and choice between different backends can be controlled by using defines. SKEPU_OPENMP can be used to use OpenMP whose support is currently limited in StarPU, hence not recommended, SKEPU_CUDA will register CUDA backend along other defined (atleast CPU if nothing else is defined) SKEPU_OPENCL will register OpenCL backend along other defined (atleast CPU if nothing else is defined) CUDA_ONLY will eliminate all other backends (even CPU) and will force StarPU to use CUDA only. if no above macro is defined, it will use sequential CPU backend.


Constructor & Destructor Documentation

template<typename MapFunc, typename T , skepu::FuncType c_type, skepu_container_type cont_type>
skepu::Map< MapFunc, T, c_type, cont_type >::Map ( MapFunc *  mapFunc)

When creating an instance of the Map skeleton, for a unary user function and Vector container type. Also the environment is set and if SKEPU_OPENCL is defined, the appropriate OpenCL program is created.

Parameters:
mapFuncA pointer to a valid unary user function. Will be deleted in the destructor.

References skepu::Environment< T >::getInstance().

Here is the call graph for this function:

template<typename MapFunc, typename T, skepu::FuncType c_type, skepu_container_type cont_type>
skepu::Map< MapFunc, T, c_type, cont_type >::Map ( MapFunc *  mapFunc,
Vector< T > *  in,
Vector< T > *  out,
int  _parts = 1 
)

When creating an instance of the Map skeleton, for a unary user function and Vector container type. Also the environment is set and if SKEPU_OPENCL is defined, the appropriate OpenCL program is created. This constructor is used to assist in calling map skeleton in a task-parallel skeleton(e.g. farm) by implementing Task class "run_async()" method. The parameters for map call should be specified before e.g. using this constructor.

Parameters:
mapFuncA pointer to a valid unary user function. Will be deleted in the destructor.
inA pointer to a input Vector object.
outA pointer to a output Vector object.
_partsAn integer specifying number of partitions(subtasks) to be created when map is called.

References skepu::Environment< T >::getInstance().

Here is the call graph for this function:

template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
skepu::Map< MapFunc, T, c_type, cont_type >::~Map ( )

When the Map skeleton with a unary user function and Vector container type is destroyed, it deletes the user function it was created with. Furthermore, it destroy OpenCL handler and performance model objects (if created) and StarPU codelet.


Member Function Documentation

template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::cpu_func ( void *  buffers[],
void *  arg 
) [static]

A static function used with StarPU codelet for MAP_UNARY user function and with Vector container and is called by the StarPU if CPU backend is selected for a skeleton invocation.

Parameters:
buffersContain all StarPU managed data which in this case consists of either only one read-write buffer (Same vector is read and written) or one read and one write buffer.
argA read only argument which is used to pass handler to the object and other data as this is a static function.
template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::createOpenCLProgram ( )

A function for MAP_UNARY user function and with Vector container called by the constructor. It creates the OpenCL program for the skeleton using StarPU helper functions and saves the kernel name. The program is built from a string containing the user function (specified when constructing the skeleton) and a generic Map kernel. The type and function names in the generic kernel are relpaced by user function specific code before it is compiled by the OpenCL JIT compiler.

Also handles the use of doubles automatically by including "#pragma OPENCL EXTENSION cl_khr_fp64: enable" if doubles are used.

References skepu::BinaryMapKernel_CL(), skepu::read_file_into_string(), skepu::TrinaryMapKernel_CL(), and skepu::UnaryMapKernel_CL().

Here is the call graph for this function:

template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::cuda_func ( void *  buffers[],
void *  arg 
) [static]

A static function used with StarPU codelet for MAP_UNARY user function and with Vector container and is called by the StarPU if CUDA backend is selected for a skeleton invocation.

Parameters:
buffersContain all StarPU managed data which in this case consists of either only one read-write buffer (Same vector is read and written) or one read and one write buffer.
argA read only argument which is used to pass handler to the object and other data as this is a static function.
template<typename MapFunc, typename T, skepu::FuncType c_type = UNARY, skepu_container_type cont_type = VECTOR>
void skepu::Map< MapFunc, T, c_type, cont_type >::finishAll ( ) [inline]

Makes sure all operations on devices are finished.

template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::omp_func ( void *  buffers[],
void *  arg 
) [static]

A static function used with StarPU codelet for MAP_UNARY user function and with Vector container and is called by the StarPU if OpenMP backend is selected for a skeleton invocation.

Parameters:
buffersContain all StarPU managed data which in this case consists of either only one read-write buffer (Same vector is read and written) or one read and one write buffer.
argA read only argument which is used to pass handler to the object and other data as this is a static function.
template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::opencl_func ( void *  buffers[],
void *  arg 
) [static]

A static function used with StarPU codelet for MAP_UNARY user function and with Vector container and is called by the StarPU if OpenCL backend is selected for a skeleton invocation.

Parameters:
buffersContain all StarPU managed data which in this case consists of either only one read-write buffer (Same vector is read and written) or one read and one write buffer.
argA read only argument which is used to pass handler to the object and other data as this is a static function.
template<typename MapFunc , typename T, skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::operator() ( Vector< T > &  input)

Performs the Map on one vector. With itself as output. The Map skeleton needs to be created with a unary user function.

Depending on which backend was used, appropriate backend will be registered. In case of multiple backends (e.g. CPU and CUDA) StarPU will decide at runtime which one to use.

Parameters:
inputA vector which the mapping will be performed on. It will be overwritten with the result.
template<typename MapFunc , typename T, skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::operator() ( Vector< T > &  input,
Vector< T > &  output 
)

Performs the Map on one vector. With a second vector as output. The Map skeleton needs to be created with a unary user function.

Depending on which backend was used, appropriate backend will be registered. In case of multiple backends (e.g. CPU and CUDA) StarPU will decide at runtime which one to use.

Parameters:
inputA vector which the mapping will be performed on.
outputThe result vector, will be overwritten with the result and resized if needed.

References skepu::Vector< T >::clear(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapFunc , typename T, skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::operator() ( Vector< T > &  input,
Vector< T > &  output,
int  parts 
)

Performs the Map on one vector. With a second vector as output. It has support for creating multiple tasks using filters/partitioning. The Map skeleton needs to be created with a unary user function.

Depending on which backend was used, appropriate backend will be registered. In case of multiple backends (e.g. CPU and CUDA) StarPU will decide at runtime which one to use.

Parameters:
inputA vector which the mapping will be performed on.
outputThe result vector, will be overwritten with the result and resized if needed.
partsThe number of parts (StarPU tasks) that will be created for this skeleton call dividing the work equally between different created tasks.

References skepu::Vector< T >::clear(), skepu::Vector< T >::registerPartitions(), skepu::Vector< T >::resize(), and skepu::Vector< T >::size().

Here is the call graph for this function:

template<typename MapFunc , typename T, skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::operator() ( Vector< T > &  input,
int  parts 
)

Performs the Map on one vector with itself as output. It has support for creating multiple tasks using filters/partitioning. The Map skeleton needs to be created with a unary user function.

Depending on which backend was used, appropriate backend will be registered. In case of multiple backends (e.g. CPU and CUDA) StarPU will decide at runtime which one to use.

Parameters:
inputA vector which the mapping will be performed on. It will be overwritten with the result.
partsThe number of parts (StarPU tasks) that will be created for this skeleton call dividing the work equally between different created tasks.

References skepu::Vector< T >::registerPartitions().

Here is the call graph for this function:

template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::replaceText ( std::string &  text,
std::string  find,
std::string  replace 
)

A helper function for MAP_UNARY user function and with Vector container used by createOpenCLProgram(). It finds all instances of a string in another string and replaces it with a third string.

Parameters:
textA std::string which is searched.
findThe std::string which is searched for and replaced.
replaceThe relpacement std::string.
template<typename MapFunc , typename T , skepu::FuncType c_type, skepu_container_type cont_type>
void skepu::Map< MapFunc, T, c_type, cont_type >::run_async ( ) [virtual]

This is an abstract method defined in the Task class which every data-parallel skeleton implements to allow itself to be used within task-parallel skeletons (e.g. farm). It relies on the fact that parameters for the function call are already provided e.g. via constructor or setter methods available in the public interface of the class.

Implements skepu::Task.

template<typename MapFunc, typename T, skepu::FuncType c_type = UNARY, skepu_container_type cont_type = VECTOR>
template<typename U >
void skepu::Map< MapFunc, T, c_type, cont_type >::setConstant ( constant1) [inline]

If the Mapping function supports a constant, set it with this function before a call.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Enumerations Friends Defines