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

forcal

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

matlab 2009a代码：

1. clear all/ x& n  O6 V& \% |: y6 g2 i/ Q/ d3 v
   
2. tic\" n& q$ h8 A, G& E% G
   
3. s=0;1 P$ `4 V( z# d
   
4. for k=1:1000& R( x# @$ _% t  N2 q' I* U7 p
   
5.   for i=1:1000
   5 U; \0 s- ?7 e  f# X+ o7 N* d& D
6.     a=linspace(2,2,1000);- u+ ~5 B( ?3 I: J) y
   
7.     s=s+a(i);
   # _) L+ q: q7 v2 F. q' v
8.   end  Z: N\" g: a: x* o3 H* E7 Q
   
9. end' L3 z  |+ s# O; K( Y
   
10. s9 e7 F7 v3 n( S
    
11. toc
      j8 `0 [; j6 h/ |\" }& `  f$ K
12. 
    + m% y# \$ r9 ^* H; @- c
13. s =1 W8 l# J- K( T) l7 `
    
14. 
    \" f* B, w7 X) z: L. _' |/ |
15.      20000007 H( E0 R\" F5 m6 M' f: K( v
    
16. 3 w# _! {( Q( d, q+ H8 w\" c  q) C: W: y
    
17. Elapsed time is 18.325900 seconds.

复制代码

程序运行时内存比较稳定。
- k  U2 |2 w5 h8 a  K) ]  @: N
- ]+ a7 o( a: u& ]/ l( a6 t－－－－－－－－
. E, R  \0 G% r4 y: d" r8 N% D. j
- ~# {; E1 s' K- i% J, ^Forcal代码：

2. !using["math","sys"];% v: ^4 I1 q# v$ H/ k
   
4. mvar:& m9 Z( C1 O- ~6 k, R9 t
   
6. main(:a)=: X; K8 f# {# P$ F
   
8. t0=clock(),5 Q1 w6 l  {( x4 l8 O5 W8 m
   
10. s=0,
    
11. 6 Y1 A4 x& @# G' [( z$ p
12. k=0, while{k<1000,7 u5 }# [+ f0 ]+ m; i\\" b
    
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)
    
15. 0 u- N, I2 v; Q$ D% E
16.   k++
    
17. , o- ]- a9 s$ F4 _. h
18. },
    
19. ' X- I; M+ S3 S
20. s;3 B, P# n9 p: Q( x2 x9 N
    
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">% v: ^4 I1 q# v$ H/ k</font><br /> mvar:<font class=\\"jammer\\">& m9 Z( C1 O- ~6 k, R9 t</font><br /> main(:a)=<font class=\\"jammer\\">: X; K8 f# {# P$ F</font><br /> t0=clock(),<font class=\\"jammer\\">5 Q1 w6 l  {( x4 l8 O5 W8 m</font><br /> s=0,<br /> <span style=\\"display:none\\">6 Y1 A4 x& @# G' [( z$ p</span> k=0, while{k<1000,<font class=\\"jammer\\">7 u5 }# [+ f0 ]+ m; i\\" b</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\\">0 u- N, I2 v; Q$ D% E</span>   k++<br /> <span style=\\"display:none\\">, o- ]- a9 s$ F4 _. h</span> },<br /> <span style=\\"display:none\\">' X- I; M+ S3 S</span> s;<font class=\\"jammer\\">3 B, P# n9 p: Q( x2 x9 N</font><br /> [clock()-t0]/1000;

结果：
2000000.
  ^! |9 Z0 V% O' e+ K* @8 c40.766 秒

程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
- y. W$ T# ~1 G2 O1 u9 R+ l" }因垃圾收集器多次启动，故耗时较长。

－－－－－－－－－－－－

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

2. !using["math","sys"];: j. b( X+ ~- j  H; @
   
4. mvar:, p& v& Y1 t) b  m\\" v# V
   
6. main(:a)=* ^\\" S- y' ^' j. t
   
8. t0=clock(),
   
9. % u' x; f+ m- n' N% Z2 i( m
10. s=0,0 T& o& P7 r: }. Y: K! b+ _
    
12. k=0, while{k<1000,
    
13. 0 c# s8 {! l% i2 b5 @) I5 K0 _6 M
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. 5 O\\" t6 g3 O8 n1 E' S) o2 ~
16.   k++
    
17. ; x; R7 X# \: F! F/ K6 v( y, @
18. },, ~' _* ?7 M( o. Z7 V
    
20. s;
    
21. $ E  P7 S0 ?0 z8 t! Q
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">: j. b( X+ ~- j  H; @</font><br /> mvar:<font class=\\"jammer\\">, p& v& Y1 t) b  m\\" v# V</font><br /> main(:a)=<font class=\\"jammer\\">* ^\\" S- y' ^' j. t</font><br /> t0=clock(),<br /> <span style=\\"display:none\\">% u' x; f+ m- n' N% Z2 i( m</span> s=0,<font class=\\"jammer\\">0 T& o& P7 r: }. Y: K! b+ _</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\">0 c# s8 {! l% i2 b5 @) I5 K0 _6 M</span>   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\\">5 O\\" t6 g3 O8 n1 E' S) o2 ~</span>   k++<br /> <span style=\\"display:none\\">; x; R7 X# \: F! F/ K6 v( y, @</span> },<font class=\\"jammer\\">, ~' _* ?7 M( o. Z7 V</font><br /> s;<br /> <span style=\\"display:none\\">$ E  P7 S0 ?0 z8 t! Q</span> [clock()-t0]/1000;

结果：
2000000.
4.609 秒
8 X8 q. V9 H! d
# ~* D( y$ A; P9 a3 I( ~可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

我就在你背后 发表于 2011-8-2 16:08
" w% S  u) g) r太强大了 看不懂啊

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

我就在你背后

forcal 发表于 2011-8-2 18:18
函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forc ...

# ^+ x. s& E5 D% l恩 我在研究研究，谢谢了

sxjm567

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