TA的每日心情 | 怒 2019-11-20 15:22 |
---|
签到天数: 2 天 [LV.1]初来乍到
|
EDA365欢迎您登录!
您需要 登录 才可以下载或查看,没有帐号?注册
x
5 I* E Q% ^4 Y/ D3 l9 `/ T$ _为什么需要PeRFormance Test框架
' L: v& T$ } v9 D+ r; UMATLAB Performance Test 框架是Mathworks在MATLAB R2016a中推出的一个新的框架,该框架用来获得代码性能在统计意义上的数据,还可以用来比较算法的性能,并且给出详细完整的报告。 如果只需要定性的性能结果,tic和toc是一个快速简单的获得代码耗时的工具,大家一定都使用过。比如下面的代码,比较对数组的不同赋值方式,衡量预先分配和不预先分配的耗时差别。test
/ y Q/ K: X- }$ ?5 D5 P% alloc_tictoc.m
0 y2 ?" c. l/ L' R6 xrows = 1000;
+ J d |% G' A, E2 A( |) { ^" hcols = 1000;& u2 g2 G9 n+ K
X=[];
) H+ F8 Q' d, I8 m" k* H. C: SY=[];
2 x( e3 I5 f% k, X1 i( N
+ {# `0 N% f; u9 V# n! \% 对不预先分配的数组X赋值计时$ a# I6 i) H5 }. M+ I1 ]
tic1 x+ i8 `0 B) O3 y1 t& K% e
for r = 1:cols" A2 o. n! }; I* e5 u
for c = 1:rows9 B6 r! [; {; [' K) |7 t
X(r,c) = 1;
9 `6 c5 M: L+ |) k end* q# l5 r: v9 P# n% i
end( Y7 Q8 l6 {; b; f( A% v
toc
6 d! j0 O2 y4 }) a/ p
: _! a: m) `' \$ R: ~2 w% 对预先分配的数组Y赋值计时: k$ ^; w' d+ F. J2 G5 H z
tic4 F( p) Z" g2 e- p" y
Y = zeros(rows,cols);
( b1 h! L) ]+ T4 ~4 @: r9 Ofor r = 1:cols2 {. o3 f$ Z/ {8 M/ r
for c = 1:rows
* T9 y# Q8 o2 D; W5 D# w Y(r,c) = 1;
3 A( A. |% c6 ]/ z0 u' ` end
' \0 _+ W2 t! h4 T" z5 Qend
C; \, n! E6 I' ntoc
4 K4 g) b% O& L$ k ~运行结果可以预料,预先分配数组赋值比不预先分配更快。
8 |& x" ^% ]$ r4 J( B. L! \: ?0 L% Command Line,fontsize=\small 1 Y9 E; b% ~) S5 G4 k, ?% g
>> alloc_tictoc0 s/ Q' d# {* b4 q: c
Elapsed time is 0.449438 seconds. % 不预先分配, Z& e/ o, k! d O( L
Elapsed time is 0.016257 seconds. % 预先分配. G* b- \- ~: m# S4 E$ @( s& V
tic,toc可以快速简单的获得定性的结果,但是有时候,在工程计算中需要代码耗时的定量结果,比如对1000 X 1000的数组赋值,想确切知道预先分配比不预先分配究竟快多少? ,再使用tic toc就捉襟见肘了,运行上述script多次, 可以发现得到的其实是一些随机的分布的结果。3 }/ S4 Q" v0 B# g) N' p
>> alloc_tictoc
# ~7 q6 l* f* H- [" b+ C$ `Elapsed time is 0.472567 seconds.3 X; x5 a, ^' F( ^/ V
Elapsed time is 0.014476 seconds.
: i. c9 ?. o' r>> alloc_tictoc P" P' v* w" V' b9 o/ ^3 s
Elapsed time is 0.434714 seconds.+ p& @( K |3 n: d4 ?$ Q% A: O2 V
Elapsed time is 0.016879 seconds.. o) `2 R- a+ p: }/ e
>> alloc_tictoc
# C+ l' L2 F# f7 @& Y0 u" i! YElapsed time is 0.448822 seconds.
+ Z. }3 ~* i) M1 [0 V+ L6 d* L' q, `Elapsed time is 0.012684 seconds.
; y% |( `, ?0 C' u n>> alloc_tictoc
( t6 K" ?( V% B f, lElapsed time is 0.474179 seconds.% m' g' Z/ o6 v4 J
Elapsed time is 0.013808 seconds.! ]$ V/ \3 v4 s, F2 s" K8 X0 X
>> alloc_tictoc: Z( O3 L+ p# ^
Elapsed time is 0.467369 seconds.
5 a$ d$ I! {8 ~/ w& @6 `& cElapsed time is 0.014176 seconds.0 H. E( l3 ]; P) V7 g( r$ @9 Z
定性的来说,可以肯定预先分配数组的方法要快得多,但是每次测量得到的结果,其实是符合一定分布规律的随机变量{(MATLAB的每一步的计算都要经过确定的函数和优化,从这个角度来说,每次测量应该得到精确唯一的结果。现实中,MATLAB工作在操作系统中,而操作系统会统筹分配系统的计算资源,不同的时刻,资源的分配不一定相同,从而带来了一定的随机性。) },测量结果在一定的范围内波动给获得定量结果造成困难。当两个算法的差别不是很大的时候,这样的波动可能甚至会影响定性的结果。如何得到可靠的性能测量的数据就是我们这章要解决的问题。最容易想到的一个改进就是把运行多次,把每次的结果收集起来,然后求平均,比如:
4 l/ M# u: w' Ctic
^1 A7 w1 P3 Y9 i' Hfor iter = 1: 100+ I$ Z3 @: R9 ^. P8 Y4 m
for r = 1:cols
/ f; k/ Q" S4 ^( \1 Q! m$ q for c = 1:rows" z4 Y+ r; n) a$ j1 ?6 F5 D z% O
X(r,c) = 1;
) P6 T+ _, _4 B& E( Z end# |! ~2 u6 x: N- M; t, o
end0 U5 a R4 Z$ ~6 d
end
/ S( U4 G$ ^( R8 z: Dtoc0 U7 y& U: u+ t* A1 i' b
% 再把得到的结果求平均,略
# ^( V$ Z, A$ F但是循环的次数很难有一个统一的标准,到底循环多少次结果求平均才可靠,次数少了结果不可靠,次数多了浪费时间。还有,理论上能否保证提高循环次数就一定可以得到统计意义上可靠的结果?一个严谨的性能测试不但需要一套规范的标准,还需要统计理论的支持。 另一个测量性能时要注意的问题是:如下所示,测量结果可能对algorithm1不公平,因为MATLAB的代码在第一次运行时候会伴随编译和优化,比如Just In Time Compilation(JIT)和最新的Language Execution Engine(LXE)的加速,这就是说,前几次运行的代码会有一些编译和优化带来的的耗时,可以把它们想象成运动之前的热身,如果algorithm1和algorithm2共用一些的代码,那么algorithm1运行时,可能已经帮助algorithm2热了一部分的身,而带来的额外时间却算在了algorithm1的耗时内6 R" S& b2 k# x% _: n
% 代码优化可能带来额外的耗时,fontsize=\small
: F" ~' g& ^! {# ?* i% J7 L3 ~) Y% 计时算法1! ~) G$ x& `% n( N' l
tic
# o, V* y* \4 P% xalgorithm1(); 6 w& m) n1 }) m9 M3 \' l. I
toc, M& R0 v7 y: K9 c" {7 V5 q4 d
+ Z0 \ i6 Y0 ]5 V5 R
% 计时算法24 y" _, W9 }( y' V ]( [
tic1 w6 J: B+ }& J: J! G) y) b
algorithm2();
9 F: R! A. \: Y7 Utoc
& j+ ^3 f9 n* `; ]所以更公平的测时方法是,剔除前几次的运行,让要比较的代码都热完身之后再计时+ C0 O# Z% {8 _: E
% 剔除代码优化可能带来额外的耗时,fontsize=\small
) y& w; L* [1 B- X& o: Q3 V% 算法1热身4次
- t* }. m, A6 c+ T0 V# Hfor iter = 1:4+ I( S1 h* U7 l% ^2 C
algorithm1()
' {! s4 A' g* F* c% k- D' D, c5 send1 _8 l2 b- U3 g' R/ {3 W
% 计时算法15 F1 x! \. Y" S4 w. @ h
tic
; T5 I3 F6 n- @! t" r* N) Ralgorithm1();
8 H. Z8 R6 X# e* G" `8 M" Mtoc* D" |. q! W% Q- J
% 算法2热身4次
6 a% J3 `* \ l) Q, Yfor iter = 1:4( M" z7 W9 I3 c8 f0 A! R. [- X
algorithm2()
+ b; f. C- J$ Q- dend
/ k/ Y& N8 V7 G! A8 `! j% 计时算法2: O# V8 G" B1 E, @ ]
tic
8 P$ ] t a& Y5 L7 ]( Palgorithm2();
% M, _' D$ a v8 H X/ }' A6 Qtoc
& W4 f6 ^: L3 [8 v: U9 I5 t/ S基于类的(Class-Based)性能测试框架
" \" k" Q9 M* w构造测试类
+ H) h; H2 j; Z* `构造一个基于类的Performance测试很简单,我们只需要把Performance Test一节中的脚本转成性能测试中的方法即可。 任何基于类的Performance 测试类都要继承自matlab.perftest.TestCase父类,也就是框架的提供者;下面的类定义中,还把rows和cols两个变量放到了类的属性中,这样test1和test2可以共享这两个变量。
/ U% z8 f" p; Y% AllocTest, fontsize=\small % c9 k/ b: G) c( h. l; b: o
classdef AllocTest < matlab.perftest.TestCase % 性能测试的公共父类
7 t7 A" ?4 `' m+ c0 s properties
1 W6 P4 v0 p) }4 w( B: ? rows = 1000
* b+ r$ `4 b8 d8 }% r0 L% \ cols = 1000
% X$ s) ^ d3 t# t8 X end
: B4 K3 S v' m8 P w; ` methods(Test)
4 c- q- o3 [, z! { % 不预先分配赋值 测试点5 e) _7 t& F) f- y
function test1(testCase) & M. `- q& X. y* b8 v8 _9 O- n' G3 A
for r = 1:testCase.cols
% B/ ]1 C; Y ~- f7 y& _% A for c = 1:testCase.rows
! D6 a( N2 N/ h: w9 d8 ` X(r,c) = 1;- Q5 _+ X3 v2 Z1 F
end
7 _4 X9 H: `% R5 ]5 J end
. J8 [; ~ E" S- s0 Q end
6 n* }1 a' E0 C! O# a7 w" T % 预先分配赋值 测试点
o5 v+ O u) X% @# Q3 U+ F9 { function test2(testCase)
8 L0 v; c6 A/ e* K; S X = zeros(testCase.rows,testCase.cols); , t' c0 ~8 A3 H( u/ w
for r = 1:testCase.cols/ _" J% y4 i. n& ^$ n
for c = 1:testCase.rows ] S" y/ E k4 V& _, `3 \/ J
X(r,c) = 1;& k1 c+ Y/ P1 b" R" J2 R/ s6 k
end
, u Q0 q; _, K; \$ w$ S end2 T1 d# R6 l7 ` M% }, `. O
end
5 A; H) e" y# |0 ]# y5 e( { end
) p& \' k- N/ dend
, w4 c( b3 i. r M运行runperf开始Performance测试
9 v; `7 ]# G; O! e' Z, a ^* g>> r = runperf('AllocTest')
3 t4 l L: z3 ], r; \Running AllocTest
& W! M+ I$ n' v' R..........
9 [2 ?4 Y5 z8 l, f2 O.......
6 R0 u/ E# z* M8 Q/ z+ IDone AllocTest
! n- j( \( Y8 \( J2 P4 i__________: ~* j* i3 |$ t B
r = 2 }9 \: ~% [( X' i& X! q+ \
) G5 u" ?8 S" X* P" a
1x2 MeasurementResult array with properties:+ F; X& W6 m- l
" c$ F- I$ o9 w8 C/ k) { Name
; Y- v- u. W$ d( V Valid. z: t4 Z' L" O( [
Samples- C2 }/ g. }9 }. Z5 u
TestActivity" k6 y/ N, w4 U$ D/ R
$ ^3 w) [1 M" R5 V2 z! f9 ITotals:9 u$ N* e: g/ u
2 Valid, 0 Invalid
, T4 x. w# f8 ]% T+ Y: n" n! f9 Arunperf返回一个1X2的结果对象数组,两个测试点都是合格的测试,% h% b2 A! u4 E8 G* X$ J: m
测试结果解析2 T* U E, s5 @4 B8 z) O Y
在命令行中检查对象数组中的一个元素,即test1的测试结果
6 f- I M& M( O; Z6 l9 K5 ?>> r(1)
' W- ?+ N j, [! r4 V8 jans = 9 R5 T3 ~' p% x9 B
MeasurementResult with properties:) P( t" b8 L! ?6 x8 I; x- f" `
' P2 c- [# [2 O: Z. N Name: 'AllocTest/test1'! `- x ^/ e- s
Valid: 1
W% t# D8 T5 |: C Samples: [5x7 table] %简报
$ N/ ]* Y4 y; M: d' ^ H TestActivity: [9x12 table] %原始数据
/ b0 {& l" z2 E( KTotals:5 p# P* W" Z- E, ? Y0 e3 S
1 Valid, 0 Invalid.
( c( e0 o* s `& }$ ~3 k- F其中属性TestActivity是测量的所有测量原始数据,原始sample是有用数据的简报,这里解析TestActivity中的原始数据
( u# g- z5 j) i: [$ L/ R>> r(1).TestActivity ! a e% B0 l- f% S4 C
% W' a, A2 `2 a6 j: @8 ]
ans =
G. C5 P% j5 d9 P$ p7 @
0 s+ j$ Q, q$ ?, B% X2 T: l Name Passed Failed Incomplete MeasuredTime Objective
6 _. r( I% d% _5 ? _______________ ______ ______ __________ ____________ _________ 9 g% S. J( [, E% j% {& Y( S
- y. _ {1 R! X9 j4 ~
AllocTest/test1 true false false 0.52387 wARMup
. s+ l. ]5 D0 Q9 y' a AllocTest/test1 true false false 0.44674 warmup
$ q1 |! G$ s8 A AllocTest/test1 true false false 0.50816 warmup
0 H* f6 }5 V) b AllocTest/test1 true false false 0.38104 warmup
; `" t/ `$ g; R9 a AllocTest/test1 true false false 0.38372 sample
3 a, |1 u2 l) {, W" N AllocTest/test1 true false false 0.4197 sample
$ r0 A$ _& |4 I2 D! ~% q AllocTest/test1 true false false 0.38647 sample ( G5 {5 ~5 ]1 N# R* o; y; J
AllocTest/test1 true false false 0.38489 sample 5 m' H$ Q' ?7 v( `) |: i
AllocTest/test1 true false false 0.37503 sample
W$ s' L& J' P测量的结果是一个table对象,从结果中看出,测试一共进行了9次,前4次是这一节尾提到对代码的热身,这四次的结果在Objective中标记被做warmup,从数值上也可以大致看出它们和后5次测量有着不同的分布,计算均值的时候需要把它们剔除,正式的测试标记做sample测试,test1的sample测试一共运行了5次。检查r(2)得到类似的结果:+ _$ _) r, ]5 ~) q
% Command Line , fontsize = \small * X7 E) p2 _4 \' t% \& A' h
>> r(2)" s; D$ C* \( j
- g& S% F) A, a+ b. Zans =
6 L( n& [* {2 q' O X0 P* V% j, S9 F8 L/ j. Z
MeasurementResult with properties:+ i) g. `" ]; Z) \6 n4 @
( I! {8 L' B, c3 O9 C# S$ b Name: 'AllocTest/test2'
, ]! v! B* j" H8 J9 x Valid: 1
0 _9 Z) o7 x {3 X/ O Samples: [4x7 table] %简报. w# ~% u5 D1 h, Z( M
TestActivity: [8x12 table] %原始数据
4 D O' k0 J5 q+ |0 h* X: c" \/ y3 E; C* A
Totals:
' y* @* K. m. Q4 c' x2 Z/ q; f 1 Valid, 0 Invalid.( @! q9 T }( o. E. {
>>
c9 B. m+ o9 D X: Y G>> r(2).TestActivity
- o3 g P) C! I$ x; W3 x# T1 w4 T- D& d& J* G
ans =
$ |1 @3 A) A) W) N
* k* J+ T) K4 g* ]" U Name Passed Failed Incomplete MeasuredTime Objective 4 J" H# q% A* C
_______________ ______ ______ __________ ____________ _________ ' {, L( ^" N& u" d& y* M
. ^3 K& {0 Q' T. b* C AllocTest/test2 true false false 0.018707 warmup 1 P. V, T9 n+ U- x$ M
AllocTest/test2 true false false 0.028393 warmup
) R# S _, y8 `% U# R. m- Y) h h AllocTest/test2 true false false 0.013336 warmup 1 z$ L7 a0 @! E& E* `/ o! J
AllocTest/test2 true false false 0.012915 warmup
% K9 m, \/ w: |* Z/ ^5 v AllocTest/test2 true false false 0.013543 sample 9 N# B4 b' m4 [' c( a
AllocTest/test2 true false false 0.012904 sample
( W( s& `9 J; N/ p& | AllocTest/test2 true false false 0.012778 sample
& M% o, o3 g/ l AllocTest/test2 true false false 0.01312 sample
. Z0 H9 f9 z' C. d4 \9 ]+ Ptest2有4次warmup,4次sample测试。 按照默认设置,每个测试点都要先warmup代码四次,再进入正式的sample测试,有四个sample测试意味着test2这个测试点一共被运行了四次,test2的测试次数和test1的测试次数不同,每个测试点运行几次是由测量数据集合是否到达统计目标所决定的,误差范围和置信区间小节将详细介绍。 有了多次测量的结果,我们可以利用一个帮助函数,从table中取出sample的数据,
$ _0 I7 I5 E2 U c* f5 _0 R$ J2 Bfunction dispMean(result)( y( I N9 f, ~' Q' @
fullTable = vertcat(result.Samples);
2 {; a3 O+ }8 l) Z% n# w. j varfun(@mean,fullTable,'InputVariables','MeasuredTime','GroupingVariables','Name')
" Y% \ J0 p* V' Z$ D2 fend0 t2 x, x5 w1 x/ O$ F4 t
然后对它们求均值,得到的结果才是统计意义上的测量结果。1 f0 P+ N* U2 w/ ^% k6 B
>> dispMean(r)
: Q9 m' \7 _' S6 j9 Z: q
5 v5 p4 z% I! N0 v0 xans =
0 t. w1 ]9 M2 w5 U+ X& d+ I# y
* j o5 Q6 F7 @8 p; H/ u; u Name GroupCount mean_MeasuredTime
& w, n1 b* `" f, P2 F# R3 A _______________ __________ _________________9 @8 g* P4 p) D7 ?+ O1 c" T. T
3 P7 P5 I. t b, h' z
AllocTest/test1 5 0.38996 * K/ O3 a& z* M: A' p
AllocTest/test2 4 0.013086 & D( Z/ G, i+ [8 R9 t4 ^
如果算法在不断的变化中,这样的测量结果也可以保留起来,从而追踪一段时间之内算法性能的变化。# C8 l8 R7 j' D4 S: W1 M
误差范围和置信区间# D4 [% t/ y2 o9 t$ X* S
Performance测试框架规定,一个测试点warmup四次之后,将再运行4到32不等的次数,直到测量数据达到0.05的Relative Margin of Error,0.95的置信区间为止,一但已有的测量值到达了上述的统计目标,就停止计算,如果超过32次还是没有达到0.05的Relative Margin of Error,框架仍然停止计算,但抛出一个警告。这就是为什么前节的test1运行了5次,而test2只运行了4次,它更快达到统计目标。 在每获得一次新的测量数据时,已有数据的Relative Margin of Error都将被重新计算,来决定是否需要再次运行测试点。下面的函数(需要统计工具箱) 帮助计算Relative Margin of Error, 用它来计算test1的数据可以验证相对误差在得到第4次测量结果仍然大于0.05,直到第5次计算小于0.05,于是停止继续测量* o! U- w+ e3 }- i/ D
% 计算Relative Margin of Error的函数, fontsize = \small
/ D- q& U$ C( rfunction er = relMarOfEr(data); o- l; `1 p8 q+ M" u1 D/ M+ Q
L = length(data);1 I8 L+ k# X/ u& s' Y
er = tinv(0.95,L-1)*std(data)/mean(data)/sqrt(L);
+ ^- r) T( I9 ?8 F+ ~end
4 V: d% S( j, \>> relMoE(r(1).Samples.MeasuredTime(1:end-1)) % 取test1的第1到第4次测量结果
/ E0 a3 X$ @! Dans =
3 t* A; | s2 p! C 0.0519. R. _3 Y3 K; ^/ x8 ^) I
( c7 Z( _7 U9 F! P9 e6 _9 a>> relMoE(r(1).Samples.MeasuredTime) % 取test1所有测量结果, P( a- H# y+ m' w- `4 ^+ L# S
ans =$ S) D( I; `5 |3 b" I- @6 o* Z
0.0421
! O4 g4 n+ a! D. V5 y! t" X; dtest2的测量结果类似,第4次的测量,整体数据达到统计目标
0 ~5 `2 z5 l( s, H9 C" v; A% R>> relMoE(r(2).Samples.MeasuredTime(1:end-1))
/ J6 i( A; `+ e, I2 C1 q9 Bans =
I9 b; v6 `, t# Q$ z 0.0529; {5 S5 i$ U. v7 n5 B6 t
) S) H) g q! v7 X>> relMoE(r(2).Samples.MeasuredTime)9 m8 c+ d. Y0 C* w$ y2 r
ans = `, {- S K2 _3 G
% ^0 [, D4 }$ n 0.0302
' X7 k, E$ N6 b8 H4 A所谓0.95的置信区间,就是说该系列的测量将确定一个区间,有百分之95的几率实际的真实值就在该区间中。调用函数fitdist得到置信区间(需要统计工具箱。)
* {" P8 @- b: ^; h2 a4 ], P>> fitdist(r(1).Samples.MeasuredTime,'Normal'), B) G% `; o4 l" T6 _. p
ans =
$ [/ |$ B5 H# w6 K NormalDistribution( K1 P8 _; B- d* m8 F
- b0 G' N0 k X. [5 G Normal distribution# w2 s9 K: O1 s6 J- b) n0 d' H
mu = 0.389962 [0.368598, 0.411326] % 0.95置信区间
) k3 r1 Z- R k% u& z sigma = 0.0172059 [0.0103086, 0.049442]
( R; g8 t z4 z0.05的Margin of Error并不是所有的测试都能达到,事实上我们如果多次运行上述的同一个测试,很有可能test2的结果会有几次含有Warning。* c- t* l4 P, M% M3 v! T; G, }
>> r = runperf('AllocTest')+ ]4 O0 K# N1 U- w5 J0 h7 y; R9 g
Running AllocTest& W. ~& y" x! a- H+ T
........... x% u* R6 B7 c9 @ J
..........
5 A- O* p0 `1 J* U8 a: G6 F l..........
4 \9 d, R, b9 ^- U1 A..........7 ~! N0 K6 }- E4 A7 J4 e
....Warning: The target Relative Margin of Error was not met after running the MaxSamples for1 z2 }6 k# @0 Y% O9 A" `: W
AllocTest/test2.
' j" b% J/ F+ u % 测试点运行超过32次任没有达到统计目标
4 A% S: C {& q! K8 n8 p$ n3 D! t' j) rDone AllocTest9 T+ B/ m8 Q$ U0 f
__________( f5 G4 w' ]' m, z- T
8 i3 S9 b, ~; K+ W4 |9 f1 y
r = " Y) v. g4 C) \1 _3 }/ m
% ^7 n# \4 O+ y6 M4 @
1x2 MeasurementResult array with properties:/ |- D+ T( ]; W9 y/ {) X/ z
0 M! I$ _% L* |/ ]* A. X* B' ^0 J8 r
Name; ^' N* \7 o) e+ R
Valid
' D8 Q% Z2 L. I. @% m; ~7 @ @ Samples
, `1 |' F6 V' h% R+ B TestActivity9 n7 o( f; B. ]# P. s
+ z: n" O2 {; p+ \0 a5 D# q
Totals:1 v5 O2 |: _, M5 A. i* z
2 Valid, 0 Invalid.
8 s l4 t. j/ c% n/ y5 b& }>> # [6 M( Z- O' C
>> r(2)
9 |7 J% u) |, r) ^$ q3 ` J5 n6 \' w; p* Q. A, `8 r; G: z6 p
ans =
! }# f. L( h. T5 Y2 \ `6 d9 Z$ ^3 E4 v# O# ~# ]0 T' m1 L
MeasurementResult with properties:; n2 E+ v7 H% t& B! B& u
. d5 f+ u& S' O V Name: 'AllocTest/test2') S/ v9 F! F9 m8 O( L" y- S1 S
Valid: 10 P ^; @; U! ]- R) z! E
Samples: [32x7 table]& |' R* K" @* @& b/ E# f
TestActivity: [36x12 table] % test2运行了一共4+32=36次+ W( x6 Z% J+ N6 I
7 c3 d' C: b6 e S1 ^, s. FTotals:2 B4 C* j% ?! p+ d
1 Valid, 0 Invalid.! D, F& F; s8 d! p: B+ o
Warning说明测量的操作过于的细微,噪音影响过大。我们可以通过增大计算量,或者放松统计目标来避免这个Warning,比如修改默认的Relative Margin of Error) f9 g7 y$ [; j
% 增大Relative Margion of Error, fontsize = \small
/ l6 B$ \7 r! t; c3 M, z* c4 X>> import matlab.perftest.TimeExperiment% \+ }- Z+ ^; C6 }+ S/ g
>> experiment = TimeExperiment.limitingSamplingError('RelativeMarginOfError',0.10);
, k2 J, {0 d, n" {( z>> suite = testsuite('AllocTest');
6 v# D* n* | o ^5 e( k- c>> run(experiment,suite)
" r7 ]7 M+ ]# x; w' d+ ]Running AllocTest
" U9 U! d4 G: ` i5 c% z..........
, ?" [( m: U* u# b, h4 j4 q......9 Z" U" t: M4 Q: a3 V# t3 q7 t. u
Done AllocTest9 z% y K2 V4 \% R9 A' C
__________
' `' |$ u- E8 o1 z1 n% V; I. P+ h$ x
4 t6 Q, S" U G% c# @2 b* w
ans = ( ^' O) G1 |! i9 d* r
5 d2 J: v, | G0 S# J# [4 T1 B7 } 1x2 MeasurementResult array with properties:
* p' A( q' N: R5 {# `( ~: e/ g. G( e( o2 M: o9 @) o- G
Name& I7 w1 l9 E! \" y/ w
Valid
9 A7 G. m# O- G# a Samples
9 D) b4 _8 h' b TestActivity
: k: g. k" x6 ]: k& p8 N& n: P3 J$ w; h' h" N# w# O7 S U; {* e* Q
Totals:" {: b; F7 I2 R' {7 T. ?
2 Valid, 0 Invalid.
( Y% d$ p* C" U性能测试的适用范围讨论0 u# Q; C6 @" {$ H" J
性能测试框架最初是Mathworks内部使用的一个框架,使用范围和单元测试一致,单元测试保证在算法的进化过程中,功能不退化;而性能测试保证算法的性能不退化。这样一个框架对MATLAB用户的算法开发显然会带来价值,但是我们要分清什么样的测量才是有价值的,构造测试类中的例子是一个简单易懂的例子,但作为MATLAB的用户,我们其实没有必要去测量和记录这些简单的MATLAB的操作的性能(这是Mathworks内部性能测试的主要工作) ,我们只需要记住它们定性的结果,比如给数组赋值之前要先分配,运算尽量向量化等等就可以了。性能测试框架真正能给我们带来的价值的用例,是如下的测试实际算法性能的情况,在用户的算法myAlgorithm的开发过程中,我们可以定期的运行该测试文件,保证性能不退化0 K: P/ U: N3 Q* x" r
classdef AlgoTest1 < matlab.perftest.TestCase( U( { e) f6 H P
methods(Test)7 \* q5 w& Y! g" P$ A4 J5 u9 \: u
function test1(testCase) # d9 q& X D( W j
myAlgorithm();
x$ ?) Z5 }1 z+ o I end$ R/ F5 i2 q- r( t, L
end; G7 n: E; e" E7 |5 `
end# j+ z' @8 s+ l7 b9 _, t
或者比较两个算法,algorithm1可以代表一个旧的算法,algorithm2代表新的改进的算法,依靠Performance Testing 框架,我们可以得到可靠的数据到底algorithm2改进了多少! J( ^' d/ L8 C2 Z& R, D
classdef AlgoTest1 < matlab.perftest.TestCase; l1 S8 ~+ j) |0 U" v' Q
methods(Test)& n* _# I( p+ ~2 ~% w4 {" b) d
function test1(testCase)
% ^" I8 z1 i" y- d+ n$ J algorithm1();' Y0 R" _, T2 g3 D" o+ P8 Y
end F O8 ?6 i, O+ B* {
" U: |# P- a" p+ `9 x function test2(testCase) - A5 o M: E; L7 I& m) C0 D
algorithm2();- A7 t( k, m, _4 M( m
end
& j% c; g- a* V: G% F% R end
! k3 o1 Y, V; g/ T0 P- E" P# fend |
|