Reference documentation for deal.II version Git 10f3285 2019-01-18 22:14:04 -0700
\(\newcommand{\dealcoloneq}{\mathrel{\vcenter{:}}=}\)
Classes | Enumerations | Functions
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 >
 
struct  CUDAWrappers::PreconditionIC< Number >::AdditionalData
 
class  CUDAWrappers::PreconditionIC< Number >
 
struct  CUDAWrappers::PreconditionILU< Number >::AdditionalData
 
class  CUDAWrappers::PreconditionILU< Number >
 
struct  CUDAWrappers::SolverDirect< Number >::AdditionalData
 
class  CUDAWrappers::SolverDirect< Number >
 
class  CUDAWrappers::FEEvaluation< dim, fe_degree, n_q_points_1d, n_components_, Number >
 
struct  CUDAWrappers::MatrixFree< dim, Number >::Data
 
class  CUDAWrappers::MatrixFree< dim, Number >
 
struct  CUDAWrappers::internal::EvaluatorTensorProduct< variant, dim, fe_degree, n_q_points_1d, Number >
 
struct  CUDAWrappers::internal::EvaluatorTensorProduct< evaluate_general, dim, fe_degree, n_q_points_1d, Number >
 

Enumerations

enum  CUDAWrappers::MatrixFree< dim, Number >::ParallelizationScheme
 
enum  CUDAWrappers::internal::EvaluatorVariant
 

Functions

float LinearAlgebra::CUDAWrappers::atomicAdd_wrapper (float *address, float val)
 
double LinearAlgebra::CUDAWrappers::atomicAdd_wrapper (double *address, double val)
 
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 , 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 >
__global__ void LinearAlgebra::CUDAWrappers::kernel::set_permutated (Number *val, const Number *v, const size_type *indices, const size_type N)
 
template<typename Number , typename IndexType >
__global__ void LinearAlgebra::CUDAWrappers::kernel::gather (Number *val, const Number *v, const IndexType *indices, const IndexType N)
 
template<typename Number >
__global__ void LinearAlgebra::CUDAWrappers::kernel::add_permutated (Number *val, const Number *v, const size_type *indices, const size_type N)
 

Detailed Description

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

Enumeration Type Documentation

template<int dim, typename Number = double>
enum CUDAWrappers::MatrixFree::ParallelizationScheme

Parallelization scheme used: parallel_in_elem (parallelism at the level of degrees of freedom) or parallel_over_elem (parallelism at the level of cells)

Definition at line 89 of file cuda_matrix_free.h.

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

Definition at line 38 of file cuda_tensor_product_kernels.h.

Function Documentation

float LinearAlgebra::CUDAWrappers::atomicAdd_wrapper ( float *  address,
float  val 
)
inline

Provide atomicAdd for floats.

Definition at line 35 of file cuda_atomic.h.

double LinearAlgebra::CUDAWrappers::atomicAdd_wrapper ( double *  address,
double  val 
)
inline

Provide atomicAdd for doubles.

Definition at line 48 of file cuda_atomic.h.

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

Provide atomicMax for floats.

Definition at line 81 of file cuda_atomic.h.

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

Provide atomicMax for doubles.

Definition at line 105 of file cuda_atomic.h.

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.

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

Template Parameters
Binopto each element of v1 and v2.
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

Template Parameters
Operation.
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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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

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

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

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

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

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