CUDA Wrappers

Collaboration diagram for CUDA Wrappers:

Classes
struct	LinearAlgebra::CUDAWrappers::kernel::Binop_Addition< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::Binop_Subtraction< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::Binop_Max< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::Binop_Min< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::ElemSum< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::L1Norm< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::LInfty< Number >
struct	LinearAlgebra::CUDAWrappers::kernel::DotProduct< Number >
class	CUDAWrappers::PreconditionIC< Number >
class	CUDAWrappers::PreconditionILU< Number >
class	CUDAWrappers::SolverDirect< Number >
class	Portable::FEEvaluation< dim, fe_degree, n_q_points_1d, n_components_, Number >
class	Portable::MatrixFree< dim, Number >
struct	Portable::internal::EvaluatorTensorProduct< variant, dim, fe_degree, n_q_points_1d, Number >
struct	Portable::internal::EvaluatorTensorProduct< evaluate_general, dim, fe_degree, n_q_points_1d, Number >

Enumerations
enum	Portable::internal::EvaluatorVariant { Portable::internal::evaluate_general , Portable::internal::evaluate_symmetric , Portable::internal::evaluate_evenodd }

Functions
float	LinearAlgebra::CUDAWrappers::atomicMax_wrapper (float *address, float val)
double	LinearAlgebra::CUDAWrappers::atomicMax_wrapper (double *address, double val)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::vec_scale (Number *val, const Number a, const size_type N)
template<typename Number , template< typename > class Binop>
__global__ void	LinearAlgebra::CUDAWrappers::kernel::vector_bin_op (Number *v1, const Number *v2, const size_type N)
template<typename Number , template< typename > class Binop>
__global__ void	LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op (const unsigned int *mask, Number *v1, const Number *v2, const size_type N)
template<typename Number , typename Operation >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::reduction (Number *result, const Number *v, const size_type N)
template<typename Number , typename Operation >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::double_vector_reduction (Number *result, const Number *v1, const Number *v2, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::vec_add (Number *val, const Number a, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::add_aV (Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::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	LinearAlgebra::CUDAWrappers::kernel::sadd (const Number s, Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::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	LinearAlgebra::CUDAWrappers::kernel::scale (Number *val, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::equ (Number *val, const Number a, const Number *V_val, const size_type N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::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	LinearAlgebra::CUDAWrappers::kernel::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	LinearAlgebra::CUDAWrappers::kernel::set (Number *val, const Number s, const size_type N)
template<typename Number , typename IndexType >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::set_permutated (const IndexType *indices, Number *val, const Number *v, const IndexType N)
template<typename Number , typename IndexType >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::gather (Number *val, const IndexType *indices, const Number *v, const IndexType N)
template<typename Number >
__global__ void	LinearAlgebra::CUDAWrappers::kernel::add_permutated (const size_type *indices, Number *val, const Number *v, const size_type N)

Detailed Description

The classes in this group are concerned with the description of features to be run on GPUs using CUDA.

Enumeration Type Documentation

EvaluatorVariant

enum Portable::internal::EvaluatorVariant

In this namespace, the evaluator routines that evaluate the tensor products are implemented.

Enumerator
evaluate_general
evaluate_symmetric
evaluate_evenodd

Definition at line 39 of file portable_tensor_product_kernels.h.

Function Documentation

atomicMax_wrapper() [1/2]

float LinearAlgebra::CUDAWrappers::atomicMax_wrapper ( float * address, float val )

inline

Provide atomicMax for floats.

Definition at line 34 of file cuda_atomic.h.

atomicMax_wrapper() [2/2]

double LinearAlgebra::CUDAWrappers::atomicMax_wrapper ( double * address, double val )

inline

Provide atomicMax for doubles.

Definition at line 58 of file cuda_atomic.h.

vec_scale()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::vec_scale	(	Number *	val,
		const Number	a,
		const size_type	N )

Multiply each entry of val of size N by a.

vector_bin_op()

template<typename Number , template< typename > class Binop>

__global__ void LinearAlgebra::CUDAWrappers::kernel::vector_bin_op	(	Number *	v1,
		const Number *	v2,
		const size_type	N )

Apply the functor Binop to each element of v1 and v2.

masked_vector_bin_op()

template<typename Number , template< typename > class Binop>

__global__ void LinearAlgebra::CUDAWrappers::kernel::masked_vector_bin_op	(	const unsigned int *	mask,
		Number *	v1,
		const Number *	v2,
		const size_type	N )

Apply the functor Binop to the elements of v1 that have indices in mask and v2. The size of mask should be greater than the size of v1. mask and v2 should have the same size N.

reduction()

template<typename Number , typename Operation >

__global__ void LinearAlgebra::CUDAWrappers::kernel::reduction	(	Number *	result,
		const Number *	v,
		const size_type	N )

Perform a reduction on v using Operation.

double_vector_reduction()

template<typename Number , typename Operation >

__global__ void LinearAlgebra::CUDAWrappers::kernel::double_vector_reduction	(	Number *	result,
		const Number *	v1,
		const Number *	v2,
		const size_type	N )

Perform a binary operation on each element of v1 and v2 followed by reduction on the resulting array.

vec_add()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::vec_add	(	Number *	val,
		const Number	a,
		const size_type	N )

Add a to each element of val.

add_aV()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::add_aV	(	Number *	val,
		const Number	a,
		const Number *	V_val,
		const size_type	N )

Addition of a multiple of a vector, i.e., val += a*V_val.

add_aVbW()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::add_aVbW	(	Number *	val,
		const Number	a,
		const Number *	V_val,
		const Number	b,
		const Number *	W_val,
		const size_type	N )

Addition of multiple scaled vector, i.e., val += a*V_val + b*W_val.

sadd() [1/2]

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::sadd	(	const Number	s,
		Number *	val,
		const Number	a,
		const Number *	V_val,
		const size_type	N )

Scaling and simple addition of a multiple of a vector, i.e. val = = s*val + a*V_val

sadd() [2/2]

template<typename Number >

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

Scaling and multiple additions of scaled vectors, i.e. val = = s*val + a*V_val + b*W_val

scale()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::scale	(	Number *	val,
		const Number *	V_val,
		const size_type	N )

Scale each element of this vector by the corresponding element in the argument.

equ() [1/2]

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::equ	(	Number *	val,
		const Number	a,
		const Number *	V_val,
		const size_type	N )

Assignment val = a*V_val.

equ() [2/2]

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::equ	(	Number *	val,
		const Number	a,
		const Number *	V_val,
		const Number	b,
		const Number *	W_val,
		const size_type	N )

Assignment val = a*V_val + b*W_val.

add_and_dot()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::add_and_dot	(	Number *	res,
		Number *	v1,
		const Number *	v2,
		const Number *	v3,
		const Number	a,
		const size_type	N )

Perform a combined operation of a vector addition and a subsequent inner product, returning the value of the inner product.

set()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::set	(	Number *	val,
		const Number	s,
		const size_type	N )

Set each element of val to s.

set_permutated()

template<typename Number , typename IndexType >

__global__ void LinearAlgebra::CUDAWrappers::kernel::set_permutated	(	const IndexType *	indices,
		Number *	val,
		const Number *	v,
		const IndexType	N )

Set each element in val to v using indices as permutation, i.e., val[indices[i]] = v[i].

gather()

template<typename Number , typename IndexType >

__global__ void LinearAlgebra::CUDAWrappers::kernel::gather	(	Number *	val,
		const IndexType *	indices,
		const Number *	v,
		const IndexType	N )

Set each element in val to v using indices as permutation, i.e., val[i] = v[indices[i]].

add_permutated()

template<typename Number >

__global__ void LinearAlgebra::CUDAWrappers::kernel::add_permutated	(	const size_type *	indices,
		Number *	val,
		const Number *	v,
		const size_type	N )

Add each element in val to v using indices as permutation, i.e., val[indices[i]] += v[i].