设为首页收藏本站

爱吱声

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

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

[复制链接]
  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?9 j" q1 g4 z# R/ n* E; g6 e
    ! b7 b# b  H% m- ?. {0 `
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。; J" A3 @  r0 v
    % x; P3 [! y& D: u9 b
    速度优化问题真的很有意思啊。. b0 Q$ b, h* V; a% [
    4 k, o+ @1 ?2 w
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1947 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    2 H  l0 B" Y$ F- u- N把代码贴上来看看?
    6 g. s/ U+ e. Q, v
    : q# @1 h% D1 g) g难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2025-6-14 10:13
  • 签到天数: 124 天

    [LV.7]分神

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

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    : Z* x$ w6 y+ _( G
    数值分析 发表于 2022-9-24 23:04
    1 w6 D* n. \6 v$ C拉下来?拉多少?
    : S  s# {1 `0 H0 c4 j% Z0 Y) o把代码贴上来看看?

    9 ^$ s, O  K- y& B$ P0 `3 u
    # d; E+ S, ]6 V' t9 G6 Svoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)) H6 u* n: H7 s
    {
    $ [& G$ Y5 T& t/ `) o( c        comp temp, xtimesy;# X( u( V" V0 {, ^
            xtimesy.re = 0;* t3 C0 s8 S+ a. a& h5 j% G
            xtimesy.im = 0;3 V7 @7 i7 X9 |  E5 s1 X
            int j0 = lenB - 1;
    : o  J- \. M5 U        int    i, j, i1, reali;1 M" S% S" i  Y
            if (lenA % 2 == 1)
    " q5 U; p7 o2 `3 N) k' A                reali = lenA + 1;( M/ P6 }- i+ Y8 }, e0 H" [8 ~
            else
      @0 R% m9 ~1 P5 p  w                reali = lenA;
    + L! Y5 D: Q3 L5 Q. W3 C        reali /= 2;+ g; R* ?) Q+ `+ L
    ' r1 d4 L* D8 G5 `+ e
            int nconv = reali + lenB;+ `" ?2 b; g: v; ?
            //#pragma omp parallel for
    , i" i0 B( K: {# {5 f# q- p  F        for (i = reali; i < nconv; i++)9 \7 n3 }4 d$ v4 Z* A5 c) M, q+ z
            {* w* ]/ A* e$ p+ `* c
                    temp.re = 0;& G# P' S5 J" q: h  B% E! h- M
                    temp.im = 0;
    : W7 \3 x. Y3 I4 Y3 C3 q3 ]2 g                i1 = i;
    : R* P3 W. p( Q6 J( f                for (j = j0; j >= 0; j--)6 r9 U" F8 ~1 q
                    {
    & }3 i& d! X# }5 r% T& f1 ^                        /* floating date operation */, h  C3 ]! K9 |
                    }

    & |' p: [1 H, J0 u" z( f1 k        }- c3 M8 k  |. O' r+ b2 s
    }
    ) K) D3 M* _( W/ f
    ! v- z1 R1 H0 l2 Mxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    : Z, Y3 z+ `7 l$ [* d, h* G/ F+ ~! }, d" R+ j  H- O! H
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    / [  V% [+ K% G* }& _0 o, s2 V现在call xcorr 100次,耗时78s.8 n( _. P8 K% f7 D0 i0 t) A0 q: Q

    * F7 I5 }/ _! M. o# t+ n. y7 u如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. . G& M/ ^4 a6 T+ I' e/ d( _

    1 u* I: k2 s/ z0 H
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    8 m5 ~& L( I* I( Y, F) xMaybe Debug mode?

    * j* R1 o2 {* U, s& H
    . h0 w9 p# q5 }0 N6 ?* E6 j不应该,看我上面的回复。( K& r* \- ^4 t. S
    # k5 n9 ]. J( `$ u$ T
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1947 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 " ]. I3 }8 [0 V4 _# y. {5 w
    雷达 发表于 2022-9-24 23:54
    , R- q# @9 f3 P8 A; s' A* T3 Tvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)& l' h, W* G# c8 p0 G3 N7 Y/ e- H
    {
    ' w+ D1 Y$ ]2 |3 c* S: V        comp temp, xtimesy;

    % ~% N3 Y- a9 `* X7 ]- d. \& j3 j' {* j
    这个不是这么比的吧。。。8 `( c8 v" Y8 n' @  Z
    ( W" \# b9 P: v5 y1 {6 F+ ^
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    + n6 L" H. h# u4 }+ l, q) V- d8 g  L. K7 m4 A: z# o4 D4 ^% B
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 7 c/ Y8 Q- s1 Z! y' t8 K! C
    数值分析 发表于 2022-9-25 00:20$ {* p4 a1 b, D: {+ c$ T7 Q
    这个不是这么比的吧。。。
    7 I( w. Y- C! J0 D
    ( v2 i+ N! U7 y. F3 D您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    5 Q; H7 H- C8 S5 X0 e5 D2 a9 y7 U  S( Q4 w: R
    有道理。
    $ E; |1 B9 q% d1 C: m" ?所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    2 w3 {9 ^( j. ^5 c) M, t$ C
    % G9 b0 _" s: w# v5 N* @9 V, C我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46% l5 q' p2 V8 v9 H6 D
    有道理。$ ]6 I( Y( `+ w
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    ) S' h' t9 h  M2 i0 }你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多3 j- S. E+ ^" D' o1 V0 H
    Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:201 S) H/ g* c/ u+ |9 I- l- U
    这个不是这么比的吧。。。0 O# |- D/ G/ s% g6 `

    3 E  ^  }. T' N8 c- s6 ^) x  i您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    ; r/ B/ `. B; N+ q' E# U& R# N
    6 E( x2 O" M1 {; k) A
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1947 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    % R% q# e6 F' ~6 v3 Z7 B  }- }1 i
    沉宝 发表于 2022-9-25 01:48' N  P# o5 e+ y4 ]0 F8 J
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    6 U3 ]3 I/ Q% o8 G# u9 _; m8 G$ S
    是的,兄台说的对。
    % i* Z+ [5 G* z- J% Z2 f# z
    / [+ i" t( \  d* _% ~* ~, s! h3 v& X其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。6 l. h' h( j) ]8 J

    # e1 F! n% X' h# U8 p雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    ( I5 V! |7 {$ C9 k- T: n3 c" h2 ]0 X) c/ U$ {
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。6 o& @# i; r& R% J2 a; D
    1 c, N( q! Z8 g) m' n3 n
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 & F) Q$ m/ y+ O' C% l
    沉宝 发表于 2022-9-25 01:27
    $ f& u: c2 j9 G& p9 n  s3 I( R* u你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    ' c9 g* S: m+ Y
    , U4 h: F1 Y! d# J& n又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    , D* n" }; q" `" ~  v( \6 B, G2 P. ]2 p) x* z+ v
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    8 q/ u/ ^; s8 {7 ^又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    " [  E# A3 `/ M1 u" \) \时间差一倍的结果可以接受。
    4 f: z4 M7 A3 z& E( N
    & }* `1 f. Q0 J2 G你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1947 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    0 ^! [, ^5 ^# j
    雷达 发表于 2022-9-25 04:47
    . n9 u  z3 a% B7 r( `( x又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    : ^- w3 D! l, s# A# Y9 n. T! f, a. V  I* e

    - R+ h2 c) u/ ~$ q7 A& {7 G: r/ j
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    ' m* q* C6 S2 h3 q3 b. @' N
    数值分析 发表于 2022-9-25 14:58# c  r+ P8 d' _; X) P# s+ Q' n
    能不能把这个也贴上来,看看和上一个有什么不同?
    4 w  J2 d- w+ T/ e* m
    理了理思路,重新做了一个测试。
    - n6 `+ l( G2 i! e( D做了两个 vector 和 两个 float *, 都长 100000
    # f/ t5 ^; |, a2 B& F, V% l外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.) m* e) G* H1 t6 B

      `( G: @1 e- V: z  q内循环试了4种方法,
    / x3 V" u; y5 U1. 直接调用 vector inner_product 247s / ?/ U6 E8 i2 S* S5 \3 k
    2. vector 循环点乘累加 237s
    ' O# u3 W9 H- M  n, v8 W3. float * 循环点乘累加 204s
    & T/ C3 w$ w, n8 u& q) P4. 空循环 100000 次 202s
    * d- {2 G& Q$ x* d/ Q5 t
    ! V0 v7 C! n( i  ?不做内循环 200s
    $ j$ u9 W( C( ~3 G
    5 A% e6 `, V4 @  Q2 c+ U, w0 T* g你昨天说的对,内循环本身占比是很小的,大头在其他处理。4 E, b, [$ z; J' N3 X0 p( |! E# X0 S
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    . z% d5 p8 O3 \4 W8 B! P$ c" a/ u* a- r0 M# M0 |/ H" ^
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试): Z: u  i! _5 {& F
    - U/ \" e* q  J, S" C  m: j/ s; c; G
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    ; a2 W/ A) ^4 C5 n6 H
    ' e9 J0 L5 N1 O
            std::vector < float > vec1(N);
    " K6 S% V, j( s5 `: p7 k$ x        std::vector < float > vec2(N);  J: z+ x2 s( F1 l' l
            float* b1 = new float[N];
    % R3 m# ^" O+ w% B8 ]" [% W        float* b2 = new float[N];
      Y2 O- \2 g/ N$ u9 |% H  I
    $ e/ E* b! \' K        for (int j = 0; j < 6000; j++)
    . E  }* X' {1 M3 T# `+ P+ @1 S        {/ v( l$ {1 X6 H' X. I# p9 {
                    std::generate(vec1.begin(), vec1.end(), []() {7 N7 H1 j- \8 M& c, }
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;* y, Z* k# u' F& q
                            });' u6 w+ R3 y! I1 V) E

    $ m- S& [! h; p                std::generate(vec2.begin(), vec2.end(), []() {
    5 D. D3 S4 O& z( g                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    & Y; _% t7 J2 v- O  L& L                        });) T+ j" R- \% k2 T2 P

      P0 D: m& Q' D7 \1 ?, }                for (size_t jj = 0; jj < vec1.size(); jj++)% q) U+ z' l4 V! s& I: @. j
                    {2 M$ V& y2 U- ?: u$ E' K: @
                            b1[jj] = vec1[jj];. I, u# B# c, P2 w( l1 `9 s
                    }5 _/ C# S- R: ~) D

    9 s1 C0 h6 e5 w  u                for (size_t jj = 0; jj < vec2.size(); jj++)0 S0 w; M* M1 b) H" \. O
                    {4 i( U& R6 j& w( X$ S$ x
                            b2[jj] = vec2[jj];* k" _2 z* x3 ^( I
                    }
    0 Z2 D& f# {- f6 v
    , e. H* F/ E3 o9 G" C; l                //Method - 1  N=100000 247s  
    $ g2 L2 N1 N% ^% `& P3 u% X                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    5 U2 i: w1 Y6 b' |" l" S! P/ O$ x                                
    / \9 O4 ^' X* \                //Method - 2  N=100000  237s' E! A- E7 F* Y
                    /*
    6 C% [" H" x/ f6 o& H/ v* J                for (int jj = 0; jj < N ; jj++)3 }4 b( }# w* S1 {! @0 |
                    {* @8 A8 ^4 d5 Y- \# u1 ?
                            fresult += vec1[jj] * vec2[jj];3 R: m/ n, d5 x1 P
                    }
    % `1 F' D/ ^  L* b! l0 _" ^                */. W, z/ W0 z/ t2 v
                                    7 X& j+ C9 G4 v2 K. n
                    //Method - 3  N=100000 204s2 m( f% Z: y: O- c4 S: I
                    /** e" B2 I7 l8 H% V$ |
                    for (int jj = 0; jj < N; jj++)
    6 G$ {3 V* F$ b7 l  ]$ Z                {* |+ {& x1 N$ I- h7 w4 x* D0 B
                            fresult += b1[jj] * b2[jj];# d9 w7 {2 u: ]) S: C/ g6 G0 P
                    }
    1 M% m! X0 a4 \4 {* D                */
    $ N* X& K- {/ i" N  k" n* G# e+ M/ Y$ R! o6 S+ S8 w
                    //Method - 4   202s' y: L3 Q- P# C1 f7 n
                    /*
    6 `3 f1 N: `  i/ Z, `                for (int jj = 0; jj < N; jj++)
    + c) M. L0 y8 j. D) L+ U3 |                {
    2 [( C" Q& x1 d, u1 x  L, T                        
    / }1 W/ V7 |6 O: l                }, w2 G# c- ?! {8 x1 X
                    */; Q' R- B2 O" v4 S( J  {+ q& m
                    //comment out all methods, N=100000  202s                  u5 Z3 C. A6 g2 I: {7 S$ ^3 V- o
            }6 {8 n1 j1 b) s
    7 N) d9 \/ L5 G/ S0 ]" c7 n1 _
            delete []b1;. D; |  @5 R/ J
            delete []b2;
    , a7 w' k# W7 j4 b% k0 Z
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    9 t# }  f5 s2 D
    5 K7 G1 O4 e3 o, }- j& J4 _你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?2 m0 N0 y' t( ~8 X
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:158 r3 O) E: s7 J4 D7 C" V6 |
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    0 p, a7 q( N( M  D
    " H. W( b; P, ~2 Q4 `: Z! _4 A/ ?你第二个试验里面的j在循环里面又重新定义 ...
    * K/ e& X4 c3 t- |1 z0 H8 r' _
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL  Y7 o6 T( Y7 z  t' j
    ( o; O# \2 s& v/ N( ~* {- v) a6 G
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    9 _5 ~: k6 s  ~( f! @内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    & s* X0 c: A! [$ H# `5 f5 f
    1 F( M4 _! U  c不和它 ...

    - E$ v7 D/ W7 m$ B) N, R3 {$ T6 ?) Y* V& d
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。; _+ L. _: Y, @5 G3 g4 b: d
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:549 I& b+ }4 W+ L
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)" O" Z: I' j8 d3 K: Q/ J
    {
    4 g2 c7 a1 n' k9 Z! K        comp temp, xtimesy;

    % Y: ~  o/ m1 ?$ ^7 K' C这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。: t! n0 @8 x( f
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?  s4 v- B4 {7 p( D5 g" z+ O& ?4 c
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-10-14 17:12 , Processed in 0.045962 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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