Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse2/pmath/exp.h

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 31 мар. 2020 г.
7 *
8 * lsp-dsp-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-dsp-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-dsp-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #ifndef PRIVATE_DSP_ARCH_X86_SSE2_PMATH_EXP_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE2_PMATH_EXP_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE2_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE2_IMPL */
28
29 namespace lsp
30 {
31 namespace sse2
32 {
33 /* Code to generate constants:
34
35 float fact(int n)
36 {
37 return (n > 1) ? n*fact(n-1) : 1;
38 }
39
40 uint32_t to_hex(float v)
41 {
42 union {
43 uint32_t i;
44 float f;
45 } r;
46 r.f = v;
47 return r.i;
48 }
49
50 int main()
51 {
52 printf("LSP_DSP_VEC4(0x7fffffff), // sign\n");
53 printf("LSP_DSP_VEC4(0x%08x), // ln(2)\n", to_hex(M_LN2));
54
55 float f7 = fact(7);
56
57 for (int i=6; i>=1; --i)
58 {
59 float C = f7 / fact(i);
60 printf("LSP_DSP_VEC4(0x%08x), // C%d = %d!/%d! = %.16f \n", to_hex(C), i-1, 7, i, C);
61 }
62 printf("LSP_DSP_VEC4(0x%08x), // 1/7! = %.16f\n", to_hex(1.0f/f7), 1.0f/f7);
63 printf("LSP_DSP_VEC4(0x%08x), // 1.0\n", to_hex(1.0f));
64 }
65
66 */
67
68 IF_ARCH_X86(
69 static const uint32_t EXP2_CONST[] __lsp_aligned16 =
70 {
71 LSP_DSP_VEC4(0x7fffffff), // sign
72 LSP_DSP_VEC4(0x3f317218), // ln(2)
73 LSP_DSP_VEC4(0x40e00000), // C5 = 7!/6! = 7.0000000000000000
74 LSP_DSP_VEC4(0x42280000), // C4 = 7!/5! = 42.0000000000000000
75 LSP_DSP_VEC4(0x43520000), // C3 = 7!/4! = 210.0000000000000000
76 LSP_DSP_VEC4(0x44520000), // C2 = 7!/3! = 840.0000000000000000
77 LSP_DSP_VEC4(0x451d8000), // C1 = 7!/2! = 2520.0000000000000000
78 LSP_DSP_VEC4(0x459d8000), // C0 = 7!/1! = 5040.0000000000000000
79 LSP_DSP_VEC4(0x39500d01), // 1/7! = 0.0001984127011383
80 LSP_DSP_VEC4(0x3f800000), // 1.0
81 LSP_DSP_VEC4(0x7f), // 0x7f
82 };
83
84 static const float EXP_LOG2E[] __lsp_aligned16 =
85 {
86 LSP_DSP_VEC4(M_LOG2E)
87 };
88 )
89
90 #define POW2_CORE_X8 \
91 /* xmm0 = x, xmm4 = y */ \
92 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = x */ \
93 __ASM_EMIT("movaps %%xmm4, %%xmm6") \
94 __ASM_EMIT("andps 0x00 + %[E2C], %%xmm2") /* xmm2 = XP = fabs(x) */ \
95 __ASM_EMIT("andps 0x00 + %[E2C], %%xmm6") \
96 __ASM_EMIT("psrad $31, %%xmm0") /* xmm0 = [ x < 0 ] */ \
97 __ASM_EMIT("psrad $31, %%xmm4") \
98 __ASM_EMIT("cvttps2dq %%xmm2, %%xmm3") /* xmm3 = R = int(XP) */ \
99 __ASM_EMIT("cvttps2dq %%xmm6, %%xmm7") \
100 __ASM_EMIT("movaps %%xmm3, %%xmm1") /* xmm1 = R */ \
101 __ASM_EMIT("movaps %%xmm7, %%xmm5") \
102 __ASM_EMIT("cvtdq2ps %%xmm3, %%xmm3") /* xmm3 = float(R) */ \
103 __ASM_EMIT("cvtdq2ps %%xmm7, %%xmm7") \
104 __ASM_EMIT("paddd 0xa0 + %[E2C], %%xmm1") /* xmm1 = R + 127 */ \
105 __ASM_EMIT("paddd 0xa0 + %[E2C], %%xmm5") \
106 __ASM_EMIT("subps %%xmm3, %%xmm2") /* xmm2 = XP - float(R) */ \
107 __ASM_EMIT("subps %%xmm7, %%xmm6") \
108 __ASM_EMIT("pslld $23, %%xmm1") /* xmm1 = 1 << (R+127) */ \
109 __ASM_EMIT("pslld $23, %%xmm5") \
110 __ASM_EMIT("mulps 0x10 + %[E2C], %%xmm2") /* xmm2 = X = ln(2) * (XP - float(R)) */ \
111 __ASM_EMIT("mulps 0x10 + %[E2C], %%xmm6") \
112 __ASM_EMIT("movaps %%xmm2, %%xmm3") /* xmm3 = X */ \
113 __ASM_EMIT("movaps %%xmm6, %%xmm7") \
114 /* xmm0 = [ x < 0 ], xmm1 = 1 << R, xmm2 = X, xmm3 = X */ \
115 __ASM_EMIT("addps 0x20 + %[E2C], %%xmm2") /* xmm2 = C5+X */ \
116 __ASM_EMIT("addps 0x20 + %[E2C], %%xmm6") \
117 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C5+X) */ \
118 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
119 __ASM_EMIT("addps 0x30 + %[E2C], %%xmm2") /* xmm2 = C4+(X*(C5+X)) */ \
120 __ASM_EMIT("addps 0x30 + %[E2C], %%xmm6") \
121 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C4+(X*(C5+X))) */ \
122 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
123 __ASM_EMIT("addps 0x40 + %[E2C], %%xmm2") /* xmm2 = C3+X*(C4+(X*(C5+X))) */ \
124 __ASM_EMIT("addps 0x40 + %[E2C], %%xmm6") \
125 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C3+X*(C4+(X*(C5+X)))) */ \
126 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
127 __ASM_EMIT("addps 0x50 + %[E2C], %%xmm2") /* xmm2 = C2+X*(C3+X*(C4+(X*(C5+X)))) */ \
128 __ASM_EMIT("addps 0x50 + %[E2C], %%xmm6") \
129 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C2+X*(C3+X*(C4+(X*(C5+X))))) */ \
130 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
131 __ASM_EMIT("addps 0x60 + %[E2C], %%xmm2") /* xmm2 = C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))) */ \
132 __ASM_EMIT("addps 0x60 + %[E2C], %%xmm6") \
133 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))) */ \
134 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
135 __ASM_EMIT("addps 0x70 + %[E2C], %%xmm2") /* xmm2 = C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))) */ \
136 __ASM_EMIT("addps 0x70 + %[E2C], %%xmm6") \
137 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
138 __ASM_EMIT("mulps %%xmm7, %%xmm6") \
139 __ASM_EMIT("mulps 0x80 + %[E2C], %%xmm2") /* xmm2 = 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
140 __ASM_EMIT("mulps 0x80 + %[E2C], %%xmm6") \
141 __ASM_EMIT("movaps 0x90 + %[E2C], %%xmm3") /* xmm3 = 1 */ \
142 __ASM_EMIT("movaps %%xmm3, %%xmm7") \
143 __ASM_EMIT("addps %%xmm3, %%xmm2") /* xmm2 = 1 + 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
144 __ASM_EMIT("addps %%xmm7, %%xmm6") \
145 __ASM_EMIT("mulps %%xmm1, %%xmm2") /* xmm2 = p = (1 << R) * (1 + 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))))) */ \
146 __ASM_EMIT("mulps %%xmm5, %%xmm6") \
147 __ASM_EMIT("divps %%xmm2, %%xmm3") /* xmm3 = 1/p */ \
148 __ASM_EMIT("divps %%xmm6, %%xmm7") \
149 /* xmm0 = [ x < 0 ], xmm2 = p, xmm3 = 1/p */ \
150 __ASM_EMIT("andps %%xmm0, %%xmm3") /* xmm3 = 1/p & [ x < 0] */ \
151 __ASM_EMIT("andps %%xmm4, %%xmm7") \
152 __ASM_EMIT("andnps %%xmm2, %%xmm0") /* xmm0 = p & [ x >= 0] */ \
153 __ASM_EMIT("andnps %%xmm6, %%xmm4") \
154 __ASM_EMIT("orps %%xmm3, %%xmm0") /* xmm0 = (1/p & [ x < 0]) | (p & [ x >= 0]) */ \
155 __ASM_EMIT("orps %%xmm7, %%xmm4")
156
157 #define POW2_CORE_X4 \
158 /* xmm0 = x */ \
159 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = x */ \
160 __ASM_EMIT("andps 0x00 + %[E2C], %%xmm2") /* xmm2 = XP = fabs(x) */ \
161 __ASM_EMIT("psrad $31, %%xmm0") /* xmm0 = [ x < 0 ] */ \
162 __ASM_EMIT("cvttps2dq %%xmm2, %%xmm3") /* xmm3 = R = int(XP) */ \
163 __ASM_EMIT("movaps %%xmm3, %%xmm1") /* xmm1 = R */ \
164 __ASM_EMIT("cvtdq2ps %%xmm3, %%xmm3") /* xmm3 = float(R) */ \
165 __ASM_EMIT("paddd 0xa0 + %[E2C], %%xmm1") /* xmm1 = R + 127 */ \
166 __ASM_EMIT("subps %%xmm3, %%xmm2") /* xmm2 = XP - float(R) */ \
167 __ASM_EMIT("pslld $23, %%xmm1") /* xmm1 = 1 << (R+127) */ \
168 __ASM_EMIT("mulps 0x10 + %[E2C], %%xmm2") /* xmm2 = X = ln(2) * (XP - float(R)) */ \
169 __ASM_EMIT("movaps %%xmm2, %%xmm3") /* xmm3 = X */ \
170 /* xmm0 = [ x < 0 ], xmm1 = 1 << R, xmm2 = X, xmm3 = X */ \
171 __ASM_EMIT("addps 0x20 + %[E2C], %%xmm2") /* xmm2 = C5+X */ \
172 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C5+X) */ \
173 __ASM_EMIT("addps 0x30 + %[E2C], %%xmm2") /* xmm2 = C4+(X*(C5+X)) */ \
174 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C4+(X*(C5+X))) */ \
175 __ASM_EMIT("addps 0x40 + %[E2C], %%xmm2") /* xmm2 = C3+X*(C4+(X*(C5+X))) */ \
176 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C3+X*(C4+(X*(C5+X)))) */ \
177 __ASM_EMIT("addps 0x50 + %[E2C], %%xmm2") /* xmm2 = C2+X*(C3+X*(C4+(X*(C5+X)))) */ \
178 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C2+X*(C3+X*(C4+(X*(C5+X))))) */ \
179 __ASM_EMIT("addps 0x60 + %[E2C], %%xmm2") /* xmm2 = C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))) */ \
180 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))) */ \
181 __ASM_EMIT("addps 0x70 + %[E2C], %%xmm2") /* xmm2 = C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))) */ \
182 __ASM_EMIT("mulps %%xmm3, %%xmm2") /* xmm2 = X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
183 __ASM_EMIT("mulps 0x80 + %[E2C], %%xmm2") /* xmm2 = 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
184 __ASM_EMIT("movaps 0x90 + %[E2C], %%xmm3") /* xmm3 = 1 */ \
185 __ASM_EMIT("addps %%xmm3, %%xmm2") /* xmm2 = 1 + 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X))))))) */ \
186 __ASM_EMIT("mulps %%xmm1, %%xmm2") /* xmm2 = p = (1 << R) * (1 + 1/7! * X*(C0+X*(C1+X*(C2+(X*C3+X*(C4+(X*(C5+X)))))))) */ \
187 __ASM_EMIT("divps %%xmm2, %%xmm3") /* xmm3 = 1/p */ \
188 /* xmm0 = [ x < 0 ], xmm2 = p, xmm3 = 1/p */ \
189 __ASM_EMIT("andps %%xmm0, %%xmm3") /* xmm3 = 1/p & [ x < 0] */ \
190 __ASM_EMIT("andnps %%xmm2, %%xmm0") /* xmm0 = p & [ x >= 0] */ \
191 __ASM_EMIT("orps %%xmm3, %%xmm0") /* xmm0 = (1/p & [ x < 0]) | (p & [ x >= 0]) */
192
193 #define EXP_CORE_X4 \
194 __ASM_EMIT("mulps %[LOG2E], %%xmm0") \
195 POW2_CORE_X4
196
197 #define EXP_CORE_X8 \
198 __ASM_EMIT("mulps %[LOG2E], %%xmm0") \
199 __ASM_EMIT("mulps %[LOG2E], %%xmm4") \
200 POW2_CORE_X8
201
202 void exp1(float *dst, size_t count)
203 {
204 IF_ARCH_X86(float *src);
205
206 ARCH_X86_ASM(
207 // x8 blocks
208 __ASM_EMIT("sub $8, %[count]")
209 __ASM_EMIT("jb 2f")
210 __ASM_EMIT("1:")
211 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
212 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4")
213 EXP_CORE_X8
214 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
215 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
216 __ASM_EMIT("add $0x20, %[dst]")
217 __ASM_EMIT("sub $8, %[count]")
218 __ASM_EMIT("jae 1b")
219 __ASM_EMIT("2:")
220 // x4 block
221 __ASM_EMIT("add $4, %[count]")
222 __ASM_EMIT("jl 4f")
223 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
224 EXP_CORE_X4
225 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
226 __ASM_EMIT("add $0x10, %[dst]")
227 __ASM_EMIT("sub $4, %[count]")
228 __ASM_EMIT("4:")
229 // Tail: 1x-3x block
230 __ASM_EMIT("add $4, %[count]")
231 __ASM_EMIT("jle 12f")
232 __ASM_EMIT("mov %[dst], %[src]")
233 __ASM_EMIT("test $1, %[count]")
234 __ASM_EMIT("jz 6f")
235 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
236 __ASM_EMIT("add $4, %[src]")
237 __ASM_EMIT("6:")
238 __ASM_EMIT("test $2, %[count]")
239 __ASM_EMIT("jz 8f")
240 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
241 __ASM_EMIT("8:")
242 EXP_CORE_X4
243 __ASM_EMIT("test $1, %[count]")
244 __ASM_EMIT("jz 10f")
245 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
246 __ASM_EMIT("add $4, %[dst]")
247 __ASM_EMIT("10:")
248 __ASM_EMIT("test $2, %[count]")
249 __ASM_EMIT("jz 12f")
250 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
251 __ASM_EMIT("12:")
252
253 : [dst] "+r" (dst), [src] "=&r" (src), [count] "+r" (count)
254 : [E2C] "o" (EXP2_CONST),
255 [LOG2E] "m" (EXP_LOG2E)
256 : "cc", "memory",
257 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
258 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
259 );
260 }
261
262 void exp2(float *dst, const float *src, size_t count)
263 {
264 ARCH_X86_ASM(
265 // x8 blocks
266 __ASM_EMIT("sub $8, %[count]")
267 __ASM_EMIT("jb 2f")
268 __ASM_EMIT("1:")
269 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
270 __ASM_EMIT("movups 0x10(%[src]), %%xmm4")
271 EXP_CORE_X8
272 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
273 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
274 __ASM_EMIT("add $0x20, %[src]")
275 __ASM_EMIT("add $0x20, %[dst]")
276 __ASM_EMIT("sub $8, %[count]")
277 __ASM_EMIT("jae 1b")
278 __ASM_EMIT("2:")
279 // x4 block
280 __ASM_EMIT("add $4, %[count]")
281 __ASM_EMIT("jl 4f")
282 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
283 EXP_CORE_X4
284 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
285 __ASM_EMIT("add $0x10, %[src]")
286 __ASM_EMIT("add $0x10, %[dst]")
287 __ASM_EMIT("sub $4, %[count]")
288 __ASM_EMIT("4:")
289 // Tail: 1x-3x block
290 __ASM_EMIT("add $4, %[count]")
291 __ASM_EMIT("jle 12f")
292 __ASM_EMIT("test $1, %[count]")
293 __ASM_EMIT("jz 6f")
294 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
295 __ASM_EMIT("add $4, %[src]")
296 __ASM_EMIT("6:")
297 __ASM_EMIT("test $2, %[count]")
298 __ASM_EMIT("jz 8f")
299 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
300 __ASM_EMIT("8:")
301 EXP_CORE_X4
302 __ASM_EMIT("test $1, %[count]")
303 __ASM_EMIT("jz 10f")
304 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
305 __ASM_EMIT("add $4, %[dst]")
306 __ASM_EMIT("10:")
307 __ASM_EMIT("test $2, %[count]")
308 __ASM_EMIT("jz 12f")
309 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
310 __ASM_EMIT("12:")
311
312 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
313 : [E2C] "o" (EXP2_CONST),
314 [LOG2E] "m" (EXP_LOG2E)
315 : "cc", "memory",
316 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
317 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
318 );
319 }
320
321 /*
322 const float *E2C = reinterpret_cast<const float *>(EXP2_CONST);
323
324 float XP = fabs(x);
325 int R = XP;
326 float X = (XP - float(R)) * E2C[1];
327
328 float p = E2C[9] + E2C[8]*X*(
329 E2C[7] + X*(
330 E2C[6] + X*(
331 E2C[5] + X*(
332 E2C[4] + X*(
333 E2C[3] + X*(
334 E2C[2] + X
335 )))))
336 );
337
338 p *= 1 << R;
339
340 return (x < 0.0f) ? 1.0f / p : p;
341 */
342 }
343 }
344
345 #endif /* PRIVATE_DSP_ARCH_X86_SSE2_PMATH_EXP_H_ */