没启用SIMD优化，计算耗时比ubuntu和rocky慢250%。

**【缺陷描述】：请补充详细的缺陷问题现象描述**

**一、缺陷信息**

**【缺陷所属的os版本】（如openEuler-22.03-LTS，参考命令"cat /etc/os-release"结果）**

openEuler-24.03-LTS-SP1

**【缺陷所属软件及版本号】（如kernel-5.10.0-60.138.0.165，参考命令"rpm -q 包名"结果）**

fftw-3.3.10-1.oe2403sp1

**【环境信息】**

Intel(R) Xeon(R) Silver 4210 CPU @ 2.20GHz

软件信息

- 跟缺陷所属软件相关的其它软件版本信息（如软件包构建失败由gcc引起，请填写gcc的版本号）

**【问题复现步骤】：请描述具体的操作步骤**

随手写个fftw测速，发现比Rocky9和Ubuntu24明显慢

![openeuler速度](https://foruda.gitee.com/images/1752118540989881742/977ee5aa_11227411.png "屏幕截图")

![ubuntu速度](https://foruda.gitee.com/images/1752118548798427371/ef7f19ec_11227411.png "屏幕截图")

**【实际结果】**，请描述出问题的结果和影响

**【期望结果】**，请描述出期望的结果和影响
**【其他相关附件信息】**

strings /usr/lib64/libfftw3*.so | fgrep -i avx

在OpenEuler下啥输出都没有。

在Rocky9和Ubuntu24下各有几百行输出。

通过perf工具确认几乎没使用向量化
```
@openeuler2403_zhoutianling build]$ perf stat -e fp_arith_inst_retired.scalar_single,fp_arith_inst_retired.scalar_double,fp_arith_inst_retired.128b_packed_single,fp_arith_inst_retired.128b_packed_double,fp_arith_inst_retired.256b_packed_single,fp_arith_inst_retired.256b_packed_double,fp_arith_inst_retired.512b_packed_single,fp_arith_inst_retired.512b_packed_double ./kmbench calib -S 5m -j fft

*arguments: calib -l 2 -j fft -a 4096:4096 -S 5242880:5242880
*actual_thr_number: 1
*ReqSize:  5242880
[ 0]: stat      :    1.006 ms    * 100
[25]: fft       :  182.931 ms    *  12
    blockzero:     0% (0/101) datazero: 4b=62.4594% 8b=25.1200% 16b=25.1200%

Performance counter stats for './kmbench calib -S 5m -j fft':

0      fp_arith_inst_retired.scalar_single:u                                        (49.97%)
       303,091,627      fp_arith_inst_retired.scalar_double:u                                        (49.97%)
                 0      fp_arith_inst_retired.128b_packed_single:u                                        (49.98%)
               799      fp_arith_inst_retired.128b_packed_double:u                                        (50.02%)
                 0      fp_arith_inst_retired.256b_packed_single:u                                        (50.03%)
                 0      fp_arith_inst_retired.256b_packed_double:u                                        (50.03%)
                 0      fp_arith_inst_retired.512b_packed_single:u                                        (50.02%)
                 0      fp_arith_inst_retired.512b_packed_double:u                                        (49.98%)

2.657821021 seconds time elapsed

2.437137000 seconds user
       0.006960000 seconds sys

```

测速代码片段

```
#if FFTW_FOUND
static std::map<int, fftw_plan> saved_fftw_plans_fft;
static std::map<int, fftw_plan> saved_fftw_plans_fft_2d;
static std::map<int, fftw_plan> saved_fftw_plans_fft_r2r;
static std::map<int, fftwf_plan> saved_fftw_plans_fftf;
static std::map<int, int> saved_fftw_n_fft;
static std::map<int, int> saved_fftw_n_fft_2d;
static std::map<int, int> saved_fftw_n_fft_r2r;
static std::map<int, int> saved_fftw_n_fftf;

static void prep_fftw_plans(const TestCaseDesc& testcase, const unsigned reqsize_samples[], unsigned reqsize_kind)
{
 for (unsigned i = 0; i < reqsize_kind; ++i) {
  unsigned s = reqsize_samples[i];
  if (saved_fftw_plans_fft.find(s) != saved_fftw_plans_fft.end())
   continue;
  int n = s / sizeof(fftw_complex);
  int n2d = s / sizeof(fftw_complex);
  int nr = s / sizeof(double);
  int nf = s /  sizeof(fftwf_complex);
  // adjust by calibration
  n = n/4;
  n2d = n2d; // adjust in case JOB_fft_2d:
  nr = nr/4;
  nf = nf/8;
  // save 
  saved_fftw_n_fft[s] = n;
  saved_fftw_n_fft_2d[s] = n2d;
  saved_fftw_n_fft_r2r[s] = nr;
  saved_fftw_n_fftf[s] = nf;

// prepare pointers
  fftw_complex* pin = NULL, *pout = NULL;
  posix_memalign(&(void*&)pin, PAGE_SIZE, s);
  posix_memalign(&(void*&)pout, PAGE_SIZE, s);
  double* pinr = (double*)pin;
  double* poutr = (double*)pout;
  fftwf_complex* pinf = (fftwf_complex*)pin;
  fftwf_complex* poutf = (fftwf_complex*)pout;

// prepare plans
  {
   fftw_plan plan = fftw_plan_dft_1d(n, pin, pout, FFTW_FORWARD, FFTW_ESTIMATE);
   saved_fftw_plans_fft[s] = plan;
   if (testcase.verbose >= 2) {
    fprintf(stderr, "fftw-1d plan (%d/%u):\n", n, s);
    fftw_fprint_plan(plan, stderr);
    fprintf(stderr, "\n");
   }
  }
  {
   int n2 = std::min(256, n2d/12);
   int n1 = n2d/n2;
   fftw_plan plan = fftw_plan_dft_2d(n1, n2, pin, pout, FFTW_FORWARD, FFTW_ESTIMATE);
   saved_fftw_plans_fft_2d[s] = plan;
   if (testcase.verbose >= 2) {
    fprintf(stderr, "fftw-2d plan (%d*%d/%u):\n", n1, n2, s);
    fftw_fprint_plan(plan, stderr);
    fprintf(stderr, "\n");
   }
  }
  {
   fftw_plan plan = fftw_plan_r2r_1d(nr, pinr, poutr, FFTW_R2HC, FFTW_ESTIMATE);
   saved_fftw_plans_fft_r2r[s] = plan;
   if (testcase.verbose >= 2) {
    fprintf(stderr, "fftw-r2r plan (%d/%u):\n", nr, s);
    fftw_fprint_plan(plan, stderr);
    fprintf(stderr, "\n");
   }
  }
  {
   fftwf_plan plan = fftwf_plan_dft_1d(nf, pinf, poutf, FFTW_FORWARD, FFTW_ESTIMATE);
   saved_fftw_plans_fftf[s] = plan;
   if (testcase.verbose >= 2) {
    fprintf(stderr, "fftwf-1d plan (%d/%u):\n", n, s);
    fftwf_fprint_plan(plan, stderr);
    fprintf(stderr, "\n");
   }
  }
  free(pin);
  free(pout);
 }
}
#endif /* FFTW_FOUND */

#if FFTW_FOUND
template<JOB_ITEM cpujob> static
long fftw_test(const size_t req_size, const uint8_t* const data, uint8_t* tmpbuf, long, bool)
{
 fftw_complex* pin = (fftw_complex*)data;
 double* pinr = (double*)data;
 fftwf_complex* pinf = (fftwf_complex*)data;
 fftw_complex* pout = (fftw_complex*)tmpbuf;
 double* poutr = (double*)tmpbuf;
 fftwf_complex* poutf = (fftwf_complex*)tmpbuf;
#define DOEXECUTE_FFT(NAME, FUNC, IN, OUT) { \
  if (saved_fftw_plans_##NAME.count(req_size) != 1) { \
   fprintf(stderr, "Can not find plan for %zu\n", req_size); \
   exit(1); \
  } \
  int s = req_size / sizeof((IN)[0]); \
  int nn = saved_fftw_n_##NAME[req_size]; \
  for (int i = 0; i+nn <= s; i += nn) \
   FUNC(saved_fftw_plans_##NAME[req_size], (IN)+i, (OUT)+i); \
  if (s%nn >= nn/2) \
   FUNC(saved_fftw_plans_##NAME[req_size], (IN)+s-nn, (OUT)+s-nn); \
 }
 switch(cpujob) {
 case JOB_fft:
  DOEXECUTE_FFT(fft, fftw_execute_dft, pin, pout);
  break;
 case JOB_fft_2d:
  DOEXECUTE_FFT(fft_2d, fftw_execute_dft, pin, pout);
  DOEXECUTE_FFT(fft_2d, fftw_execute_dft, pin, pout);
  break;
 case JOB_fft_r2r:
  DOEXECUTE_FFT(fft_r2r, fftw_execute_r2r, pinr, poutr);
  break;
 case JOB_fftf:
  DOEXECUTE_FFT(fftf, fftwf_execute_dft, pinf, poutf);
  break;
 default:
  assert(false);
 }
#undef DOEXECUTE_FFT
 return 0;
}
#endif /* FFTW_FOUND */

#if FFTW_FOUND
template<JOB_ITEM cpujob> static
long fftw_test(const size_t req_size, const uint8_t* const data, uint8_t* tmpbuf, long, bool)
{
 fftw_complex* pin = (fftw_complex*)data;
 double* pinr = (double*)data;
 fftwf_complex* pinf = (fftwf_complex*)data;
 fftw_complex* pout = (fftw_complex*)tmpbuf;
 double* poutr = (double*)tmpbuf;
 fftwf_complex* poutf = (fftwf_complex*)tmpbuf;
#define DOEXECUTE_FFT(NAME, FUNC, IN, OUT) { \
  if (saved_fftw_plans_##NAME.count(req_size) != 1) { \
   fprintf(stderr, "Can not find plan for %zu\n", req_size); \
   exit(1); \
  } \
  int s = req_size / sizeof((IN)[0]); \
  int nn = saved_fftw_n_##NAME[req_size]; \
  for (int i = 0; i+nn <= s; i += nn) \
   FUNC(saved_fftw_plans_##NAME[req_size], (IN)+i, (OUT)+i); \
  if (s%nn >= nn/2) \
   FUNC(saved_fftw_plans_##NAME[req_size], (IN)+s-nn, (OUT)+s-nn); \
 }
 switch(cpujob) {
 case JOB_fft:
  DOEXECUTE_FFT(fft, fftw_execute_dft, pin, pout);
  break;
 case JOB_fft_2d:
  DOEXECUTE_FFT(fft_2d, fftw_execute_dft, pin, pout);
  DOEXECUTE_FFT(fft_2d, fftw_execute_dft, pin, pout);
  break;
 case JOB_fft_r2r:
  DOEXECUTE_FFT(fft_r2r, fftw_execute_r2r, pinr, poutr);
  break;
 case JOB_fftf:
  DOEXECUTE_FFT(fftf, fftwf_execute_dft, pinf, poutf);
  break;
 default:
  assert(false);
 }
#undef DOEXECUTE_FFT
 return 0;
}
#endif /* FFTW_FOUND */
```

**【缺陷详情及分析指导参考链接】**

编译这个包的时候没开SIMD优化，请参考其他发行版的spec文件。

**二、缺陷分析结构反馈**
影响性分析说明：

缺陷严重等级:(Critical/High/Moderate/Low)

缺陷根因说明:

受影响版本排查(受影响/不受影响):
openEuler-20.03-LTS-SP4
openEuler-22.03-LTS-SP3
openEuler-22.03-LTS-SP4
openEuler-24.03-LTS
openEuler-24.03-LTS-SP1

修复是否涉及abi变化(是/否):
openEuler-20.03-LTS-SP4
openEuler-22.03-LTS-SP3
openEuler-22.03-LTS-SP4
openEuler-24.03-LTS
openEuler-24.03-LTS-SP1

src-openEuler/fftw

内容风险标识

评论 (3)

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

内容风险标识