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

forcal

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

matlab 2009a代码：

1. clear all& x/ [8 z\" O* S% x* z+ k
   
2. tic* q! q- f, R5 i% j
   
3. s=0;/ b* I. s7 y+ A8 T6 N( M# u
   
4. for k=1:1000, H9 I9 h. H\" b4 L\" X/ A
   
5.   for i=1:1000: t; e$ W0 U! e; l: {\" L( f
   
6.     a=linspace(2,2,1000);% k7 |4 d0 A9 y, B' j
   
7.     s=s+a(i);4 b1 N2 S' O' i: M' t' k, s0 b8 Y+ e
   
8.   end
   1 J6 j$ x9 m/ B' w; D; d
9. end
     C  k/ ]6 x' I# F+ ?! O$ D1 C, k
10. s9 x+ b, J  Q) ^/ m3 ?
    
11. toc* Y0 d+ p5 B8 N5 _9 ?- ^, g
    
12. ) f# P  K# z0 Y2 @' ^! D6 s
    
13. s =6 g! r: R! ~3 O! _3 R/ w5 P8 U; }
    
14. ( N% f0 l0 H9 v5 C
    
15.      2000000( c# e; H, m0 N! y* r* `  e, |\" s
    
16. 
    # a* }1 f/ X3 M\" l- O
17. Elapsed time is 18.325900 seconds.

复制代码

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

3 Q9 n9 z; o! O$ J% Y－－－－－－－－
, _: \/ c: ~! q7 o$ X+ T3 {# g4 O1 O
Forcal代码：

2. !using["math","sys"];: g2 M* N% {/ L
   
4. mvar:\\" O4 {: K0 p! y6 Q, R, ?
   
6. main(:a)=
   
7. , m8 q7 H1 D% C: g) T/ N% E. Z
8. t0=clock(),, r- ~# }4 }/ I& b4 u: U2 Y* k3 G
   
10. s=0,
    
11. ; s) C% b7 f7 I4 v\\" v5 n( Z
12. k=0, while{k<1000,1 @+ G* \/ m8 w' b/ H
    
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)# t' p# B9 g+ c% T
    
16.   k++/ |0 a  p' S& d) h7 x& {* ]6 H
    
18. },
    
19. \\" S/ l+ i# r$ B' |4 [1 f
20. s;
    
21. & W' m3 A3 n! ]/ v7 `9 Y
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">: g2 M* N% {/ L</font><br /> mvar:<font class=\\"jammer\\">\\" O4 {: K0 p! y6 Q, R, ?</font><br /> main(:a)=<br /> <span style=\\"display:none\\">, m8 q7 H1 D% C: g) T/ N% E. Z</span> t0=clock(),<font class=\\"jammer\\">, r- ~# }4 }/ I& b4 u: U2 Y* k3 G</font><br /> s=0,<br /> <span style=\\"display:none\\">; s) C% b7 f7 I4 v\\" v5 n( Z</span> k=0, while{k<1000,<font class=\\"jammer\\">1 @+ G* \/ m8 w' b/ H</font><br />   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<font class=\\"jammer\\"># t' p# B9 g+ c% T</font><br />   k++<font class=\\"jammer\\">/ |0 a  p' S& d) h7 x& {* ]6 H</font><br /> },<br /> <span style=\\"display:none\\">\\" S/ l+ i# r$ B' |4 [1 f</span> s;<br /> <span style=\\"display:none\\">& W' m3 A3 n! ]/ v7 `9 Y</span> [clock()-t0]/1000;

结果：
; g6 J& Q) K( ~2000000.
40.766 秒
7 W! ~' i4 _. k9 I, U/ k2 P; L
) I' E( ^! ?; o) y; S$ p程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
7 ]$ w0 ^) n* X0 L. k因垃圾收集器多次启动，故耗时较长。

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

1 @1 H, e) {& [# F以下将a=linspace(2,2,1000)放到了oo{  }函数中：

2. !using["math","sys"];
   
3. 5 H9 I' V. w4 q3 H\\" N/ Q7 G
4. mvar:
   
5. \\" `3 \  Q4 _* Z7 D- G, e
6. main(:a)=
   
7. 4 l) P8 g) d% Y7 ^( e5 D; k9 u
8. t0=clock(),0 U* N: _$ @) s$ q3 T
   
10. s=0,- w6 |* E$ ?' n0 Y. {7 b
    
12. k=0, while{k<1000,
    
13. 3 T8 T- |( \' g- N! a\\" l) I
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. & b; h) v* ^; y
16.   k++
    
17. 2 N' S; o' j- O- O+ r4 j0 S
18. },2 @  t9 Y5 J: A  H. l
    
20. s;
    
21. \\" m# Y, ^$ ]) [5 _
22. [clock()-t0]/1000;

!using["math","sys"];<br /> <span style=\\"display:none\\">5 H9 I' V. w4 q3 H\\" N/ Q7 G</span> mvar:<br /> <span style=\\"display:none\\">\\" `3 \  Q4 _* Z7 D- G, e</span> main(:a)=<br /> <span style=\\"display:none\\">4 l) P8 g) d% Y7 ^( e5 D; k9 u</span> t0=clock(),<font class=\\"jammer\\">0 U* N: _$ @) s$ q3 T</font><br /> s=0,<font class=\\"jammer\\">- w6 |* E$ ?' n0 Y. {7 b</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\">3 T8 T- |( \' g- N! a\\" l) I</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\\">& b; h) v* ^; y</span>   k++<br /> <span style=\\"display:none\\">2 N' S; o' j- O- O+ r4 j0 S</span> },<font class=\\"jammer\\">2 @  t9 Y5 J: A  H. l</font><br /> s;<br /> <span style=\\"display:none\\">\\" m# Y, ^$ ]) [5 _</span> [clock()-t0]/1000;

结果：
/ z9 o$ Y1 L( O% u0 h2000000.
4.609 秒
  `$ T2 ~: c  G. z
可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

我就在你背后 发表于 2011-8-2 16:08
- p' f' |8 k1 H7 ?太强大了 看不懂啊

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

我就在你背后

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

3 o) t! |5 V& J: ^恩 我在研究研究，谢谢了

sxjm567

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