我正试图在i7上以最有效的方式计算浮点数和位向量之间的点积。 实际上，我在128或256维向量上进行此操作，但为了说明，让我编写64维代码来说明问题：
// a has 64 elements. b is a bitvector of 64 dimensions.
float dot(float *restrict a, uint64_t b) {
float sum = 0;
for(int i=0; b && i<64; i++, b>>=1) {
if (b & 1) sum += a[i];
}
return sum;
}
当然，这是有效的，但问题是，这是整个程序的时间关键点（占用50分钟运行的95％CPU时间）所以我迫切需要让它更快。
我的猜测是上面的分支是游戏杀手（防止无序执行，导致错误的分支预测）。 我不确定矢量指令是否可以在这里使用和帮助。 使用gcc 4.8和-std = c99 -march = native -mtune = native -Ofast -funroll-loops，我现在得到这个输出
movl $4660, %edx
movl $5, %ecx
xorps %xmm0, %xmm0
.p2align 4,,10
.p2align 3
.L4:
testb $1, %cl
je .L2
addss (%rdx), %xmm0
.L2:
leaq 4(%rdx), %rax
shrq %rcx
testb $1, %cl
je .L8
addss 4(%rdx), %xmm0
.L8:
shrq %rcx
testb $1, %cl
je .L9
addss 4(%rax), %xmm0
.L9:
shrq %rcx
testb $1, %cl
je .L10
addss 8(%rax), %xmm0
.L10:
shrq %rcx
testb $1, %cl
je .L11
addss 12(%rax), %xmm0
.L11:
shrq %rcx
testb $1, %cl
je .L12
addss 16(%rax), %xmm0
.L12:
shrq %rcx
testb $1, %cl
je .L13
addss 20(%rax), %xmm0
.L13:
shrq %rcx
testb $1, %cl
je .L14
addss 24(%rax), %xmm0
.L14:
leaq 28(%rax), %rdx
shrq %rcx
cmpq $4916, %rdx
jne .L4
ret
编辑可以置换数据（只要所有参数的排列相同），排序无关紧要。
我想知道是否有一些东西可以在Chris Dodd的SSE2代码的3倍速度下工作。
新笔记：AVX / AVX2代码也欢迎！
编辑2 给定一个位向量，我必须将它与128（或256，如果它是256位）不同的浮点向量相乘（所以它也可以一次涉及更多的单个浮点向量）。这是整个过程。任何能够加速整个过程的东西也是受欢迎的！
答案 0 :(得分：16)
最好的选择是使用SSE ps指令，一次操作4个浮点数。你可以利用浮点数0.0都是0位的事实来使用andps指令掩盖不需要的元素：
#include <stdint.h>
#include <xmmintrin.h>
union {
uint32_t i[4];
__m128 xmm;
} mask[16] = {
{ 0, 0, 0, 0 },
{ ~0, 0, 0, 0 },
{ 0, ~0, 0, 0 },
{ ~0, ~0, 0, 0 },
{ 0, 0, ~0, 0 },
{ ~0, 0, ~0, 0 },
{ 0, ~0, ~0, 0 },
{ ~0, ~0, ~0, 0 },
{ 0, 0, 0, ~0 },
{ ~0, 0, 0, ~0 },
{ 0, ~0, 0, ~0 },
{ ~0, ~0, 0, ~0 },
{ 0, 0, ~0, ~0 },
{ ~0, 0, ~0, ~0 },
{ 0, ~0, ~0, ~0 },
{ ~0, ~0, ~0, ~0 },
};
float dot(__m128 *a, uint64_t b) {
__m128 sum = { 0.0 };
for (int i = 0; i < 16; i++, b>>=4)
sum += _mm_and_ps(a[i], mask[b&0xf].xmm);
return sum[0] + sum[1] + sum[2] + sum[3];
}
如果您希望掩码中有很多0，那么短暂地缩短0可能会更快：
for (int i = 0; b; i++, b >>= 4)
if (b & 0xf)
sum += _mm_and_ps(a[i], mask[b&0xf].xmm);
但如果b是随机的，这将会更慢。
答案 1 :(得分：7)
为了扩展Aki Suihkonen的答案，重新塑造位串有助于有条件地移动浮子。在下面的解决方案中，使用SSE指令PMOVMASKB和PSHUFB进行两级位置换，加上指令BLENDVPS已用于在Core 2 Duo 2.26GHz上实现1.25个元素处理/周期，这是我参考速度的20倍C代码。
[编辑：增加了AVX2实施。性能未知，因为我不能自己测试，但预计速度会加倍。 ]
这是我的实现和测试平台，解释如下。
/* Includes */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <smmintrin.h> /* SSE 4.1 */
#include <time.h>
/* Defines */
#define ALIGNTO(n) __attribute__((aligned(n)))
#define USE_PINSRW 1
#define NUM_ITERS 2260000
/**
* Bit mask shuffle.
*
* This version uses a loop to store eight u16 and reloads them as one __m128i.
*/
__m128 bitMaskShuffleStoreAndReload(__m128i mask){
const __m128i perm ALIGNTO(16) = _mm_set_epi8(15, 7, 14, 6, 13, 5, 12, 4,
11, 3, 10, 2, 9, 1, 8, 0);
int i;
uint16_t interMask[8] ALIGNTO(16);
/* Shuffle bitmask */
/* Stage 1 */
for(i=7;i>=0;i--){
interMask[i] = _mm_movemask_epi8(mask);
mask = _mm_slli_epi32(mask, 1);
}
/* Stage 2 */
return _mm_castsi128_ps(
_mm_shuffle_epi8(
_mm_load_si128((const __m128i*)interMask),
perm)
);
}
/**
* Bit mask shuffle.
*
* This version uses the PINSTRW instruction.
*/
__m128 bitMaskShufflePINSRW(__m128i mask){
const __m128i perm ALIGNTO(16) = _mm_set_epi8(15, 7, 14, 6, 13, 5, 12, 4,
11, 3, 10, 2, 9, 1, 8, 0);
__m128i imask ALIGNTO(16);
/* Shuffle bitmask */
/* Stage 1 */
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 7);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 6);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 5);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 4);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 3);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 2);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 1);
mask = _mm_slli_epi16(mask, 1);
imask = _mm_insert_epi16(imask, _mm_movemask_epi8(mask), 0);
/* Stage 2 */
return _mm_castsi128_ps(
_mm_shuffle_epi8(
imask,
perm)
);
}
/**
* SSE 4.1 implementation.
*/
float dotSSE41(__m128 f[32], unsigned char maskArg[16]){
int i, j, k;
__m128i mask ALIGNTO(16) = _mm_load_si128((const __m128i*)maskArg);
__m128 shufdMask ALIGNTO(16);
__m128 zblended ALIGNTO(16);
__m128 sums ALIGNTO(16) = _mm_setzero_ps();
float sumsf[4] ALIGNTO(16);
/* Shuffle bitmask */
#if USE_PINSRW
shufdMask = bitMaskShufflePINSRW(mask);
#else
shufdMask = bitMaskShuffleStoreAndReload(mask);
#endif
/* Dot product */
for(i=1;i>=0;i--){
for(j=1;j>=0;j--){
for(k=7;k>=0;k--){
zblended = _mm_setzero_ps();
zblended = _mm_blendv_ps(zblended, f[i*16+j+k*2], shufdMask);
sums = _mm_add_ps(sums, zblended);
shufdMask = _mm_castsi128_ps(_mm_slli_epi32(_mm_castps_si128(shufdMask), 1));
}
}
}
/* Final Summation */
_mm_store_ps(sumsf, sums);
return sumsf[0] + sumsf[1] + sumsf[2] + sumsf[3];
}
/**
* Reference C implementation
*/
float dotRefC(float f[128], unsigned char mask[16]){
float sum = 0.0;
int i;
for(i=0;i<128;i++){
sum += ((mask[i>>3]>>(i&7))&1) ? f[i] : 0.0;
}
return sum;
}
/**
* Main
*/
int main(void){
/* Variables */
/* Loop Counter */
int i;
/* Data to process */
float data[128] ALIGNTO(16);
unsigned char mask[16] ALIGNTO(16);
float refCSum, sseSum;
/* Time tracking */
clock_t t1, t2, t3;
double refCTime, sseTime;
/* Initialize mask and float arrays with some random data. */
for(i=0;i<128;i++){
if(i<16)
mask[i]=rand();
data[i] = random();
}
/* RUN TESTS */
t1 = clock();
for(i=0;i<NUM_ITERS;i++){
refCSum = dotRefC(data, mask);
}
t2 = clock();
for(i=0;i<NUM_ITERS;i++){
sseSum = dotSSE41((__m128*)data, mask);
}
t3 = clock();
/* Compute time taken */
refCTime = (double)(t2-t1)/CLOCKS_PER_SEC;
sseTime = (double)(t3-t2)/CLOCKS_PER_SEC;
/* Print out results */
printf("Results:\n"
"RefC: Time: %f Value: %f\n"
"SSE: Time: %f Value: %f\n",
refCTime, refCSum,
sseTime, sseSum);
return 0;
}
BLENDVPS使用128位寄存器XMM0的所有四个32位通道中的最高位来确定是否移动其源操作数的相应通道中的值到其目标操作数。使用MOVAPS加载数据时，会得到4个连续的浮点数：例如，第8，第9，第10和第11个浮点数。当然，它们的选择或取消选择必须由相应的位组控制：例如，位串中的第8，第9，第10和第11位。
问题在于，当首次加载掩码时，这些组的位彼此正好（在第8，第9，第10和第11位置），实际上它们应该相隔32位;请记住，在某些时候，它们必须占据每个通道的第31位位置（XMM0寄存器中的第31位，第63位，第95位和第127位）。
理想情况下会发生一个位转换，它会在通道0，位，0位，4位，8位，12位... 1，5,9,13 ......，在第一车道，第2，第6，第10，第14 ......，第2车道，第3，第7，第11，第15 ......，第3车道。因此，先前连续的所有4比特组现在跨越32比特，在四个32比特通道中的每一个中一个。然后所需要的是一个迭代32次的循环，每次移动到每个通道的最高位位置一组新的4位。
不幸的是，x86没有良好的位操作指令，所以由于缺乏一种完美换位的简洁方法，这里的合理折衷就是。
在掩码中，128位
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
通过8个PMOVMASKB和8个PSLLW指令进行置换，首先是
0 8 16 24 32 40 48 56 64 72 80 88 96 104 112 120
1 9 17 25 33 41 49 57 65 73 81 89 97 105 113 121
2 10 18 26 34 42 50 58 66 74 82 90 98 106 114 122
3 11 19 27 35 43 51 59 67 75 83 91 99 107 115 123
4 12 20 28 36 44 52 60 68 76 84 92 100 108 116 124
5 13 21 29 37 45 53 61 69 77 85 93 101 109 117 125
6 14 22 30 38 46 54 62 70 78 86 94 102 110 118 126
7 15 23 31 39 47 55 63 71 79 87 95 103 111 119 127
并通过单个PSHUFB指令
0 8 16 24 32 40 48 56 4 12 20 28 36 44 52 60
64 72 80 88 96 104 112 120 68 76 84 92 100 108 116 124
1 9 17 25 33 41 49 57 5 13 21 29 37 45 53 61
65 73 81 89 97 105 113 121 69 77 85 93 101 109 117 125
2 10 18 26 34 42 50 58 6 14 22 30 38 46 54 62
66 74 82 90 98 106 114 122 70 78 86 94 102 110 118 126
3 11 19 27 35 43 51 59 7 15 23 31 39 47 55 63
67 75 83 91 99 107 115 123 71 79 87 95 103 111 119 127
。我们现在迭代四次“运行”，每次运行包含8组，每组间隔32位（如我们所希望的那样），使用这些集合作为BLENDVPS的屏蔽控制。 bit shuffle固有的尴尬导致dotSSE41()中看起来笨拙的三重嵌套循环，但是
clang -Ofast -ftree-vectorize -finline-functions -funroll-loops -msse4.1 -mssse3 dot.c -o dottest
无论如何都要展开循环。内循环迭代由16次重复
组成blendvps 0x90(%rsi),%xmm1
addps %xmm4,%xmm1
pslld $0x1,%xmm2
movdqa %xmm2,%xmm0
xorps %xmm4,%xmm4
顺便说一句，我无法确定哪个版本的两个版本最快，所以我在答案中给出了两个实现。
/* Includes */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <immintrin.h> /* AVX2 */
#include <time.h>
/* Defines */
#define ALIGNTO(n) __attribute__((aligned(n)))
#define NUM_ITERS 2260000
/**
* Bit mask shuffle.
*
* This version uses the PINSTRW instruction.
*/
__m256 bitMaskShufflePINSRW(__m256i mask){
__m256i imask ALIGNTO(32);
/* Shuffle bitmask */
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 7);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 6);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 5);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 4);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 3);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 2);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 1);
mask = _mm256_slli_epi32(mask, 1);
imask = _mm256_insert_epi32(imask, _mm256_movemask_epi8(mask), 0);
/* Return bitmask */
return _mm256_castsi256_ps(imask);
}
/**
* AVX2 implementation.
*/
float dotAVX2(__m256 f[16], unsigned char maskArg[16]){
int i, j, k;
/* Use _mm_loadu_si128 */
__m256i mask ALIGNTO(32) = _mm256_castsi128_si256(_mm_load_si128((const __m128i*)maskArg));
__m256 shufdMask ALIGNTO(32);
__m256 zblended ALIGNTO(32);
__m256 sums ALIGNTO(32) = _mm256_setzero_ps();
float sumsf[8] ALIGNTO(32);
/* Shuffle bitmask */
shufdMask = bitMaskShufflePINSRW(mask);
shufdMask = _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_castps_si256(shufdMask), 16));
/* Dot product */
for(i=15;i>=0;i--){
zblended = _mm256_setzero_ps();
/* Replace f[i] with _mm256_loadu_ps((float*)&f[i]) */
zblended = _mm256_blendv_ps(zblended, f[i], shufdMask);
sums = _mm256_add_ps(sums, zblended);
shufdMask = _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_castps_si256(shufdMask), 1));
}
/* Final Summation */
_mm256_store_ps(sumsf, sums);
return sumsf[0] + sumsf[1] + sumsf[2] + sumsf[3] + sumsf[4] + sumsf[5] + sumsf[6] + sumsf[7];
}
/**
* Reference C implementation
*/
float dotRefC(float f[128], unsigned char mask[16]){
float sum = 0.0;
int i;
for(i=0;i<128;i++){
sum += ((mask[i>>3]>>(i&7))&1) ? f[i] : 0.0;
}
return sum;
}
/**
* Main
*/
int main(void){
/* Variables */
/* Loop Counter */
int i;
/* Data to process */
float data[128] ALIGNTO(32);
unsigned char mask[16] ALIGNTO(32);
float refCSum, sseSum;
/* Time tracking */
clock_t t1, t2, t3;
double refCTime, sseTime;
/* Initialize mask and float arrays with some random data. */
for(i=0;i<128;i++){
if(i<16)
mask[i]=rand();
data[i] = random();
}
/* RUN TESTS */
t1 = clock();
for(i=0;i<NUM_ITERS;i++){
refCSum = dotRefC(data, mask);
}
t2 = clock();
for(i=0;i<NUM_ITERS;i++){
sseSum = dotAVX2((__m256*)data, mask);
}
t3 = clock();
/* Compute time taken */
refCTime = (double)(t2-t1)/CLOCKS_PER_SEC;
sseTime = (double)(t3-t2)/CLOCKS_PER_SEC;
/* Print out results */
printf("Results:\n"
"RefC: Time: %f Value: %f\n"
"SSE: Time: %f Value: %f\n",
refCTime, refCSum,
sseTime, sseSum);
return 0;
}
使用与SSE4.1相同的概念。不同的是，现在我们一次处理8个浮点数，并使用AVX2的256位寄存器和来自ymm寄存器的PMOVMASKB（收集256/8 = 32位）。因此，我们现在有一个更简单的位掩码shuffle和一个更简单的循环。
在掩码中，256位
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
使用8 PMOVMASKB和8 PSLLW指令进行置换
0 8 16 24 32 40 48 56 64 72 80 88 96 104 112 120
128 136 144 152 160 168 176 184 192 200 208 216 224 232 240 248
1 9 17 25 33 41 49 57 65 73 81 89 97 105 113 121
129 137 145 153 161 169 177 185 193 201 209 217 225 233 241 249
2 10 18 26 34 42 50 58 66 74 82 90 98 106 114 122
130 138 146 154 162 170 178 186 194 202 210 218 226 234 242 250
3 11 19 27 35 43 51 59 67 75 83 91 99 107 115 123
131 139 147 155 163 171 179 187 195 203 211 219 227 235 243 251
4 12 20 28 36 44 52 60 68 76 84 92 100 108 116 124
132 140 148 156 164 172 180 188 196 204 212 220 228 236 244 252
5 13 21 29 37 45 53 61 69 77 85 93 101 109 117 125
133 141 149 157 165 173 181 189 197 205 213 221 229 237 245 253
6 14 22 30 38 46 54 62 70 78 86 94 102 110 118 126
134 142 150 158 166 174 182 190 198 206 214 222 230 238 246 254
7 15 23 31 39 47 55 63 71 79 87 95 103 111 119 127
135 143 151 159 167 175 183 191 199 207 215 223 231 239 247 255
。对于128元素的浮点阵产品，我们然后在8组16个元素上并行迭代。通过迭代32个元素集，可以轻松地为256个元素的DP扩展该实现。现在只需要一个循环。
具体来说，要将其更改为256-elment dot产品，您可以
__m256 f[32], unsigned char maskArg[32]。= _mm256_castsi128_si256(_mm_load_si128((const __m128i*)maskArg));交换蒙版加载（= _mm256_load_si256((const __m256i*)maskArg);）。bitMaskShufflePINSRW号召唤下方16左侧的补偿转移。 for(i=31;i>=0;i--) 我既不能测试也不能运行代码，因为我的CPU是SSE4.1 ，但是Clang with
clang -Ofast -ftree-vectorize -finline-functions -funroll-loops -mavx2 -msse4.1 -mssse3 dotavx2.c -o dottest
干净地编译（你可以在不展开的情况下获得更快的代码），产生这个：
(gdb) disas dotAVX2
Dump of assembler code for function dotAVX2:
0x0000000100001730 <+0>: push %rbp
0x0000000100001731 <+1>: mov %rsp,%rbp
0x0000000100001734 <+4>: vmovdqa (%rsi),%xmm0
0x0000000100001738 <+8>: vpslld $0x1,%ymm0,%ymm1
0x000000010000173d <+13>: vpslld $0x1,%ymm1,%ymm2
0x0000000100001742 <+18>: vpmovmskb %ymm2,%eax
0x0000000100001746 <+22>: vpslld $0x1,%ymm2,%ymm2
0x000000010000174b <+27>: vpmovmskb %ymm2,%ecx
0x000000010000174f <+31>: vxorps %ymm3,%ymm3,%ymm3
0x0000000100001753 <+35>: vmovd %ecx,%xmm4
0x0000000100001757 <+39>: vpinsrd $0x1,%eax,%xmm4,%xmm4
0x000000010000175d <+45>: vpmovmskb %ymm1,%eax
0x0000000100001761 <+49>: vpinsrd $0x2,%eax,%xmm4,%xmm1
0x0000000100001767 <+55>: vpslld $0x1,%ymm2,%ymm2
0x000000010000176c <+60>: vpslld $0x1,%ymm2,%ymm4
0x0000000100001771 <+65>: vpslld $0x1,%ymm4,%ymm5
0x0000000100001776 <+70>: vpmovmskb %ymm0,%eax
0x000000010000177a <+74>: vpinsrd $0x3,%eax,%xmm1,%xmm0
0x0000000100001780 <+80>: vpmovmskb %ymm5,%eax
0x0000000100001784 <+84>: vpslld $0x1,%ymm5,%ymm1
0x0000000100001789 <+89>: vpmovmskb %ymm1,%ecx
0x000000010000178d <+93>: vmovd %ecx,%xmm1
0x0000000100001791 <+97>: vpinsrd $0x1,%eax,%xmm1,%xmm1
0x0000000100001797 <+103>: vpmovmskb %ymm4,%eax
0x000000010000179b <+107>: vpinsrd $0x2,%eax,%xmm1,%xmm1
0x00000001000017a1 <+113>: vpmovmskb %ymm2,%eax
0x00000001000017a5 <+117>: vpinsrd $0x3,%eax,%xmm1,%xmm1
0x00000001000017ab <+123>: vinserti128 $0x1,%xmm0,%ymm1,%ymm0
0x00000001000017b1 <+129>: vpslld $0x10,%ymm0,%ymm0
0x00000001000017b6 <+134>: vblendvps %ymm0,0x1e0(%rdi),%ymm3,%ymm1
0x00000001000017c0 <+144>: vpslld $0x1,%ymm0,%ymm0
0x00000001000017c5 <+149>: vblendvps %ymm0,0x1c0(%rdi),%ymm3,%ymm2
0x00000001000017cf <+159>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000017d3 <+163>: vpslld $0x1,%ymm0,%ymm0
0x00000001000017d8 <+168>: vblendvps %ymm0,0x1a0(%rdi),%ymm3,%ymm2
0x00000001000017e2 <+178>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000017e6 <+182>: vpslld $0x1,%ymm0,%ymm0
0x00000001000017eb <+187>: vblendvps %ymm0,0x180(%rdi),%ymm3,%ymm2
0x00000001000017f5 <+197>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000017f9 <+201>: vpslld $0x1,%ymm0,%ymm0
0x00000001000017fe <+206>: vblendvps %ymm0,0x160(%rdi),%ymm3,%ymm2
0x0000000100001808 <+216>: vaddps %ymm2,%ymm1,%ymm1
0x000000010000180c <+220>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001811 <+225>: vblendvps %ymm0,0x140(%rdi),%ymm3,%ymm2
0x000000010000181b <+235>: vaddps %ymm2,%ymm1,%ymm1
0x000000010000181f <+239>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001824 <+244>: vblendvps %ymm0,0x120(%rdi),%ymm3,%ymm2
0x000000010000182e <+254>: vaddps %ymm2,%ymm1,%ymm1
0x0000000100001832 <+258>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001837 <+263>: vblendvps %ymm0,0x100(%rdi),%ymm3,%ymm2
0x0000000100001841 <+273>: vaddps %ymm2,%ymm1,%ymm1
0x0000000100001845 <+277>: vpslld $0x1,%ymm0,%ymm0
0x000000010000184a <+282>: vblendvps %ymm0,0xe0(%rdi),%ymm3,%ymm2
0x0000000100001854 <+292>: vaddps %ymm2,%ymm1,%ymm1
0x0000000100001858 <+296>: vpslld $0x1,%ymm0,%ymm0
0x000000010000185d <+301>: vblendvps %ymm0,0xc0(%rdi),%ymm3,%ymm2
0x0000000100001867 <+311>: vaddps %ymm2,%ymm1,%ymm1
0x000000010000186b <+315>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001870 <+320>: vblendvps %ymm0,0xa0(%rdi),%ymm3,%ymm2
0x000000010000187a <+330>: vaddps %ymm2,%ymm1,%ymm1
0x000000010000187e <+334>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001883 <+339>: vblendvps %ymm0,0x80(%rdi),%ymm3,%ymm2
0x000000010000188d <+349>: vaddps %ymm2,%ymm1,%ymm1
0x0000000100001891 <+353>: vpslld $0x1,%ymm0,%ymm0
0x0000000100001896 <+358>: vblendvps %ymm0,0x60(%rdi),%ymm3,%ymm2
0x000000010000189d <+365>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000018a1 <+369>: vpslld $0x1,%ymm0,%ymm0
0x00000001000018a6 <+374>: vblendvps %ymm0,0x40(%rdi),%ymm3,%ymm2
0x00000001000018ad <+381>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000018b1 <+385>: vpslld $0x1,%ymm0,%ymm0
0x00000001000018b6 <+390>: vblendvps %ymm0,0x20(%rdi),%ymm3,%ymm2
0x00000001000018bd <+397>: vaddps %ymm2,%ymm1,%ymm1
0x00000001000018c1 <+401>: vpslld $0x1,%ymm0,%ymm0
0x00000001000018c6 <+406>: vblendvps %ymm0,(%rdi),%ymm3,%ymm0
0x00000001000018cc <+412>: vaddps %ymm0,%ymm1,%ymm0
0x00000001000018d0 <+416>: vpshufd $0x1,%xmm0,%xmm1
0x00000001000018d5 <+421>: vaddss %xmm1,%xmm0,%xmm1
0x00000001000018d9 <+425>: vmovhlps %xmm0,%xmm0,%xmm2
0x00000001000018dd <+429>: vaddss %xmm1,%xmm2,%xmm1
0x00000001000018e1 <+433>: vpshufd $0x3,%xmm0,%xmm2
0x00000001000018e6 <+438>: vaddss %xmm1,%xmm2,%xmm1
0x00000001000018ea <+442>: vextracti128 $0x1,%ymm0,%xmm0
0x00000001000018f0 <+448>: vaddss %xmm1,%xmm0,%xmm1
0x00000001000018f4 <+452>: vpshufd $0x1,%xmm0,%xmm2
0x00000001000018f9 <+457>: vaddss %xmm1,%xmm2,%xmm1
0x00000001000018fd <+461>: vpshufd $0x3,%xmm0,%xmm2
0x0000000100001902 <+466>: vmovhlps %xmm0,%xmm0,%xmm0
0x0000000100001906 <+470>: vaddss %xmm1,%xmm0,%xmm0
0x000000010000190a <+474>: vaddss %xmm0,%xmm2,%xmm0
0x000000010000190e <+478>: pop %rbp
0x000000010000190f <+479>: vzeroupper
0x0000000100001912 <+482>: retq
End of assembler dump.
正如我们所看到的，内核现在是3条指令（vblendvps，vaddps，vpslld）。
答案 2 :(得分：4)
如果在 数据float data[128]中允许稍微不同的排列，或者在__m128 mask;的位掩码中进行相应的排列，则可以略微改进建议的算法克里斯多德上面。 （不计算置换掩码所需的时间，这种实现（+开销）大约快25％）。这当然只是评论中提供的我的想法的快速草案。
union {
unsigned int i[4];
float f[4];
__m128 xmm;
} mask = { 0xFF00FF00, 0xF0F0F0F0, 0xCCCCCCCC, 0xAAAAAAAA };
float dot2(__m128 *a, __m128 mask);
// 20M times 1.161s
float dotref(__m128 *a, unsigned int *mask) // 20M times 8.174s
{
float z=0.0f;
int i;
for (i=0;i<32;i++) {
if (mask[0] & (0x80000000U >> i)) z+= a[i][0];
if (mask[1] & (0x80000000U >> i)) z+= a[i][1];
if (mask[2] & (0x80000000U >> i)) z+= a[i][2];
if (mask[3] & (0x80000000U >> i)) z+= a[i][3];
}
return z;
}
相应的汇编程序实现将是：
dot2:
// warm up stage: fill in initial data and
// set up registers
pxor %xmm1, %xmm1 ;; // clear partial sum1
pxor %xmm2, %xmm2 ;; // clear partial sum2
movaps (%rdi), %xmm3 ;; // register warm up stage1
movaps 16(%rdi), %xmm4 ;; // next 4 values
pxor %xmm5, %xmm5
pxor %xmm6, %xmm6
lea 32(%rdi), %rdi
movl $16, %ecx ;; // process 2x4 items per iteration (total=128)
a: ;; // inner loop -- 2 independent data paths
blendvps %xmm3, %xmm5
pslld $1, %xmm0
movaps (%rdi), %xmm3
blendvps %xmm4, %xmm6
pslld $1, %xmm0
movaps 16(%rdi), %xmm4
addps %xmm5, %xmm1
pxor %xmm5, %xmm5
addps %xmm6, %xmm2
pxor %xmm6, %xmm6
lea 32(%rdi), %rdi
loop a
;; // cool down stage: gather results (xmm0 = xmm1+xmm2)
;; // in beautiful world this stage is interleaved
;; // with the warm up stage of the next block
addps %xmm2, %xmm1
movaps %xmm1, %xmm2
movaps %xmm1, %xmm0
shufps $85, %xmm1, %xmm2
addss %xmm2, %xmm0
movaps %xmm1, %xmm2
unpckhps %xmm1, %xmm2
shufps $255, %xmm1, %xmm1
addss %xmm2, %xmm0
addss %xmm1, %xmm0
ret
答案 3 :(得分：3)
以下是一些可以尝试的事情。
尝试让编译器使用CMOV而不是分支。 （Note that using a union this way is well-defined in C11 but undefined in C++11.）
union {
int i;
float f;
} u;
u.i = 0;
if (b & 1) {
u.f = a[i];
}
sum += u.f;
使用乘法而不是分支。
sum += (b & 1) * a[i];
保留多个总和并在末尾添加它们以减少数据流依赖性。 （您可以将上述任何一项建议与此建议结合起来。）
float sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
for (int i = 0; i < 64; i += 4; b >>= 4) {
if (b & 1) sum0 += a[i];
if (b & 2) sum1 += a[i+1];
if (b & 4) sum2 += a[i+2];
if (b & 8) sum3 += a[i+3];
}
return sum0 + sum1 + sum2 + sum3;
通过一次处理几个位来减少分支数量：
for (int i = 0; i < 64; i += 4, b >>= 4) {
switch (b & 0xf) {
case 0:
break;
case 1:
sum += a[i];
break;
case 2:
sum += a[i + 1];
break;
case 3:
sum += a[i] + a[i+1];
break;
case 4:
sum += a[i+2];
break;
// etc. for cases up to and including 15
}
}
您可以为每个汇总流程保留几个总和和，一次几个位。在这种情况下，您可能希望使用宏或内联函数并调用它四次。
答案 4 :(得分：3)
我发现为Chris Dodd的代码生成的程序集非常依赖于编译器; clang将gcc转换为循环，icc（4.6和4.7）和英特尔sum +=（12.x和13.x）展开循环。仍然可以通过将其转换为map-reduce来减少依赖性（需要等待之前的float dot(__m128 *a, uint64_t b) {
__m128 sum[8];
int i;
for (i = 0; i < 8; i++) {
sum[i] = _mm_add_ps(
_mm_and_ps(a[2*i], mask[b & 0xf].xmm),
_mm_and_ps(a[2*i+1], mask[(b & 0xf0) >> 4].xmm));
b >>= 8;
}
for (i = 0; i < 4; i++) {
sum[i] = _mm_add_ps(sum[2*i], sum[2*i+1]);
}
sum[0] = _mm_add_ps(sum[0], sum[1]);
sum[2] = _mm_add_ps(sum[2], sum[3]);
sum[0] = _mm_add_ps(sum[0], sum[2]);
sum[0] = _mm_hadd_ps(sum[0], sum[0]);
sum[0] = _mm_hadd_ps(sum[0], sum[0]);
i = _mm_extract_ps(sum[0], 0);
return *((float*)(&i));
}
），
clang这会创建明显的劣等程序集sum[]（将addps存储在堆栈中），但更好的代码（不依赖于后续{ {1}}）gcc和icc。有趣的是，只有gcc才能得出结论float中的sum[0]可以就地返回...
关于如何调整特定编译器的好习题......
答案 5 :(得分：1)
如果你有i7，那么你有SSE4.1，你可以使用_mm_dp_ps内在函数，它是一个点积。使用示例代码，它看起来像
#include <stdint.h>
#include <immintrin.h>
const float fltmask[][4] =
{{0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 0}, {0, 0, 1, 1},
{0, 1, 0, 0}, {0, 1, 0, 1}, {0, 1, 1, 0}, {0, 1, 1, 1},
{1, 0, 0, 0}, {1, 0, 0, 1}, {1, 0, 1, 0}, {1, 0, 1, 1},
{1, 1, 0, 0}, {1, 1, 0, 1}, {1, 1, 1, 0}, {1, 1, 1, 1}};
// a has 64 elements. b is a bitvector of 64 dimensions.
float dot(float * restrict a, uint64_t b) {
int i;
float sum = 0;
for(i=0; b && i<64; i+=4,b>>=4) {
__m128 t0 = _mm_load_ps (a);
a += 4;
__m128 t1 = _mm_load_ps (fltmask[b & 15]);
sum += _mm_cvtss_f32 (_mm_dp_ps (t0, t1, 15));
}
return sum;
}
PS。数组a和fltmask最好是16字节对齐！
PPS。使用gcc -std=c99 -msse4 -O2编译时，循环如下所示：
.L3:
movq %rdx, %rax
movaps (%rcx), %xmm1
shrq $4, %rdx
andl $15, %eax
addq $16, %rcx
addl $4, %r8d
salq $4, %rax
testq %rdx, %rdx
dpps $15, (%r9,%rax), %xmm1
addss %xmm1, %xmm0
jne .L13
和-O3展开了。
答案 6 :(得分：1)
另一种描述这种情况的方法是掩盖减少量（总和）。
AVX512内置了屏蔽功能，例如与_mm256_mask_add_ps。 （对于这样的短数组，您可能只想在Skylake-AVX512上使用256位向量，以避免限制最大Turbo。除非您的代码花费大量时间进行此操作或其他可以从512位向量中受益的循环。 / p>
从字面上看，这是一条从存储器源到vaddps的asm指令，在未设置掩码寄存器中的位的地方，元素保持不变。例如您的循环主体实际上可以简单到
vaddps zmm0{k1}, zmm0, [rdi] ; merge-masking into ZMM0
kshiftrq k1, k1, 16 ; bring the next 16 mask bits down to the bottom
（并且从零掩码加载开始以初始化zmm0。实际上，您将需要多个累加器隐藏FP添加延迟，因此使用来自掩码的低位比特矢量对多个零掩码加载是理想的。）
所以您真的希望编译器将这样的东西吐出asm。 （使用内在函数写起来应该很简单，但是更冗长，所以我只写了asm而不是花时间查找内在名字。）
;float dot(float *restrict a, uint64_t b)
dot:
kmovq k1, rsi ; __mmask64 m = b
vmovups zmm0{k1}{z}, [rdi] ; zero-masking
kshiftrq k2, k1, 16
vmovups zmm1{k2}{z}, [rdi+ 16*4] ; next vector of 16x 4-byte floats
kshiftrq k3, k1, 32
kshiftrq k4, k1, 48
vaddps zmm0{k3}, zmm0, [rdi + 16*4 * 2] ; merge-masking into ZMM0
vaddps zmm1{k4}, zmm1, [rdi + 16*4 * 3]
;; if you have more mask data, use it and do some more adds, or maybe run 2 more dep chains of FP add before combining.
vaddps zmm0, zmm0, zmm1 ; reduce down to 1 accumulator
;then horizontal sum down to scalar
VEXTRACTF64x4 ymm1, zmm0, 1
vaddps ymm0, ymm0, ymm1 ; narrow to 256
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm0, xmm1 ; narrow to 128
vmovshdup / vaddps / vmovhlps / vaddss
ret
有关如何使用内在函数在C中有效地编写水平和，请参见Fastest way to do horizontal float vector sum on x86，以便它们可以编译为不会吸引的asm。 （不是haddps，也不是要对其进行数组和循环遍历的幼稚商店。）
如果掩码数据来自内存，则可以将其直接加载到掩码寄存器中。不幸的是，在当前的Skylake-AVX512上，它的成本为3微秒，因此您要执行64位加载并使用掩码移位。或者让编译器执行其任务。
使用AVX2 ，@ IWill的答案似乎在正确的轨道上，但是我怀疑最好将遮罩处理与遮罩使用情况相结合。
例如从float数组的末尾开始，并使用掩码的高8位。首先，向YMM的所有元素广播掩码的高32位。然后vpsllvd向左移动[0,1,2,3,4,5,6,7]，将掩码的最高位保留在高位元素的顶部，将掩模的最高8位保留在低位元素的位置。
然后使用vblendvps或更佳的vmaskmovps从向量的高端进行掩蔽负载（在Skylake上的oop减少，与Haswell上的blendv相同）。 vblendvps始终至少为2 oups。有趣的事实：带有隐式XMM0源的非VEX版本在Skylake上是单-uop。
然后将vpslld减8，以将接下来的8个掩码位放到位，并将指针减少32个字节。
您必须在每4个向量中停止并广播+可变移位的新掩码位，但是与FP添加的交织可能对隐藏所有涉及的延迟非常有用。
有关将位掩码转换为矢量掩码的更多详细信息，请参见 is there an inverse instruction to the movemask instruction in intel avx2? ，包括我上面介绍的广播+可变移位策略。 （克里斯·多德（Chris Dodd）的LUT适合4位-> 4个双字，因为表很小。除此之外，您还需要ALU。）
答案 7 :(得分：0)
你可以像这样删除分支：
for(int i=0; b && i<64; i++, b>>=1)
sum += a[i] * (b & 1);
虽然这会增加额外的mult，但至少它不会破坏你的管道。
控制分支的另一种方法是使用它，就像使用编译器宏一样。我想在gcc中它是likely(if ...)宏。您将使用分支，但是这样您告诉编译器分支将经常执行，并且gcc将优化更多。
可以做的另一个优化是“缓存”点积。因此，没有一个函数来计算点积，你将有一个变量将产品初始化为0。每次插入/删除/更新向量的元素时，您还会更新保存结果的变量。