Reference documentation for deal.II version GIT relicensing-29-g1d56f85c36 2024-02-28 12:40: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\}}\)
Loading...
Searching...
No Matches
cuda_kernels.cc
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2018 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#include <deal.II/lac/cuda_kernels.templates.h>
16
18
19namespace LinearAlgebra
20{
21 namespace CUDAWrappers
22 {
23 namespace kernel
24 {
26 // Explicit instantiation //
28
29 template __global__ void
30 vec_scale<float>(float *, const float a, const size_type);
31 template __global__ void
33 const float *v2,
34 const size_type N);
35 template __global__ void
37 const float *v2,
38 const size_type N);
39 template __global__ void
40 masked_vector_bin_op<float, Binop_Addition>(const unsigned int *mask,
41 float *v1,
42 const float *v2,
43 const size_type N);
44 template __global__ void
46 float *v1,
47 const float *v2,
48 const size_type N);
49 template struct ElemSum<float>;
50 template struct L1Norm<float>;
51 template struct LInfty<float>;
52 template __global__ void
53 reduction<float, ElemSum<float>>(float *result,
54 const float *v,
55 const size_type N);
56 template __global__ void
57 reduction<float, L1Norm<float>>(float *result,
58 const float *v,
59 const size_type N);
60 template __global__ void
61 reduction<float, LInfty<float>>(float *result,
62 const float *v,
63 const size_type N);
64 template struct DotProduct<float>;
65 template __global__ void
66 double_vector_reduction<float, DotProduct<float>>(float *result,
67 const float *v1,
68 const float *v2,
69 const size_type N);
70 template __global__ void
71 vec_add<float>(float *val, const float, const size_type N);
72 template __global__ void
73 add_aV<float>(float *val,
74 const float a,
75 const float *V_val,
76 const size_type N);
77 template __global__ void
78 add_aVbW<float>(float *val,
79 const float a,
80 const float *V_val,
81 const float b,
82 const float *W_val,
83 const size_type N);
84 template __global__ void
85 sadd<float>(const float s,
86 float *val,
87 const float a,
88 const float *V_val,
89 const size_type N);
90 template __global__ void
91 sadd<float>(const float s,
92 float *val,
93 const float a,
94 const float *V_val,
95 const float b,
96 const float *W_val,
97 const size_type N);
98 template __global__ void
99 scale<float>(float *val, const float *V_val, const size_type N);
100 template __global__ void
101 equ<float>(float *val,
102 const float a,
103 const float *V_val,
104 const size_type N);
105 template __global__ void
106 equ<float>(float *val,
107 const float a,
108 const float *V_val,
109 const float b,
110 const float *W_val,
111 const size_type N);
112 template __global__ void
113 add_and_dot<float>(float *res,
114 float *v1,
115 const float *v2,
116 const float *v3,
117 const float a,
118 const size_type N);
119 template __global__ void
120 set<float>(float *val, const float s, const size_type N);
121 template __global__ void
123 float *val,
124 const float *v,
125 const size_type N);
126 template __global__ void
127 gather<float, size_type>(float *val,
128 const size_type *indices,
129 const float *v,
130 const size_type N);
131 template __global__ void
132 add_permutated<float>(const size_type *indices,
133 float *val,
134 const float *v,
135 const size_type N);
136
137
138
139 template __global__ void
140 vec_scale<double>(double *, const double a, const size_type);
141 template __global__ void
143 const double *v2,
144 const size_type N);
145 template __global__ void
147 const double *v2,
148 const size_type N);
149 template __global__ void
150 masked_vector_bin_op<double, Binop_Addition>(const unsigned int *mask,
151 double *v1,
152 const double *v2,
153 const size_type N);
154 template __global__ void
156 double *v1,
157 const double *v2,
158 const size_type N);
159 template struct ElemSum<double>;
160 template struct L1Norm<double>;
161 template struct LInfty<double>;
162 template __global__ void
163 reduction<double, ElemSum<double>>(double *result,
164 const double *v,
165 const size_type N);
166 template __global__ void
167 reduction<double, L1Norm<double>>(double *result,
168 const double *v,
169 const size_type N);
170 template __global__ void
171 reduction<double, LInfty<double>>(double *result,
172 const double *v,
173 const size_type N);
174 template struct DotProduct<double>;
175 template __global__ void
176 double_vector_reduction<double, DotProduct<double>>(double *result,
177 const double *v1,
178 const double *v2,
179 const size_type N);
180 template __global__ void
181 vec_add<double>(double *val, const double, const size_type N);
182 template __global__ void
183 add_aV<double>(double *val,
184 const double a,
185 const double *V_val,
186 const size_type N);
187 template __global__ void
188 add_aVbW<double>(double *val,
189 const double a,
190 const double *V_val,
191 const double b,
192 const double *W_val,
193 const size_type N);
194 template __global__ void
195 sadd<double>(const double s,
196 double *val,
197 const double a,
198 const double *V_val,
199 const size_type N);
200 template __global__ void
201 sadd<double>(const double s,
202 double *val,
203 const double a,
204 const double *V_val,
205 const double b,
206 const double *W_val,
207 const size_type N);
208 template __global__ void
209 scale<double>(double *val, const double *V_val, const size_type N);
210 template __global__ void
211 equ<double>(double *val,
212 const double a,
213 const double *V_val,
214 const size_type N);
215 template __global__ void
216 equ<double>(double *val,
217 const double a,
218 const double *V_val,
219 const double b,
220 const double *W_val,
221 const size_type N);
222 template __global__ void
223 add_and_dot<double>(double *res,
224 double *v1,
225 const double *v2,
226 const double *v3,
227 const double a,
228 const size_type N);
229 template __global__ void
230 set<double>(double *val, const double s, const size_type N);
231 template __global__ void
233 double *val,
234 const double *v,
235 const size_type N);
236 template __global__ void
237 gather<double, size_type>(double *val,
238 const size_type *indices,
239 const double *v,
240 const size_type N);
241 template __global__ void
242 add_permutated<double>(const size_type *indices,
243 double *val,
244 const double *v,
245 const size_type N);
246 } // namespace kernel
247 } // namespace CUDAWrappers
248} // namespace LinearAlgebra
249
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:502
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:503
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)