LinearAlgebra::CUDAWrappers::kernel Namespace Reference

Classes
struct	Binop_Addition
struct	Binop_Addition< std::complex< Number > >
struct	Binop_Max
struct	Binop_Max< std::complex< Number > >
struct	Binop_Min
struct	Binop_Min< std::complex< Number > >
struct	Binop_Subtraction
struct	Binop_Subtraction< std::complex< Number > >
struct	DotProduct
struct	ElemSum
struct	L1Norm
struct	LInfty

Typedefs
using	size_type = types::global_dof_index

Functions
template<typename Number >
__global__ void	vec_scale (Number *val, const Number a, const size_type N)
template<typename Number , template< typename > class Binop>
__global__ void	vector_bin_op (Number *v1, const Number *v2, const size_type N)
template<typename Number , template< typename > class Binop>
__global__ void	masked_vector_bin_op (const unsigned int *mask, Number *v1, const Number *v2, const size_type N)
template<typename Number , typename Operation >
__global__ void	reduction (Number *result, const Number *v, const size_type N)
template<typename Number , typename Operation >
__global__ void	double_vector_reduction (Number *result, const Number *v1, const Number *v2, const size_type N)
template<typename Number >
__global__ void	vec_add (Number *val, const Number a, const size_type N)
template<typename Number >
__global__ void	add_aV (Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	add_aVbW (Number *val, const Number a, const Number *V_val, const Number b, const Number *W_val, const size_type N)
template<typename Number >
__global__ void	sadd (const Number s, Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	sadd (const Number s, Number *val, const Number a, const Number *V_val, const Number b, const Number *W_val, const size_type N)
template<typename Number >
__global__ void	scale (Number *val, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	equ (Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	equ (Number *val, const Number a, const Number *V_val, const Number b, const Number *W_val, const size_type N)
template<typename Number >
__global__ void	add_and_dot (Number *res, Number *v1, const Number *v2, const Number *v3, const Number a, const size_type N)
template<typename Number >
__global__ void	set (Number *val, const Number s, const size_type N)
template<typename Number , typename IndexType >
__global__ void	set_permutated (const IndexType *indices, Number *val, const Number *v, const IndexType N)
template<typename Number , typename IndexType >
__global__ void	gather (Number *val, const IndexType *indices, const Number *v, const IndexType N)
template<typename Number >
__global__ void	add_permutated (const size_type *indices, Number *val, const Number *v, const size_type N)
template __global__ void	vec_scale< float > (float *, const float a, const size_type)
template __global__ void	vector_bin_op< float, Binop_Addition > (float *v1, const float *v2, const size_type N)
template __global__ void	vector_bin_op< float, Binop_Subtraction > (float *v1, const float *v2, const size_type N)
template __global__ void	masked_vector_bin_op< float, Binop_Addition > (const unsigned int *mask, float *v1, const float *v2, const size_type N)
template __global__ void	masked_vector_bin_op< float, Binop_Subtraction > (const unsigned int *mask, float *v1, const float *v2, const size_type N)
template __global__ void	reduction< float, ElemSum< float > > (float *result, const float *v, const size_type N)
template __global__ void	reduction< float, L1Norm< float > > (float *result, const float *v, const size_type N)
template __global__ void	reduction< float, LInfty< float > > (float *result, const float *v, const size_type N)
template __global__ void	double_vector_reduction< float, DotProduct< float > > (float *result, const float *v1, const float *v2, const size_type N)
template __global__ void	vec_add< float > (float *val, const float, const size_type N)
template __global__ void	add_aV< float > (float *val, const float a, const float *V_val, const size_type N)
template __global__ void	add_aVbW< float > (float *val, const float a, const float *V_val, const float b, const float *W_val, const size_type N)
template __global__ void	sadd< float > (const float s, float *val, const float a, const float *V_val, const size_type N)
template __global__ void	sadd< float > (const float s, float *val, const float a, const float *V_val, const float b, const float *W_val, const size_type N)
template __global__ void	scale< float > (float *val, const float *V_val, const size_type N)
template __global__ void	equ< float > (float *val, const float a, const float *V_val, const size_type N)
template __global__ void	equ< float > (float *val, const float a, const float *V_val, const float b, const float *W_val, const size_type N)
template __global__ void	add_and_dot< float > (float *res, float *v1, const float *v2, const float *v3, const float a, const size_type N)
template __global__ void	set< float > (float *val, const float s, const size_type N)
template __global__ void	set_permutated< float, size_type > (const size_type *indices, float *val, const float *v, const size_type N)
template __global__ void	gather< float, size_type > (float *val, const size_type *indices, const float *v, const size_type N)
template __global__ void	add_permutated< float > (const size_type *indices, float *val, const float *v, const size_type N)
template __global__ void	vec_scale< double > (double *, const double a, const size_type)
template __global__ void	vector_bin_op< double, Binop_Addition > (double *v1, const double *v2, const size_type N)
template __global__ void	vector_bin_op< double, Binop_Subtraction > (double *v1, const double *v2, const size_type N)
template __global__ void	masked_vector_bin_op< double, Binop_Addition > (const unsigned int *mask, double *v1, const double *v2, const size_type N)
template __global__ void	masked_vector_bin_op< double, Binop_Subtraction > (const unsigned int *mask, double *v1, const double *v2, const size_type N)
template __global__ void	reduction< double, ElemSum< double > > (double *result, const double *v, const size_type N)
template __global__ void	reduction< double, L1Norm< double > > (double *result, const double *v, const size_type N)
template __global__ void	reduction< double, LInfty< double > > (double *result, const double *v, const size_type N)
template __global__ void	double_vector_reduction< double, DotProduct< double > > (double *result, const double *v1, const double *v2, const size_type N)
template __global__ void	vec_add< double > (double *val, const double, const size_type N)
template __global__ void	add_aV< double > (double *val, const double a, const double *V_val, const size_type N)
template __global__ void	add_aVbW< double > (double *val, const double a, const double *V_val, const double b, const double *W_val, const size_type N)
template __global__ void	sadd< double > (const double s, double *val, const double a, const double *V_val, const size_type N)
template __global__ void	sadd< double > (const double s, double *val, const double a, const double *V_val, const double b, const double *W_val, const size_type N)
template __global__ void	scale< double > (double *val, const double *V_val, const size_type N)
template __global__ void	equ< double > (double *val, const double a, const double *V_val, const size_type N)
template __global__ void	equ< double > (double *val, const double a, const double *V_val, const double b, const double *W_val, const size_type N)
template __global__ void	add_and_dot< double > (double *res, double *v1, const double *v2, const double *v3, const double a, const size_type N)
template __global__ void	set< double > (double *val, const double s, const size_type N)
template __global__ void	set_permutated< double, size_type > (const size_type *indices, double *val, const double *v, const size_type N)
template __global__ void	gather< double, size_type > (double *val, const size_type *indices, const double *v, const size_type N)
template __global__ void	add_permutated< double > (const size_type *indices, double *val, const double *v, const size_type N)

Detailed Description

Namespace containing the CUDA kernels.

Typedef Documentation

size_type

using LinearAlgebra::CUDAWrappers::kernel::size_type = typedef types::global_dof_index

Definition at line 45 of file cuda_kernels.h.

Function Documentation

vec_scale< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vec_scale< float >	(	float *	,
		const float	a,
		const size_type
	)

vector_bin_op< float, Binop_Addition >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vector_bin_op< float, Binop_Addition >	(	float *	v1,
		const float *	v2,
		const size_type	N
	)

vector_bin_op< float, Binop_Subtraction >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vector_bin_op< float, Binop_Subtraction >	(	float *	v1,
		const float *	v2,
		const size_type	N
	)

masked_vector_bin_op< float, Binop_Addition >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op< float, Binop_Addition >	(	const unsigned int *	mask,
		float *	v1,
		const float *	v2,
		const size_type	N
	)

masked_vector_bin_op< float, Binop_Subtraction >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op< float, Binop_Subtraction >	(	const unsigned int *	mask,
		float *	v1,
		const float *	v2,
		const size_type	N
	)

reduction< float, ElemSum< float > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< float, ElemSum< float > >	(	float *	result,
		const float *	v,
		const size_type	N
	)

reduction< float, L1Norm< float > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< float, L1Norm< float > >	(	float *	result,
		const float *	v,
		const size_type	N
	)

reduction< float, LInfty< float > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< float, LInfty< float > >	(	float *	result,
		const float *	v,
		const size_type	N
	)

double_vector_reduction< float, DotProduct< float > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::double_vector_reduction< float, DotProduct< float > >	(	float *	result,
		const float *	v1,
		const float *	v2,
		const size_type	N
	)

vec_add< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vec_add< float >	(	float *	val,
		const float	,
		const size_type	N
	)

add_aV< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_aV< float >	(	float *	val,
		const float	a,
		const float *	V_val,
		const size_type	N
	)

add_aVbW< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_aVbW< float >	(	float *	val,
		const float	a,
		const float *	V_val,
		const float	b,
		const float *	W_val,
		const size_type	N
	)

sadd< float >() [1/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::sadd< float >	(	const float	s,
		float *	val,
		const float	a,
		const float *	V_val,
		const size_type	N
	)

sadd< float >() [2/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::sadd< float >	(	const float	s,
		float *	val,
		const float	a,
		const float *	V_val,
		const float	b,
		const float *	W_val,
		const size_type	N
	)

scale< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::scale< float >	(	float *	val,
		const float *	V_val,
		const size_type	N
	)

equ< float >() [1/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::equ< float >	(	float *	val,
		const float	a,
		const float *	V_val,
		const size_type	N
	)

equ< float >() [2/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::equ< float >	(	float *	val,
		const float	a,
		const float *	V_val,
		const float	b,
		const float *	W_val,
		const size_type	N
	)

add_and_dot< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_and_dot< float >	(	float *	res,
		float *	v1,
		const float *	v2,
		const float *	v3,
		const float	a,
		const size_type	N
	)

set< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::set< float >	(	float *	val,
		const float	s,
		const size_type	N
	)

set_permutated< float, size_type >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::set_permutated< float, size_type >	(	const size_type *	indices,
		float *	val,
		const float *	v,
		const size_type	N
	)

gather< float, size_type >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::gather< float, size_type >	(	float *	val,
		const size_type *	indices,
		const float *	v,
		const size_type	N
	)

add_permutated< float >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_permutated< float >	(	const size_type *	indices,
		float *	val,
		const float *	v,
		const size_type	N
	)

vec_scale< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vec_scale< double >	(	double *	,
		const double	a,
		const size_type
	)

vector_bin_op< double, Binop_Addition >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vector_bin_op< double, Binop_Addition >	(	double *	v1,
		const double *	v2,
		const size_type	N
	)

vector_bin_op< double, Binop_Subtraction >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vector_bin_op< double, Binop_Subtraction >	(	double *	v1,
		const double *	v2,
		const size_type	N
	)

masked_vector_bin_op< double, Binop_Addition >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op< double, Binop_Addition >	(	const unsigned int *	mask,
		double *	v1,
		const double *	v2,
		const size_type	N
	)

masked_vector_bin_op< double, Binop_Subtraction >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op< double, Binop_Subtraction >	(	const unsigned int *	mask,
		double *	v1,
		const double *	v2,
		const size_type	N
	)

reduction< double, ElemSum< double > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< double, ElemSum< double > >	(	double *	result,
		const double *	v,
		const size_type	N
	)

reduction< double, L1Norm< double > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< double, L1Norm< double > >	(	double *	result,
		const double *	v,
		const size_type	N
	)

reduction< double, LInfty< double > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::reduction< double, LInfty< double > >	(	double *	result,
		const double *	v,
		const size_type	N
	)

double_vector_reduction< double, DotProduct< double > >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::double_vector_reduction< double, DotProduct< double > >	(	double *	result,
		const double *	v1,
		const double *	v2,
		const size_type	N
	)

vec_add< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::vec_add< double >	(	double *	val,
		const double	,
		const size_type	N
	)

add_aV< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_aV< double >	(	double *	val,
		const double	a,
		const double *	V_val,
		const size_type	N
	)

add_aVbW< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_aVbW< double >	(	double *	val,
		const double	a,
		const double *	V_val,
		const double	b,
		const double *	W_val,
		const size_type	N
	)

sadd< double >() [1/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::sadd< double >	(	const double	s,
		double *	val,
		const double	a,
		const double *	V_val,
		const size_type	N
	)

sadd< double >() [2/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::sadd< double >	(	const double	s,
		double *	val,
		const double	a,
		const double *	V_val,
		const double	b,
		const double *	W_val,
		const size_type	N
	)

scale< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::scale< double >	(	double *	val,
		const double *	V_val,
		const size_type	N
	)

equ< double >() [1/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::equ< double >	(	double *	val,
		const double	a,
		const double *	V_val,
		const size_type	N
	)

equ< double >() [2/2]

template __global__ void LinearAlgebra::CUDAWrappers::kernel::equ< double >	(	double *	val,
		const double	a,
		const double *	V_val,
		const double	b,
		const double *	W_val,
		const size_type	N
	)

add_and_dot< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_and_dot< double >	(	double *	res,
		double *	v1,
		const double *	v2,
		const double *	v3,
		const double	a,
		const size_type	N
	)

set< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::set< double >	(	double *	val,
		const double	s,
		const size_type	N
	)

set_permutated< double, size_type >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::set_permutated< double, size_type >	(	const size_type *	indices,
		double *	val,
		const double *	v,
		const size_type	N
	)

gather< double, size_type >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::gather< double, size_type >	(	double *	val,
		const size_type *	indices,
		const double *	v,
		const size_type	N
	)

add_permutated< double >()

template __global__ void LinearAlgebra::CUDAWrappers::kernel::add_permutated< double >	(	const size_type *	indices,
		double *	val,
		const double *	v,
		const size_type	N
	)