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

forcal

这里用一个不太常用的小例子说明一下。
/ H; ?. e! h. ?9 N
matlab 2009a代码：

1. clear all( J7 d& `\" w3 Q7 a5 {& ]9 d: f
   
2. tic' Z2 Y- e% X* F2 f  N0 e5 z  ]7 b6 [
   
3. s=0;, V! y( M) T% i5 P* \
   
4. for k=1:1000
   . F2 B6 R, \9 E6 j3 K
5.   for i=1:1000& N  x. a- ^  o( r3 r# ~
   
6.     a=linspace(2,2,1000);; E- V$ w( f1 k+ V
   
7.     s=s+a(i);
   4 ^6 y/ l5 B7 {0 F% ~1 j
8.   end
     F1 l4 p; V/ y& P# e$ e; N
9. end
     ~: X$ f- y2 L7 A
10. s1 B7 f/ Y7 p$ K/ f9 X2 K\" P
    
11. toc
    $ s; }( W. X, s- c- {
12. 
    , A2 i7 R  h4 s4 }7 a1 Z
13. s =
    9 Z3 Z. L4 F& C6 [& X$ F
14.   C5 Z, A/ b! ^; B! K- K
    
15.      2000000
    \" Z3 }+ ^8 |& C( ^; q# Q) f
16. 
    ' o* @7 V: W: B' r. L\" X
17. Elapsed time is 18.325900 seconds.

复制代码

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

－－－－－－－－

Forcal代码：

2. !using["math","sys"];, h. r* S; l\\" Q. ]! K
   
4. mvar:: p4 P, a' p$ X1 E$ g6 _
   
6. main(:a)=
   
7. 2 Z' L/ ]' U# h
8. t0=clock(),
   
9. ( S. Y- _' O\\" S' t* i- s0 B
10. s=0,
    
11. ! Q' e- }6 H( z( u2 L
12. k=0, while{k<1000,
    
13. - v( g1 l4 c% A$ u' p
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)
    
15. 1 P9 G' ?0 o5 r  p9 c; h: e
16.   k++
    
17. 9 ]  c( `6 O$ B0 W! H
18. },2 o' T, O\\" m9 q/ [
    
20. s;
    
21. 7 B' r3 q1 i2 q# }- Q
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">, h. r* S; l\\" Q. ]! K</font><br /> mvar:<font class=\\"jammer\\">: p4 P, a' p$ X1 E$ g6 _</font><br /> main(:a)=<br /> <span style=\\"display:none\\">2 Z' L/ ]' U# h</span> t0=clock(),<br /> <span style=\\"display:none\\">( S. Y- _' O\\" S' t* i- s0 B</span> s=0,<br /> <span style=\\"display:none\\">! Q' e- }6 H( z( u2 L</span> k=0, while{k<1000,<br /> <span style=\\"display:none\\">- v( g1 l4 c% A$ u' p</span>   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<br /> <span style=\\"display:none\\">1 P9 G' ?0 o5 r  p9 c; h: e</span>   k++<br /> <span style=\\"display:none\\">9 ]  c( `6 O$ B0 W! H</span> },<font class=\\"jammer\\">2 o' T, O\\" m9 q/ [</font><br /> s;<br /> <span style=\\"display:none\\">7 B' r3 q1 i2 q# }- Q</span> [clock()-t0]/1000;

结果：
2000000.
40.766 秒
! R2 N9 z/ |/ C/ W
2 w) l, ]# B/ P  Q; @! }程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
. C  U2 C) O7 S1 r因垃圾收集器多次启动，故耗时较长。

1 u9 K+ L* V9 t* [+ z8 v( T－－－－－－－－－－－－
6 U3 l/ ]: f6 ]# P4 t, M) x
以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];( `+ h7 L/ }0 V0 S5 g
   
4. mvar:
   
5. ' D/ ]& k8 J9 a9 M! N
6. main(:a)=, s  d+ \! r% o: w; i
   
8. t0=clock(),3 c' y! {2 r/ }6 G5 O' n
   
10. s=0,& W& g6 K6 @* w! x# ^\\" Q
    
12. k=0, while{k<1000,
    
13. 0 n: Y$ K& l/ l+ S( [
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. 4 f  J% {% C# G; e5 H
16.   k++
    
17. 8 u  A% x# N/ Z3 a: O* J
18. },
    
19. 5 c4 k) l# Q7 [
20. s;
    
21. ' m: h4 z5 w9 u8 D4 u  v3 f
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">( `+ h7 L/ }0 V0 S5 g</font><br /> mvar:<br /> <span style=\\"display:none\\">' D/ ]& k8 J9 a9 M! N</span> main(:a)=<font class=\\"jammer\\">, s  d+ \! r% o: w; i</font><br /> t0=clock(),<font class=\\"jammer\\">3 c' y! {2 r/ }6 G5 O' n</font><br /> s=0,<font class=\\"jammer\\">& W& g6 K6 @* w! x# ^\\" Q</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\">0 n: Y$ K& l/ l+ S( [</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\\">4 f  J% {% C# G; e5 H</span>   k++<br /> <span style=\\"display:none\\">8 u  A% x# N/ Z3 a: O* J</span> },<br /> <span style=\\"display:none\\">5 c4 k) l# Q7 [</span> s;<br /> <span style=\\"display:none\\">' m: h4 z5 w9 u8 D4 u  v3 f</span> [clock()-t0]/1000;

结果：
6 `6 e7 x3 T; U7 g: ]5 a* ~  ^, k6 ?2000000.
4.609 秒
9 N; E3 T9 k5 {5 L+ m3 Q4 Z
  X2 T0 k* }1 O! \- C可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
" S& x( w# a7 q( F) C- G在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

sxjm567

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

我就在你背后

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

3 R9 g% x* `4 R1 q恩 我在研究研究，谢谢了

forcal

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

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

我就在你背后

太强大了 看不懂啊