#define	UNARY_FUNC(name, type1, param1, func)
#define	UNARY_FUNC_CONSTANT(name, type1, param1, const1, func)
#define	BINARY_FUNC(name, type1, param1, param2, func)
#define	BINARY_FUNC_CONSTANT(name, type1, param1, param2, const1, func)
#define	TERNARY_FUNC(name, type1, param1, param2, param3, func)
#define	TERNARY_FUNC_CONSTANT(name, type1, param1, param2, param3, const1, func)
#define	OVERLAP_FUNC(name, type1, over, param1, func)
#define	OVERLAP_FUNC_STR(name, type1, over, param1, stride, func)
#define	ARRAY_FUNC(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR_CONST(name, type1, param1, param2, const1, const2, func)
#define	GENERATE_FUNC(name, type1, index, const1, func)
#define	UNARY_FUNC(name, type1, param1, func)
#define	BINARY_FUNC_CONSTANT(name, type1, param1, param2, const1, func)
#define	TERNARY_FUNC(name, type1, param1, param2, param3, func)
#define	TERNARY_FUNC_CONSTANT(name, type1, param1, param2, param3, const1, func)
#define	OVERLAP_FUNC(name, type1, over, param1, func)
#define	OVERLAP_FUNC_STR(name, type1, over, param1, stride, func)
#define	ARRAY_FUNC(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR_CONST(name, type1, param1, param2, const1, const2, func)
#define	GENERATE_FUNC(name, type1, index, const1, func)
#define	UNARY_FUNC(name, type1, param1, func)
#define	UNARY_FUNC_CONSTANT(name, type1, param1, const1, func)
#define	BINARY_FUNC(name, type1, param1, param2, func)
#define	BINARY_FUNC_CONSTANT(name, type1, param1, param2, const1, func)
#define	TERNARY_FUNC(name, type1, param1, param2, param3, func)
#define	TERNARY_FUNC_CONSTANT(name, type1, param1, param2, param3, const1, func)
#define	OVERLAP_FUNC(name, type1, over, param1, func)
#define	OVERLAP_FUNC_STR(name, type1, over, param1, stride, func)
#define	ARRAY_FUNC(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR_CONST(name, type1, param1, param2, const1, const2, func)
#define	GENERATE_FUNC(name, type1, index, const1, func)
#define	UNARY_FUNC(name, type1, param1, func)
#define	UNARY_FUNC_CONSTANT(name, type1, param1, const1, func)
#define	BINARY_FUNC(name, type1, param1, param2, func)
#define	BINARY_FUNC_CONSTANT(name, type1, param1, param2, const1, func)
#define	TERNARY_FUNC(name, type1, param1, param2, param3, func)
#define	TERNARY_FUNC_CONSTANT(name, type1, param1, param2, param3, const1, func)
#define	OVERLAP_FUNC(name, type1, over, param1, func)
#define	OVERLAP_FUNC_STR(name, type1, over, param1, stride, func)
#define	ARRAY_FUNC(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR(name, type1, param1, param2, func)
#define	ARRAY_FUNC_MATR_CONST(name, type1, param1, param2, const1, const2, func)
#define	GENERATE_FUNC(name, type1, index, const1, func)

Detailed Description

Macros that generate user functions that can be used togeher with the Skeletons.

Define Documentation

#define ARRAY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    std::string func_CL;\
    std::string funcName_CL;\
    std::string datatype_CL;\
    name()\
    {\
        funcType = skepu::ARRAY;\
        funcName_CL.append(#name);\
        datatype_CL.append(#type1);\
        func_CL.append(\
        datatype_CL + " " + funcName_CL + "(__global " + datatype_CL + "* " + #param1 + "," + datatype_CL + " " + #param2 + ")\n"\
        "{\n"\
        "   " #func "\n"\
        "}\n");\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        func\
    }\
};

Macro defintion for Array user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::ARRAY;\
    }\
    inline type1 CPU(type1 * param1, type1 param2)\
    {\
        func\
    }\
};

Macro defintion for Array user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::ARRAY;\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1, type1 param2)\
    {\
        func\
    }\
};

Macro defintion for Array user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    std::string func_CL;\
    std::string funcName_CL;\
    std::string datatype_CL;\
    name()\
    {\
        funcType = skepu::ARRAY;\
        funcName_CL.append(#name);\
        datatype_CL.append(#type1);\
        func_CL.append(\
        datatype_CL + " " + funcName_CL + "(__global " + datatype_CL + "* " + #param1 + "," + datatype_CL + " " + #param2 + ")\n"\
        "{\n"\
        "   " #func "\n"\
        "}\n");\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1, type1 param2)\
    {\
        func\
    }\
};

Macro defintion for Array user functions. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC_MATR	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    int xindex;\
    int yindex;\
    name()\
    {\
        funcType = skepu::ARRAY;\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1, type1 param2)\
    {\
        func\
    }\
    type1 CPU(type1 * param1, type1 param2, int xindex, int yindex)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1, type1 param2, int xindex, int yindex)\
    {\
        func\
    }\
};

Macro defintion for Array user functions for Matrix. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC_MATR	(	name,
		type1,
		param1,
		param2,
		func
	)

Macro defintion for Array user functions for Matrix. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC_MATR	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    std::string func_CL;\
    std::string funcName_CL;\
    std::string datatype_CL;\
    name()\
    {\
        funcType = skepu::ARRAY;\
        funcName_CL.append(#name);\
        datatype_CL.append(#type1);\
        func_CL.append(\
        datatype_CL + " " + funcName_CL + "(__global " + datatype_CL + "* " + #param1 + "," + datatype_CL + " " + #param2 + ")\n"\
        "{\n"\
        "   " #func "\n"\
        "}\n");\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        int xindex; int yindex; \
        func\
    }\
    type1 CPU(type1 * param1, type1 param2, int xindex, int yindex)\
    {\
        func\
    }\
};

Macro defintion for Array user functions for Matrix. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC_MATR	(	name,
		type1,
		param1,
		param2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::ARRAY;\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        int xindex; int yindex; \
        func\
    }\
    type1 CPU(type1 * param1, type1 param2, int xindex, int yindex)\
    {\
        func\
    }\
};

Macro defintion for Array user functions for Matrix. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
func	Function body.

#define ARRAY_FUNC_MATR_CONST	(	name,
		type1,
		param1,
		param2,
		const1,
		const2,
		func
	)

Macro defintion for Array user functions for Matrix which also supports two constants. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
const1	Name of constant one which can be used in the body.
const1	Name of constant two which can be used in the body.
func	Function body.

#define ARRAY_FUNC_MATR_CONST	(	name,
		type1,
		param1,
		param2,
		const1,
		const2,
		func
	)

Macro defintion for Array user functions for Matrix which also supports two constants. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
const1	Name of constant one which can be used in the body.
const1	Name of constant two which can be used in the body.
func	Function body.

#define ARRAY_FUNC_MATR_CONST	(	name,
		type1,
		param1,
		param2,
		const1,
		const2,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    type1 const1;\
    type1 getConstant1() {return const1;}\
    void setConstant1(type1 _v)\
    {\
        const1 = _v;\
    }\
    type1 const2;\
    type1 getConstant2() {return const2;}\
    void setConstant2(type1 _v)\
    {\
        const2 = _v;\
    }\
    name()\
    {\
        funcType = skepu::ARRAY;\
    }\
    type1 CPU(type1 * param1, type1 param2)\
    {\
        int xindex; int yindex; \
        func\
    }\
    type1 CPU(type1 * param1, type1 param2, int xindex, int yindex)\
    {\
        func\
    }\
};

Macro defintion for Array user functions for Matrix which also supports two contants. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
const1	Name of constant one which can be used in the body.
const1	Name of constant two which can be used in the body.
func	Function body.

#define ARRAY_FUNC_MATR_CONST	(	name,
		type1,
		param1,
		param2,
		const1,
		const2,
		func
	)

Macro defintion for Array user functions for Matrix with constants. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the MapArray skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one. Can be accessed as an array in the body.
param2	Name of parameter two. Only one element is accessible in the body.
const1	Name of constant one which can be used in the body.
const1	Name of constant two which can be used in the body.
func	Function body.

#define BINARY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Macro defintion for Binary user functions. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map, Reduce and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
func	Function body.

#define BINARY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Macro defintion for Binary user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map, Reduce and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
func	Function body.

#define BINARY_FUNC	(	name,
		type1,
		param1,
		param2,
		func
	)

Macro defintion for Binary user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map, Reduce and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
func	Function body.

#define BINARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    bool isConst;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::BINARY;\
        isConst = true;\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v)\
    {\
        const1 = _v;\
    }\
    type1 CPU(type1 param1, type1 param2)\
    {\
        return CPU(param1, param2, const1);\
    }\
    type1 CPU(type1 param1, type1 param2, type1 const1)\
    {\
        func\
    }\
};

Macro defintion for Binary user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
func	Function body.

Macro defintion for Binary user functions which also uses a constant. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
const1	Name of a constant which can be used in the body.
func	Function body.

#define BINARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		const1,
		func
	)

Macro defintion for Binary user functions which also uses a constant. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
const1	Name of a constant which can be used in the body.
func	Function body.

#define BINARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		const1,
		func
	)

Macro defintion for Binary user functions which also uses a constant. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
const1	Name of a constant which can be used in the body.
func	Function body.

#define BINARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		const1,
		func
	)

Macro defintion for Binary user functions which also uses a constant. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
const1	Name of a constant which can be used in the body.
func	Function body.

#define GENERATE_FUNC	(	name,
		type1,
		index,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::GENERATE;\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v) {const1 = _v;}\
    type1 CPU(unsigned int index)\
    {\
        func\
    }\
    __device__ type1 CU(unsigned int index)\
    {\
        func\
    }\
};

Macro defintion for Generate user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the Generate skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
index	Name of the index variable which will hold the index of the value to be generated.
const1	Name of a constant which can be used in the body.
func	Function body.

#define GENERATE_FUNC	(	name,
		type1,
		index,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    std::string func_CL;\
    std::string funcName_CL;\
    std::string datatype_CL;\
    name()\
    {\
        funcType = skepu::GENERATE;\
        funcName_CL.append(#name);\
        datatype_CL.append(#type1);\
        func_CL.append(\
        datatype_CL + " " + funcName_CL + "(unsigned int " + #index + ", " + datatype_CL + " " + #const1 + ")\n"\
        "{\n"\
        "   " #func "\n"\
        "}\n");\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v) {const1 = _v;}\
    type1 CPU(unsigned int index)\
    {\
        func\
    }\
    __device__ type1 CU(unsigned int index)\
    {\
        func\
    }\
};

Macro defintion for Generate user functions. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the Generate skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
index	Name of the index variable which will hold the index of the value to be generated.
const1	Name of a constant which can be used in the body.
func	Function body.

#define GENERATE_FUNC	(	name,
		type1,
		index,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::GENERATE;\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v) {const1 = _v;}\
    type1 CPU(unsigned int index)\
    {\
        func\
    }\
};

Macro defintion for Generate user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the Generate skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
index	Name of the index variable which will hold the index of the value to be generated.
const1	Name of a constant which can be used in the body.
func	Function body.

#define GENERATE_FUNC	(	name,
		type1,
		index,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    skepu::FuncType funcType;\
    std::string func_CL;\
    std::string funcName_CL;\
    std::string datatype_CL;\
    name()\
    {\
        funcType = skepu::GENERATE;\
        funcName_CL.append(#name);\
        datatype_CL.append(#type1);\
        func_CL.append(\
        datatype_CL + " " + funcName_CL + "(unsigned int " + #index + ", " + datatype_CL + " " + #const1 + ")\n"\
        "{\n"\
        "   " #func "\n"\
        "}\n");\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v) {const1 = _v;}\
    type1 CPU(unsigned int index)\
    {\
        func\
    }\
};

Macro defintion for Generate user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used by the Generate skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
index	Name of the index variable which will hold the index of the value to be generated.
const1	Name of a constant which can be used in the body.
func	Function body.

#define OVERLAP_FUNC	(	name,
		type1,
		over,
		param1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    int overlap;\
    int stride;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::OVERLAP;\
        overlap = over;\
    stride = 1;\
    }\
    int getStride() {return stride;}\
    void setStride(int _v) {stride = _v;}\
    type1 CPU(type1 * param1)\
    {\
        func\
    }\
    type1 CPU_stride(type1 * param1)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1)\
    {\
        func\
    }\
};

Macro defintion for Overlap user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC	(	name,
		type1,
		over,
		param1,
		func
	)

Macro defintion for Overlap user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC	(	name,
		type1,
		over,
		param1,
		func
	)

Macro defintion for Overlap user functions. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC	(	name,
		type1,
		over,
		param1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    int overlap;\
    int stride;\
    int getStride() {return stride;}\
    void setStride(int _v) {stride = _v;}\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::OVERLAP;\
        overlap = over;\
    stride = 1;\
    }\
    inline type1 CPU(type1 * param1)\
    {\
        func\
    }\
    type1 CPU_stride(type1 * param1)\
    {\
        func\
    }\
};

Macro defintion for Overlap user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC_STR	(	name,
		type1,
		over,
		param1,
		stride,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    int overlap;\
    int stride;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::OVERLAP;\
        overlap = over;\
    stride = 1;\
    }\
    int getStride() {return stride;}\
    void setStride(int _v) {stride = _v;}\
    type1 CPU(type1 * param1)\
    {\
        int stride=1;\
        func\
    }\
    type1 CPU_stride(type1 * param1)\
    {\
        func\
    }\
    __device__ type1 CU(type1 * param1)\
    {\
        int stride=1;\
        func\
    }\
};

Macro defintion for Overlap user functions with support for strided access in body. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC_STR	(	name,
		type1,
		over,
		param1,
		stride,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    int overlap;\
    int stride;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::OVERLAP;\
        overlap = over;\
    stride = 1;\
    }\
    int getStride() {return stride;}\
    void setStride(int _v) {stride = _v;}\
    type1 CPU(type1 * param1)\
    {\
        int stride=1;\
        func\
    }\
    type1 CPU_stride(type1 * param1)\
    {\
        func\
    }\
};

Macro defintion for Overlap user functions with support for strided access. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC_STR	(	name,
		type1,
		over,
		param1,
		stride,
		func
	)

Macro defintion for Overlap user functions that allows option for stride access. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define OVERLAP_FUNC_STR	(	name,
		type1,
		over,
		param1,
		stride,
		func
	)

Macro defintion for Overlap user functions that allows option for stride access. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can only be used for MapOverlap skeleton.

Parameters:

name	Function name.
type1	Type of function parameters.
over	The overlap length used by the function.
param1	Name of parameter one.
func	Function body.

#define TERNARY_FUNC	(	name,
		type1,
		param1,
		param2,
		param3,
		func
	)

Macro defintion for Trinary user functions. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
func	Function body.

#define TERNARY_FUNC	(	name,
		type1,
		param1,
		param2,
		param3,
		func
	)

Macro defintion for Trinary user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
func	Function body.

#define TERNARY_FUNC	(	name,
		type1,
		param1,
		param2,
		param3,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    bool isConst;\
    skepu::FuncType funcType;\
    starpu_data_handle dummy_handle;\
    name()\
    {\
        funcType = skepu::TERNARY;\
        isConst = false;\
    }\
    type1 dummy;\
    type1 getConstant() {return dummy;}\
    starpu_data_handle getConstantHandler()\
    { return dummy_handle; }\
    type1 CPU(type1 param1, type1 param2, type1 param3)\
    {\
        return CPU(param1, param2, param3, dummy);\
    }\
    type1 CPU(type1 param1, type1 param2, type1 param3, type1 dummy)\
    {\
        func\
    }\
};

Macro defintion for Trinary user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
func	Function body.

#define TERNARY_FUNC	(	name,
		type1,
		param1,
		param2,
		param3,
		func
	)

Macro defintion for Trinary user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
func	Function body.

#define TERNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		param3,
		const1,
		func
	)

Macro defintion for Trinary user functions which also uses a constant. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
const1	Name of a constant which can be used in the body.
func	Function body.

#define TERNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		param3,
		const1,
		func
	)

Macro defintion for Trinary user functions which also uses a constant. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
const1	Name of a constant which can be used in the body.
func	Function body.

#define TERNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		param3,
		const1,
		func
	)

Macro defintion for Trinary user functions which also uses a constant. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
const1	Name of a constant which can be used in the body.
func	Function body.

#define TERNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		param2,
		param3,
		const1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    bool isConst;\
    skepu::FuncType funcType;\
    name()\
    {\
        funcType = skepu::TERNARY;\
        isConst = true;\
    }\
    type1 const1;\
    type1 getConstant() {return const1;}\
    void setConstant(type1 _v)\
    {\
        const1 = _v;\
    }\
    type1 CPU(type1 param1, type1 param2, type1 param3)\
    {\
        return CPU(param1, param2, param3, const1);\
    }\
    type1 CPU(type1 param1, type1 param2, type1 param3, type1 const1)\
    {\
        func\
    }\
};

Macro defintion for Trinary user functions which also uses a constant. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
param2	Name of parameter two.
param3	Name of parameter three.
const1	Name of a constant which can be used in the body.
func	Function body.

#define UNARY_FUNC	(	name,
		type1,
		param1,
		func
	)

Value:

struct name\
{\
    typedef type1 TYPE;\
    bool isConst;\
    skepu::FuncType funcType;\
    starpu_data_handle dummy_handle;\
    name()\
    {\
        funcType = skepu::UNARY;\
        isConst = false;\
    }\
    type1 dummy;\
    type1 getConstant() {return dummy;}\
    starpu_data_handle getConstantHandler()\
    { return dummy_handle; }\
    type1 CPU(type1 param1)\
    {\
        return CPU(param1, dummy);\
    }\
    type1 CPU(type1 param1, type1 dummy)\
    {\
        func\
    }\
};

Macro defintion for Unary user functions. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
func	Function body.

Macro defintion for Unary user functions which also uses a constant. Includes only a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
const1	Name of a constant which can be used in the body.
func	Function body.

#define UNARY_FUNC	(	name,
		type1,
		param1,
		func
	)

Macro defintion for Unary user functions. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
func	Function body.

#define UNARY_FUNC	(	name,
		type1,
		param1,
		func
	)

Macro defintion for Unary user functions.Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
func	Function body.

#define UNARY_FUNC	(	name,
		type1,
		param1,
		func
	)

Macro defintion for Unary user functions. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
func	Function body.

#define UNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		const1,
		func
	)

Macro defintion for Unary user functions which also uses a constant. Includes an OpenCL variant (string), a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
const1	Name of a constant which can be used in the body.
func	Function body.

#define UNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		const1,
		func
	)

Macro defintion for Unary user functions which also uses a constant. Includes both a CUDA variant (__device__ function) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
const1	Name of a constant which can be used in the body.
func	Function body.

#define UNARY_FUNC_CONSTANT	(	name,
		type1,
		param1,
		const1,
		func
	)

Macro defintion for Unary user functions which also uses a constant. Includes both an OpenCL variant (string) and a CPU variant also used for OpenMP. The defintion expands as a Struct which can be used when creating new skeletons. Can be used by the Map and MapReduce skeletons.

Parameters:

name	Function name.
type1	Type of function parameters.
param1	Name of parameter one.
const1	Name of a constant which can be used in the body.
func	Function body.