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

forcal

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

! N7 \8 Y, W' A9 ^( amatlab 2009a代码：

1. clear all7 e9 b1 ^1 x7 S, @! I
   
2. tic
   ) |# I9 u4 G# G+ t1 v8 c
3. s=0;
   7 H  }4 ]* j5 _6 I* [
4. for k=1:10009 Y- b7 @2 H1 l# K, M
   
5.   for i=1:1000+ m& }- \2 i8 j# A7 q! c
   
6.     a=linspace(2,2,1000);
   1 H) [2 ^) @: M8 K; t  a( a
7.     s=s+a(i);) |$ j  H* m, o- F% b; T2 E: f
   
8.   end3 [7 t* q  k: s! k9 ^
   
9. end8 m( ?+ w' C5 d: r
   
10. s
    $ K  K0 [* W& K' p* K
11. toc7 x) o0 I; b. \
    
12. 
    * C* b: Q, n# I) y- P
13. s =\" _# V0 A) f- k, E. b
    
14. 
    0 H1 v+ g+ T$ i# ^4 |: r
15.      2000000
    2 i2 ~# z7 y' p
16. 3 e1 u; @) D! ^, c+ R
    
17. Elapsed time is 18.325900 seconds.

复制代码

程序运行时内存比较稳定。
* U% F2 ?8 {& I8 }3 F! n3 m+ P5 N
－－－－－－－－

6 B- e2 _4 Z. WForcal代码：

2. !using["math","sys"];8 c8 o5 M) a( P2 c
   
4. mvar:
   
5. 8 X! i4 W, \/ _! q
6. main(:a)=5 {4 N7 v/ M4 f8 W
   
8. t0=clock(),
   
9. \\" T/ B\\" D' D/ S; N2 s/ a# A
10. s=0,1 c$ A/ @) F! s& O& r  f
    
12. k=0, while{k<1000,* Y0 i5 E: k! @2 D$ N4 C
    
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)
    
15. 3 I$ p; ^8 O/ q\\" Z# E\\" O4 s
16.   k++
    
17. # y: F; E1 j5 Q; q4 b3 N* u
18. },
    
19. . w6 Q; l# {. V  ^3 }8 V) @) A0 L\\" h
20. s;\\" B- M& U+ s& `5 [
    
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">8 c8 o5 M) a( P2 c</font><br /> mvar:<br /> <span style=\\"display:none\\">8 X! i4 W, \/ _! q</span> main(:a)=<font class=\\"jammer\\">5 {4 N7 v/ M4 f8 W</font><br /> t0=clock(),<br /> <span style=\\"display:none\\">\\" T/ B\\" D' D/ S; N2 s/ a# A</span> s=0,<font class=\\"jammer\\">1 c$ A/ @) F! s& O& r  f</font><br /> k=0, while{k<1000,<font class=\\"jammer\\">* Y0 i5 E: k! @2 D$ N4 C</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\\">3 I$ p; ^8 O/ q\\" Z# E\\" O4 s</span>   k++<br /> <span style=\\"display:none\\"># y: F; E1 j5 Q; q4 b3 N* u</span> },<br /> <span style=\\"display:none\\">. w6 Q; l# {. V  ^3 }8 V) @) A0 L\\" h</span> s;<font class=\\"jammer\\">\\" B- M& U+ s& `5 [</font><br /> [clock()-t0]/1000;

结果：
2000000.
40.766 秒
5 t' q4 v1 j9 A1 Q9 t
程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
因垃圾收集器多次启动，故耗时较长。

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

3 P* f$ K( q) V' _3 J: Y. u8 j以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];
   
3. ' N\\" N' G5 Q. k) j9 r6 N
4. mvar:/ w1 \8 p( P( ?0 c& L* r
   
6. main(:a)=
   
7. 5 G1 \, r1 F* Y+ i
8. t0=clock(),
   
9. 8 `' v' N) \! f6 l/ b
10. s=0,7 U% e6 w, ], ?9 U
    
12. k=0, while{k<1000,
    
13. # M\\" b; }7 v\\" H' \  N
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. 9 \5 K\\" N$ X! I  X
16.   k++. F% W, f3 n# X' D1 t\\" y4 N
    
18. },
    
19. 2 S) ^1 A( y6 ~' {3 r
20. s;
    
21. 5 R0 D+ n1 {0 Q* ]$ b\\" O
22. [clock()-t0]/1000;

!using["math","sys"];<br /> <span style=\\"display:none\\">' N\\" N' G5 Q. k) j9 r6 N</span> mvar:<font class=\\"jammer\\">/ w1 \8 p( P( ?0 c& L* r</font><br /> main(:a)=<br /> <span style=\\"display:none\\">5 G1 \, r1 F* Y+ i</span> t0=clock(),<br /> <span style=\\"display:none\\">8 `' v' N) \! f6 l/ b</span> s=0,<font class=\\"jammer\\">7 U% e6 w, ], ?9 U</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\"># M\\" b; }7 v\\" H' \  N</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\\">9 \5 K\\" N$ X! I  X</span>   k++<font class=\\"jammer\\">. F% W, f3 n# X' D1 t\\" y4 N</font><br /> },<br /> <span style=\\"display:none\\">2 S) ^1 A( y6 ~' {3 r</span> s;<br /> <span style=\\"display:none\\">5 R0 D+ n1 {0 Q* ]$ b\\" O</span> [clock()-t0]/1000;

结果：
! S$ z  C/ [" P4 \6 X2000000.
( \8 }+ o# q7 @9 j; _, [6 ^4.609 秒
0 @% {/ F" `, g$ k0 K
' ]- {) _+ ~% ]可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
+ W$ Q( Z5 M* K! Z在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

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

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

我就在你背后

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

4 H! @$ l4 V* Z恩 我在研究研究，谢谢了

sxjm567

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