Reference documentation for deal.II version GIT 6dd81a2340 2022-11-29 05:55:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Classes | Typedefs | Functions
LinearAlgebra::CUDAWrappers::kernel Namespace Reference

Classes

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

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

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 
)