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

forcal

这里用一个不太常用的小例子说明一下。
- t- `" J( l" K% ?+ e! {
' O1 z' r6 z! }matlab 2009a代码：

1. clear all6 X9 h9 P: v! v5 _
   
2. tic
   0 m6 t+ Q7 C6 H# Y9 S
3. s=0;
   5 V4 ?0 S  R. ?6 }- U4 d2 e
4. for k=1:10006 _/ P) N$ o* R
   
5.   for i=1:10008 D' t) F. L4 S, p
   
6.     a=linspace(2,2,1000);
   ; `* w* I: p  y8 u
7.     s=s+a(i);
     `* h4 n* x& d# ]% }
8.   end$ I% P& p1 T; L& E5 W' l
   
9. end% `4 J  i& }# y! `
   
10. s: q\" T3 U: `1 r\" d
    
11. toc
    . l5 z' J+ a\" ]
12. 2 [1 z3 j$ S) @% F- V
    
13. s =& q* T: E: |( ?! ?7 x1 j2 v
    
14. 
    ( e; j2 A) R9 ~
15.      2000000/ b+ X5 ]7 ]8 H% G, a+ t- }: r
    
16. , X7 L, S) T: k8 I1 L
    
17. Elapsed time is 18.325900 seconds.

复制代码

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

－－－－－－－－
5 `2 R0 M( N8 E3 H  d% _+ @
Forcal代码：

2. !using["math","sys"];
   
3. 3 m& J. j$ y0 f+ K+ @4 F! r6 U+ H6 B( S
4. mvar:6 J$ @4 W, c+ [3 s
   
6. main(:a)=
   
7. & Q) r2 S( ?9 _\\" U% R
8. t0=clock(),- A) Q9 f/ H8 Q2 O2 p
   
10. s=0,) ~3 o4 K/ R5 w5 R7 {2 X1 B
    
12. k=0, while{k<1000,
    
13.   P9 I( F$ L; X& a9 [
14.   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)8 g1 {  j. e! n2 ^
    
16.   k++( Q% i) j, T/ `8 N( `
    
18. },
    
19. 1 G; A4 [  @% I7 X) i
20. s;
    
21. 3 S2 S- |; W7 w6 V5 ~( W( Y
22. [clock()-t0]/1000;

!using["math","sys"];<br /> <span style=\\"display:none\\">3 m& J. j$ y0 f+ K+ @4 F! r6 U+ H6 B( S</span> mvar:<font class=\\"jammer\\">6 J$ @4 W, c+ [3 s</font><br /> main(:a)=<br /> <span style=\\"display:none\\">& Q) r2 S( ?9 _\\" U% R</span> t0=clock(),<font class=\\"jammer\\">- A) Q9 f/ H8 Q2 O2 p</font><br /> s=0,<font class=\\"jammer\\">) ~3 o4 K/ R5 w5 R7 {2 X1 B</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\">  P9 I( F$ L; X& a9 [</span>   i=0, while{i<1000, a=linspace(2,2,1000), s=s+a.i, i++},  // 嗯，a.i 就是 a(i)<font class=\\"jammer\\">8 g1 {  j. e! n2 ^</font><br />   k++<font class=\\"jammer\\">( Q% i) j, T/ `8 N( `</font><br /> },<br /> <span style=\\"display:none\\">1 G; A4 [  @% I7 X) i</span> s;<br /> <span style=\\"display:none\\">3 S2 S- |; W7 w6 V5 ~( W( Y</span> [clock()-t0]/1000;

结果：
4 w" U) ^: X4 ^" [; V2000000.
40.766 秒
( W6 U8 K7 s* v
# }' S8 R6 m9 a  I程序运行时内存不稳定，时大时小。该程序导致Forcal垃圾收集器启动约10次，垃圾收集前内存消耗大，垃圾收集后内存小。
因垃圾收集器多次启动，故耗时较长。
# X9 q: \' V! C% K; [6 H- \
8 X# k( N: q& L2 X% ^0 T－－－－－－－－－－－－

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

2. !using["math","sys"];9 j' i$ x3 Z  L$ k5 o
   
4. mvar:/ X& x9 y4 ~. K: ?9 G. w
   
6. main(:a)=7 `9 Q: {$ @2 w( `
   
8. t0=clock(),
   
9. + h6 P) u& }% J
10. s=0,: U+ v8 d3 t6 W8 d; z  w
    
12. k=0, while{k<1000,
    
13. 5 v( M/ J# f! H
14.   i=0, while{i<1000, oo{a=linspace(2,2,1000)}, s=s+a.i, i++},  // 嗯，a.i就是a(i)
    
15. \\" }\\" k4 I9 V\\" h
16.   k++
    
17. 5 x' B! [- [6 j& K1 _2 L: j
18. },8 O6 f) D4 F; U  y' O: Q, w7 E
    
20. s;
    
21. / O- B$ d; y# j; t7 w$ x
22. [clock()-t0]/1000;

!using["math","sys"];<font class=\\"jammer\\">9 j' i$ x3 Z  L$ k5 o</font><br /> mvar:<font class=\\"jammer\\">/ X& x9 y4 ~. K: ?9 G. w</font><br /> main(:a)=<font class=\\"jammer\\">7 `9 Q: {$ @2 w( `</font><br /> t0=clock(),<br /> <span style=\\"display:none\\">+ h6 P) u& }% J</span> s=0,<font class=\\"jammer\\">: U+ v8 d3 t6 W8 d; z  w</font><br /> k=0, while{k<1000,<br /> <span style=\\"display:none\\">5 v( M/ J# f! H</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\\">\\" }\\" k4 I9 V\\" h</span>   k++<br /> <span style=\\"display:none\\">5 x' B! [- [6 j& K1 _2 L: j</span> },<font class=\\"jammer\\">8 O6 f) D4 F; U  y' O: Q, w7 E</font><br /> s;<br /> <span style=\\"display:none\\">/ O- B$ d; y# j; t7 w$ x</span> [clock()-t0]/1000;

结果：
2000000.
0 d5 O( P9 i+ Q6 e% j9 v% Y4.609 秒

+ S+ c7 c, l% T: F7 a可以发现，Forcal耗时大大减少了，远小于matlab耗时，这要归功于oo{ }函数。
6 L$ q$ D  o2 D' i在Forcal中，函数oo{ }不仅提供了运算符重载功能，而且会自动高效地回收垃圾。通常，所有涉及到对象的代码都要放到函数oo{ }中。

我就在你背后

太强大了 看不懂啊

forcal

我就在你背后 发表于 2011-8-2 16:08
4 E6 P: C& h5 U- i太强大了 看不懂啊

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

我就在你背后

forcal 发表于 2011-8-2 18:18
4 P9 C$ [7 v, P+ C* ~. d函数linspace(2,2,1000)放到循环里，每循环一次就会产生一个垃圾对象（一维数组），主要对比Matlab和Forc ...

恩 我在研究研究，谢谢了

sxjm567

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