极限测试之Matlab与Forcal动态内存管理效率

forcal

这里用一个不太常用的小例子说明一下。

( l/ ]. y( ?1 zmatlab 2009a代码：

1. clear all' m- }1 W' _4 @- G3 h- a
   
2. tic8 @6 F- J! M* L( h) f+ b; E0 G
   
3. s=0;$ `4 w8 m9 O' `, T
   
4. for k=1:1000
   6 Z) S* i. `6 [\" J; d/ p* `
5.   for i=1:1000+ T5 s7 P( @7 O8 W8 U
   
6.     a=linspace(2,2,1000);( K  \1 [: I& _% u8 b# I
   
7.     s=s+a(i);. W5 h4 U2 A5 r  ~' U$ H, a0 \- e
   
8.   end' v! `- ~0 U5 E\" N2 P0 z
   
9. end
   0 L% q  v  b5 \1 i7 x
10. s* W) s0 `% r4 F$ C
    
11. toc9 J( X/ x\" h( H- @# A: x
    
12. 
    / h0 v7 Z3 G3 S
13. s =) \, u% u# x4 `& f
    
14. 
    1 R: O: N8 P0 r
15.      2000000
    & h0 Q* S$ t. V
16. ) m) R0 {8 m# ^
    
17. Elapsed time is 18.325900 seconds.

复制代码

程序运行时内存比较稳定。
0 ]/ d+ u& }3 }* O6 J* ~" g! G: N
－－－－－－－－

' |. G& Z& i+ Y0 X; VForcal代码：

2. !using["math","sys"];' l- q6 W! D8 D7 t, T6 J3 q
   
4. mvar:
   
5. 8 ^/ e# J3 i% X) n
6. main(:a)=6 j! l0 r! H7 c' C: n
   
8. t0=clock(),
   
9. 7 ]4 U- S7 D/ Q# U! }
10. s=0,: l4 V- d2 ]- P  B$ r: J9 y& F
    
12. k=0, while{k<1000,! C1 b# H6 Y9 X% U3 h5 D
    
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)
    
15. - j* J. W: g) G! M3 [+ ?- Y, K
16.   k++# \: J' N; N/ J, t\\" c
    
18. },5 S1 {5 A% r$ P2 K' P. P! q
    
20. s;$ E; n- T! C9 c3 F: O4 D
    
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">' l- q6 W! D8 D7 t, T6 J3 q</font><br /> mvar:<br /> <span style=\\"display:none\\">8 ^/ e# J3 i% X) n</span> main(:a)=<font class=\\"jammer\\">6 j! l0 r! H7 c' C: n</font><br /> t0=clock(),<br /> <span style=\\"display:none\\">7 ]4 U- S7 D/ Q# U! }</span> s=0,<font class=\\"jammer\\">: l4 V- d2 ]- P  B$ r: J9 y& F</font><br /> k=0, while{k<1000,<font class=\\"jammer\\">! C1 b# H6 Y9 X% U3 h5 D</font><br />   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<br /> <span style=\\"display:none\\">- j* J. W: g) G! M3 [+ ?- Y, K</span>   k++<font class=\\"jammer\\"># \: J' N; N/ J, t\\" c</font><br /> },<font class=\\"jammer\\">5 S1 {5 A% r$ P2 K' P. P! q</font><br /> s;<font class=\\"jammer\\">$ E; n- T! C9 c3 F: O4 D</font><br /> [clock()-t0]/1000;

结果：
2000000.
40.766 秒
' o8 r1 r3 b+ P0 g" y
程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
- o# n- O2 D- s- H$ e) H/ P因垃圾收集器多次启动，故耗时较长。
$ H/ Y2 r1 P4 z" l* E
－－－－－－－－－－－－

7 H! L4 ?$ }) w9 m; P+ T以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];
   
3. % k3 u\\" w/ A9 G$ n  f; S5 U
4. mvar:6 d/ x( _* t6 M' }\\" u* m! x
   
6. main(:a)=8 S% D! E3 I  p8 D0 e
   
8. t0=clock(),2 u2 F# h1 j5 c
   
10. s=0,% C/ r1 g\\" `+ l. P$ S. }
    
12. k=0, while{k<1000,  q! x' y9 \  |* Q* M
    
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15.   V$ f\\" e' i7 f\\" c
16.   k++  I+ l' _. i6 m( a3 H+ M1 l
    
18. },
    
19. / _: K$ k\\" Z. g( g% `
20. s;
    
21. % f! J% N& h; F
22. [clock()-t0]/1000;

!using["math","sys"];<br /> <span style=\\"display:none\\">% k3 u\\" w/ A9 G$ n  f; S5 U</span> mvar:<font class=\\"jammer\\">6 d/ x( _* t6 M' }\\" u* m! x</font><br /> main(:a)=<font class=\\"jammer\\">8 S% D! E3 I  p8 D0 e</font><br /> t0=clock(),<font class=\\"jammer\\">2 u2 F# h1 j5 c</font><br /> s=0,<font class=\\"jammer\\">% C/ r1 g\\" `+ l. P$ S. }</font><br /> k=0, while{k<1000,<font class=\\"jammer\\">  q! x' y9 \  |* Q* M</font><br />   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)<br /> <span style=\\"display:none\\">  V$ f\\" e' i7 f\\" c</span>   k++<font class=\\"jammer\\">  I+ l' _. i6 m( a3 H+ M1 l</font><br /> },<br /> <span style=\\"display:none\\">/ _: K$ k\\" Z. g( g% `</span> s;<br /> <span style=\\"display:none\\">% f! J% N& h; F</span> [clock()-t0]/1000;

结果：
2000000.
4.609 秒
) t1 Y  b! Q! X- J# w* Z0 w
可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

我就在你背后 发表于 2011-8-2 16:08
太强大了 看不懂啊

函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forcal如何处理垃圾对象和进行内存管理。

我就在你背后

forcal 发表于 2011-8-2 18:18
9 d; K0 [  q4 M* w0 ^- i, W函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forc ...

恩 我在研究研究，谢谢了

sxjm567

我反复看了多遍，好帖，得支持