设为首页收藏本站

爱吱声

 找回密码
 注册
搜索
查看: 4611|回复: 25
打印 上一主题 下一主题

[信息技术] C++ 提速的新发现

[复制链接]
  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    - u2 c* w4 U! w: h3 A
    & P! r) |& q8 K* W( y自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。8 `( K  l7 m2 u) E" I
    7 S4 H# t3 d/ q" K: ?% x
    速度优化问题真的很有意思啊。
    " q$ W& n/ ]) S) `: o" B4 B% D9 o
    . ]0 c- w1 Y% X- \欢迎大家继续讨论

    评分

    参与人数 2爱元 +8 收起 理由
    helloworld + 4
    住在乡下 + 4 涨姿势

    查看全部评分

  • TA的每日心情

    6 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?4 \3 Z4 o& S( V# d
    把代码贴上来看看?
    ) S" e+ z  Z. [. f5 `2 x3 ^( k5 X
    . K9 l8 N, N% \5 [! r难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 2022-9-24 23:15:41 | 只看该作者
    会不会代码本身的缺陷阻止了自动优化?另外,硬件配置和开发环境可能也有关系。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2024-4-22 03:36
  • 签到天数: 120 天

    [LV.7]分神

    地板
    发表于 2022-9-24 23:33:02 | 只看该作者
    Maybe Debug mode?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    6 A% |6 q8 i6 P7 f
    数值分析 发表于 2022-9-24 23:04
    9 p! F5 ~! q* s拉下来?拉多少?
    , ^, c( j  Q& w5 H# m把代码贴上来看看?

    ! m! P% C& u8 u1 N/ G) r/ B6 n% Y; B3 s2 u- p) z
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)# T9 z5 ^$ i. n& x& ]
    {9 x+ c4 X: ~& c& E$ \
            comp temp, xtimesy;1 W* f( X7 ?* a2 Q/ u( i
            xtimesy.re = 0;
    * G3 F8 n  c7 z/ @, L        xtimesy.im = 0;$ `9 j" v+ e5 H3 o
            int j0 = lenB - 1;) a0 T, X0 p4 ?6 |7 _+ j
            int    i, j, i1, reali;
    ; K1 E5 h1 c, U" f1 B" d4 }        if (lenA % 2 == 1)
    $ z6 {/ F0 P. b                reali = lenA + 1;
    / Z$ S, z( {: X' F$ e2 V- h        else
    . b- q; x8 f; A3 R$ w( H                reali = lenA;/ \: W' }% y$ A- e
            reali /= 2;
    ) F' x% @& l. k% Y7 n( K6 c. n6 H: w4 y/ y' L
            int nconv = reali + lenB;# s3 z. U6 i- `0 e& L$ a
            //#pragma omp parallel for
    6 S) T3 k; s1 \$ K: q% q4 C# E        for (i = reali; i < nconv; i++)
    6 d8 M( N; L/ X# B9 Y        {
    ; _5 Y. E/ t: f2 H; ?' Q                temp.re = 0;7 @$ A; C( e& ~: V5 n8 }
                    temp.im = 0;# A: x0 T7 u- q  i
                    i1 = i;' X' C. Y8 h; g; C
                    for (j = j0; j >= 0; j--)! [/ H. _5 s3 e* I
                    {+ M; [$ c# s! P% {3 j- k3 y. Z
                            /* floating date operation */" V" Y6 A- B7 V& i0 f) F" t" N
                    }
    / j& I* m. x: q3 a0 y5 y
            }' Q. t) K3 i( ~2 |  U+ @
    }! \5 a2 X& `: B8 h4 g

    . M) h9 a6 ?0 R! O, f& Ixcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    0 Z. u1 K. {4 p5 S' q+ y
    ; }6 P) z% e& _/ w' o; e4 M( w6 n红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    2 I5 L% j+ _1 A8 a现在call xcorr 100次,耗时78s.
    3 U" Z- R3 L: ]+ s% ?# D
    ( k) p6 P; Z. a5 l如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 0 G& ^# R5 _: ]1 m9 K: w7 [
    3 p" k" l  w/ O! @
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    7 ^1 S7 o3 a$ s8 i  e3 ~% Z0 rMaybe Debug mode?
    & u/ q. |7 P& `
    5 b4 Y- C8 X4 c4 s5 F3 _
    不应该,看我上面的回复。/ E5 U" r6 g3 t) g1 _) `" U
    ' ^# S) l/ a4 X; j9 v& i! J/ ~
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    6 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    & v: `" R8 Z3 h; N% |/ v3 Z5 {$ w
    雷达 发表于 2022-9-24 23:547 j8 x& x* V" t+ N, H" @9 p
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB). T4 Z; ~/ V& f% T( x) h( P, P0 m% h
    {2 a2 b6 H: S5 j  ]. M- I
            comp temp, xtimesy;
    # b' ^4 R. {% g' [5 y8 n8 H
    : R$ r- B6 O4 v1 p& I" P  k
    这个不是这么比的吧。。。% E# c5 @* u4 ~+ M. s

    . ?7 Y- J/ @; D: P4 ]1 q" r! n( R您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。- @, ]- S: j# C

    ' Y- b5 t- B  z/ ~而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    6 _7 L- E* O/ n2 A$ `
    数值分析 发表于 2022-9-25 00:20* s* f' Q& x! d, H0 {, f
    这个不是这么比的吧。。。' n: G  ?) d% o% x0 C$ V0 h+ A

    ; ~6 ?. X- O/ ]2 a7 k您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    1 B* h: h3 U  c/ d1 F4 P5 |
    " u) o( J6 d; h0 T% D& P1 X
    有道理。
    + U8 O" s# v3 ?5 R: v- r" y所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。7 Q* G: N5 h* Y( `

    & G! a9 {) s1 w3 v我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:464 e- H  g# l6 j  i* f) a$ x
    有道理。
    ! S; B5 N8 Q; Q+ v% i' g7 W所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    0 p' ^  y0 u$ E
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    ) ?! R  x0 ]% ^Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    5 i6 ~9 e; N' I/ K这个不是这么比的吧。。。
    % X2 s; n. J- \9 S
    : {& k+ z# Y% s您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    3 X3 b9 F( l( q% r) {7 R- G5 |9 O1 P8 K" d! k
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    6 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    ( ?: z/ q9 Q. L
    沉宝 发表于 2022-9-25 01:48
    ( s1 h) e8 n, L* P4 I# |* `现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    0 y8 O: C( g) B  @1 I: t

    ( F$ m; B: l5 V- N是的,兄台说的对。' Y6 j% [% [" Y6 }/ f1 h4 V
    3 O  q  F* C- A
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。& g" j$ M) X: Z# C4 V
    9 z1 W4 a, U: c$ Z1 d
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。" c) V- b" R* O8 e

    & N  q: G# k) l4 s3 @0 }7 B比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    & O) A* c4 Y6 r; D/ F& `9 q% y8 [) T
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 , P! l, i; C- K6 Q' B7 Y0 k4 r0 }" M
    沉宝 发表于 2022-9-25 01:27" x! E  F5 U( Q' @
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    % j  E; I6 x. g9 Z8 t8 ^6 J( S

    . \( ^$ O" j: T又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。0 T& `0 g/ }& Q2 t: \; u
      [( O8 P2 b- w
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    : ?3 M- U) x' \又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    4 v/ T7 t" f, p9 r时间差一倍的结果可以接受。
    3 {6 t4 _0 p% h% Z, [; v" W/ u3 H  v) N
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    6 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 # `6 x8 P6 ]! j) K) D
    雷达 发表于 2022-9-25 04:47: y: ?. D. U* p3 m4 {9 M, N
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ' V; T6 d0 I$ d3 L1 o" S  N- s. E- I9 l/ N# g

    8 M: N: j5 q5 @  x2 K/ m4 {' u0 M; h- C0 ^
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    : H1 I% p/ |% O0 v& C7 F5 D1 z: e
    数值分析 发表于 2022-9-25 14:58
    3 R8 B. N$ o; i能不能把这个也贴上来,看看和上一个有什么不同?

    7 c+ e: W" j4 V( D0 }. D理了理思路,重新做了一个测试。
    . C- z- Q0 r& H4 N做了两个 vector 和 两个 float *, 都长 100000: y% P; J9 f5 h+ j7 S$ h3 t2 w
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    : e' n" W4 E0 Y8 z5 |1 a1 i9 C2 P8 C: ?" R
    内循环试了4种方法,
    1 y: @) v: G5 s! o# K1. 直接调用 vector inner_product 247s
    1 I: F- p, Z: d2. vector 循环点乘累加 237s
    3 j4 d/ r6 K7 h; ^0 \3. float * 循环点乘累加 204s8 L  d6 m4 n# r: c: `; x$ f$ |. W' Y+ |
    4. 空循环 100000 次 202s
    ' v6 C" p& V& b( j6 E" l
    . o! z& V8 F0 o  V; N# S  z. r不做内循环 200s
    ; m  z/ ^* W8 T9 _: k. h
    2 C7 T. c4 |( K3 {- Q你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    * v. m1 D2 p. Z5 S1 R另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    4 z) S# C5 f0 r- |& c/ x
    # T1 q7 L4 D' {' h至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    / Y( q8 y- C- N& v
    8 {: s  `$ N1 f0 F3 P8 K; l4 D(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    . x) N$ O3 F- @, U; z6 ~1 }% |4 i2 [1 m; y; v0 j, Q( }
            std::vector < float > vec1(N);- V/ v2 ^! D7 i# @5 [5 h
            std::vector < float > vec2(N);
    . \# p/ E! p  [# u        float* b1 = new float[N];
    3 A! |% B8 O- W        float* b2 = new float[N];
    4 k. S; f) \: |+ i5 m5 y
    3 [) @' S& f+ b$ b        for (int j = 0; j < 6000; j++)1 s7 r9 O/ `' D& u0 a& Q3 Q4 a* S6 T, c
            {" v: s$ ?  m$ u1 O
                    std::generate(vec1.begin(), vec1.end(), []() {, ?2 H5 f! @* P0 q0 _: U
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;' n$ X% K& w& q/ r& H+ b6 `' z
                            });
    ! W1 M3 e6 {5 ~3 S& N2 \9 Q  c: V: K- F: F. ^
                    std::generate(vec2.begin(), vec2.end(), []() {
    8 }: W4 f1 d$ D" S1 v; k                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;! F$ h. \$ Y- v) ?
                            });% T% S+ I0 j6 t9 x1 y
    ) h% N- }! r  O: Q1 w8 ~$ w
                    for (size_t jj = 0; jj < vec1.size(); jj++)! t/ W# a4 w% X1 w. {0 X. Q
                    {2 A# J: E1 r- [- s( b
                            b1[jj] = vec1[jj];
    0 j' g8 Z2 P. B1 F: j9 h                }3 @4 b: m3 h* w9 B6 D* y( X7 [

    . v/ i5 H9 S$ ~# m6 ~                for (size_t jj = 0; jj < vec2.size(); jj++)% y$ S: Q3 l' q: [, O; I
                    {
    ( q3 o: D, \# t$ e) a9 e% `                        b2[jj] = vec2[jj];. ?; O* |2 m0 ]! |& C
                    }
    : H5 K! [! W, N$ u8 }) p  Z7 o7 q
                    //Method - 1  N=100000 247s  , y' S1 y- N! T1 K# E* n
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    2 x! ^) Z' N; d5 _7 S+ S* w: E# \% H                                . H9 [7 g& G5 q- t3 l
                    //Method - 2  N=100000  237s
    0 O& Y0 `- n! x" L- g, c( s- ~9 D                /*! o- Y( j/ w3 m
                    for (int jj = 0; jj < N ; jj++)
    % Q2 W0 a; I7 X, Y) N                {- J- }' |. @9 R5 \  A
                            fresult += vec1[jj] * vec2[jj];
    / N8 r; e; a! g  \( D                }% X" u$ M6 X3 B( k' \; h
                    */
    2 H. C0 Z6 i% f                                9 u3 A# N5 J( J$ O" M+ V6 Y( S! \* z
                    //Method - 3  N=100000 204s
    , F2 ]5 I9 c. W' w9 {                /*; n  t4 e8 x$ A
                    for (int jj = 0; jj < N; jj++)
    % s( [) Z9 j; h- x& C& ^/ Z                {
    ( R! b' F5 D! |                        fresult += b1[jj] * b2[jj];+ i) x7 m& X8 e1 g' i
                    }
    4 D  M6 P. `4 m# n6 k" G                */
    3 u( e) }: ~0 z6 I/ n# T3 d$ |- U4 c! v, @, n9 o
                    //Method - 4   202s& m$ P+ R- x" z
                    /*
    6 P6 x( h) _+ v                for (int jj = 0; jj < N; jj++)
    ) U8 |7 Q, \& @& {0 X( h                {( V/ H0 i6 R1 _$ g( G. H0 [7 D7 T; o
                            
    8 }7 N- d8 v7 G& X; C5 f( @, i                }/ h* i- V* O5 s6 |  F; @' k
                    */" M& k6 f4 h3 P, t3 b# a
                    //comment out all methods, N=100000  202s               
    & G$ U, ]& \- Q4 W, `' |        }% l3 }- u, N" B' Z8 O9 U
    ! ^* C; G' _9 ~- S' Q: D; a; X
            delete []b1;9 \/ w# P/ C/ Y9 s4 T- q
            delete []b2;

    & G0 V. h1 {; g$ W: {/ y3 C
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    奋斗
    2020-2-8 10:08
  • 签到天数: 2 天

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?/ g' v5 C0 ?$ ?8 h
    1 S  j4 ^/ w0 H8 }1 b5 y9 v1 a+ m
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?1 e5 l% M6 T5 b& G
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    2 f7 D: S4 A8 j: b% a瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?' L( Q# h6 N( o( u/ r9 S  e- d& v

    3 Y# y6 D2 |% ?. P- T你第二个试验里面的j在循环里面又重新定义 ...
    & \% H, D( n" M8 B' X7 z
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL2 D  g8 z" ]& |/ x

    ! H0 A7 k% w: z/ y不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    奋斗
    2020-2-8 10:08
  • 签到天数: 2 天

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
      U5 y/ o) Q* c2 E: F& ]$ C内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    * ?1 D! h. K. A) J* s4 j! [1 r3 ]0 V6 J4 n' ^# W0 L
    不和它 ...

    8 m; ^" {3 B% y8 e# C
    5 b2 M* X5 B2 ?. s1 p9 \! [6 P不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。' h# C4 {. z* S- P- g8 ~
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    19#
    发表于 2022-9-27 07:25:57 | 只看该作者
    一个无关问题,为什么爱坛的帖子里在我这里有好些奇怪的东东在里面,是防拷贝措施吗?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    0 r! l$ n6 L1 N1 [# H% C2 L, @void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 W' B' Q/ `  n) j/ ^
    {& a0 m: A$ x6 L- r& P
            comp temp, xtimesy;

    0 M, u$ i+ }0 b- G这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。% m& d" W6 H) M6 ?
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    3 q) |6 q4 \* a6 dVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

    手机版|小黑屋|Archiver|网站错误报告|爱吱声   

    GMT+8, 2025-2-19 06:40 , Processed in 0.041827 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

    快速回复 返回顶部 返回列表