Reference documentation for deal.II version 9.6.0
\(\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\}}\)
Loading...
Searching...
No Matches
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

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 )