38 const ptrdiff_t unroll16 = max1(16 * VEC_SIZE >> ldf);
41 const ptrdiff_t unroll8 = max1(8 * VEC_SIZE >> ldf);
44 const ptrdiff_t unroll4 = max1(4 * VEC_SIZE >> ldf);
47 const ptrdiff_t unroll2 = max1(2 * VEC_SIZE >> ldf);
50 const ptrdiff_t unroll1 = max1(1 * VEC_SIZE >> ldf);
57 for (
l = 0;
l <
nri;
l++) {
63 for (;
i < (rimap_inv_max[
l] - unroll16 + 1);
i += unroll16) {
65 for (k = 0; k < (1 << ldf); k += 16 * VEC_SIZE) {
66 register VEC_TYPE a0, a1, a2, a3;
67 register VEC_TYPE a4, a5, a6, a7;
68 register VEC_TYPE a8, a9, aa, ab;
69 register VEC_TYPE ac, ad, ae, af;
71 a0 = a1 = a2 = a3 = VEC_ZERO;
72 a4 = a5 = a6 = a7 = VEC_ZERO;
73 a8 = a9 = aa = ab = VEC_ZERO;
74 ac = ad = ae = af = VEC_ZERO;
78 for (
j = 0;
j < npairs;
j++) {
79 register VEC_TYPE wj = VEC_SCAL(wpair[
j]);
82 register VEC_TYPE pos = LOAD(fi + indexj_pos);
83 register VEC_TYPE neg = LOAD(fi + indexj_neg);
84 a0 = VEC_FMA(wj, VEC_SUB(pos, neg), a0);
85 pos = LOAD(fi + indexj_pos + 1 * VEC_SIZE);
86 neg = LOAD(fi + indexj_neg + 1 * VEC_SIZE);
87 a1 = VEC_FMA(wj, VEC_SUB(pos, neg), a1);
88 pos = LOAD(fi + indexj_pos + 2 * VEC_SIZE);
89 neg = LOAD(fi + indexj_neg + 2 * VEC_SIZE);
90 a2 = VEC_FMA(wj, VEC_SUB(pos, neg), a2);
91 pos = LOAD(fi + indexj_pos + 3 * VEC_SIZE);
92 neg = LOAD(fi + indexj_neg + 3 * VEC_SIZE);
93 a3 = VEC_FMA(wj, VEC_SUB(pos, neg), a3);
94 pos = LOAD(fi + indexj_pos + 4 * VEC_SIZE);
95 neg = LOAD(fi + indexj_neg + 4 * VEC_SIZE);
96 a4 = VEC_FMA(wj, VEC_SUB(pos, neg), a4);
97 pos = LOAD(fi + indexj_pos + 5 * VEC_SIZE);
98 neg = LOAD(fi + indexj_neg + 5 * VEC_SIZE);
99 a5 = VEC_FMA(wj, VEC_SUB(pos, neg), a5);
100 pos = LOAD(fi + indexj_pos + 6 * VEC_SIZE);
101 neg = LOAD(fi + indexj_neg + 6 * VEC_SIZE);
102 a6 = VEC_FMA(wj, VEC_SUB(pos, neg), a6);
103 pos = LOAD(fi + indexj_pos + 7 * VEC_SIZE);
104 neg = LOAD(fi + indexj_neg + 7 * VEC_SIZE);
105 a7 = VEC_FMA(wj, VEC_SUB(pos, neg), a7);
106 pos = LOAD(fi + indexj_pos + 8 * VEC_SIZE);
107 neg = LOAD(fi + indexj_neg + 8 * VEC_SIZE);
108 a8 = VEC_FMA(wj, VEC_SUB(pos, neg), a8);
109 pos = LOAD(fi + indexj_pos + 9 * VEC_SIZE);
110 neg = LOAD(fi + indexj_neg + 9 * VEC_SIZE);
111 a9 = VEC_FMA(wj, VEC_SUB(pos, neg), a9);
112 pos = LOAD(fi + indexj_pos + 10 * VEC_SIZE);
113 neg = LOAD(fi + indexj_neg + 10 * VEC_SIZE);
114 aa = VEC_FMA(wj, VEC_SUB(pos, neg), aa);
115 pos = LOAD(fi + indexj_pos + 11 * VEC_SIZE);
116 neg = LOAD(fi + indexj_neg + 11 * VEC_SIZE);
117 ab = VEC_FMA(wj, VEC_SUB(pos, neg), ab);
118 pos = LOAD(fi + indexj_pos + 12 * VEC_SIZE);
119 neg = LOAD(fi + indexj_neg + 12 * VEC_SIZE);
120 ac = VEC_FMA(wj, VEC_SUB(pos, neg), ac);
121 pos = LOAD(fi + indexj_pos + 13 * VEC_SIZE);
122 neg = LOAD(fi + indexj_neg + 13 * VEC_SIZE);
123 ad = VEC_FMA(wj, VEC_SUB(pos, neg), ad);
124 pos = LOAD(fi + indexj_pos + 14 * VEC_SIZE);
125 neg = LOAD(fi + indexj_neg + 14 * VEC_SIZE);
126 ae = VEC_FMA(wj, VEC_SUB(pos, neg), ae);
127 pos = LOAD(fi + indexj_pos + 15 * VEC_SIZE);
128 neg = LOAD(fi + indexj_neg + 15 * VEC_SIZE);
129 af = VEC_FMA(wj, VEC_SUB(pos, neg), af);
132 STORE(fo + base_ik, a0);
133 STORE(fo + base_ik + 1 * VEC_SIZE, a1);
134 STORE(fo + base_ik + 2 * VEC_SIZE, a2);
135 STORE(fo + base_ik + 3 * VEC_SIZE, a3);
136 STORE(fo + base_ik + 4 * VEC_SIZE, a4);
137 STORE(fo + base_ik + 5 * VEC_SIZE, a5);
138 STORE(fo + base_ik + 6 * VEC_SIZE, a6);
139 STORE(fo + base_ik + 7 * VEC_SIZE, a7);
140 STORE(fo + base_ik + 8 * VEC_SIZE, a8);
141 STORE(fo + base_ik + 9 * VEC_SIZE, a9);
142 STORE(fo + base_ik + 10 * VEC_SIZE, aa);
143 STORE(fo + base_ik + 11 * VEC_SIZE, ab);
144 STORE(fo + base_ik + 12 * VEC_SIZE, ac);
145 STORE(fo + base_ik + 13 * VEC_SIZE, ad);
146 STORE(fo + base_ik + 14 * VEC_SIZE, ae);
147 STORE(fo + base_ik + 15 * VEC_SIZE, af);
153 for (;
i < (rimap_inv_max[
l] - unroll8 + 1);
i += unroll8) {
155 for (k = 0; k < (1 << ldf); k += 8 * VEC_SIZE) {
156 register VEC_TYPE a0, a1, a2, a3;
157 register VEC_TYPE a4, a5, a6, a7;
159 a0 = a1 = a2 = a3 = VEC_ZERO;
160 a4 = a5 = a6 = a7 = VEC_ZERO;
164 for (
j = 0;
j < npairs;
j++) {
165 register VEC_TYPE wj = VEC_SCAL(wpair[
j]);
168 register VEC_TYPE pos = LOAD(fi + indexj_pos);
169 register VEC_TYPE neg = LOAD(fi + indexj_neg);
170 a0 = VEC_FMA(wj, VEC_SUB(pos, neg), a0);
171 pos = LOAD(fi + indexj_pos + 1 * VEC_SIZE);
172 neg = LOAD(fi + indexj_neg + 1 * VEC_SIZE);
173 a1 = VEC_FMA(wj, VEC_SUB(pos, neg), a1);
174 pos = LOAD(fi + indexj_pos + 2 * VEC_SIZE);
175 neg = LOAD(fi + indexj_neg + 2 * VEC_SIZE);
176 a2 = VEC_FMA(wj, VEC_SUB(pos, neg), a2);
177 pos = LOAD(fi + indexj_pos + 3 * VEC_SIZE);
178 neg = LOAD(fi + indexj_neg + 3 * VEC_SIZE);
179 a3 = VEC_FMA(wj, VEC_SUB(pos, neg), a3);
180 pos = LOAD(fi + indexj_pos + 4 * VEC_SIZE);
181 neg = LOAD(fi + indexj_neg + 4 * VEC_SIZE);
182 a4 = VEC_FMA(wj, VEC_SUB(pos, neg), a4);
183 pos = LOAD(fi + indexj_pos + 5 * VEC_SIZE);
184 neg = LOAD(fi + indexj_neg + 5 * VEC_SIZE);
185 a5 = VEC_FMA(wj, VEC_SUB(pos, neg), a5);
186 pos = LOAD(fi + indexj_pos + 6 * VEC_SIZE);
187 neg = LOAD(fi + indexj_neg + 6 * VEC_SIZE);
188 a6 = VEC_FMA(wj, VEC_SUB(pos, neg), a6);
189 pos = LOAD(fi + indexj_pos + 7 * VEC_SIZE);
190 neg = LOAD(fi + indexj_neg + 7 * VEC_SIZE);
191 a7 = VEC_FMA(wj, VEC_SUB(pos, neg), a7);
193 STORE(fo + base_ik, a0);
194 STORE(fo + base_ik + 1 * VEC_SIZE, a1);
195 STORE(fo + base_ik + 2 * VEC_SIZE, a2);
196 STORE(fo + base_ik + 3 * VEC_SIZE, a3);
197 STORE(fo + base_ik + 4 * VEC_SIZE, a4);
198 STORE(fo + base_ik + 5 * VEC_SIZE, a5);
199 STORE(fo + base_ik + 6 * VEC_SIZE, a6);
200 STORE(fo + base_ik + 7 * VEC_SIZE, a7);
206 for (;
i < (rimap_inv_max[
l] - unroll4 + 1);
i += unroll4) {
208 for (k = 0; k < (1 << ldf); k += 4 * VEC_SIZE) {
209 register VEC_TYPE a0, a1, a2, a3;
211 a0 = a1 = a2 = a3 = VEC_ZERO;
215 for (
j = 0;
j < npairs;
j++) {
216 register VEC_TYPE wj = VEC_SCAL(wpair[
j]);
219 register VEC_TYPE pos = LOAD(fi + indexj_pos);
220 register VEC_TYPE neg = LOAD(fi + indexj_neg);
221 a0 = VEC_FMA(wj, VEC_SUB(pos, neg), a0);
222 pos = LOAD(fi + indexj_pos + 1 * VEC_SIZE);
223 neg = LOAD(fi + indexj_neg + 1 * VEC_SIZE);
224 a1 = VEC_FMA(wj, VEC_SUB(pos, neg), a1);
225 pos = LOAD(fi + indexj_pos + 2 * VEC_SIZE);
226 neg = LOAD(fi + indexj_neg + 2 * VEC_SIZE);
227 a2 = VEC_FMA(wj, VEC_SUB(pos, neg), a2);
228 pos = LOAD(fi + indexj_pos + 3 * VEC_SIZE);
229 neg = LOAD(fi + indexj_neg + 3 * VEC_SIZE);
230 a3 = VEC_FMA(wj, VEC_SUB(pos, neg), a3);
232 STORE(fo + base_ik, a0);
233 STORE(fo + base_ik + 1 * VEC_SIZE, a1);
234 STORE(fo + base_ik + 2 * VEC_SIZE, a2);
235 STORE(fo + base_ik + 3 * VEC_SIZE, a3);
241 for (;
i < (rimap_inv_max[
l] - unroll2 + 1);
i += unroll2) {
243 for (k = 0; k < (1 << ldf); k += 2 * VEC_SIZE) {
244 register VEC_TYPE a0, a1;
250 for (
j = 0;
j < npairs;
j++) {
251 register VEC_TYPE wj = VEC_SCAL(wpair[
j]);
254 register VEC_TYPE pos = LOAD(fi + indexj_pos);
255 register VEC_TYPE neg = LOAD(fi + indexj_neg);
256 a0 = VEC_FMA(wj, VEC_SUB(pos, neg), a0);
257 pos = LOAD(fi + indexj_pos + 1 * VEC_SIZE);
258 neg = LOAD(fi + indexj_neg + 1 * VEC_SIZE);
259 a1 = VEC_FMA(wj, VEC_SUB(pos, neg), a1);
261 STORE(fo + base_ik, a0);
262 STORE(fo + base_ik + 1 * VEC_SIZE, a1);
268 for (;
i < (rimap_inv_max[
l] - unroll1 + 1);
i += unroll1) {
270 for (k = 0; k < (1 << ldf); k += VEC_SIZE) {
271 register VEC_TYPE a0 = VEC_ZERO;
273 for (
j = 0;
j < npairs;
j++) {
274 register VEC_TYPE wj = VEC_SCAL(wpair[
j]);
277 register VEC_TYPE pos = LOAD(fi + indexj_pos);
278 register VEC_TYPE neg = LOAD(fi + indexj_neg);
279 a0 = VEC_FMA(wj, VEC_SUB(pos, neg), a0);
281 STORE(fo + base_ik, a0);
291 for (;
i < rimap_inv_max[
l];
i++) {
295 for (
j = 0;
j < npairs;
j++) {
298 const double diff = fi[indexj_pos] - fi[indexj_neg];
299 a += wpair[
j] * diff;
310#if defined(ALIGNED) && defined(STREAM) && defined(FENCE)
const int *restrict index_neg
const int *restrict index_pos