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

forcal

这里用一个不太常用的小例子说明一下。
( r; }! Y8 ]. Q& J
matlab 2009a代码：

1. clear all; M. L1 v3 m6 c) q# k5 C
   
2. tic( _% C; Q: L: N1 m  X8 P
   
3. s=0;0 _8 g! B3 L% z9 K7 }
   
4. for k=1:1000. g( H# x* y* i6 U& e: U8 A$ V
   
5.   for i=1:1000
   1 U$ g\" A/ B) c; j/ r  o$ K
6.     a=linspace(2,2,1000);* D+ d5 K8 V& z7 z1 ~, X2 z$ r# v
   
7.     s=s+a(i);$ I. N# A+ d: m! T9 ?
   
8.   end4 d( N2 V! q8 g, Z: ?
   
9. end
   5 Y1 p) _- c\" x$ Q
10. s
    6 u! f* g6 @' V7 P1 q( B: k
11. toc* e* W- \8 J\" N1 P
    
12. 
      N$ {! E. C( R1 r6 N+ m! x) _
13. s =( O3 d: {( L+ \& K: q
    
14. 
    1 e+ D0 x- T\" |( ^$ b* q
15.      2000000. J2 t- m+ A8 K  k
    
16. 3 r/ m- C( ]5 h+ e& }# p
    
17. Elapsed time is 18.325900 seconds.

复制代码

程序运行时内存比较稳定。
3 w8 v8 y, j$ @9 h4 l3 p1 H4 Z9 \& C- D
- O! D& ]$ n( R－－－－－－－－
* E) a- a3 h! a) ^8 i
0 K: y3 x% t" ~3 O' _9 P2 @1 z8 LForcal代码：

2. !using["math","sys"];
   
3. 7 m4 D  \( L. h/ ?; K4 [3 _
4. mvar:4 B+ M0 {( M\\" _8 p! |  I( T+ ]6 P
   
6. main(:a)=4 l8 d: R7 h: U( I7 H/ z
   
8. t0=clock(),/ f\\" {5 O$ }3 ?% ^9 V$ }
   
10. s=0,
    
11. \\" B! R' ?5 w% ^$ l
12. k=0, while{k<1000,
    
13. 8 V3 F' ^8 x& l- k
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)6 }2 U# E* k! Z: v9 z
    
16.   k++
    
17. 6 ^* E+ x2 r- c, p5 h9 E
18. },
    
19. 9 d! Z8 w: R! `9 ]6 x- Z, W
20. s;
    
21.   w+ Z% D: O- D' b5 N! s
22. [clock()-t0]/1000;

!using["math","sys"];<br /> <span style=\\"display:none\\">7 m4 D  \( L. h/ ?; K4 [3 _</span> mvar:<font class=\\"jammer\\">4 B+ M0 {( M\\" _8 p! |  I( T+ ]6 P</font><br /> main(:a)=<font class=\\"jammer\\">4 l8 d: R7 h: U( I7 H/ z</font><br /> t0=clock(),<font class=\\"jammer\\">/ f\\" {5 O$ }3 ?% ^9 V$ }</font><br /> s=0,<br /> <span style=\\"display:none\\">\\" B! R' ?5 w% ^$ l</span> k=0, while{k<1000,<br /> <span style=\\"display:none\\">8 V3 F' ^8 x& l- k</span>   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<font class=\\"jammer\\">6 }2 U# E* k! Z: v9 z</font><br />   k++<br /> <span style=\\"display:none\\">6 ^* E+ x2 r- c, p5 h9 E</span> },<br /> <span style=\\"display:none\\">9 d! Z8 w: R! `9 ]6 x- Z, W</span> s;<br /> <span style=\\"display:none\\">  w+ Z% D: O- D' b5 N! s</span> [clock()-t0]/1000;

结果：
2000000.
40.766 秒
& f/ R7 N3 n4 l1 F
4 X/ @" Q7 R" s. L程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
因垃圾收集器多次启动，故耗时较长。
0 ^8 [, I( C9 Y* \5 \
－－－－－－－－－－－－
; o" D* \" ?9 }% i* u
& i% F; Q- Z. ^* N7 A( Q以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];# M\\" O/ {4 `' Q- F& V' ^7 i( p- W
   
4. mvar:
   
5. ' l5 z2 K\\" Y) X! K
6. main(:a)=
   
7. . R+ k5 M1 a! C: Q4 p, W: N: D
8. t0=clock(),. Q0 u4 q: ~7 ^  x
   
10. s=0,
    
11. ) ^& z! m7 P/ Q7 |5 p$ G! b
12. k=0, while{k<1000,
    
13. ; }, X8 Y$ o) M# R9 G+ O7 o. a- _( E
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. , S+ F' R  q6 ~3 x+ j
16.   k++9 h9 U% s% s0 h
    
18. },+ A: y* R' H0 q' g6 ^\\" l% Q6 I- G8 C
    
20. s;
    
21. ' U( S( c% x; P5 b$ u8 O\\" v
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\"># M\\" O/ {4 `' Q- F& V' ^7 i( p- W</font><br /> mvar:<br /> <span style=\\"display:none\\">' l5 z2 K\\" Y) X! K</span> main(:a)=<br /> <span style=\\"display:none\\">. R+ k5 M1 a! C: Q4 p, W: N: D</span> t0=clock(),<font class=\\"jammer\\">. Q0 u4 q: ~7 ^  x</font><br /> s=0,<br /> <span style=\\"display:none\\">) ^& z! m7 P/ Q7 |5 p$ G! b</span> k=0, while{k<1000,<br /> <span style=\\"display:none\\">; }, X8 Y$ o) M# R9 G+ O7 o. a- _( E</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\\">, S+ F' R  q6 ~3 x+ j</span>   k++<font class=\\"jammer\\">9 h9 U% s% s0 h</font><br /> },<font class=\\"jammer\\">+ A: y* R' H0 q' g6 ^\\" l% Q6 I- G8 C</font><br /> s;<br /> <span style=\\"display:none\\">' U( S( c% x; P5 b$ u8 O\\" v</span> [clock()-t0]/1000;

结果：
2000000.
; z- s4 v# e5 k4 h# [4 ]4.609 秒

可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
% ~1 c% x9 i. g6 ]8 S9 f在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

sxjm567

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

我就在你背后

forcal 发表于 2011-8-2 18:18
  K# V1 F* u! t4 L. f& n2 y函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forc ...

' o7 B( v) x! ~2 J8 G  r: L" x4 e& Q% [+ o恩 我在研究研究，谢谢了

forcal

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

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

我就在你背后

太强大了 看不懂啊