设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?! J/ ?/ \* N- @8 _
    2 X' q, d( ^4 M0 k: ~% a) {
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    ) Z! ?3 o( c" D, c) f/ N3 j/ I: k, i: |
    速度优化问题真的很有意思啊。) q. A: V8 S4 q4 K

    ' X- f6 E" L1 _  V) M欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    + y: u0 Q! p. R: v' a把代码贴上来看看?4 O, i, s1 b: J  V/ {' _& {0 `
    ' o+ w# \; j5 d* e) p9 `' m& [
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    5 i: z$ f. a( H* L
    数值分析 发表于 2022-9-24 23:04
    ( N" M$ K7 p2 x! N7 t' L: [1 u3 |拉下来?拉多少?
    7 Y5 s+ _! G6 D9 A( C把代码贴上来看看?
    & |# m+ s8 H. z6 f2 F4 v2 R

    : i% s, e, m: Mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)3 h5 J: u; Z* k/ |9 j3 h* \2 R
    {2 q( ]  N0 N6 N5 D
            comp temp, xtimesy;
    3 H( D+ o4 ?/ q  c        xtimesy.re = 0;  G* t* S" Y* B+ C7 ?
            xtimesy.im = 0;9 ^# Q' ]% b. O/ Q$ S0 i: q
            int j0 = lenB - 1;
    + E% e" c; b7 g) l: X9 a' J: |        int    i, j, i1, reali;
    ; U0 K) G7 s$ Y8 p        if (lenA % 2 == 1)
    ( A! t9 ]9 D& x+ V                reali = lenA + 1;
    ' E2 ?" _% e1 s; j: m% O/ ^7 Q        else  }7 I0 S" {2 X# ~" l
                    reali = lenA;
    % Z! i% q" x. a5 X* U" d3 w        reali /= 2;
    . Q% i) J$ }5 q5 @8 Y; U5 \, x
    / K* J, @  L* G        int nconv = reali + lenB;
    % \0 Q; _5 E: }, d! b        //#pragma omp parallel for
    8 _+ r- A: {+ {" U        for (i = reali; i < nconv; i++)
    5 d/ x9 S+ \! e, a7 r! w        {7 ^2 q; U  b" d, W; j
                    temp.re = 0;
    8 z3 v- r- y4 I) [- S& a5 f$ e" _                temp.im = 0;
    " P; A6 _+ K! Q1 `% O2 E8 ^                i1 = i;- h6 w; E3 ?9 T, q+ Z
                    for (j = j0; j >= 0; j--)
    4 n( d! U( R/ Y& m; x4 O8 R4 ?                {
    * ]5 f& Z! B9 C& n                        /* floating date operation */
    % S) s( e( `! x6 @                }

    " j" i: F/ f8 c# h        }$ C+ r+ I2 t8 e
    }& h6 p! g" X; z' C$ a+ u' O& I) \

    2 v8 Y4 f! W, M7 x0 {/ M8 Dxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样+ Z" G, W9 p% h& h. f0 s7 M, F
    7 R, K/ f# V4 p. u7 H
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。: ]4 _7 |3 l% C9 S
    现在call xcorr 100次,耗时78s.! H- I  B! N( O+ I* l: M

    % I2 t$ T7 a2 X! E4 e, n如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    ( D$ Q, |( f2 q+ _. ^  P0 d$ B
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:331 g/ O' t# J' d* K* {# B* m- _
    Maybe Debug mode?
    ; ~; b3 N5 ~7 [" @% |7 p6 p

    ' [* h/ C4 M; t$ j5 ^0 G不应该,看我上面的回复。$ z$ y$ L, ?- ?6 J, O6 K

    3 p/ \# `4 ]8 n我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 ) f+ I+ ]  `4 F0 _
    雷达 发表于 2022-9-24 23:54- I1 H: K7 X+ \% E
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 B1 f" n  Z# O, Z0 P
    {
    . I; D% i+ n" b. X$ F: Y% j; V% U        comp temp, xtimesy;

    , b9 d7 @, ^/ [" H  M8 j% q+ G% I7 Y! U8 M9 L4 k& g2 h5 S" ^
    这个不是这么比的吧。。。
    * G. w' X* h1 z2 k( A
    + R# K1 x' Y  s3 I) A2 Z+ z6 j& j您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    0 P  z4 ?7 N5 t9 `9 W8 m6 O3 ^% D# g& q- G' r* R8 {9 Q  B! W
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 / N% Z0 X* E0 Z3 z0 V7 ]2 q
    数值分析 发表于 2022-9-25 00:20$ d. w' V& \$ ?
    这个不是这么比的吧。。。& r3 b6 V. [' r- h( B
    / B+ T2 j- {8 M, n  H! p% R
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    ; G. ^# t- f+ @

    ) V& [2 c1 p1 y& S有道理。
    / h+ ~# j: l* s4 q所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。; g  T1 A( C# j. q
    - J" e6 P. T: }( m8 w
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:461 x0 A* ?. N# ]1 s! B
    有道理。6 S# ?; Y: I( c0 Y. C
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    + m6 w* \0 T1 f9 i4 _你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    $ C: u. ^2 T" |7 o5 I- ^3 c+ q" wWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    # W0 r1 o8 N2 O3 K, i) y这个不是这么比的吧。。。
    1 K3 C2 F3 M8 v( q% x; z+ f8 S, Y" M. x' m, T6 M1 P
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    ' A' R( |1 h$ ?

    6 U6 X( d7 @, r" [) ?' l现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    " _7 {' g9 }7 y( K# _
    沉宝 发表于 2022-9-25 01:48
    ) |, q. U4 a: M# S! G: B/ ?$ m现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    ; _0 @; N' A7 D* ?: R
    # N9 _; ^3 F+ u. n) l是的,兄台说的对。8 J! @0 M1 O( M! Y1 M" O
    & c8 C3 ?2 l/ e; p% G9 r
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。3 Q" R; {9 {5 ~: G
    9 W. \: M: n& h% y1 U5 N$ t
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    1 f6 o3 P0 n9 C/ v: O) G
    7 m* [2 V; J( K: q+ S& p( o. k$ @1 h比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。: a+ j+ E0 f4 Q4 n! Q7 D
    % G# I, e3 ^+ f: A+ v
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 7 N5 U: `/ P/ C, h
    沉宝 发表于 2022-9-25 01:27  ?# |* N5 t/ x/ X' H$ w% g! Q
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    3 P+ r1 g" d; E- _, J
    # G, x9 I% [+ I* V/ P& O1 l9 M% m
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    0 ?4 A# `! x. c3 s
    ' ^! P% Z: m/ Q, ?, V: A4 M& c我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47% X# v  k# l- B" _6 B! I
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    - v: n- d( M8 x3 K" u- n  m/ @时间差一倍的结果可以接受。
    : B! z& \/ W" |4 t
    7 Y( O8 E1 y2 b3 B. i5 w/ M你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 ' ]& l( _) P* v4 w4 H
    雷达 发表于 2022-9-25 04:47, {2 X, ?( K- d5 ^
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    - U4 [; q3 {  C& f5 h
    5 e8 T' s: N1 n; m  v) i; }& T# J9 c, d

    4 j1 k/ }) V4 K3 i能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 + Q3 z$ q- r% E! e1 R2 m4 K. N( O1 z
    数值分析 发表于 2022-9-25 14:58
    1 \- t' f( C* o% }, j能不能把这个也贴上来,看看和上一个有什么不同?
    8 L) k* W' x$ z; ]
    理了理思路,重新做了一个测试。) f3 ?" o9 T- O$ L6 l
    做了两个 vector 和 两个 float *, 都长 100000
    : p0 [+ _" ^/ y( \2 C* J; p1 E* G外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.  j( @1 C/ y3 R( x0 [
    3 F2 r- D4 X' n
    内循环试了4种方法,
    1 \! {) B# D) @+ b. n8 K1 d* \1. 直接调用 vector inner_product 247s $ p+ t$ J7 o9 s
    2. vector 循环点乘累加 237s) B! x/ A" e5 f# {0 X" d
    3. float * 循环点乘累加 204s- L, E* N" s8 }1 L, W2 c: y
    4. 空循环 100000 次 202s
    # f4 E- K9 a( e4 z" ]1 O& H$ y) {* q+ q
    不做内循环 200s
    2 \. i0 s$ f! g
    7 E& N7 B2 H2 ^) j) E8 B( l你昨天说的对,内循环本身占比是很小的,大头在其他处理。) c" Q  n9 e0 b
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。: X% b5 Y* G5 x: Z7 g, G
    $ s; S% p9 w8 u: Y9 y# N
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试). G3 t# I2 ~& L+ y. z: a
    " }) R) @' \# |# e1 U* w
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    1 e) r$ B, \$ g1 i: W' k, H
    $ [; x8 k& b  @) v0 H
            std::vector < float > vec1(N);9 F( [: X( _* H3 Q, L& a- t
            std::vector < float > vec2(N);' Z/ z) ~6 v' Y' j
            float* b1 = new float[N];& V, N2 K0 ]' a* `) v( I( D
            float* b2 = new float[N];
    $ x& H" [8 ]0 k2 i1 f7 T; {* o& ^
            for (int j = 0; j < 6000; j++)6 w9 r  l& R1 R$ i6 Z" h& A
            {
    ! L. w. {: a+ ]' x- u* C                std::generate(vec1.begin(), vec1.end(), []() {# U- F* E- R' j9 S
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    5 r! V# C) L, X. g3 C                        });9 I/ L' G, ?5 b" }

    5 _9 R% ~# f* C% W, V" m: v% B/ p                std::generate(vec2.begin(), vec2.end(), []() {1 x$ V) z9 c0 x2 l
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;) F3 c% |* o" t( ^4 N) ?6 b1 S
                            });
    . p! C1 ?5 j  W0 S- |
    / E& K( m5 E- ~! g                for (size_t jj = 0; jj < vec1.size(); jj++)
    ( ]! @  m& T6 Y0 x( m0 n                {1 _  f: \& W; k1 K; i
                            b1[jj] = vec1[jj];
    5 F( b0 ~6 p1 |: I5 w& M                }
    2 Y" w+ Y- y+ Z) ^$ M: B
    + N# F: @" K1 [& C7 h/ B                for (size_t jj = 0; jj < vec2.size(); jj++): w8 @9 R' t) `' c# ^5 M
                    {
    & Y# p- s! r. t, v9 ?- y                        b2[jj] = vec2[jj];
    1 [3 R0 r+ v) ]. @* f* Q$ H/ v+ C                }
    0 X7 J; s9 `6 J/ G, _6 B- Q' y
    ! E3 ^: P1 ]: M+ Q0 r! `# E                //Method - 1  N=100000 247s  
    & q3 L# S9 T8 c/ l1 W                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);  i/ v: t0 i- l/ W
                                    
    " s3 ^( ^% @! _& F4 [+ C9 T& g                //Method - 2  N=100000  237s5 w5 y& }0 Z2 @
                    /*$ W, l; Y( j/ f
                    for (int jj = 0; jj < N ; jj++)
    . F, p1 C* q3 c3 Y( h                {# b& s/ G8 J5 z
                            fresult += vec1[jj] * vec2[jj];8 J7 I8 |& R/ j/ S% N" n/ ]
                    }" M( A: Z% w, H5 x, b$ ?
                    */9 b6 m  V) m! y- F
                                    % L1 @. x& K3 Q) M
                    //Method - 3  N=100000 204s
      t* S7 V# }4 }8 m; G0 y1 ?                /*
    2 Y: ?4 Y0 J' p* T6 v, I) I                for (int jj = 0; jj < N; jj++)* U$ |8 y0 ?) g8 N
                    {* S& G  m- `4 B5 R; H
                            fresult += b1[jj] * b2[jj];3 ], _# H& I) b. g% A$ o
                    }
    ! H( f+ j2 H3 j' N8 q. N2 p                */
    4 l. v6 _5 y( B: L. d% y! c
    + {9 W7 I  f7 [9 P                //Method - 4   202s
    ( E+ D7 s1 [! ?7 Y( i8 c                /*7 D) X" N' t# L. T
                    for (int jj = 0; jj < N; jj++)* g  n6 J. p. S4 i
                    {; |+ |* x, n& u$ t& m3 K8 d
                            
    & \" o1 C+ {* M/ _                }
    / I& D! I  [' o1 m                */' @4 t0 I+ o: a. }8 A! n
                    //comment out all methods, N=100000  202s               
    ' ~  S! b$ Z; ?# R- ^# I        }% L, z3 U$ g9 _' u

    ! p: j* _. w! o7 J: t        delete []b1;
    ) @+ W/ M) a7 f9 ?" @. R- f        delete []b2;

    - J: J! @9 q, D, m1 F; `5 C+ w
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    6 }" T4 Y+ z0 S7 }) @
    " s1 O4 ~  L3 A1 r你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?$ V9 ^/ W! Q& J0 a! J; P
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    : s( V: X' ?/ T4 A9 A" I瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?: A1 b0 T) T9 h% v& P
    * Y8 J" P! p" H8 t3 b$ l% N
    你第二个试验里面的j在循环里面又重新定义 ...

    & G: D: L! w: ~内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    & h7 x2 N' [! e7 r- M) _1 `4 K8 L9 h
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:162 w1 }& `+ [6 a7 T0 U, f; @
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    - E; I" v# @" r9 X; e( h" k1 h1 |+ m! l: d7 ~# W
    不和它 ...

    + V1 Y, `* Y, j* {$ E& d) P; x, z! \& G  h
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    5 J1 D6 K7 I* A+ U0 r5 K后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    3 J( i. V! R% v4 y! Y; s$ H/ m+ \void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ' ?7 c- g# ^4 ?. f) `{
    + b, c- M+ E7 `  ?1 @        comp temp, xtimesy;
    " B+ x( P1 c' w5 o
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    9 a. N0 T6 o% n! _/ _: t内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    1 y9 X- i- }3 {6 E' h; d9 l2 gVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-8-19 06:56 , Processed in 0.048433 second(s), 21 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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