openEuler-20.03-LTS-SP3版本与openEuler-22.03-LTS版本x86上gcc参数差异导致编译出的二进制性能下降

版本切换时遇到两个影响性能的问题：
一、两个gcc版本的默认参数 max-inline-insns-single 不一样， gcc7.3是 400 ，  gcc10.3 只有70，  触发限制导致了inline失败。inline失败编译的二进制会导致性能下降。
有两个问题希望得到解答：
1、开源为什么会有max-inline-insns-single参数变更？
2、社区对于这种跨版本参数不同导致性能下降的情况有没有好的排查与处理办法？

gcc10.3参数
```
[root@localhost gcc-10.3.0]# gcc -Q -O2 --help=params | grep inline
  --param=builtin-string-cmp-inline-length=<0,100>      3
  --param=inline-heuristics-hint-percent=<100,1000000>  200
  --param=inline-min-speedup=<0,100>            30
  --param=inline-unit-growth=           40
  --param=max-early-inliner-iterations=         1
  --param=max-inline-insns-auto=        15
  --param=max-inline-insns-recursive-auto=      450
  --param=max-inline-insns-recursive=   450
  --param=max-inline-insns-single=      70
  --param=max-inline-insns-size=        0
  --param=max-inline-insns-small=       0
  --param=max-inline-recursive-depth-auto=      8
  --param=max-inline-recursive-depth=   8
  --param=min-inline-recursive-probability=     10
  --param=uninlined-function-insns=<0,1000000>  2
  --param=uninlined-function-time=<0,1000000>   0
  --param=uninlined-thunk-insns=<0,1000000>     2
  --param=uninlined-thunk-time=<0,1000000>      2
```
gcc7.3参数
```
[root@localhost ~]# gcc -Q -O2 --help=params | grep inline
  inline-min-speedup          default 8 minimum 0 maximum 0
  max-inline-insns-single     default 400 minimum 0 maximum 0
  max-inline-insns-auto       default 40 minimum 0 maximum 0
  max-inline-insns-recursive  default 450 minimum 0 maximum 0
  max-inline-insns-recursive-auto default 450 minimum 0 maximum 0
  max-inline-recursive-depth  default 8 minimum 0 maximum 0
  max-inline-recursive-depth-auto default 8 minimum 0 maximum 0
  min-inline-recursive-probability default 10 minimum 0 maximum 0
  max-early-inliner-iterations default 1 minimum 0 maximum 0
  inline-unit-growth          default 20 minimum 0 maximum 0
```

二、编译一样的代码，不考虑内联，二者有性能差异，gcc10.3编译的性能要更差。
```
gcc main.c -g -o main_gcc10.3 -O2 -msse4.2 -mavx2 -fno-inline
```
main.c 内容如下

```
#include <stdio.h>
#include <stdint.h>
#include <immintrin.h>

void
rte_mov128blocks(uint8_t *dst, const uint8_t *src, size_t n)
{
	__m256i ymm0, ymm1, ymm2, ymm3;

while (n >= 128) {
		ymm0 = _mm256_loadu_si256((const __m256i *)(const void *)
					  ((const uint8_t *)src + 0 * 32));
		n -= 128;
		ymm1 = _mm256_loadu_si256((const __m256i *)(const void *)
					  ((const uint8_t *)src + 1 * 32));
		ymm2 = _mm256_loadu_si256((const __m256i *)(const void *)
					  ((const uint8_t *)src + 2 * 32));
		ymm3 = _mm256_loadu_si256((const __m256i *)(const void *)
					  ((const uint8_t *)src + 3 * 32));
		src = (const uint8_t *)src + 128;
		_mm256_storeu_si256((__m256i *)(void *)
				    ((uint8_t *)dst + 0 * 32), ymm0);
		_mm256_storeu_si256((__m256i *)(void *)
				    ((uint8_t *)dst + 1 * 32), ymm1);
		_mm256_storeu_si256((__m256i *)(void *)
				    ((uint8_t *)dst + 2 * 32), ymm2);
		_mm256_storeu_si256((__m256i *)(void *)
				    ((uint8_t *)dst + 3 * 32), ymm3);
		dst = (uint8_t *)dst + 128;
	}
}

uint8_t a[1ULL * 1024 * 1024 *1024];
uint8_t b[1ULL * 1024 * 1024 *1024];

int main(int argc, char **argv)
{
    int i = 0;
    int n;

if (argc != 2) {
        printf("input run times as parameter.\n");
        return -1;
    }
    n = atoi(argv[1]);
    printf("start to run %d.\n", n);

while (i++ < n) {
        rte_mov128blocks(a, b, sizeof(a));
    }

printf("end to run %d.\n", n);

return 0;
}
```

结果
```
[root@localhost ~]# time ./main_gcc7.3 2000
start to run 2000.
end to run 2000.

real    6m30.461s
user    6m26.587s
sys     0m0.814s
[root@localhost ~]# time ./main_gcc10.3 2000
start to run 2000.
end to run 2000.

real    7m18.696s
user    7m13.912s
sys     0m1.098s
```

src-openEuler/gcc

内容风险标识

评论 (3)

src-openEuler/gcc .gitee-modal { width: 500px !important; }

内容风险标识