变量零初始化会降低性能吗？

Question

我正在纠正静态分析 (MISRA-C-2012) 违规行为，其中一条规则（规则 9.3）规定变量应在使用前初始化。

例如：

void bar_read(int * array)
{
    printf("array[1]: %u\n",array[1]);    
}

void bar_write(int * array)
{
    array[1]=1;    
}

int main(void)
{
    #define FOO_SIZE 12
 #ifdef MISRA_VIOLATION_DISABLED
    int foo[FOO_SIZE]  = {0}; //ok
 #else
    int foo[FOO_SIZE]; //violation
 #endif
    bar_read(foo);
    bar_write(foo);
    bar_read(foo); 

    return 0;
}

我的一些同事宣称他们正在删除变量初始化（对于大数组）foo[FOO_SIZE] = {0}; 因为它会降低性能，这让我感到困惑。

据我了解，零初始化变量在编译时放在 bss 部分，对运行时性能没有影响。

我会不会错了？可能取决于编译器？是否有任何优化使其成为现实？

Answer 1

在没有 static 关键字的函数内部定义的变量具有 自动存储期限 。这些变量通常在进入范围时在堆栈上创建。

这意味着如果初始化此类变量，则在运行时会产生初始化它们的成本。

只有具有 静态存储持续时间 的变量，即在文件范围或使用 static 关键字声明的变量，通常在显式初始化的 .data 或 .data 中定义。 bss 如果没有。

在 gcc 4.8.5 下使用 -O0 编译此代码时，定义 MISRA_VIOLATION_DISABLED 会产生以下附加代码：

subq    , %rsp
leaq    -48(%rbp), %rsi
movl    [=10=], %eax
movl    , %edx
movq    %rsi, %rdi
movq    %rdx, %rcx
rep stosq

Answer 2

在函数中使用int foo[FOO_SIZE]（没有static或extern）定义的数组具有自动存储持续时间，这意味着它是“创建的”（为其保留内存）每个time 执行到达它所在的块，并在该块的执行结束时被“销毁”（释放内存）。因为可以递归调用函数，所以无法在 .bss 部分中保留自动对象的内存。栈一般都是给他们用的

此外，即使它们位于 .bss 部分，它们在 C 模型中的生命周期仍然在每次它们所在的块开始和结束时开始和结束。因此，如果它们被初始化，则每次新的生命周期开始时都必须对其进行初始化。将它们存储在 .bss 部分不会在这方面节省任何东西。

此外，如果 .bss 部分是零初始化的，那不是免费的。每当操作系统提供内存来支持零初始化部分时，它必须清除该内存。

Answer 3

auto 变量在运行时被实例化，因此任何初始化也必须在运行时发生，这将导致一些性能损失 - 具体多少取决于编译器和优化级别。

话虽如此，你的同事不应该在没有做以下两件事之一的情况下删除初始化：

证明没有代码会在分配之前尝试读取任何数组元素；
量化性能损失和表明它超出了某些要求或规范 - 例如“要求 X 表示此操作必须在 100 毫秒或更短时间内完成，但初始化需要 120 毫秒”或类似的时间。

编辑

例如，我更改了代码以将初始化程序定义为构建命令的一部分，然后我使用 clock 库函数进行了一些粗略的检测：

#include <stdio.h>
<strong>#include <time.h></strong>

void bar_read( int *array )
{
  printf( "array[1]: %d\n", array[1] );
}

void bar_write( int *array )
{
  array[1] = 1;
}

int main( void )
{
  <strong>clock_t start = clock();</strong>
#ifndef FOO_SIZE
#define FOO_SIZE 2000
#endif

#ifndef INIT 
#define INIT
#endif

  int foo[FOO_SIZE] INIT ; // will expand to nothing or ={0} depending on build command
  bar_read( foo );
  bar_write( foo );
  bar_read( foo );

  <strong>clock_t end = clock();</strong>
  printf( "operation took %lu clocks (%f seconds)\n", end-start, (double)(end-start)/CLOCKS_PER_SEC );
  <strong>return (int)(end-start);</strong>
}

所以我可以在有和没有初始化的情况下进行构建，看看运行需要多长时间是否有区别：

$ gcc -o init -std=c11 -pedantic -Wall -Werror -DFOO_SIZE=2000 -DINIT="" init.c
$ ./init
array[1]: -1898976766
array[1]: 1
operation took 39 clocks (0.000039 seconds)

$ gcc -o init -std=c11 -pedantic -Wall -Werror -DFOO_SIZE=2000 -DINIT="={0}" init.c
$ ./init
array[1]: 0
array[1]: 1
operation took 53 clocks (0.000053 seconds)

我有mainreturn程序主要部分占用的时钟数。然后我写了一个 shell 脚本来构建有和没有数组初始值设定项的代码，每个版本运行一百次（比我们需要的样本大，但它不需要那么多时间运行) 并取这些运行的平均值（整数平均值，但足以说明）：

#!/bin/bash

INIT_PARAMS=( '""' '"={0}"' )
let runs=100

for INIT in "${INIT_PARAMS[@]}"
do
  cmd="gcc -o init -std=c11 -pedantic -Wall -Werror -DFOO_SIZE=2000 -DINIT=${INIT} init.c"
  echo $cmd
  eval $cmd
  let x=0
  for i in `seq 1 1 $runs`
  do
    ./init >/dev/null # suppress output from init itself
    let x=$x+$?
  done
done

我得到的输出是：

$ . init_test.sh 
gcc -o init -std=c11 -pedantic -Wall -Werror -DFOO_SIZE=2000 -DINIT="" init.c
Average clocks per run for INIT="" is 24
gcc -o init -std=c11 -pedantic -Wall -Werror -DFOO_SIZE=2000 -DINIT="={0}" init.c
Average clocks per run for INIT="={0}" is 33

因此，将 int 的 2000 个元素的数组初始化为声明的一部分有一定的惩罚，平均为 9 个时钟（0.000009 秒），或增加 37%，没有任何优化.提高优化级别会降低该成本（可能），但不会完全消除它。

变量零初始化会降低性能吗？

Could variable zero-initialization reduce performances?

c

arrays

performance

static-analysis

initialization