我的问题是基于另一个SO问题：为什么 _mm_stream_ps 会产生 L1/LL 缓存未命中？ https://stackoverflow.com/questions/9068246/why-does-mm-stream-ps-produce-l1-ll-cache-misses
阅读完它并对其感兴趣后，我尝试复制结果并亲自看看哪个更快：朴素循环，展开朴素循环，_mm_stream_ps（展开），_mm_store_ps（展开）最后但并非最不重要的memset_pattern4。 （最后一个函数采用 4 字节模式，例如浮点数，并将其粘贴到整个目标数组上，这应该与所有其他函数执行相同的操作，但它可能是 OS X 独有的）。
我已确保将数组的开头对齐到缓存行（64 字节，我检查过），并在参数中传递数组以及上一个问题中提到的任何其他性能调整。
其他人想在 gamedev 上了解同样的事情：http://www.gamedev.net/topic/532112-fast-memset/ http://www.gamedev.net/topic/532112-fast-memset/
该线程的结论反映了我自己的结论：当目标数组小于最大（L3）缓存时，_mm_store_ps比_mm_stream_ps。当目标数组较大时，_mm_stream_ps是比较快的。我不太确定为什么__mm_store_ps在第一种情况下更快，因为我从不在缓存中使用这些值，但我明白为什么_mm_stream_ps在后一种情况下胜出。它是针对这种情况而设计的：将字节写入您不会立即（或永远）不需要的内存。
以下是使用 gcc 4.8 编译的目标数组比 L3 缓存大 256 倍（在我的例子中为 1.5GB）的一些结果：
gcc-4.8 stream.c -o stream -std=c11 -O3 -g3 -ftree-vectorize -march=native -minline-all-stringops && ./stream
bench L3-MASS, array 1610612736 bytes (402653184 floats, 0 remainder, 0x104803040 pointer)
warm up round...
6% ( 20.81148 ms) : MEMSET CHEAT
8% ( 28.49419 ms) : MEMSET PATTER
100% ( 371.40385 ms) : NAIVE NORMAL
54% ( 202.01147 ms) : NAIVE UNROLL
31% ( 113.53433 ms) : STREAM NORMAL
30% ( 111.41691 ms) : STREAM UNROLL
51% ( 190.70412 ms) : STORE NORMAL
51% ( 189.15338 ms) : STORE UNROLL
51% ( 189.36182 ms) : STORE PREFET
那么我们从中学到什么呢？memset_pattern4快得令人难以置信。我包括沼泽标准memset即使它只使用 1 字节模式进行比较。在本质上，memset作弊，但是memset_pattern4不，而且速度仍然很快。
我尝试查看程序集以查找我认为是源代码的内容memset_pattern4在 OS X 字符串库中：
- 苹果的libc，
memset_pattern4: http://www.opensource.apple.com/source/Libc/Libc-825.25/string/memset_pattern.c?txt http://www.opensource.apple.com/source/Libc/Libc-825.25/string/memset_pattern.c?txt
- 这引用了所谓的 bcopy 函数。让我们来挖掘一下：
字符串库：http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/ http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/
- 我的情况很可能使用的是 SSE 4.2 版本：http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/bcopy_sse42.s http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/bcopy_sse42.s
我对 asm 的了解（到目前为止）已经足够多了，我看到他们正在使用movdqa重要的指示（在LAlignedLoop部分），这基本上是整数（不是浮点数）的 SSE 移动指令，内在：_mm_store_si128。位和字节在这里并不重要，对吧？
- 似乎还有一个纯 asm 实现
memset_pattern4，这看起来不同，因为它没有调用bcopy: http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/memset.s http://www.opensource.apple.com/source/Libc/Libc-763.13/x86_64/string/memset.s (EDIT：这是正确的，通过在 gdb 下运行验证）
...该死的，这个似乎使用非时间（_mm_stream_ps存储很长的数组=>movntdq %xmm0,(%rdi,%rcx)...，查看LVeryLong函数的部分），这正是我所做的！那么怎样才能更快呢？也许这不是memset_pattern4我在找。
那么，什么是memset_pattern4为什么它比我的最佳尝试快 5 倍？尽管我一直在努力学习足够的 x86 汇编以便能够剖析该函数，但我担心目前调试优化至死函数中的性能问题有点超出我的能力。
NOTE：对于那些好奇的人来说，这个微基准还可以说明 clang 及其高级矢量化的绝对强大之处（-fslp-vectorize），它设法使朴素循环成为几乎在所有情况下保存 memset 最快的循环。它似乎与最佳组合一样好_mm_store_ps and _mm_stream_ps.
CODE：这是我用来执行基准测试的代码（要点：https://gist.github.com/6571379 https://gist.github.com/6571379):
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
/**
* compile and run:
*
* OSX:
* clang stream.c -o stream -std=c11 -O3 -g -ftree-vectorize -fslp-vectorize -march=native -minline-all-stringops && ./stream
* gcc-4.8 stream.c -o stream -std=c11 -O3 -g3 -ftree-vectorize -march=native -minline-all-stringops && ./stream
*
* linux:
* clang stream.c -o stream -lrt -std=c11 -O3 -ftree-vectorize -fslp-vectorize -march=native && ./stream
* gcc-4.8 stream.c -o stream -lrt -std=c11 -O3 -ftree-vectorize -march=native && ./stream
*
* to generate the assembly:
* gcc-4.8 -S stream.c -o stream.s -std=c11 -O3 -g3 -ftree-vectorize -march=native -minline-all-stringops
* gobjdump -dS stream > stream.obj.s
*
* clang is the (very clear) winner here, the SLP vectorizer is absolutely killer, it even turns the
* plain naive loop into something hyper-performant
*/
/* posix headers */
#include <sys/time.h>
/* intrinsics */
#include <x86intrin.h>
#define ARRAY_SIZE(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
/**
* some stats from my system
*
* sudo sysctl -a | grep cache
*
* hw.cachelinesize = 64
* hw.l1icachesize = 32768
* hw.l1dcachesize = 32768
* hw.l2cachesize = 262144
* hw.l3cachesize = 6291456
*/
/* most processors these days (2013) have a 64 byte cache line */
#define FACTOR 1024
#define CACHE_LINE 64
#define FLOATS_PER_LINE (CACHE_LINE / sizeof(float))
#define L1_CACHE_BYTES 32768
#define L2_CACHE_BYTES 262144
#define L3_CACHE_BYTES 6291456
#ifdef __MACH__
#include <mach/mach_time.h>
double ns_conversion_factor;
double us_conversion_factor;
double ms_conversion_factor;
void timeinit() {
mach_timebase_info_data_t timebase;
mach_timebase_info(&timebase);
ns_conversion_factor = (double)timebase.numer / (double)timebase.denom;
us_conversion_factor = (double)timebase.numer / (double)timebase.denom / 1000;
ms_conversion_factor = (double)timebase.numer / (double)timebase.denom / 1000000;
}
double nsticks() {
return mach_absolute_time() * ns_conversion_factor;
}
double msticks() {
return mach_absolute_time() * ms_conversion_factor;
}
#else
void timeinit() {
/* do nothing */
}
double nsticks() {
timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ((double)ts.tv_sec) / 1000000000 + ((double)ts.tv_nsec);
}
double msticks() {
timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ((double)ts.tv_sec) / 1000 + ((double)ts.tv_nsec) * 1000000;
}
#endif
void *aligned_malloc(size_t size, size_t alignment) {
void *pa, *ptr;
pa = malloc((size+alignment-1)+sizeof(void *));
if (!pa) return NULL;
ptr=(void*)( ((intptr_t)pa+sizeof(void *)+alignment-1)&~(alignment-1) );
*((void **)ptr-1)=pa;
return ptr;
}
void aligned_free(void *ptr) {
if (ptr) free(*((void **)ptr-1));
}
void pollute_cache(uint8_t volatile *arr, size_t length) {
for (int i = 0; i < length; ++i) {
arr[i] = (arr[i] > 0xFE) ? 0xAA : 0x55;
}
}
void pollute_cache_standalone() {
const size_t pollute_len = 2 * L3_CACHE_BYTES;
uint8_t *arr = aligned_malloc(pollute_len * sizeof(uint8_t), 64);
for (int i = 0; i < pollute_len; ++i) {
arr[i] = (arr[i] > 0xFE) ? 0xAA : 0x55;
}
aligned_free(arr);
}
/**
* returns the time passed, in milliseconds
*/
double tim(const char *name, double baseline, void (*pre)(void), void (*func)(float *, size_t), float * restrict arr, size_t length) {
struct timeval t1, t2;
if (pre) pre();
const double ms1 = msticks();
func(arr, length);
const double ms2 = msticks();
const double ms = (ms2 - ms1);
if (baseline == -2.0) return ms;
/* first run, equal to baseline (itself) by definition */
if (baseline == -1.0) baseline = ms;
if (baseline != 0.0) {
fprintf(stderr, "%7.0f%% (%10.5f ms) : %s\n", (ms / baseline) * 100, ms, name);
}
else {
fprintf(stderr, "%7.3f ms : %s\n", ms, name);
}
return ms;
}
void func0(float * const restrict arr, size_t length) {
memset(arr, 0x05, length);
}
#ifdef __MACH__
void funcB(float * const restrict arr, size_t length) {
const float val = 5.0f;
memset_pattern4(arr, &val,length);
}
#endif
void func1(float * const restrict arr, size_t length) {
for (int i = 0; i < length; ++i) {
arr[i] = 5.0f;
}
}
void func2(float * const restrict arr, size_t length) {
for(int i = 0; i < length; i += 4) {
arr[i] = 5.0f;
arr[i+1] = 5.0f;
arr[i+2] = 5.0f;
arr[i+3] = 5.0f;
}
}
void func3(float * const restrict arr, size_t length) {
const __m128 buf = _mm_setr_ps(5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 4) {
_mm_stream_ps(&arr[i], buf);
}
_mm_mfence();
}
void func4(float * const restrict arr, size_t length) {
const __m128 buf = _mm_setr_ps(5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 16) {
_mm_stream_ps(&arr[i + 0], buf);
_mm_stream_ps(&arr[i + 4], buf);
_mm_stream_ps(&arr[i + 8], buf);
_mm_stream_ps(&arr[i + 12], buf);
}
_mm_mfence();
}
void func5(float * const restrict arr, size_t length) {
const __m128 buf = _mm_setr_ps(5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 4) {
_mm_store_ps(&arr[i], buf);
}
}
void fstore_prefetch(float * const restrict arr, size_t length) {
const __m128 buf = _mm_setr_ps(5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 16) {
__builtin_prefetch(&arr[i + FLOATS_PER_LINE * 32], 1, 0);
_mm_store_ps(&arr[i + 0], buf);
_mm_store_ps(&arr[i + 4], buf);
_mm_store_ps(&arr[i + 8], buf);
_mm_store_ps(&arr[i + 12], buf);
}
}
void func6(float * const restrict arr, size_t length) {
const __m128 buf = _mm_setr_ps(5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 16) {
_mm_store_ps(&arr[i + 0], buf);
_mm_store_ps(&arr[i + 4], buf);
_mm_store_ps(&arr[i + 8], buf);
_mm_store_ps(&arr[i + 12], buf);
}
}
#ifdef __AVX__
void func7(float * restrict arr, size_t length) {
const __m256 buf = _mm256_setr_ps(5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 8) {
_mm256_stream_ps(&arr[i], buf);
}
}
void func8(float * restrict arr, size_t length) {
const __m256 buf = _mm256_setr_ps(5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 32) {
_mm256_stream_ps(&arr[i + 0], buf);
_mm256_stream_ps(&arr[i + 8], buf);
_mm256_stream_ps(&arr[i + 16], buf);
_mm256_stream_ps(&arr[i + 24], buf);
}
}
void func9(float * restrict arr, size_t length) {
const __m256 buf = _mm256_setr_ps(5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 8) {
_mm256_store_ps(&arr[i], buf);
}
}
void funcA(float * restrict arr, size_t length) {
const __m256 buf = _mm256_setr_ps(5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f);
for (int i = 0; i < length; i += 32) {
_mm256_store_ps(&arr[i + 0], buf);
_mm256_store_ps(&arr[i + 8], buf);
_mm256_store_ps(&arr[i + 16], buf);
_mm256_store_ps(&arr[i + 24], buf);
}
}
#endif
void bench(const char * restrict name, float * restrict arr, size_t length) {
fprintf(stderr, "bench %s, array %zu bytes (%zu floats, %zu remainder, %p pointer)\n", name, length, length / sizeof(float), length % sizeof(float), arr);
size_t nfloats = length / sizeof(float);
fprintf(stderr, "warm up round...");
func1(arr, nfloats);
fprintf(stderr, "done\n");
double baseline = tim("func1: NAIVE ", -2.0, NULL, func1, arr, nfloats);
tim("MEMSET CHEAT ", baseline, NULL, func0, arr, nfloats);
#ifdef __MACH__
tim("MEMSET PATTER", baseline, NULL, funcB, arr, nfloats);
#endif
tim("NAIVE NORMAL", -1.0, NULL, func1, arr, nfloats);
tim("NAIVE UNROLL", baseline, NULL, func2, arr, nfloats);
tim("STREAM NORMAL", baseline, NULL, func3, arr, nfloats);
tim("STREAM UNROLL", baseline, NULL, func4, arr, nfloats);
tim("STORE NORMAL", baseline, NULL, func5, arr, nfloats);
tim("STORE UNROLL", baseline, NULL, func6, arr, nfloats);
tim("STORE PREFET", baseline, NULL, fstore_prefetch, arr, nfloats);
// for (int i = 0; i < 1; ++i) {
// tim("func0: MEMSET (cache polluted)", NULL, func0, arr, nfloats);
// tim("func1: NAIVE (cache polluted)", pollute_cache_standalone, func1, arr, nfloats);
// tim("func2: UNROLL (cache polluted)", pollute_cache_standalone, func2, arr, nfloats);
// tim("func3: STREAM (cache polluted)", pollute_cache_standalone, func3, arr, nfloats);
// tim("func4: STRUN (cache polluted)", pollute_cache_standalone, func4, arr, nfloats);
// tim("func5: STORE (cache polluted)", pollute_cache_standalone, func5, arr, nfloats);
// tim("func6: STOUN (cache polluted)", pollute_cache_standalone, func6, arr, nfloats);
// }
}
int main() {
timeinit();
static const struct {
const char *name;
size_t bytes;
} sizes[] = {
{ "L1-HALF", L1_CACHE_BYTES / 2 },
{ "L1-FULL", L1_CACHE_BYTES },
{ "L2-HALF", L2_CACHE_BYTES / 2 },
{ "L2-FULL", L2_CACHE_BYTES },
{ "L3-HALF", L3_CACHE_BYTES / 2 },
{ "L3-FULL", L3_CACHE_BYTES },
{ "L3-DOUB", L3_CACHE_BYTES * 2 },
{ "L3-HUGE", L3_CACHE_BYTES * 64 },
{ "L3-MASS", L3_CACHE_BYTES * 256 }
};
for (int i = 0; i < ARRAY_SIZE(sizes); ++i) {
size_t bytes = sizes[i].bytes;
/* align to cache line */
float *arr = aligned_malloc(bytes, CACHE_LINE);
bench(sizes[i].name, arr, bytes);
aligned_free(arr);
}
return 0;
}
EDIT：我进一步挖掘了一下，编辑了 gcc 生成的程序集，使其或多或少与苹果使用的程序集相同（memset.s, label LVeryLong，即：4 个展开movntdq紧密循环中的指令）。令我惊讶的是，我获得了与使用以下函数相同的性能_mm_store_ps (movaps）。这让我很困惑，因为我本来期望它是
- 跟...一样快
memset_pattern4（大概是展开的movntdq)
- 与展开一样快
_mm_stream_ps (movntdq)
但不，它似乎是一样的_mm_store_ps，想象一下，也许我做错了什么。在生成的二进制文件上运行 objdump 确认它正在使用movntdq，这更让我惊讶，这到底是怎么回事？
因为我在那里遇到了死胡同，所以我决定在调试器中单步执行可执行文件并在以下位置设置一个断点memset_pattern4。进入该函数后，我注意到它的功能与我的预期完全一致，是一个带有四个展开的紧密循环movntdq:
0x00007fff92a5f7d2 <+318>: jmp 0x7fff92a5f7e0 <memset_pattern4+332>
0x00007fff92a5f7d4 <+320>: nopw 0x0(%rax,%rax,1)
0x00007fff92a5f7da <+326>: nopw 0x0(%rax,%rax,1)
0x00007fff92a5f7e0 <+332>: movntdq %xmm0,(%rdi,%rcx,1)
0x00007fff92a5f7e5 <+337>: movntdq %xmm0,0x10(%rdi,%rcx,1)
0x00007fff92a5f7eb <+343>: movntdq %xmm0,0x20(%rdi,%rcx,1)
0x00007fff92a5f7f1 <+349>: movntdq %xmm0,0x30(%rdi,%rcx,1)
0x00007fff92a5f7f7 <+355>: add $0x40,%rcx
=> 0x00007fff92a5f7fb <+359>: jne 0x7fff92a5f7e0 <memset_pattern4+332>
0x00007fff92a5f7fd <+361>: sfence
那么，是什么让苹果酱比我的更神奇，我想知道......
EDIT 2：我在这里错了两次，Apple 的魔法酱并没有那么神奇，我只是传递了一个比我传递给函数的数组小 4 倍的数组。感谢@PaulR 的关注！其次，我正在编辑函数的汇编，但 gcc 已经内联了它。所以我正在编辑一个从未使用过的副本。
结论:
我发现的其他一些事情：
- Clang 和 gcc 确实很好，有了正确的内在函数，它们就进行了很多优化（当启用 SLP 矢量器时，clang 甚至在没有内在函数的情况下也能做得很好）。他们还将内联函数指针。
- Clang 会将一个简单的循环替换为一个常量
memset打电话，澄清了我的另一个令人困惑的结果。
- 非临时存储（即：流）仅对大量写入有益
-
memset确实优化得很好，它会根据要写入的数组的长度自动在常规存储和非临时存储（流）之间切换。我不确定这在 OSX 以外的平台上有多少是正确的
- 在编写基准测试时，请绝对确保该函数按照您的想法进行操作，并且编译器不会比您更聪明。第一种情况是我的问题，我没有提供正确的参数。
EDIT: 最近偶然发现英特尔优化指南 http://www.intel.com/content/dam/doc/manual/64-ia-32-architectures-optimization-manual.pdf，如果对这些事情感兴趣，请先阅读其中的某些部分（也许从 3.7.6 开始）。
