Reference documentation for deal.II version 9.5.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
cuda_kernels.cc
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 2018 - 2022 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
20namespace 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
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
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:472
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:473
const unsigned int v1
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)
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)