diff --git a/ipynb/examples/android/benchmarks/Android_UiBench.ipynb b/ipynb/examples/android/benchmarks/Android_UiBench.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f5f9355a2228833a8c684c79c261055154c7b46d --- /dev/null +++ b/ipynb/examples/android/benchmarks/Android_UiBench.ipynb @@ -0,0 +1,585 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# UiBench benchmark on Android\n", + "\n", + "This benchmark is used to evaluate the responsiveness of an Android system to user interaction. Also **systraces** are captured during the benchmark run and represented at the end of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-12-09 13:51:08,534 INFO : root : Using LISA logging configuration:\n", + "2016-12-09 13:51:08,534 INFO : root : /home/vagrant/lisa/logging.conf\n" + ] + } + ], + "source": [ + "import logging\n", + "\n", + "from conf import LisaLogging\n", + "LisaLogging.setup()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "\n", + "import json\n", + "import os\n", + "\n", + "# Support to access the remote target\n", + "import devlib\n", + "from env import TestEnv\n", + "\n", + "# Import support for Android devices\n", + "from android import Screen, Workload, System\n", + "\n", + "# Support for trace events analysis\n", + "from trace import Trace\n", + "#from trace_analysis import TraceAnalysis\n", + "\n", + "# Suport for FTrace events parsing and visualization\n", + "import trappy\n", + "\n", + "import pandas as pd\n", + "import sqlite3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Support Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This function helps us run our experiments:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def experiment():\n", + " # Unlock device screen (assume no password required)\n", + " target.execute('input keyevent 82')\n", + " \n", + " # Configure governor\n", + " target.cpufreq.set_all_governors('sched')\n", + " \n", + " # Configure screen to max brightness and no dimming\n", + " Screen.set_brightness(target, percent=100)\n", + " Screen.set_dim(target, auto=False)\n", + " Screen.set_timeout(target, 60*60*10) # 10 hours should be enought for an experiment\n", + " \n", + " wload = Workload(te).get(te, 'UiBench')\n", + " \n", + " # Start systrace\n", + " trace_file = os.path.join(te.res_dir, 'trace.html')\n", + " systrace_output = System.systrace_start(te, trace_file, 15)\n", + " \n", + " # UiBench\n", + " db_file, nrg_report = wload.run(te.res_dir, 'TrivialAnimation', duration_s=10, collect='systrace')\n", + "\n", + " if systrace_output:\n", + " logging.info('Waiting systrace report [%s]...', trace_file)\n", + " systrace_output.wait()\n", + " else:\n", + " logging.warning('Systrace is not running!')\n", + "\n", + " # Reset screen brightness and auto dimming\n", + " Screen.set_defaults(target)\n", + " \n", + " # Dump platform descriptor\n", + " te.platform_dump(te.res_dir)\n", + "\n", + " # return all the experiment data\n", + " return {\n", + " 'dir' : te.res_dir,\n", + " 'db_file' : db_file,\n", + " 'nrg_report' : nrg_report,\n", + " 'trace_file' : trace_file,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test environment setup\n", + "For more details on this please check out **examples/utils/testenv_example.ipynb**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**devlib** requires the ANDROID_HOME environment variable configured to point to your local installation of the Android SDK. If you have not this variable configured in the shell used to start the notebook server, you need to run a cell to define where your Android SDK is installed or specify the ANDROID_HOME in your target configuration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case more than one Android device are conencted to the host, you must specify the ID of the device you want to target in **my_target_conf**. Run **adb devices** on your host to get the ID." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Setup target configuration\n", + "my_conf = {\n", + "\n", + " # Target platform and board\n", + " \"platform\" : 'android',\n", + " \"board\" : 'pixel',\n", + " \n", + " # Device\n", + " \"device\" : \"HT6670300102\",\n", + " \n", + " # Android home\n", + " \"ANDROID_HOME\" : \"/home/vagrant/lisa/tools/android-sdk-linux\",\n", + "\n", + " # Folder where all the results will be collected\n", + " \"results_dir\" : \"UiBench_example\",\n", + "\n", + " # Define devlib modules to load\n", + " \"modules\" : [\n", + " 'cpufreq' # enable CPUFreq support\n", + " ],\n", + "\n", + " # FTrace events to collect for all the tests configuration which have\n", + " # the \"ftrace\" flag enabled\n", + " \"ftrace\" : {\n", + " \"events\" : [\n", + " \"sched_switch\",\n", + " \"sched_wakeup\",\n", + " \"sched_wakeup_new\",\n", + " \"sched_overutilized\",\n", + " \"sched_load_avg_cpu\",\n", + " \"sched_load_avg_task\",\n", + " \"cpu_capacity\",\n", + " \"cpu_frequency\",\n", + " ],\n", + " \"buffsize\" : 100 * 1024,\n", + " },\n", + "\n", + " # Tools required by the experiments\n", + " \"tools\" : [ 'trace-cmd', 'taskset'],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-12-09 13:51:26,134 INFO : TestEnv : Using base path: /home/vagrant/lisa\n", + "2016-12-09 13:51:26,134 INFO : TestEnv : Loading custom (inline) target configuration\n", + "2016-12-09 13:51:26,135 INFO : TestEnv : External tools using:\n", + "2016-12-09 13:51:26,135 INFO : TestEnv : ANDROID_HOME: /home/vagrant/lisa/tools/android-sdk-linux\n", + "2016-12-09 13:51:26,136 INFO : TestEnv : CATAPULT_HOME: /home/vagrant/lisa/tools/catapult\n", + "2016-12-09 13:51:26,136 INFO : TestEnv : Loading board:\n", + "2016-12-09 13:51:26,137 INFO : TestEnv : /home/vagrant/lisa/libs/utils/platforms/pixel.json\n", + "2016-12-09 13:51:26,138 INFO : TestEnv : Devlib modules to load: [u'bl', u'cpufreq']\n", + "2016-12-09 13:51:26,138 INFO : TestEnv : Connecting Android target [HT6670300102]\n", + "2016-12-09 13:51:26,138 INFO : TestEnv : Connection settings:\n", + "2016-12-09 13:51:26,139 INFO : TestEnv : {'device': 'HT6670300102'}\n", + "2016-12-09 13:51:26,305 INFO : android : ls command is set to ls -1\n", + "2016-12-09 13:51:27,623 INFO : TestEnv : Initializing target workdir:\n", + "2016-12-09 13:51:27,626 INFO : TestEnv : /data/local/tmp/devlib-target\n", + "2016-12-09 13:51:32,146 INFO : TestEnv : Topology:\n", + "2016-12-09 13:51:32,149 INFO : TestEnv : [[0, 1], [2, 3]]\n", + "2016-12-09 13:51:32,551 INFO : TestEnv : Loading default EM:\n", + "2016-12-09 13:51:32,554 INFO : TestEnv : /home/vagrant/lisa/libs/utils/platforms/pixel.json\n", + "2016-12-09 13:51:34,075 INFO : TestEnv : Enabled tracepoints:\n", + "2016-12-09 13:51:34,076 INFO : TestEnv : sched_switch\n", + "2016-12-09 13:51:34,077 INFO : TestEnv : sched_wakeup\n", + "2016-12-09 13:51:34,077 INFO : TestEnv : sched_wakeup_new\n", + "2016-12-09 13:51:34,078 INFO : TestEnv : sched_overutilized\n", + "2016-12-09 13:51:34,078 INFO : TestEnv : sched_load_avg_cpu\n", + "2016-12-09 13:51:34,078 INFO : TestEnv : sched_load_avg_task\n", + "2016-12-09 13:51:34,079 INFO : TestEnv : cpu_capacity\n", + "2016-12-09 13:51:34,079 INFO : TestEnv : cpu_frequency\n", + "2016-12-09 13:51:34,080 INFO : TestEnv : Set results folder to:\n", + "2016-12-09 13:51:34,080 INFO : TestEnv : /home/vagrant/lisa/results/UiBench_example\n", + "2016-12-09 13:51:34,080 INFO : TestEnv : Experiment results available also in:\n", + "2016-12-09 13:51:34,081 INFO : TestEnv : /home/vagrant/lisa/results_latest\n" + ] + } + ], + "source": [ + "# Initialize a test environment using:\n", + "te = TestEnv(my_conf, wipe=False)\n", + "target = te.target" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Workloads execution\n", + "\n", + "This is done using the **experiment** helper function defined above which is configured to run a **UiBench - TrivialAnimation** experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-12-09 13:52:24,254 INFO : Screen : Set brightness: 100%\n", + "2016-12-09 13:52:24,721 INFO : Screen : Dim screen mode: OFF\n", + "2016-12-09 13:52:25,261 INFO : Screen : Screen timeout: 36000 [s]\n", + "2016-12-09 13:52:26,884 INFO : Workload : Workloads available on target:\n", + "2016-12-09 13:52:26,887 INFO : Workload : ['YouTube', 'Jankbench', 'UiBench']\n", + "2016-12-09 13:52:26,888 INFO : Workload : Workloads available on target:\n", + "2016-12-09 13:52:26,890 INFO : Workload : ['YouTube', 'Jankbench', 'UiBench']\n", + "2016-12-09 13:52:26,891 INFO : System : SysTrace: /home/vagrant/lisa/tools/catapult/systrace/systrace/run_systrace.py -e HT6670300102 -o /home/vagrant/lisa/results/UiBench_example/trace.html gfx view sched freq idle -t 15\n", + "2016-12-09 13:52:30,694 INFO : Screen : Force manual orientation\n", + "2016-12-09 13:52:30,697 INFO : Screen : Set orientation: PORTRAIT\n", + "2016-12-09 13:52:33,085 INFO : UiBench : adb -s HT6670300102 logcat ActivityManager:* System.out:I *:S BENCH:*\n", + "2016-12-09 13:52:33,851 INFO : root : Benchmark [.TrivialAnimationActivity] started, waiting 10 [s]\n", + "2016-12-09 13:52:45,915 INFO : Screen : Set orientation: AUTO\n", + "2016-12-09 13:52:46,871 INFO : root : Waiting systrace report [/home/vagrant/lisa/results/UiBench_example/trace.html]...\n", + "2016-12-09 13:52:48,714 INFO : Screen : Set orientation: AUTO\n", + "2016-12-09 13:52:50,500 INFO : Screen : Set brightness: AUTO\n", + "2016-12-09 13:52:51,099 INFO : Screen : Dim screen mode: ON\n", + "2016-12-09 13:52:51,712 INFO : Screen : Screen timeout: 30 [s]\n" + ] + } + ], + "source": [ + "# Intialize Workloads for this test environment\n", + "results = experiment()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmarks results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stats since: 94537383291004ns\r\n", + "Total frames rendered: 625\r\n", + "Janky frames: 26 (4.16%)\r\n", + "50th percentile: 8ms\r\n", + "90th percentile: 13ms\r\n", + "95th percentile: 15ms\r\n", + "99th percentile: 26ms\r\n" + ] + } + ], + "source": [ + "# Benchmark statistics\n", + "!sed '/Stats since/,/99th/!d;/99th/q' {results['db_file']}\n", + "\n", + "# For all results:\n", + "# !cat {results['db_file']}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Traces visualisation\n", + "\n", + "For more information on this please check **examples/trace_analysis/TraceAnalysis_TasksLatencies.ipynb**." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-12-09 13:53:30,879 INFO : Trace : Parsing SysTrace format...\n", + "2016-12-09 13:53:35,029 INFO : Trace : Platform clusters verified to be Frequency coherent\n", + "2016-12-09 13:53:36,579 INFO : Trace : Collected events spans a 12.543 [s] time interval\n", + "2016-12-09 13:53:36,579 INFO : Trace : Set plots time range to (0.000000, 12.543107)[s]\n", + "2016-12-09 13:53:36,580 INFO : Analysis : Registering trace analysis modules:\n", + "2016-12-09 13:53:36,581 INFO : Analysis : tasks\n", + "2016-12-09 13:53:36,582 INFO : Analysis : status\n", + "2016-12-09 13:53:36,583 INFO : Analysis : frequency\n", + "2016-12-09 13:53:36,583 INFO : Analysis : cpus\n", + "2016-12-09 13:53:36,584 INFO : Analysis : latency\n", + "2016-12-09 13:53:36,585 INFO : Analysis : idle\n", + "2016-12-09 13:53:36,586 INFO : Analysis : functions\n", + "2016-12-09 13:53:36,586 INFO : Analysis : eas\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Parse all traces\n", + "platform_file = os.path.join(te.res_dir, 'platform.json')\n", + "with open(platform_file, 'r') as fh:\n", + " platform = json.load(fh)\n", + "trace_file = os.path.join(te.res_dir, 'trace.html')\n", + "trace = Trace(platform, trace_file, events=my_conf['ftrace']['events'])\n", + "\n", + "trappy.plotter.plot_trace(trace.ftrace)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-12-09 13:53:47,779 WARNING : Analysis : Event [sched_overutilized] not found, plot DISABLED!\n", + "2016-12-09 13:53:47,801 WARNING : Analysis : Event [sched_overutilized] not found, plot DISABLED!\n", + "2016-12-09 13:53:48,053 INFO : Analysis : LITTLE cluster average frequency: 0.672 GHz\n", + "2016-12-09 13:53:48,054 INFO : Analysis : big cluster average frequency: 0.892 GHz\n", + "2016-12-09 13:53:48,054 INFO : root : Plotting cluster frequencies for [sched]...\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSgAAALgCAYAAACXjZnfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "try:\n", + " trace.analysis.frequency.plotClusterFrequencies();\n", + " logging.info('Plotting cluster frequencies for [sched]...')\n", + "except: pass" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + }, + "toc": { + "toc_cell": false, + "toc_number_sections": true, + "toc_threshold": 6, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/libs/utils/android/workloads/uibench.py b/libs/utils/android/workloads/uibench.py new file mode 100644 index 0000000000000000000000000000000000000000..20cb6b210bcc2fe5edfb53ea09184b35077a9678 --- /dev/null +++ b/libs/utils/android/workloads/uibench.py @@ -0,0 +1,141 @@ +# SPDX-License-Identifier: Apache-2.0 +# +# Copyright (C) 2015, ARM Limited and contributors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import re +import os +import logging + +from subprocess import Popen, PIPE +from android import Screen, System, Workload +from time import sleep + + +class UiBench(Workload): + """ + Android UiBench workload + """ + + # Package required by this workload + package = 'com.android.test.uibench' + + # Supported activities list, obtained via: + # adb shell dumpsys package | grep -i uibench | grep Activity + test_BitmapUpload = 'BitmapUpload' + test_DialogList = 'DialogList' + test_EditTextType = 'EditTextType' + test_FullscreenOverdraw = 'FullscreenOverdraw' + test_GlTextureView = 'GlTextureView' + test_InflatingList = 'InflatingList' + test_Invalidate = 'Invalidate' + test_ShadowGrid = 'ShadowGrid' + test_TextCacheHighHitrate = 'TextCacheHighHitrate' + test_TextCacheLowHitrate = 'TextCacheLowHitrate' + test_Transition = 'Transition' + test_TransitionDetails = 'TransitionDetails' + test_TrivialAnimation = 'TrivialAnimation' + test_TrivialList = 'TrivialList' + test_TrivialRecyclerView = 'TrivialRecyclerView' + + def __init__(self, test_env): + super(UiBench, self).__init__(test_env) + self._log = logging.getLogger('UiBench') + self._log.debug('Workload created') + + def run(self, exp_dir, test_name, duration_s, collect=''): + activity = '.' + test_name + 'Activity' + + # Initialize energy meter results + nrg_report = None + + # Press Back button to be sure we run the video from the start + System.menu(self.target) + System.back(self.target) + + # Close and clear application + System.force_stop(self.target, self.package, clear=True) + + # Set airplane mode + System.set_airplane_mode(self.target, on=True) + + # Start the main view of the app which must be running + # to reset the frame statistics. + System.monkey(self.target, self.package) + + # Force screen in PORTRAIT mode + Screen.set_orientation(self.target, portrait=True) + + # Reset frame statistics + System.gfxinfo_reset(self.target, self.package) + sleep(1) + + # Clear logcat + os.system(self._adb('logcat -c')); + + # Regexps for benchmark synchronization + start_logline = r'ActivityManager: START.*'\ + 'cmp=com.android.test.uibench/{}'.format(activity) + UIBENCH_BENCHMARK_START_RE = re.compile(start_logline) + self._log.debug("START string [%s]", start_logline) + + # Parse logcat output lines + logcat_cmd = self._adb( + 'logcat ActivityManager:* System.out:I *:S BENCH:*'\ + .format(self.target.adb_name)) + self._log.info("%s", logcat_cmd) + + # Start the activity + System.start_activity(self.target, self.package, activity) + logcat = Popen(logcat_cmd, shell=True, stdout=PIPE) + while True: + + # read next logcat line (up to max 1024 chars) + message = logcat.stdout.readline(1024) + + # Benchmark start trigger + match = UIBENCH_BENCHMARK_START_RE.search(message) + if match: + if 'energy' in collect and self.te.emeter: + self.te.emeter.reset() + self._log.debug("Benchmark started!") + break + + # Run the workload for the required time + self._log.info('Benchmark [%s] started, waiting %d [s]', + activity, duration_s) + sleep(duration_s) + self._log.debug("Benchmark done!") + + if 'energy' in collect and self.te.emeter: + nrg_report = self.te.emeter.report(exp_dir) + + # Get frame stats + db_file = os.path.join(exp_dir, "framestats.txt") + System.gfxinfo_get(self.target, self.package, db_file) + + # Close and clear application + System.force_stop(self.target, self.package, clear=True) + + # Go back to home screen + System.home(self.target) + + # Switch back to original settings + Screen.set_orientation(self.target, auto=True) + System.set_airplane_mode(self.target, on=False) + + return db_file, nrg_report + +# vim :set tabstop=4 shiftwidth=4 expandtab