Android性能测试之fps获取
关键点
在testerhome看到一个好的帖子，说的是fps的获取方式，值得好好研究一下。
获取的方式是通过下面的命令获取
adb shell dumpsys SurfaceFlinger --latency <window_activity>
命令意义
上面的命令是做什么的？
可以看看老罗的关于SurfaceFlinger的详细讲解，那我这里只是简单的描述一下：
SurfaceFlinger是一个系统服务，管理Android帧缓冲区，了解这些就足够啦，因为我们要获得的FPS值(Frames Per Second)中文翻译过来是每秒钟填充图像的帧数。
ok，那我们知道了这个服务的作用。
命令的结果
我们来看一下这个命令的结果，取android系统的主界面的帧数据
qianhuis-Mac-mini:app qianhui$ adb shell dumpsys SurfaceFlinger --latency com.android.launcher/com.android.launcher2.Launcher 16666666 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 53476438728 53483331194 53476438728 53774334579 53783331182 53774334579 53804473320 53833331180 53804473320 53821433876 53849997846 53821433876 54482172942 54499997820 54482172942 62828275267 62849997486 62828275267 77744212604 77749996890 77744212604 137676463526 137683327826 137676463526 197665365491 197683325426 197665365491 257656215141 257666656360 257656215141 317667889815 317666653960 317667889815 377658368227 377666651560 377658368227 437659404105 437666649160 437659404105 497680028798 497683313426 497680028798 557661828695 557666644360 557661828695 617669142813 617683308626 617669142813 677664261743 677683306226 677664261743 737664607859 737683303826 737664607859 797520577853 797549968098 797520577853 797663672552 797683301426 797663672552 813703318654 813749967450 813703318654 857696035562 857716632358 857696035562 917697480455 917716629958 917697480455 977667175775 977666627560 977667175775 1037666198546 1037666625160 1037666198546 1097679780732 1097699956092 1097679780732 1157680091691 1157699953692 1157680091691 1217681064721 1217699951292 1217681064721 1277681725100 1277699948892 1277681725100 1337665343758 1337683279826 1337665343758 1397664084052 1397683277426 1397664084052 1457665440087 1457683275026 1457665440087 1517669937332 1517666605960 1517669937332 1524620120922 1524649939014 1524620120922 1549500333658 1549533271352 1549500333658 1577676396539 1577699936892 1577676396539 1637681916267 1637699934492 1637681916267 1697678605745 1697699932092 1697678605745 1757681427632 1757699929692 1757681427632 1817680212373 1817699927292 1817680212373 1877681586834 1877699924892 1877681586834 1937702217412 1937733255824 1937702217412 1997665879256 1997683253426 1997665879256 2057664998469 2057683251026 2057664998469 2117667796048 2117683248626 2117667796048 2177667609969 2177683246226 2177667609969 2237666557333 2237666577160 2237666557333 2260655440820 2260683242906 2260655440820 2295708486334 2295733241504 2295708486334 2297667588171 2297666574760 2297667588171 2357668458964 2357666572360 2357668458964 2417677948705 2417699903292 2417677948705 2477680415203 2477699900892 2477680415203 2537681084888 2537699898492 2537681084888 2597682623610 2597699896092 2597682623610 2657662892357 2657683227026 2657662892357 2717663341559 2717683224626 2717663341559 2777684593156 2777683222226 2777684593156 2837677400623 2837699886492 2837677400623 2897718308856 2897733217424 2897718308856 2957669662475 2957683215026 2957669662475 3007072891033 3007099879716 3007072891033 3017678196794 3017699879292 3017678196794 3077679633292 3077683210226 3077679633292 3137681037968 3137699874492 3137681037968 3169623894137 3169666539880 3169623894137 3197683176766 3197699872092 3197683176766 3257684223564 3257699869692 3257684223564 3317680588767 3317733200624 3317680588767 3377665920385 3377683198226 3377665920385 3437676819013 3437683195826 3437676819013 3497666530549 3497683193426 3497666530549 3557665435190 3557666524360 3557665435190 3617697519980 3617716521958 3617697519980 3677680073314 3677699852892 3677680073314 3737679371848 3737699850492 3737679371848 3797700730719 3797733181424 3797700730719 3857682152646 3857699845692 3857682152646 3881320403971 3881349844746 3881320403971 3917683549768 3917699843292 3917683549768
是不是有点晕，这些数字都是啥跟啥啊。其实testerhome上面的那篇文章提供了获取fps方法具体解释
用到了一个第三方的库：pylib
# adb shell dumpsys SurfaceFlinger --latency <window name>
# prints some information about the last 128 frames displayed in
# that window.只打印128行的帧数据
# The data returned looks like this:
# 16954612
# 7657467895508 7657482691352 7657493499756
# 7657484466553 7657499645964 7657511077881
# 7657500793457 7657516600576 7657527404785
# (...)
#
# The first line is the refresh period (here 16.95 ms), it is followed
# by 128 lines w/ 3 timestamps in nanosecond each:
# A) when the app started to draw
# B) the vsync immediately preceding SF submitting the frame to the h/w
# C) timestamp immediately after SF submitted that frame to the h/w
#
# The difference between the 1st and 3rd timestamp is the frame-latency.
# An interesting data is when the frame latency crosses a refresh period
# boundary, this can be calculated this way:
#
# ceil((C - A) / refresh-period)
#
# (each time the number above changes, we have a "jank").
# If this happens a lot during an animation, the animation appears
# janky, even if it runs at 60 fps in average.
#
# We use the special "SurfaceView" window name because the statistics for
# the activity's main window are not updated when the main web content is
# composited into a SurfaceView.
上面的解释信息有如下主要信息：
数据的单位是纳秒，时间是以开机时间为起始点。
每一次的命令都会得到128行的帧相关的数据。
第一行数据，表示刷新的时间间隔refresh_period，我的机器打印出来的间隔期是：
16666666/1000/1000 = 16.67ms(毫秒)
那么剩下来127行的数据分为3部分，每一行的数据的每一列都代表一部分。
第一部分
这一部分的数据表示应用程序绘制图像的时间点。
第二部分
在SF(软件)将帧提交给H/W(硬件)绘制之前的垂直同步时间。
第三部分
在SF将帧提交给H/W的时间点，算是H/W接受完SF发来数据的时间点，绘制完成的时间点。
那么可以看出第一部分和第三部分类似，那么差异在于哪里？差异在于帧有延迟时间，从准备好绘制完成绘制的时间间隔就是帧延迟。
何为jank，即掉帧 。每一行都可以通过下面的公式得到一个值，该值是一个标准，我们称为jankflag，如果当前行的jankflag与上一行的jankflag发生改变，那么就叫掉帧。
ceil((C - A) / refresh-period)
所以掉帧是一个状态。
FPS计算
那么我们要用到上面的哪些数据了？那么我们去库里面一步一步去按照方法来找到最后的答案，首先它是调用了下面方法：
collector = surface_stats_collector.SurfaceStatsCollector(adb, activityName,0.5) results = collector.SampleResults()
那么我们首先找到SurfaceStatsCollector这个类，在pylib库中的perl包下
SampleResults方法：
def SampleResults(self): self._StorePerfResults() results = self.GetResults() self._results = [] return results
首先调用了 _StorePerfResults方法
从上面看出计算方法有两种方式，一个是支持legacy方法，一个不支持legacy方法。
第一种情况
支持legacy方法。判断是否支持legacy方法，可以通过执行dumpsys SurfaceFlinger --latency-clear SurfaceView来判断。
然后我们进入
def _GetSurfaceStatsLegacy(self):
"""Legacy method (before JellyBean), returns the current Surface index
and timestamp.
Calculate FPS by measuring the difference of Surface index returned by
SurfaceFlinger in a period of time.
Returns:
Dict of {page_flip_count (or 0 if there was an error), timestamp}.
"""
results = self._adb.RunShellCommand('service call SurfaceFlinger 1013')
assert len(results) == 1
match = re.search('^Result: Parcel\((\w+)', results[0])
cur_surface = 0
if match:
try:
cur_surface = int(match.group(1), 16)
except Exception:
logging.error('Failed to parse current surface from ' + match.group(1))
else:
logging.warning('Failed to call SurfaceFlinger surface ' + results[0])
return {
'page_flip_count': cur_surface,
'timestamp': datetime.datetime.now(),
}
这个_GetSurfaceStatsLegacy方法会调用"service call SurfaceFlinger 1013"这个命令，结果是如下形式：
10|root@generic_x86:/ # service call SurfaceFlinger 1013 Result: Parcel(00000b5e '^...')
然后我们会提取里面的00000b5e这个16进制的数，然后通过int('str',16)方法将16进制数转化为10进制的数，这个值就是当前surface的索引值。可以通过2个不同索引值的surface之间的间隔时间获得。然后返回一个字典，里面包含了2个内容：当前surface索引，以及当前时间戳。这个方法就结束了。该字典将赋值给surface_after。我们就回到了_StorePerfResults方法中,看下一行要执行的代码：
td = surface_after['timestamp'] - self._surface_before['timestamp'] seconds =td.seconds +td.microseconds/1e6 frame_count = (surface_after['page_flip_count'] -self._surface_before['page_flip_count']
上面的代码，是将这次的时间－上次的时间，得到的值就是2次获取surface索引的时间间隔，赋值给td，然后取得td的秒数，但是精确到微妙级别。赋值给seconds。
然后计算2次surface索引值的差值，得到的值就是在seconds时间内产生surface的个数。赋值给frame_count。
然后用frame_count/seconds公式计算，做4舍5入，最后转化为整形，追加到results数组中，该方法就返回了。就到了SampleResults方法中：
results = self.GetResults() self._results = []
由于上面的第二行可以看出来，每次的results的数组都会重新设置为空，那么当前results的值就只有一个值，就是我们这次所获得值，所以返回的results数组里就只有一个数值。就是我们的fps的值,然后至于你获得多少次这样的值，以及间隔时间，那是你自己决定的事啦。
what?
有人看完上面的内容，有蒙的感觉么？其实我也蒙了，我们说了那么多的dumpsys SurfaceFlinger --latency，但是经过我们一分析，居然真正的计算是没有用到这个里面的数据的，是不是很奔溃。但是要想到的一点是，在调用collector.SampleResults()方法前，是需要启动_CollectorThread(self)的，尝试执行dumpsys命令3次获得需要的值。该线程中的就是调用了
_GetSurfaceFlingerFrameData()里的方法，具体实现细节如下代码所示。
def _CollectorThread(self):
last_timestamp = 0
timestamps = []
retries = 0
while not self._stop_event.is_set():
self._get_data_event.wait(1)
try:
refresh_period, new_timestamps = self._GetSurfaceFlingerFrameData()
if refresh_period is None or timestamps is None:
retries += 1
if retries < 3:
continue
if last_timestamp:
# Some data has already been collected, but either the app
# was closed or there's no new data. Signal the main thread and
# wait.
self._data_queue.put((None, None))
self._stop_event.wait()
break
raise Exception('Unable to get surface flinger latency data')
timestamps += [timestamp for timestamp in new_timestamps
if timestamp > last_timestamp]
if len(timestamps):
last_timestamp = timestamps[-1]
if self._get_data_event.is_set():
self._get_data_event.clear()
self._data_queue.put((refresh_period, timestamps))
timestamps = []
except Exception as e:
# On any error, before aborting, put the exception into _data_queue to
# prevent the main thread from waiting at _data_queue.get() infinitely.
self._data_queue.put(e)
raise
_GetSurfaceFlingerFrameData方法实现细节如下：
def _GetSurfaceFlingerFrameData(self): results = self._adb.RunShellCommand( 'dumpsys SurfaceFlinger --latency SurfaceView', log_result=logging.getLogger().isEnabledFor(logging.DEBUG)) if not len(results): return (None, None) timestamps = [] nanoseconds_per_second = 1e9 refresh_period = long(results[0]) / nanoseconds_per_second pending_fence_timestamp = (1 << 63) - 1 for line in results[1:]: fields = line.split() if len(fields) != 3: continue timestamp = long(fields[1]) if timestamp == pending_fence_timestamp: continue timestamp /= nanoseconds_per_second timestamps.append(timestamp) return (refresh_period, timestamps)
上面的具体执行流程，是先运行dumpsys SurfaceFlinger --latency 命令，从得到的128行数据中，提取第一行的刷新时间，然后得到每一行的中第二部分数据，获取其中秒数，保存到timestamps数组中。然后方法返回包含刷新时间refresh_period和timestamps的数组。然后回到线程的主方法中。
1.判断获取到的数据为NONE
如果尝试的次数没到3次，再执行一遍dumpsys命令。
如果超过了3次，我们要判断上一次获取的timestamps数组中最后一个值是否为0。因为last_timestamp的赋值语句如下：
last_timestamp = timestamps[-1]
如果不为0，说明我们已经收集过了，直接在队列中加上NONE值，让线程等待，跳出循环了。否则抛出异常
2.不为NONE
如果为0，说明我们fps的数据还没有开始收集，我们会将_GetSurfaceFlingerFrameData方法返回的数组中元素一个一个赋值到我们本地数组中。然后给last_timestamp赋值。
然后我们会向_data_queue队列中添加refresh_period, timestamps数据。
总结
从上面的分析可知，要想获得获取fps值，需要3步：
1.adb shell dumpsys SurfaceFlinger --latency命令产生fps数据
2.通过service call SurfaceFlinger 1013 来得到当前帧的索引以及时间戳，设置为A = {indexA,timeA}
3.公式：
设上一次的数据为B = {indexB,timeB}
FPS = (indexA-indexB)/(timeA-timeB)
第二种情况
当--latency-clear不能使用，也就是`service call SurfaceFlinger 1013`命令不能使用，那自然上面的方法就不起作用了。这个时候我们就要从下面的代码进行分析了：
# Non-legacy method.
assert self._collector_thread
(refresh_period, timestamps) = self._GetDataFromThread()
if not refresh_period or not len(timestamps) >= 3:
if self._warn_about_empty_data:
logging.warning('Surface stat data is empty')
return
self._results.append(SurfaceStatsCollector.Result(
'refresh_period', refresh_period, 'seconds'))
self._results += self._CalculateResults(refresh_period, timestamps, '')
self._results += self._CalculateBuckets(refresh_period, timestamps)
首先我们从线程中获得dumpsys命令得到的值，然后创建Result对象，该对象中含有属性名和属性值，以及单位。
然后我们要进入_CalculateResults和_CalculateBuckets方法。
_CalculateResults
上面的方法中，首先得到帧的数量frame_count，然后得到产生frame_count所用的时间seconds。然后调用_GetNormalizedDeltas方法
上面巧妙的使用zip来计算各个数据之间的差值。由于_MIN_NORMALIZED_FRAME_LENGTH =0.5,所以要执行后续的语句，filter函数中，从deltas数组中取出元素除以refresh_period，判断杯除后的值是否大于0.5，这个函数作用过滤掉被除后小于0.5的值。那么我们最终返回的值就是这个数组deltas，以及数组中每个元素除以refresh_period后的生成的新的数组。然后回到_CalculateResults方法中，差值数组赋值给frame_lengths，新的数组赋值给normalized_frame_lengths。然后对frame_lengths的个数进行判断。然后我们再调用一次_GetNormalizedDeltas，这个时候传入的min_normalized_delta是空的，所以不会执行filter函数。直接求出frame_lengths数组中各个元素的差值保存到数组deltas中。然后再计算deltas的值与refresh_period比值，这是为了求jank(掉帧)。然后方法返回，将deltas值赋给length_changes，将比值赋给normalized_changes。
为了求出jank，我们需要求出normalized_changes数组中比0大的数。下面的代码就是求出jank_count代码块。
jankiness = [max(0, round(change)) for change in normalized_changes] pause_threshold = 20 jank_count = sum(1 for change in jankiness if change > 0 and change < pause_threshold)
jank_count初始值设为，然后遍历jankiness，求出大于0，小于20的数的个数。这个值就是jank的值，掉帧值。而fps的值是通过下面公式得到的：
int(round((frame_count - 1) / seconds))
这样我们就得到了fps和jank，然后fps-jank 就是我们要得到的数。
_CalculateBuckets
这个地方是帮助你去头去尾后的数据。
总结
当无法使用--latency--clear方法的时候，我们需要计算fps和jank的值，
fps的值计算公司变为int(round((frame_count-1)/ seconds))，
而且还可以得到吊帧的个数
感谢
testerhome_小A帮助我分析python相关源码
kasi前辈的补充
其他计算fps的方法
android开发中计算
百度经验
http://wuche.info/android-fps/