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

forcal

这里用一个不太常用的小例子说明一下。
  K3 Z- @8 C) v; `
9 }8 F" x& c# k9 J, Bmatlab 2009a代码：

1. clear all; n% r4 b4 f7 ~2 S+ v% A- x# z
   
2. tic
   ; h, Z% N) L% c+ i/ t8 v& L
3. s=0;+ I- M& T) u$ q+ Y( V
   
4. for k=1:1000
   % W1 G$ ~) E- ~+ k3 T% y; W
5.   for i=1:1000
   6 M( W% K4 {\" D
6.     a=linspace(2,2,1000);9 I3 F# j  d3 n# N' \  B2 V$ [; b\" `) a
   
7.     s=s+a(i);
   / o! z/ L; s0 B7 y5 X6 Y
8.   end. u1 t6 t7 a' n
   
9. end# U& @: \' S  a
   
10. s
    ) i5 }$ L( W9 T' D9 }
11. toc5 T% p: y4 N3 x4 ~
    
12. . }9 T- H9 y( i5 R4 ]\" h0 Z5 q
    
13. s =
    / s3 m% F4 r$ ?\" Z2 i\" M9 p
14. 
    9 d) e4 U- E8 N5 y1 ?9 I# Q
15.      2000000
    , T9 D5 a+ ~; C) i\" F# ]* x) _\" |/ c
16. 
    # p1 J# d2 V- Q, o  _8 ?
17. Elapsed time is 18.325900 seconds.

复制代码

程序运行时内存比较稳定。

6 c- J* \8 z/ x* o/ ?1 J! o－－－－－－－－

! M. d. e* J' J9 O. B( z1 FForcal代码：

2. !using["math","sys"];$ x- V/ q& T8 s( p) z# [# Z  D
   
4. mvar:/ H+ q# X3 |, m& m1 E
   
6. main(:a)=
   
7. # c! ?* W; F& ]' U) C0 S) Q
8. t0=clock(),
   
9. ; J0 F6 B, F( d' E0 S
10. s=0,
    
11. * X% t+ m' h' n, D! B
12. k=0, while{k<1000,, s! k6 Y* D+ s* q9 W
    
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)! h% w' B\\" J+ S$ q4 @) t
    
16.   k++
    
17. ( _2 c3 \9 [- y) Z) C1 W' f- n
18. },
    
19. 7 M# ]) `6 L: b; i1 C, \0 ~
20. s;) u% e! }- O1 I! q2 ?
    
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">$ x- V/ q& T8 s( p) z# [# Z  D</font><br /> mvar:<font class=\\"jammer\\">/ H+ q# X3 |, m& m1 E</font><br /> main(:a)=<br /> <span style=\\"display:none\\"># c! ?* W; F& ]' U) C0 S) Q</span> t0=clock(),<br /> <span style=\\"display:none\\">; J0 F6 B, F( d' E0 S</span> s=0,<br /> <span style=\\"display:none\\">* X% t+ m' h' n, D! B</span> k=0, while{k<1000,<font class=\\"jammer\\">, s! k6 Y* D+ s* q9 W</font><br />   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<font class=\\"jammer\\">! h% w' B\\" J+ S$ q4 @) t</font><br />   k++<br /> <span style=\\"display:none\\">( _2 c3 \9 [- y) Z) C1 W' f- n</span> },<br /> <span style=\\"display:none\\">7 M# ]) `6 L: b; i1 C, \0 ~</span> s;<font class=\\"jammer\\">) u% e! }- O1 I! q2 ?</font><br /> [clock()-t0]/1000;

结果：
2000000.
40.766 秒
4 |! D! S, G1 q! M: x
) a* C. C5 i- X# a" B8 K程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
因垃圾收集器多次启动，故耗时较长。

" }% J0 b& y6 }－－－－－－－－－－－－

以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];4 d* L/ F# e7 i1 d. t
   
4. mvar:
   
5. / a9 ]8 ?3 a. G9 a' r
6. main(:a)=0 c: [. g0 m9 `, S7 C0 A  c- }$ G; S5 m
   
8. t0=clock(),$ o/ m  }\\" x0 H, L0 K2 H
   
10. s=0,+ v$ [\\" T0 R! Z0 u5 _7 v  h; }
    
12. k=0, while{k<1000,$ G- G, d: U8 c1 J
    
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. ' Z$ y$ {9 w8 Y$ [/ {  `: g( V
16.   k++$ {. N- Y) @, z5 P: D
    
18. },; }; a# Q0 J- L$ v: K
    
20. s;
    
21. ( P1 G% z8 X6 [4 {9 S
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">4 d* L/ F# e7 i1 d. t</font><br /> mvar:<br /> <span style=\\"display:none\\">/ a9 ]8 ?3 a. G9 a' r</span> main(:a)=<font class=\\"jammer\\">0 c: [. g0 m9 `, S7 C0 A  c- }$ G; S5 m</font><br /> t0=clock(),<font class=\\"jammer\\">$ o/ m  }\\" x0 H, L0 K2 H</font><br /> s=0,<font class=\\"jammer\\">+ v$ [\\" T0 R! Z0 u5 _7 v  h; }</font><br /> k=0, while{k<1000,<font class=\\"jammer\\">$ G- G, d: U8 c1 J</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\\">' Z$ y$ {9 w8 Y$ [/ {  `: g( V</span>   k++<font class=\\"jammer\\">$ {. N- Y) @, z5 P: D</font><br /> },<font class=\\"jammer\\">; }; a# Q0 J- L$ v: K</font><br /> s;<br /> <span style=\\"display:none\\">( P1 G% z8 X6 [4 {9 S</span> [clock()-t0]/1000;

结果：
2000000.
4.609 秒
/ G$ u* {8 o- \7 K' w
可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
) }( F% L! v$ ^# `0 ~9 E8 ?在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

我就在你背后 发表于 2011-8-2 16:08
; z! M9 }" O/ r太强大了 看不懂啊

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

我就在你背后

forcal 发表于 2011-8-2 18:18
- \& U" ?4 ~# P2 v6 t+ Q" H% A3 R$ L函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forc ...

恩 我在研究研究，谢谢了

sxjm567

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