将C int数组重置为零：最快的方法？

假设我们有一个T myarray[100]T = int，unsigned int，long long int或unsigned long long int，将所有内容重置为零的最快方法是什么（不仅用于初始化，而且在程序中多次重置内容） ？也许与记忆模式？

对于类似的动态数组也存在同样的问题T *myarray = new T[100]。

memset（from <string.h>）可能是最快的标准方法，因为它通常是直接用汇编语言编写并手工优化的例程。

memset(myarray, 0, sizeof(myarray)); // for automatically-allocated arrays
memset(myarray, 0, N*sizeof(*myarray)); // for heap-allocated arrays, where N is the number of elements

顺便说一下，在C ++中，惯用的方式是使用std::fill（from <algorithm>）：

std::fill(myarray, myarray+N, 0);

这可以被自动优化成memset; 我敢肯定，它会以最快的速度为工作memset为intS，虽然它可能对较小的类型，如果优化器是不够聪明执行略差。不过，如果有疑问，请关注。

这个问题虽然比较老，但是却需要一些基准测试，因为它要求的不是最惯用的方式，也不是可以用最少的行数编写的方法，而是最快的方法。在没有实际测试的情况下回答这个问题是很愚蠢的。因此，我比较了四种解决方案，即AnT答案的memset与std :: fill与ZERO与我使用AVX内部函数制作的解决方案。

请注意，此解决方案不是通用的，它仅适用于32位或64位数据。如果此代码做错了什么，请发表评论。

#include<immintrin.h>
#define intrin_ZERO(a,n){\
size_t x = 0;\
const size_t inc = 32 / sizeof(*(a));/*size of 256 bit register over size of variable*/\
for (;x < n-inc;x+=inc)\
    _mm256_storeu_ps((float *)((a)+x),_mm256_setzero_ps());\
if(4 == sizeof(*(a))){\
    switch(n-x){\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
    };\
}\
else if(8 == sizeof(*(a))){\
switch(n-x){\
    case 7:\
        (a)[x] = 0;x++;\
    case 6:\
        (a)[x] = 0;x++;\
    case 5:\
        (a)[x] = 0;x++;\
    case 4:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        ((long long *)(a))[x] = 0;break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
};\
}\
}

我不会声称这是最快的方法，因为我不是底层优化专家。相反，它是一个正确的，依赖于体系结构的实现的示例，它比memset更快。

现在，进入结果。我计算了大小为100的int和long long数组（静态和动态分配）的性能，但msvc除外，它消除了静态数组上的死代码，结果非常可比，因此，我仅显示动态数组的性能。使用time.h的低精度时钟功能，时间标记为毫秒，表示一百万次迭代。

clang 3.8（使用clang-cl前端，优化标志= / OX / arch：AVX / Oi / Ot）

int:
memset:      99
fill:        97
ZERO:        98
intrin_ZERO: 90

long long:
memset:      285
fill:        286
ZERO:        285
intrin_ZERO: 188

gcc 5.1.0（优化标志：-O3 -march = native -mtune = native -mavx）：

int:
memset:      268
fill:        268
ZERO:        268
intrin_ZERO: 91
long long:
memset:      402
fill:        399
ZERO:        400
intrin_ZERO: 185

msvc 2015（优化标志：/ OX / arch：AVX / Oi / Ot）：

int
memset:      196
fill:        613
ZERO:        221
intrin_ZERO: 95
long long:
memset:      273
fill:        559
ZERO:        376
intrin_ZERO: 188

这里有很多有趣的事情：llvm杀死了gcc，这是MSVC的典型斑点优化（它在静态数组上完成了令人印象深刻的死代码消除，然后具有糟糕的填充性能）。尽管我的实现明显更快，但这可能仅是因为它认识到位清除的开销比任何其他设置操作要少得多。

Clang的实现值得关注，因为它的速度明显更快。一些额外的测试表明，它的内存集实际上专用于零-400字节数组的非零内存集要慢得多（〜220ms），与gcc相当。但是，具有800字节数组的非零内存设置不会造成速度差异，这可能就是为什么在这种情况下，其内存集的性能比我的实现差的原因-专业化仅适用于小型数组，截止时间恰好在800字节左右。还要注意，gcc的“ fill”和“ ZERO”没有针对内存集进行优化（查看生成的代码），gcc只是生成具有相同性能特征的代码。

结论：memset并没有像人们想象的那样针对此任务进行真正的优化（否则gcc和msvc以及llvm的memset具有相同的性能）。如果性能很重要，那么memset并不是最终的解决方案，尤其是对于这些笨拙的中型数组，因为它不是专门用于位清除的，而且它的手动优化也没有编译器自己能做的更好。

来自memset()：

memset(myarray, 0, sizeof(myarray));

sizeof(myarray)如果myarray在编译时已知的大小，则可以使用。否则，如果您使用的是动态大小的数组（例如通过malloc或获取的数组），new则需要跟踪长度。

您可以使用memset，但这仅是因为我们对类型的选择仅限于整数类型。

在C语言中，通常情况下实现宏

#define ZERO_ANY(T, a, n) do{\
   T *a_ = (a);\
   size_t n_ = (n);\
   for (; n_ > 0; --n_, ++a_)\
     *a_ = (T) { 0 };\
} while (0)

这将为您提供类似于C ++的功能，使您可以将任何类型的对象数组“重置为零”，而不必诉诸于hack等memset。基本上，这是C ++函数模板的C类似物，除了必须显式指定type参数。

最重要的是，您可以为未衰减的数组构建一个“模板”

#define ARRAY_SIZE(a) (sizeof (a) / sizeof *(a))
#define ZERO_ANY_A(T, a) ZERO_ANY(T, (a), ARRAY_SIZE(a))

在您的示例中，它将作为

int a[100];

ZERO_ANY(int, a, 100);
// or
ZERO_ANY_A(int, a);

还值得注意的是，专门针对标量类型的对象可以实现与类型无关的宏

#define ZERO(a, n) do{\
   size_t i_ = 0, n_ = (n);\
   for (; i_ < n_; ++i_)\
     (a)[i_] = 0;\
} while (0)

和

#define ZERO_A(a) ZERO((a), ARRAY_SIZE(a))

把上面的例子变成

 int a[100];

 ZERO(a, 100);
 // or
 ZERO_A(a);

对于静态声明，我认为您可以使用：

T myarray[100] = {0};

对于动态声明，我建议采用相同的方式： memset

zero(myarray); 是C ++中所需的全部。

只需将其添加到标题中：

template<typename T, size_t SIZE> inline void zero(T(&arr)[SIZE]){
    memset(arr, 0, SIZE*sizeof(T));
}

这是我使用的功能：

template<typename T>
static void setValue(T arr[], size_t length, const T& val)
{
    std::fill(arr, arr + length, val);
}

template<typename T, size_t N>
static void setValue(T (&arr)[N], const T& val)
{
    std::fill(arr, arr + N, val);
}

您可以这样称呼它：

//fixed arrays
int a[10];
setValue(a, 0);

//dynamic arrays
int *d = new int[length];
setValue(d, length, 0);

上面是比使用memset更多的C ++ 11方法。如果使用动态数组并指定大小，也会出现编译时错误。