Reference documentation for deal.II version GIT 4efb66ecd0 2023-02-07 13:45: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\}}\)
cuda_kernels.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2018 - 2019 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #include <deal.II/lac/cuda_kernels.templates.h>
17 
19 
20 namespace LinearAlgebra
21 {
22  namespace CUDAWrappers
23  {
24  namespace kernel
25  {
27  // Explicit instantiation //
29 
30  template __global__ void
31  vec_scale<float>(float *, const float a, const size_type);
32  template __global__ void
34  const float * v2,
35  const size_type N);
36  template __global__ void
38  const float * v2,
39  const size_type N);
40  template __global__ void
41  masked_vector_bin_op<float, Binop_Addition>(const unsigned int *mask,
42  float * v1,
43  const float * v2,
44  const size_type N);
45  template __global__ void
46  masked_vector_bin_op<float, Binop_Subtraction>(const unsigned int *mask,
47  float * v1,
48  const float * v2,
49  const size_type N);
50  template struct ElemSum<float>;
51  template struct L1Norm<float>;
52  template struct LInfty<float>;
53  template __global__ void
54  reduction<float, ElemSum<float>>(float * result,
55  const float * v,
56  const size_type N);
57  template __global__ void
58  reduction<float, L1Norm<float>>(float * result,
59  const float * v,
60  const size_type N);
61  template __global__ void
62  reduction<float, LInfty<float>>(float * result,
63  const float * v,
64  const size_type N);
65  template struct DotProduct<float>;
66  template __global__ void
67  double_vector_reduction<float, DotProduct<float>>(float * result,
68  const float * v1,
69  const float * v2,
70  const size_type N);
71  template __global__ void
72  vec_add<float>(float *val, const float, const size_type N);
73  template __global__ void
74  add_aV<float>(float * val,
75  const float a,
76  const float * V_val,
77  const size_type N);
78  template __global__ void
79  add_aVbW<float>(float * val,
80  const float a,
81  const float * V_val,
82  const float b,
83  const float * W_val,
84  const size_type N);
85  template __global__ void
86  sadd<float>(const float s,
87  float * val,
88  const float a,
89  const float * V_val,
90  const size_type N);
91  template __global__ void
92  sadd<float>(const float s,
93  float * val,
94  const float a,
95  const float * V_val,
96  const float b,
97  const float * W_val,
98  const size_type N);
99  template __global__ void
100  scale<float>(float *val, const float *V_val, const size_type N);
101  template __global__ void
102  equ<float>(float * val,
103  const float a,
104  const float * V_val,
105  const size_type N);
106  template __global__ void
107  equ<float>(float * val,
108  const float a,
109  const float * V_val,
110  const float b,
111  const float * W_val,
112  const size_type N);
113  template __global__ void
114  add_and_dot<float>(float * res,
115  float * v1,
116  const float * v2,
117  const float * v3,
118  const float a,
119  const size_type N);
120  template __global__ void
121  set<float>(float *val, const float s, const size_type N);
122  template __global__ void
124  float * val,
125  const float * v,
126  const size_type N);
127  template __global__ void
128  gather<float, size_type>(float * val,
129  const size_type *indices,
130  const float * v,
131  const size_type N);
132  template __global__ void
133  add_permutated<float>(const size_type *indices,
134  float * val,
135  const float * v,
136  const size_type N);
137 
138 
139 
140  template __global__ void
141  vec_scale<double>(double *, const double a, const size_type);
142  template __global__ void
144  const double * v2,
145  const size_type N);
146  template __global__ void
148  const double * v2,
149  const size_type N);
150  template __global__ void
151  masked_vector_bin_op<double, Binop_Addition>(const unsigned int *mask,
152  double * v1,
153  const double * v2,
154  const size_type N);
155  template __global__ void
156  masked_vector_bin_op<double, Binop_Subtraction>(const unsigned int *mask,
157  double * v1,
158  const double * v2,
159  const size_type N);
160  template struct ElemSum<double>;
161  template struct L1Norm<double>;
162  template struct LInfty<double>;
163  template __global__ void
164  reduction<double, ElemSum<double>>(double * result,
165  const double * v,
166  const size_type N);
167  template __global__ void
168  reduction<double, L1Norm<double>>(double * result,
169  const double * v,
170  const size_type N);
171  template __global__ void
172  reduction<double, LInfty<double>>(double * result,
173  const double * v,
174  const size_type N);
175  template struct DotProduct<double>;
176  template __global__ void
177  double_vector_reduction<double, DotProduct<double>>(double * result,
178  const double *v1,
179  const double *v2,
180  const size_type N);
181  template __global__ void
182  vec_add<double>(double *val, const double, const size_type N);
183  template __global__ void
184  add_aV<double>(double * val,
185  const double a,
186  const double * V_val,
187  const size_type N);
188  template __global__ void
189  add_aVbW<double>(double * val,
190  const double a,
191  const double * V_val,
192  const double b,
193  const double * W_val,
194  const size_type N);
195  template __global__ void
196  sadd<double>(const double s,
197  double * val,
198  const double a,
199  const double * V_val,
200  const size_type N);
201  template __global__ void
202  sadd<double>(const double s,
203  double * val,
204  const double a,
205  const double * V_val,
206  const double b,
207  const double * W_val,
208  const size_type N);
209  template __global__ void
210  scale<double>(double *val, const double *V_val, const size_type N);
211  template __global__ void
212  equ<double>(double * val,
213  const double a,
214  const double * V_val,
215  const size_type N);
216  template __global__ void
217  equ<double>(double * val,
218  const double a,
219  const double * V_val,
220  const double b,
221  const double * W_val,
222  const size_type N);
223  template __global__ void
224  add_and_dot<double>(double * res,
225  double * v1,
226  const double * v2,
227  const double * v3,
228  const double a,
229  const size_type N);
230  template __global__ void
231  set<double>(double *val, const double s, const size_type N);
232  template __global__ void
234  double * val,
235  const double * v,
236  const size_type N);
237  template __global__ void
238  gather<double, size_type>(double * val,
239  const size_type *indices,
240  const double * v,
241  const size_type N);
242  template __global__ void
243  add_permutated<double>(const size_type *indices,
244  double * val,
245  const double * v,
246  const size_type N);
247  } // namespace kernel
248  } // namespace CUDAWrappers
249 } // namespace LinearAlgebra
250 
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:461
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:462
const unsigned int v1
Definition: grid_tools.cc:1048
static const char N
template __global__ void equ< float >(float *val, const float a, const float *V_val, const size_type N)
template __global__ void vec_scale< double >(double *, const double a, const size_type)
template __global__ void scale< float >(float *val, const float *V_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 vec_scale< float >(float *, const float a, const size_type)
template __global__ void add_aV< double >(double *val, const double a, const double *V_val, 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 masked_vector_bin_op< double, Binop_Subtraction >(const unsigned int *mask, double *v1, const double *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 sadd< double >(const double s, double *val, const double a, const double *V_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 add_permutated< float >(const size_type *indices, float *val, const float *v, 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 set< double >(double *val, const double s, 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 vector_bin_op< float, Binop_Addition >(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 masked_vector_bin_op< double, Binop_Addition >(const unsigned int *mask, double *v1, const double *v2, const size_type N)
template __global__ void vector_bin_op< double, Binop_Addition >(double *v1, const double *v2, 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 add_permutated< double >(const size_type *indices, double *val, const double *v, 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 equ< double >(double *val, const double a, const double *V_val, 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 add_aVbW< double >(double *val, const double a, const double *V_val, const double b, const double *W_val, const size_type N)
types::global_dof_index size_type
Definition: cuda_kernels.h:45
template __global__ void set_permutated< float, size_type >(const size_type *indices, float *val, const float *v, const size_type N)
template __global__ void set< float >(float *val, const float s, 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 scale< double >(double *val, const double *V_val, const size_type N)
template __global__ void vec_add< double >(double *val, const double, const size_type N)
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)