From 785108f3dd1a1088ae6b691bc2c1d6e4122db8cb Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Thu, 22 Sep 2016 19:36:34 +0100 Subject: [PATCH 01/20] android/workloads: do not clean the YouTube data folder In case multiple accounts are enabled on the target device, by cleaning the data folder, YouTube ask to select which account to use at every new start of the workload. Let's keep the account pre-configured in the target device. Signed-off-by: Patrick Bellasi --- libs/utils/android/workloads/youtube.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libs/utils/android/workloads/youtube.py b/libs/utils/android/workloads/youtube.py index 998f10cff..142bef49b 100644 --- a/libs/utils/android/workloads/youtube.py +++ b/libs/utils/android/workloads/youtube.py @@ -83,8 +83,11 @@ class YouTube(Workload): db_file = os.path.join(exp_dir, "framestats.txt") System.gfxinfo_get(self.target, self.package, db_file) - System.force_stop(self.target, self.package, clear=True) + # Close the app without clearing the local data to + # avoid the dialog to select the account at next start + System.force_stop(self.target, self.package, clear=False) + # Go back to home screen System.home(self.target) # Switch back to screen auto rotation -- GitLab From 14268c75672ef9b6152c6ce304ac5e29bb3e8e8a Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 21 Sep 2016 16:23:29 +0100 Subject: [PATCH 02/20] utils/env: add support for ANDROID_HOME and CATAPULT_HOME These environment variables are required by devlib and some notebooks to properly access and trace an Android device. This path add the required support to verify that these env variables are defined when an Android target is in use as well as the required support to override these variables via the target configuration. Signed-off-by: Patrick Bellasi --- libs/utils/env.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/libs/utils/env.py b/libs/utils/env.py index 348284655..3f2bbc8fa 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -117,6 +117,12 @@ class TestEnv(ShareState): # The platform descriptor to be saved into the results folder self.platform = {} + # Keep track of android support + self.LISA_HOME = os.environ.get('LISA_HOME', '/vagrant') + self.ANDROID_HOME = os.environ.get('ANDROID_HOME', None) + self.CATAPULT_HOME = os.environ.get('CATAPULT_HOME', + os.path.join(self.LISA_HOME, 'tools', 'catapult')) + # Compute base installation path logging.info('%14s - Using base path: %s', 'Target', basepath) @@ -331,6 +337,30 @@ class TestEnv(ShareState): except KeyError: raise ValueError('Config error: missing [platform] parameter') + if platform_type.lower() == 'android': + self.ANDROID_HOME = self.conf.get('ANDROID_HOME', + self.ANDROID_HOME) + if self.ANDROID_HOME: + self._adb = os.path.join(self.ANDROID_HOME, + 'platform-tools', 'adb') + self._fastboot = os.path.join(self.ANDROID_HOME, + 'platform-tools', 'fastboot') + os.environ['ANDROID_HOME'] = self.ANDROID_HOME + os.environ['CATAPULT_HOME'] = self.CATAPULT_HOME + else: + raise RuntimeError('Android SDK not found, ANDROID_HOME must be defined!') + + logging.info(r'%14s - External tools using:', 'Target') + logging.info(r'%14s - ANDROID_HOME: %s', 'Target', + self.ANDROID_HOME) + logging.info(r'%14s - CATAPULT_HOME: %s', 'Target', + self.CATAPULT_HOME) + + if not os.path.exists(self._adb): + raise RuntimeError('\nADB binary not found\n\t{}\ndoes not exists!\n\n' + 'Please configure ANDROID_HOME to point to ' + 'a valid Android SDK installation folder.'\ + .format(self._adb)) ######################################################################## # Board configuration -- GitLab From aa4eb8d7800bcf987975008f3e7724334b9fccb9 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Thu, 22 Sep 2016 12:14:27 +0100 Subject: [PATCH 03/20] android: add new method to start the main VIEW of an APK Signed-off-by: Patrick Bellasi --- libs/utils/android/system.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/libs/utils/android/system.py b/libs/utils/android/system.py index 77e58e12c..7529cf680 100644 --- a/libs/utils/android/system.py +++ b/libs/utils/android/system.py @@ -40,6 +40,17 @@ class System(object): '--ez state {}'\ .format(ap_state)) + @staticmethod + def start_app(target, apk_name): + """ + Start the main activity of the specified application + + :param apk_name: name of the apk + :type apk_name: str + """ + target.execute('monkey -p {} -c android.intent.category.LAUNCHER 1'\ + .format(apk_name)) + @staticmethod def start_activity(target, apk_name, activity_name): """ -- GitLab From 32f8e27641e10fba208a5cc862a378c75a7eddcf Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Tue, 27 Sep 2016 22:54:16 +0100 Subject: [PATCH 04/20] android: add methods to get APKs and Info for a given app name Signed-off-by: Patrick Bellasi --- libs/utils/android/system.py | 51 ++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/libs/utils/android/system.py b/libs/utils/android/system.py index 7529cf680..4de65761f 100644 --- a/libs/utils/android/system.py +++ b/libs/utils/android/system.py @@ -269,4 +269,55 @@ class System(object): """ target.execute('monkey -p {} {}'.format(apk_name, event_count)) + @staticmethod + def list_packages(target, apk_filter=''): + """ + List the packages matching the specified filter + + :param target: instance of devlib Android target + :type target: devlib.target.AndroidTarget + + :param apk_filter: a substring which must be part of the package name + :type apk_filter: str + """ + packages = [] + + pkgs = target.execute('cmd package list packages {}'\ + .format(apk_filter.lower())) + for pkg in pkgs.splitlines(): + packages.append(pkg.replace('package:', '')) + packages.sort() + + if len(packages): + return packages + return None + + @staticmethod + def packages_info(target, apk_filter=''): + """ + Get a dictionary of installed APKs and related information + + :param target: instance of devlib Android target + :type target: devlib.target.AndroidTarget + + :param apk_filter: a substring which must be part of the package name + :type apk_filter: str + """ + packages = {} + + pkgs = target.execute('cmd package list packages {}'\ + .format(apk_filter.lower())) + for pkg in pkgs.splitlines(): + pkg = pkg.replace('package:', '') + # Lookup for additional APK information + apk = target.execute('pm path {}'.format(pkg)) + apk = apk.replace('package:', '') + packages[pkg] = { + 'apk' : apk.strip() + } + + if len(packages): + return packages + return None + # vim :set tabstop=4 shiftwidth=4 expandtab -- GitLab From 5aaebe77cca68d419631f24e286a00b2d208c279 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Thu, 22 Sep 2016 19:33:05 +0100 Subject: [PATCH 05/20] android: never fail on airlplane mode setup Setting Airplane mode could requires special permissions on non rooted devices. This patch ensure that this command is executed as root and, in case of failures, it just reports a warning to the user. Signed-off-by: Patrick Bellasi --- libs/utils/android/system.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/libs/utils/android/system.py b/libs/utils/android/system.py index 4de65761f..2268a4f91 100644 --- a/libs/utils/android/system.py +++ b/libs/utils/android/system.py @@ -17,6 +17,7 @@ import logging from devlib.utils.android import adb_command +from devlib import TargetError GET_FRAMESTATS_CMD = 'shell dumpsys gfxinfo {} > {}' @@ -33,12 +34,15 @@ class System(object): ap_mode = 1 if on else 0 ap_state = 'true' if on else 'false' - target.execute('settings put global airplane_mode_on {}'\ - .format(ap_mode)) - target.execute('am broadcast '\ - '-a android.intent.action.AIRPLANE_MODE '\ - '--ez state {}'\ - .format(ap_state)) + try: + target.execute('settings put global airplane_mode_on {}'\ + .format(ap_mode), as_root=True) + target.execute('am broadcast '\ + '-a android.intent.action.AIRPLANE_MODE '\ + '--ez state {}'\ + .format(ap_state), as_root=True) + except TargetError: + target.logger.warning("Failed to toggle airplane mode, permission denied.") @staticmethod def start_app(target, apk_name): -- GitLab From f1cff8311dc7612a18a69c0a9a80a8c8af8333a2 Mon Sep 17 00:00:00 2001 From: Javi Merino Date: Fri, 26 Aug 2016 17:13:05 +0100 Subject: [PATCH 06/20] tests/eas/capacity_capping: Add a capacity capping test Add a simple test to verify that if the maximum frequency of the big cpus is reduced, busy threads are moved from the bigs to the littles. When the maximum frequency is allowed to go back to the absolute maximum, check that the threads are migrated back to bigs. --- tests/eas/capacity_capping.config | 15 +++ tests/eas/capacity_capping.py | 215 ++++++++++++++++++++++++++++++ 2 files changed, 230 insertions(+) create mode 100644 tests/eas/capacity_capping.config create mode 100644 tests/eas/capacity_capping.py diff --git a/tests/eas/capacity_capping.config b/tests/eas/capacity_capping.config new file mode 100644 index 000000000..d2515deb6 --- /dev/null +++ b/tests/eas/capacity_capping.config @@ -0,0 +1,15 @@ +{ + "BIG_DCYCLE": 100, + "WORKLOAD_DURATION_S": 9, + "WORKLOAD_PERIOD_MS": 100, + "MIGRATION_WINDOW": 0.75, + "EXPECTED_BUSY_TIME_PCT": 99, + "TEST_CONF": { + "modules": ["bl", "cpufreq"], + "tools": ["rt-app"], + "ftrace" : { + "events" : ["sched_switch"], + "buffsize" : 10240 + } + } +} diff --git a/tests/eas/capacity_capping.py b/tests/eas/capacity_capping.py new file mode 100644 index 000000000..040151a05 --- /dev/null +++ b/tests/eas/capacity_capping.py @@ -0,0 +1,215 @@ +# SPDX-License-Identifier: Apache-2.0 +# +# Copyright (C) 2016, 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. +# + +from bart.sched.SchedMultiAssert import SchedMultiAssert +from env import TestEnv +import json +import logging +import time +import trappy +import unittest +import os +from wlgen import Periodic, RTA + +# Configure logging to print something while the test runs +reload(logging) +logging.basicConfig(level=logging.INFO) + +# Read the config file and update the globals +CONF_FILE = os.path.join( + os.path.dirname( + os.path.abspath(__file__)), + "capacity_capping.config") + +with open(CONF_FILE, "r") as fh: + CONF_VARS = json.load(fh) + globals().update(CONF_VARS) + +class CapacityCappingTest(unittest.TestCase): + """ + Goal + ==== + + Verify that dynamic CPU capacity capping works in the system. + + Detailed Description + ==================== + + The maximum frequency of a core can be restricted to a lower value + than its absolute maximum frequency. This may happen because of + thermal management or as a request from userspace via sysfs. + Dynamic CPU capacity capping provides PELT and the scheduler CPU + capacity management with a maximum frequency scaling corrector + which describes the influence of running a CPU with a current + maximum frequency lower than the absolute maximum frequency. + + The test creates as many busy threads as there are big cpus. + These busy threads have high load and should run in the CPUs with + highest capacity. The test has three phases of equal length. In + the first phase, the system runs unconstrained. In the second + phase, the maximum frequency of the big cpus is limited to the + lowest frequency that the big frequency domain can run at. + Finally, in the third phase, the maximum frequency of the big cpus + is restored to its absolute maximum, i.e. the system is + unconstrained again. + + This test assumes that the lowest OPPs of the big cpus have less + capacity than the highest OPP of the little cpus. If that is not + the case, this test will fail. Arguably, capacity capping is not + needed in such a system. + + Expected Behaviour + ================== + + The threads have high load, so they should always run in the CPUs + with the highest capacity of the system. In the first phase the + system is unconstrained, so they should run on the big CPUs. In + the second phase, the big cluster's maximum frequency is limited + and the little CPUs have higher capacity. Therefore, in the + second phase of the test, the threads should migrate to the little + cpus. In the third phase the maximum frequency of the big cpus is + restored, so they become again the CPUs with the higest capacity + in the system. The busy threads must run on the big cpus in the + third phase. + + """ + + @classmethod + def setUpClass(cls): + cls.params = {} + cls.env = TestEnv(test_conf=TEST_CONF) + cls.trace_file = os.path.join(cls.env.res_dir, "cap_cap.dat") + cls.populate_params() + + cls.run_workload() + + trace = trappy.FTrace(cls.trace_file) + cls.sa = SchedMultiAssert(trace, cls.env.topology, + execnames=cls.params.keys()) + + @classmethod + def populate_params(cls): + for idx in range(len(cls.env.target.bl.bigs)): + task_name = "busy_thread{}".format(idx) + cls.params[task_name] = Periodic( + duty_cycle_pct=BIG_DCYCLE, + duration_s=WORKLOAD_DURATION_S, + period_ms=WORKLOAD_PERIOD_MS, + ).get() + + @classmethod + def run_workload(cls): + big_cpu = cls.env.target.bl.bigs[0] + big_cpufreq = "/sys/devices/system/cpu/cpu{}/cpufreq".format(big_cpu) + max_freq_path = os.path.join(big_cpufreq, "scaling_max_freq") + available_freqs_path = os.path.join(big_cpufreq, + "scaling_available_frequencies") + + available_freqs_str = cls.env.target.read_value(available_freqs_path) + available_freqs = available_freqs_str.split() + min_frequency = available_freqs[0] + max_frequency = available_freqs[-1] + + wload = RTA(cls.env.target, "busy_threads", + calibration=cls.env.calibration()) + wload.conf(kind="profile", params=cls.params) + phase_duration = WORKLOAD_DURATION_S / 3. + + cls.env.ftrace.start() + + wload.run(out_dir=cls.env.res_dir, background=True) + time.sleep(phase_duration) + + cls.env.target.write_value(max_freq_path, min_frequency) + time.sleep(phase_duration) + + cls.env.target.write_value(max_freq_path, max_frequency) + time.sleep(phase_duration) + + cls.env.ftrace.stop() + cls.env.ftrace.get_trace(cls.trace_file) + + def check_residencies(self, cpus, cpus_name, window, phase_description): + """Helper function to check the residencies of all busy threads on a + given set of cpus for a period of time.""" + + residency_dict = self.sa.getResidency("cluster", cpus, window=window, + percent=True) + + for pid, task_res in residency_dict.iteritems(): + msg = "Pid {} ran in {} cpus only {:.2f}% percent of the time when the system was {} (expected {:.2f}%)" \ + .format(pid, cpus_name, task_res["residency"], + phase_description, EXPECTED_BUSY_TIME_PCT) + + self.assertGreater(task_res["residency"], EXPECTED_BUSY_TIME_PCT, + msg) + + def test_tasks_starts_on_big(self): + """All busy threads run in the beginning in big cpus""" + + phase_duration = WORKLOAD_DURATION_S / 3. + unconstrained_window = (0, phase_duration) + self.check_residencies(self.env.target.bl.bigs, "big", + unconstrained_window, "unconstrained") + + def test_task_migrates_to_little_when_constrained(self): + """Busy threads migrate to little in the thermally constrained phase""" + + phase_duration = WORKLOAD_DURATION_S / 3. + migration_window = (phase_duration, phase_duration + MIGRATION_WINDOW) + num_tasks = len(self.params) + + msg = "One or more of the busy threads didn't migrate to a little cpu between {} and {}" \ + .format(migration_window[0], migration_window[1]) + self.assertTrue(self.sa.assertSwitch("cluster", self.env.target.bl.bigs, + self.env.target.bl.littles, + window=migration_window, + rank=num_tasks), + msg=msg) + + # The tasks must have migrated by the end of the + # migration_window and they should not move until the end of + # the phase. + constrained_window = (migration_window[1], 2 * phase_duration) + self.check_residencies(self.env.target.bl.littles, "little", + constrained_window, "thermally constrained") + + def test_task_returns_to_big_when_back_to_unconstrained(self): + """Busy threads return to big when system goes back to unconstrained + + In the last phase, when the frequency capping is released, busy threads + return to the big cpus""" + + phase_duration = WORKLOAD_DURATION_S / 3. + migration_window = (2 * phase_duration, + 2 * phase_duration + MIGRATION_WINDOW) + num_tasks = len(self.params) + + msg = "One of the busy threads didn't return to a big cpu" + self.assertTrue(self.sa.assertSwitch("cluster", + self.env.target.bl.littles, + self.env.target.bl.bigs, + window=migration_window, + rank=num_tasks), + msg=msg) + + # The tasks must have migrated by the end of the + # migration_window and they should continue to run on bigs + # until the end of the run. + last_phase = (migration_window[1], WORKLOAD_DURATION_S) + self.check_residencies(self.env.target.bl.bigs, "big", + last_phase, "unconstrained") -- GitLab From e6be697b92641476df52a168931df2e58dc58bac Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Mon, 3 Oct 2016 11:31:29 +0100 Subject: [PATCH 07/20] tests/eas/acceptance: Reduce expected LITTLE busy time for offload test Where the 'migrator' tasks in the OffloadMigrationAndIdlePull are initially placed on the same CPU, the busy time of the LITTLE CPUs that are exercised can be below 99% during the period where big CPUs are occupied. This shouldn't be considered a failure. In my experiments 97% appeared to be a low enough value to prevent these failures. In fact I observed no failures with the value at 98% either, but it seems wise to allow a little margin for error. --- tests/eas/acceptance.config | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/eas/acceptance.config b/tests/eas/acceptance.config index e5c2e1b08..620307bf5 100644 --- a/tests/eas/acceptance.config +++ b/tests/eas/acceptance.config @@ -9,7 +9,7 @@ "STEP_HIGH_DCYCLE" : 50, "EXPECTED_RESIDENCY_PCT" : 85, "OFFLOAD_MIGRATION_MIGRATOR_DELAY": 1, - "OFFLOAD_EXPECTED_BUSY_TIME_PCT": 99, + "OFFLOAD_EXPECTED_BUSY_TIME_PCT": 97, "SET_IS_BIG_LITTLE": true, "TEST_CONF" : { "modules" : [ "bl", "cpufreq" ], -- GitLab From 5097288cb483da6dc20546fa8034f68c0d70ebf2 Mon Sep 17 00:00:00 2001 From: Javi Merino Date: Thu, 29 Sep 2016 17:06:59 +0100 Subject: [PATCH 08/20] test/eas/acceptance: documentation fixes Some minor documentation fixes xoming from the EAS 1.1 integration guide. --- tests/eas/acceptance.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/tests/eas/acceptance.py b/tests/eas/acceptance.py index c8c80f8ed..3fc65a9ed 100644 --- a/tests/eas/acceptance.py +++ b/tests/eas/acceptance.py @@ -201,7 +201,7 @@ class SmallTaskPacking(unittest.TestCase): ==================== The tests spawns as many tasks as there are cpus in the system. - The tasks are small, so none of them should be run on big cpus, + The tasks are small, so none of them should be run on big cpus and the scheduler should pack them on little cpus. Expected Behaviour @@ -322,12 +322,17 @@ class OffloadMigrationAndIdlePull(unittest.TestCase): That is why this test doesn't test for migrations of the migrator tasks to the bigs when we expect that the early starters have - finished. Instead, it tests that the big cpus were fully loaded - as long as there are tasks left to run in the system; that the - little cpus run tasks while the bigs are busy (offload migration); - that all tasks get a chance on a big cpu (either because they - started there or because of idle pull); and that all tasks are - finished off in a big cpu. + finished. Instead, it tests that: + + * The big cpus were fully loaded as long as there are tasks left + to run in the system + + * The little cpus run tasks while the bigs are busy (offload migration) + + * All tasks get a chance on a big cpu (either because they + started there or because of idle pull) + + * All tasks are finished off in a big cpu. """ @@ -537,7 +542,8 @@ class WakeMigration(unittest.TestCase): Goal ==== - A task that switches between being big and small moves to big and little cores accordingly + A task that switches between being high and low utilization moves + to big and little cores accordingly Detailed Description ==================== -- GitLab From 98c2e9d78b6e39bdad20d1eba575b26233574dc8 Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Thu, 6 Oct 2016 11:44:23 +0100 Subject: [PATCH 09/20] submodules: Update devlib to cae239d1 and trappy to 5.9.0 --- libs/devlib | 2 +- libs/trappy | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/devlib b/libs/devlib index 08b36e71c..cae239d1d 160000 --- a/libs/devlib +++ b/libs/devlib @@ -1 +1 @@ -Subproject commit 08b36e71cbb6b58e40e8f13abd84bf1ba14911df +Subproject commit cae239d1dc1d379c3acdec081583a56bf5392313 diff --git a/libs/trappy b/libs/trappy index fa7d75c4d..d7565ebcd 160000 --- a/libs/trappy +++ b/libs/trappy @@ -1 +1 @@ -Subproject commit fa7d75c4d74c4ad640f7acd1bdbe980ad058f5cc +Subproject commit d7565ebcd0c4d4a01bf8aa8db522405c6ee2a190 -- GitLab From 2098e032bff7a8f2298248a0134dcd687b619b86 Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Mon, 3 Oct 2016 16:11:43 +0100 Subject: [PATCH 10/20] libs/wlgen/rta: Limit task name to 15 characters rt-app uses pthread_setname_np(3) to set the names of tasks on the target [1]. This interface limits thread name length to 16 characters including the null '\0'. Although rt-app prints a message on the target, the workload execution goes ahead when the provided task names are too long, and the tasks are named "rt-app". This means they are not found when later examining the trace. Therefore, raise an exception on the host to prevent this situation arising. [1] https://github.com/scheduler-tools/rt-app/blob/dcaf5a04aa63b69d8b5e174d10a9e459f88772cf/src/rt-app.c#L152 --- libs/wlgen/wlgen/rta.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/libs/wlgen/wlgen/rta.py b/libs/wlgen/wlgen/rta.py index 1b792ffe9..65535ebf7 100644 --- a/libs/wlgen/wlgen/rta.py +++ b/libs/wlgen/wlgen/rta.py @@ -495,6 +495,14 @@ class RTA(Workload): """ + for task in params.keys(): + if len(task) > 15: + # rt-app uses pthread_setname_np(3) which limits the task name + # to 16 characters including the terminal '\0'. + msg = ('Task name "{}" too long, please configure your tasks ' + 'with names shorter than 16 characters').format(task) + raise ValueError(msg) + if not sched: sched = {'policy' : 'OTHER'} -- GitLab From edfc75a4fd2edc10baaedd499ab33f5a5d392d53 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Wed, 28 Sep 2016 17:50:04 +0000 Subject: [PATCH 11/20] android/workloads: remove hard-coded energy report --- libs/utils/android/workloads/jankbench.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/libs/utils/android/workloads/jankbench.py b/libs/utils/android/workloads/jankbench.py index e545fbabe..b510ae838 100644 --- a/libs/utils/android/workloads/jankbench.py +++ b/libs/utils/android/workloads/jankbench.py @@ -129,8 +129,6 @@ class Jankbench(Workload): if match: if 'energy' in collect and self.te.emeter: nrg_report = self.te.emeter.report(exp_dir) - self.logger.info("Estimated energy: %7.3f", - float(nrg_report.channels['BAT'])) self.logger.debug("Benchmark done!") break -- GitLab From dde159d9fe7effc1154f052329b6917b6a55460f Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Sat, 8 Oct 2016 00:49:47 +0100 Subject: [PATCH 12/20] ipynb: fix bug in android workload notebook wload is a Jankbench notebook not a dictionary. Let's use 10 seconds systrace for each iteration instead. --- ipynb/android/Android_Workloads.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ipynb/android/Android_Workloads.ipynb b/ipynb/android/Android_Workloads.ipynb index d57bde61a..2b99359d3 100644 --- a/ipynb/android/Android_Workloads.ipynb +++ b/ipynb/android/Android_Workloads.ipynb @@ -354,7 +354,7 @@ " elif 'systrace' in collect:\n", " # Start systrace\n", " trace_file = os.path.join(exp_dir, 'trace.html')\n", - " trace_cmd = SYSTRACE_CMD.format(DEVICE, trace_file, wload['duration'] * iterations)\n", + " trace_cmd = SYSTRACE_CMD.format(DEVICE, trace_file, 10 * iterations)\n", " logging.info('SysTrace: %s', trace_cmd)\n", " systrace_output = pe.spawn(trace_cmd)\n", " \n", -- GitLab From 663a3274ea4d5c690b4b522e23d0239aa93ade07 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Sat, 8 Oct 2016 18:17:12 +0000 Subject: [PATCH 13/20] libs/utils/env: add default platform file for Hikey board Signed-off-by: Michele Di Giorgio --- libs/utils/platforms/hikey.json | 42 +++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 libs/utils/platforms/hikey.json diff --git a/libs/utils/platforms/hikey.json b/libs/utils/platforms/hikey.json new file mode 100644 index 000000000..8fb444f19 --- /dev/null +++ b/libs/utils/platforms/hikey.json @@ -0,0 +1,42 @@ +{ + // HiKey boards have two SMP clusters + // Even being an SMP platform, being a two cluster system + // we can still load the devlib's bl module to get access + // to all the per-cluster functions it exposes + "board" : { + "cores" : [ + "A53_0", "A53_0", "A53_0", "A53_0", + "A53_1", "A53_1", "A53_1", "A53_1" + ], + "big_core" : "A53_1", + "modules" : [ "bl", "cpufreq" ] + }, + + // Energy Model related functions requires cluster + // to be named "big.LITTLE". Thus, for the time being, + // let's use this naming also for HiKey. This is going + // to be updated once we introduce proper SMP and + // multi-cluster support. + "nrg_model": { + "little": { + "cluster": { + "nrg_max": 112 + }, + "cpu": { + "nrg_max": 670, "cap_max": 1024 + } + }, + "big": { + "cluster": { + "nrg_max": 112 + }, + "cpu": { + "nrg_max": 670, + "cap_max": 1024 + } + } + } + +} + +// vim: set tabstop=4: -- GitLab From 6542cd0145b31416872646dd11c22d42fc05f002 Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Thu, 13 Oct 2016 17:39:19 +0100 Subject: [PATCH 14/20] libs/utils/executor: Require root when setting sched_features --- libs/utils/executor.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libs/utils/executor.py b/libs/utils/executor.py index e946d96dc..6d06e785e 100644 --- a/libs/utils/executor.py +++ b/libs/utils/executor.py @@ -185,7 +185,8 @@ class Executor(): for feat in feats: logging.info('%14s - Set scheduler feature: %s', 'SchedFeatures', feat) - self.target.execute('echo {} > /sys/kernel/debug/sched_features'.format(feat)) + self.target.execute('echo {} > /sys/kernel/debug/sched_features'.format(feat), + as_root=True) def _setup_rootfs(self, tc): # Initialize CGroups if required -- GitLab From b44bc5b9b67b83823e84482831acc988eea31b4c Mon Sep 17 00:00:00 2001 From: Chris Redpath Date: Fri, 14 Oct 2016 14:20:38 +0100 Subject: [PATCH 15/20] Add a scratchpad folder for your own notebooks which will be ignored This is somewhere to put your own notebooks that you don't want to pollute the git repo with, in order to reduce the stash/checkout/unstash dances needed. Signed-off-by: Chris Redpath --- ipynb/scratchpad/.gitignore | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 ipynb/scratchpad/.gitignore diff --git a/ipynb/scratchpad/.gitignore b/ipynb/scratchpad/.gitignore new file mode 100644 index 000000000..5e7d2734c --- /dev/null +++ b/ipynb/scratchpad/.gitignore @@ -0,0 +1,4 @@ +# Ignore everything in this directory +* +# Except this file +!.gitignore -- GitLab From edcd27ef1536b3e3fd11d0c731c5960560f3df0e Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Tue, 18 Oct 2016 11:31:10 +0100 Subject: [PATCH 16/20] Vagrantfile: Bail out of provisioning if anything fails If something fails to install in the provisioning script, the script currently continues, burying the error in the log. `set -e` means the shell exits with an error if any command fails. --- Vagrantfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Vagrantfile b/Vagrantfile index 86c95ac34..f45c0110a 100644 --- a/Vagrantfile +++ b/Vagrantfile @@ -14,6 +14,8 @@ Vagrant.configure(2) do |config| config.vm.network "forwarded_port", guest: 8888, host: 8888 config.vm.provision "shell", inline: <<-SHELL + set -e + sudo apt-get update sudo apt-get install -y autoconf automake build-essential expect git \ libfreetype6-dev libpng12-dev libtool nmap openjdk-7-jdk \ -- GitLab From 74a2bdac408b0e8f1325e9fe1ad03273200c9cda Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Tue, 18 Oct 2016 11:38:58 +0100 Subject: [PATCH 17/20] Vagrantfile: Explicitly install Cython before pandas Pandas 1.19 requires Cython but it is not automatically installed by Pip. --- Vagrantfile | 1 + 1 file changed, 1 insertion(+) diff --git a/Vagrantfile b/Vagrantfile index f45c0110a..eef54b793 100644 --- a/Vagrantfile +++ b/Vagrantfile @@ -22,6 +22,7 @@ Vagrant.configure(2) do |config| openjdk-7-jre pkg-config python-all-dev python-matplotlib \ python-nose python-numpy python-pip python-zmq sshpass trace-cmd \ tree wget + pip install Cython sudo pip install ipython[notebook] pandas psutil wrapt sudo apt-get remove -y w3m -- GitLab From 3f4fa0892cb8d7fbd7e11b54b14cac8ad2ac4cdc Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Wed, 26 Oct 2016 18:39:44 +0100 Subject: [PATCH 18/20] libs/utils/env: Explicitly check 'host' setting is present for Linux For Linux targets you need a 'host' parameter to set up the SSH connection. If it's missing, the error appears at the end of a deep dark call stack. Add an explicit check before constructing the LinuxTarget so it's more obvious what you did wrong when this param is missing. --- libs/utils/env.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libs/utils/env.py b/libs/utils/env.py index 3f2bbc8fa..3d76cd872 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -462,6 +462,9 @@ class TestEnv(ShareState): if platform_type.lower() == 'linux': logging.debug('%14s - Setup LINUX target...', 'Target') + if "host" not in self.__connection_settings: + raise ValueError('Missing "host" param in Linux target conf') + self.target = devlib.LinuxTarget( platform = platform, connection_settings = self.__connection_settings, -- GitLab From 261bae0185f5a94a818274a36f3d78a4e15bb589 Mon Sep 17 00:00:00 2001 From: Brendan Jackman Date: Mon, 24 Oct 2016 12:22:57 +0100 Subject: [PATCH 19/20] lisa_shall: Improve lisa-test documentation - Add some examples and explanation to the usage string. - Rename variables and pseudo-variables to clarify meaning --- src/shell/lisa_shell | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/shell/lisa_shell b/src/shell/lisa_shell index 33755bbd6..0847d5957 100755 --- a/src/shell/lisa_shell +++ b/src/shell/lisa_shell @@ -250,13 +250,23 @@ echo function _lisa-test-usage { cat < Date: Fri, 23 Sep 2016 19:04:00 +0100 Subject: [PATCH 20/20] ipynb/releases: APIs changes for v16.10 Here is a notebook to summarize the main features added by this new release of the Linux Integrated System Analysis toolkit. Signed-off-by: Patrick Bellasi --- ipynb/releases/ReleaseNotes_v16.10.ipynb | 2511 ++++++++++++++++++++++ 1 file changed, 2511 insertions(+) create mode 100644 ipynb/releases/ReleaseNotes_v16.10.ipynb diff --git a/ipynb/releases/ReleaseNotes_v16.10.ipynb b/ipynb/releases/ReleaseNotes_v16.10.ipynb new file mode 100644 index 000000000..18914e223 --- /dev/null +++ b/ipynb/releases/ReleaseNotes_v16.10.ipynb @@ -0,0 +1,2511 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [], + "source": [ + "import logging\n", + "reload(logging)\n", + "log_fmt = '%(asctime)-9s %(levelname)-8s: %(message)s'\n", + "logging.basicConfig(format=log_fmt)\n", + "\n", + "# Change to info once the notebook runs ok\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Generate plots inline\n", + "%matplotlib inline\n", + "\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Target Connectivity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Board specific settings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Boards specific settings can be collected into a JSON\n", + "platform description file:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 32\r\n", + "drwxrwxr-x 2 derkling derkling 4096 Sep 23 12:12 .\r\n", + "drwxrwxr-x 5 derkling derkling 4096 Sep 23 15:58 ..\r\n", + "-rw------- 1 derkling derkling 896 Sep 23 12:12 hikey.json\r\n", + "-rw-rw-r-- 1 derkling derkling 468 Jan 22 2016 juno.json\r\n", + "-rw-rw-r-- 1 derkling derkling 427 Aug 24 12:52 marlin.json\r\n", + "-rw-rw-r-- 1 derkling derkling 176 Aug 31 12:18 nexus5x.json\r\n", + "-rw-rw-r-- 1 derkling derkling 473 Feb 2 2016 oak.json\r\n", + "-rw-rw-r-- 1 derkling derkling 473 Jan 22 2016 tc2.json\r\n" + ] + } + ], + "source": [ + "!ls -la $LISA_HOME/libs/utils/platforms/" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\r\n", + "\t// HiKey boards have two SMP clusters\r\n", + "\t// Even being an SMP platform, being a two cluster system\r\n", + "\t// we can still load the devlib's bl module to get access\r\n", + "\t// to all the per-cluster functions it exposes\r\n", + "\t\"board\" : {\r\n", + "\t\t\"cores\" : [\r\n", + "\t\t\t\"A53_0\", \"A53_0\", \"A53_0\", \"A53_0\",\r\n", + "\t\t\t\"A53_1\", \"A53_1\", \"A53_1\", \"A53_1\"\r\n", + "\t\t],\r\n", + "\t\t\"big_core\" : \"A53_1\",\r\n", + "\t\t\"modules\" : [ \"bl\", \"cpufreq\" ]\r\n", + "\t},\r\n", + "\r\n", + "\t// Energy Model related functions requires cluster\r\n", + "\t// to be named \"big.LITTLE\". Thus, for the time being,\r\n", + "\t// let's use this naming also for HiKey. This is going\r\n", + "\t// to be updated once we introduce proper SMP and\r\n", + "\t// multi-cluster support.\r\n", + "\t\"nrg_model\": {\r\n", + "\t\t\"little\": {\r\n", + "\t\t\t\"cluster\": {\r\n", + "\t\t\t\t\"nrg_max\": 112\r\n", + "\t\t\t},\r\n", + "\t\t\t\"cpu\": {\r\n", + "\t\t\t\t\"nrg_max\": 670, \"cap_max\": 1024\r\n", + "\t\t\t}\r\n", + "\t\t},\r\n", + "\t\t\"big\": {\r\n", + "\t\t\t\"cluster\": {\r\n", + "\t\t\t\t\"nrg_max\": 112\r\n", + "\t\t\t},\r\n", + "\t\t\t\"cpu\": {\r\n", + "\t\t\t\t\"nrg_max\": 670,\r\n", + "\t\t\t\t\"cap_max\": 1024\r\n", + "\t\t\t}\r\n", + "\t\t}\r\n", + "\t}\r\n", + "\r\n", + "}\r\n", + "\r\n", + "// vim: set tabstop=4:\r\n" + ] + } + ], + "source": [ + "!cat $LISA_HOME/libs/utils/platforms/hikey.json" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single configuration dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "List of devices attached\r\n", + "00b43d0b08a8a4b8\tdevice\r\n", + "607A87C400055E6E\tdevice\r\n", + "\r\n" + ] + } + ], + "source": [ + "# Check which Android devices are available\n", + "!adb devices" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true, + "run_control": { + "marked": false + } + }, + "outputs": [], + "source": [ + "ADB_DEVICE = '00b43d0b08a8a4b8'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Unified configuration dictionary\n", + "my_conf = {\n", + "\n", + " # Target platform\n", + " \"platform\" : 'android',\n", + "\n", + " # Location of external tools (adb, fastboot, systrace, etc)\n", + " # These properties can be used to override the environment variables:\n", + " # ANDROID_HOME and CATAPULT_HOME\n", + " \"ANDROID_HOME\" : \"/opt/android-sdk-linux\",\n", + " \"CATAPULT_HOME\" : \"/home/derkling/Code/catapult\",\n", + "\n", + " # Boards specific settings can be collected into a JSON\n", + " # platform description file, to be placed under:\n", + " # LISA_HOME/libs/utils/platforms\n", + " \"board\" : 'hikey',\n", + " \n", + " # If you have multiple Android device connected, here\n", + " # we can specify which one to target\n", + " \"device\" : ADB_DEVICE,\n", + "\n", + " # Folder where all the results will be collected\n", + " \"results_dir\" : \"ReleaseNotes_v16.09\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:26:53,404 INFO : Target - Using base path: /home/derkling/Code/lisa\n", + "2016-09-23 18:26:53,404 INFO : Target - Loading custom (inline) target configuration\n", + "2016-09-23 18:26:53,404 INFO : Target - External tools using:\n", + "2016-09-23 18:26:53,405 INFO : Target - ANDROID_HOME: /opt/android-sdk-linux\n", + "2016-09-23 18:26:53,405 INFO : Target - CATAPULT_HOME: /home/derkling/Code/lisa/tools/catapult\n", + "2016-09-23 18:26:53,405 INFO : Platform - Loading board:\n", + "2016-09-23 18:26:53,405 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:26:53,406 INFO : Target - Devlib modules to load: [u'bl', u'cpufreq']\n", + "2016-09-23 18:26:53,406 INFO : Target - Connecting Android target [607A87C400055E6E]\n", + "2016-09-23 18:26:53,406 INFO : Target - Connection settings:\n", + "2016-09-23 18:26:53,406 INFO : Target - {'device': '607A87C400055E6E'}\n", + "2016-09-23 18:26:53,951 INFO : Target - Initializing target workdir:\n", + "2016-09-23 18:26:53,952 INFO : Target - /data/local/tmp/devlib-target\n", + "2016-09-23 18:26:54,746 INFO : Target - Topology:\n", + "2016-09-23 18:26:54,747 INFO : Target - [[0, 1, 2, 3], [4, 5, 6, 7]]\n", + "2016-09-23 18:26:54,946 INFO : Platform - Loading default EM:\n", + "2016-09-23 18:26:54,946 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:26:54,947 WARNING : TestEnv - Wipe previous contents of the results folder:\n", + "2016-09-23 18:26:54,947 WARNING : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:26:54,960 INFO : AEP - AEP configuration\n", + "2016-09-23 18:26:54,960 INFO : AEP - {'instrument': 'aep', 'channel_map': {'LITTLE': 'LITTLE'}, 'conf': {'resistor_values': [0.033], 'device_entry': '/dev/ttyACM0'}}\n", + "2016-09-23 18:26:54,967 INFO : AEP - Channels selected for energy sampling:\n", + "[CHAN(LITTLE_current), CHAN(LITTLE_power), CHAN(LITTLE_voltage)]\n", + "2016-09-23 18:26:54,967 INFO : TestEnv - Set results folder to:\n", + "2016-09-23 18:26:54,968 INFO : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:26:54,968 INFO : TestEnv - Experiment results available also in:\n", + "2016-09-23 18:26:54,968 INFO : TestEnv - /home/derkling/Code/lisa/results_latest\n" + ] + } + ], + "source": [ + "from env import TestEnv\n", + "\n", + "te = TestEnv(my_conf, force_new=True)\n", + "target = te.target" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Energy Meters Support" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Simple unified interface for multiple acquisition board\n", + " - exposes two simple methods: **reset()** and **report()**\n", + " - reporting **energy** consumptions\n", + " - reports additional info supported by the specific probe,
\n", + " e.g. collected samples, stats on current and voltages, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from time import sleep\n", + "\n", + "def sample_energy(energy_meter, time_s):\n", + " \n", + " # Reset the configured energy counters\n", + " energy_meter.reset()\n", + "\n", + " # Run the workload you want to measure\n", + " #\n", + " # In this simple example we just wait some time while the\n", + " # energy counters accumulate power samples\n", + " sleep(time_s)\n", + "\n", + " # Read and report the measured energy (since last reset)\n", + " return energy_meter.report(te.res_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Channels mapping support\n", + " - allows to give a custom name to each channel used" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ARM Energy Probe (AEP)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Requirements:\n", + "1. the **caimin binary tool** must be availabe in PATH
\n", + " https://github.com/ARM-software/lisa/wiki/Energy-Meters-Requirements#arm-energy-probe-aep\n", + "2. the **ttyACMx device** created once you plug in the AEP device" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crw-rw---- 1 root dialout 166, 1 Sep 23 18:28 /dev/ttyACM1\r\n" + ] + } + ], + "source": [ + "!ls -la /dev/ttyACM*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ACM_DEVICE = '/dev/ttyACM1'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Direct usage" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:28:22,422 INFO : AEP - AEP configuration\n", + "2016-09-23 18:28:22,422 INFO : AEP - {'channel_map': {'BAT': 'CH0'}, 'conf': {'resistor_values': [0.01], 'device_entry': '/dev/ttyACM1'}}\n", + "2016-09-23 18:28:22,472 INFO : AEP - Channels selected for energy sampling:\n", + "[CHAN(BAT_current), CHAN(BAT_power), CHAN(BAT_voltage)]\n" + ] + } + ], + "source": [ + "# Energy Meters Configuration for ARM Energy Probe\n", + "aep_conf = {\n", + " 'conf' : {\n", + " # Value of the shunt resistor [Ohm] for each channel\n", + " 'resistor_values' : [0.010],\n", + " # Device entry assigned to the probe on the host\n", + " 'device_entry' : ACM_DEVICE,\n", + " },\n", + " 'channel_map' : {\n", + " 'BAT' : 'CH0'\n", + " }\n", + "}\n", + "\n", + "from energy import AEP\n", + "ape_em = AEP(target, aep_conf, '/tmp')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EnergyReport(channels={'BAT': 0.00341733929419313}, report_file='/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/energy.json')\n" + ] + } + ], + "source": [ + "nrg_report = sample_energy(ape_em, 2)\n", + "print nrg_report" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\r\n", + " \"BAT\": 0.00341733929419313\r\n", + "}" + ] + } + ], + "source": [ + "!cat $nrg_report.report_file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Usage via TestEnv" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "my_conf = {\n", + "\n", + " # Configure the energy meter to use\n", + " \"emeter\" : {\n", + " \n", + " # Require usage of an AEP meter\n", + " \"instrument\" : \"aep\",\n", + " \n", + " # Configuration parameters require by the AEP device\n", + " \"conf\" : {\n", + " # Value of the shunt resistor in Ohm\n", + " 'resistor_values' : [0.099],\n", + " # Device entry assigned to the probe on the host\n", + " 'device_entry' : ACM_DEVICE,\n", + " },\n", + " \n", + " # Map AEP's channels to logical names (used to generate reports)\n", + " 'channel_map' : {\n", + " 'BAT' : 'CH0'\n", + " }\n", + " },\n", + "\n", + " # Other target configurations\n", + " \"platform\" : 'android',\n", + " \"board\" : 'hikey',\n", + " \"device\" : ADB_DEVICE,\n", + " \"results_dir\" : \"ReleaseNotes_v16.09\",\n", + " \"ANDROID_HOME\" : \"/opt/android-sdk-linux\",\n", + " \"CATAPULT_HOME\" : \"/home/derkling/Code/catapult\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:53:00,113 INFO : Target - Using base path: /home/derkling/Code/lisa\n", + "2016-09-23 18:53:00,113 INFO : Target - Loading custom (inline) target configuration\n", + "2016-09-23 18:53:00,113 INFO : Target - External tools using:\n", + "2016-09-23 18:53:00,114 INFO : Target - ANDROID_HOME: /opt/android-sdk-linux\n", + "2016-09-23 18:53:00,114 INFO : Target - CATAPULT_HOME: /home/derkling/Code/lisa/tools/catapult\n", + "2016-09-23 18:53:00,114 INFO : Platform - Loading board:\n", + "2016-09-23 18:53:00,115 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:53:00,116 INFO : Target - Devlib modules to load: [u'bl', u'cpufreq']\n", + "2016-09-23 18:53:00,116 INFO : Target - Connecting Android target [00b43d0b08a8a4b8]\n", + "2016-09-23 18:53:00,117 INFO : Target - Connection settings:\n", + "2016-09-23 18:53:00,118 INFO : Target - {'device': '00b43d0b08a8a4b8'}\n", + "2016-09-23 18:53:00,352 INFO : Target - Initializing target workdir:\n", + "2016-09-23 18:53:00,353 INFO : Target - /data/local/tmp/devlib-target\n", + "2016-09-23 18:53:01,166 INFO : Target - Topology:\n", + "2016-09-23 18:53:01,166 INFO : Target - [[0, 1, 2, 3], [4, 5, 6, 7]]\n", + "2016-09-23 18:53:01,275 INFO : Platform - Loading default EM:\n", + "2016-09-23 18:53:01,276 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:53:01,277 WARNING : TestEnv - Wipe previous contents of the results folder:\n", + "2016-09-23 18:53:01,277 WARNING : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:53:01,278 INFO : AEP - AEP configuration\n", + "2016-09-23 18:53:01,278 INFO : AEP - {'instrument': 'aep', 'channel_map': {'BAT': 'CH0'}, 'conf': {'resistor_values': [0.099], 'device_entry': '/dev/ttyACM1'}}\n", + "2016-09-23 18:53:01,283 INFO : AEP - Channels selected for energy sampling:\n", + "[CHAN(BAT_current), CHAN(BAT_power), CHAN(BAT_voltage)]\n", + "2016-09-23 18:53:01,284 INFO : TestEnv - Set results folder to:\n", + "2016-09-23 18:53:01,284 INFO : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:53:01,284 INFO : TestEnv - Experiment results available also in:\n", + "2016-09-23 18:53:01,284 INFO : TestEnv - /home/derkling/Code/lisa/results_latest\n" + ] + } + ], + "source": [ + "from env import TestEnv\n", + "\n", + "te = TestEnv(my_conf, force_new=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "for i in xrange(1,11):\n", + " nrg_report = sample_energy(te.emeter, 1)\n", + " nrg_bat = float(nrg_report.channels['BAT'])\n", + " print \"Sample {:2d}: {:.3f}\".format(i, nrg_bat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BayLibre's ACME board (ACME)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Requirements:\n", + "1. the **iio-capture tool** must be available in PATH
\n", + " https://github.com/ARM-software/lisa/wiki/Energy-Meters-Requirements#iiocapture---baylibre-acme-cape\n", + "2. the ACME CAPE should be reacable by network" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64 bytes from 192.168.0.1: icmp_seq=1 ttl=64 time=1.60 ms\r\n" + ] + } + ], + "source": [ + "!ping -c1 baylibre-acme.local | grep '64 bytes'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Direct usage" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:49:31,422 INFO : ACME - ACME configuration:\n", + "2016-09-23 18:49:31,422 INFO : ACME - binary: iio-capture\n", + "2016-09-23 18:49:31,422 INFO : ACME - device: baylibre-acme.local\n", + "2016-09-23 18:49:31,423 INFO : ACME - channels:\n", + "2016-09-23 18:49:31,423 INFO : ACME - Device1 (iio:device1)\n", + "2016-09-23 18:49:31,423 INFO : ACME - Device0 (iio:device0)\n" + ] + } + ], + "source": [ + "# Energy Meters Configuration for BayLibre's ACME\n", + "acme_conf = {\n", + " \"conf\" : {\n", + " #'iio-capture' : '/usr/bin/iio-capture',\n", + " #'ip_address' : 'baylibre-acme.local',\n", + " },\n", + " \"channel_map\" : {\n", + " \"Device0\" : 0,\n", + " \"Device1\" : 1,\n", + " },\n", + "}\n", + "\n", + "from energy import ACME\n", + "acme_em = ACME(target, acme_conf, '/tmp')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EnergyReport(channels={'Device1': 654.82, 'Device0': 0.0}, report_file='/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/energy.json')\n" + ] + } + ], + "source": [ + "nrg_report = sample_energy(acme_em, 2)\n", + "print nrg_report" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\r\n", + " \"Device0\": 0.0, \r\n", + " \"Device1\": 654.82\r\n", + "}" + ] + } + ], + "source": [ + "!cat $nrg_report.report_file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Usage via TestEnv" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [], + "source": [ + "my_conf = {\n", + "\n", + " # Configure the energy meter to use\n", + " \"emeter\" : {\n", + " \n", + " # Require usage of an AEP meter\n", + " \"instrument\" : \"acme\",\n", + " \n", + " \"conf\" : {\n", + " #'iio-capture' : '/usr/bin/iio-capture',\n", + " #'ip_address' : 'baylibre-acme.local',\n", + " },\n", + " 'channel_map' : {\n", + " 'Device0' : 0,\n", + " 'Device1' : 1,\n", + " },\n", + " },\n", + "\n", + " # Other target configurations\n", + " \"platform\" : 'android',\n", + " \"board\" : 'hikey',\n", + " \"device\" : ADB_DEVICE,\n", + " \"results_dir\" : \"ReleaseNotes_v16.09\",\n", + " \"ANDROID_HOME\" : \"/opt/android-sdk-linux\",\n", + " \"CATAPULT_HOME\" : \"/home/derkling/Code/catapult\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:54:37,835 INFO : Target - Using base path: /home/derkling/Code/lisa\n", + "2016-09-23 18:54:37,835 INFO : Target - Loading custom (inline) target configuration\n", + "2016-09-23 18:54:37,836 INFO : Target - External tools using:\n", + "2016-09-23 18:54:37,836 INFO : Target - ANDROID_HOME: /opt/android-sdk-linux\n", + "2016-09-23 18:54:37,836 INFO : Target - CATAPULT_HOME: /home/derkling/Code/lisa/tools/catapult\n", + "2016-09-23 18:54:37,837 INFO : Platform - Loading board:\n", + "2016-09-23 18:54:37,837 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:54:37,838 INFO : Target - Devlib modules to load: [u'bl', u'cpufreq']\n", + "2016-09-23 18:54:37,838 INFO : Target - Connecting Android target [00b43d0b08a8a4b8]\n", + "2016-09-23 18:54:37,839 INFO : Target - Connection settings:\n", + "2016-09-23 18:54:37,839 INFO : Target - {'device': '00b43d0b08a8a4b8'}\n", + "2016-09-23 18:54:38,177 INFO : Target - Initializing target workdir:\n", + "2016-09-23 18:54:38,177 INFO : Target - /data/local/tmp/devlib-target\n", + "2016-09-23 18:54:39,025 INFO : Target - Topology:\n", + "2016-09-23 18:54:39,026 INFO : Target - [[0, 1, 2, 3], [4, 5, 6, 7]]\n", + "2016-09-23 18:54:39,134 INFO : Platform - Loading default EM:\n", + "2016-09-23 18:54:39,135 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:54:39,135 WARNING : TestEnv - Wipe previous contents of the results folder:\n", + "2016-09-23 18:54:39,135 WARNING : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:54:39,136 INFO : ACME - ACME configuration:\n", + "2016-09-23 18:54:39,136 INFO : ACME - binary: iio-capture\n", + "2016-09-23 18:54:39,136 INFO : ACME - device: baylibre-acme.local\n", + "2016-09-23 18:54:39,137 INFO : ACME - channels:\n", + "2016-09-23 18:54:39,137 INFO : ACME - Device1 (iio:device1)\n", + "2016-09-23 18:54:39,137 INFO : ACME - Device0 (iio:device0)\n", + "2016-09-23 18:54:39,142 INFO : TestEnv - Set results folder to:\n", + "2016-09-23 18:54:39,142 INFO : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:54:39,143 INFO : TestEnv - Experiment results available also in:\n", + "2016-09-23 18:54:39,143 INFO : TestEnv - /home/derkling/Code/lisa/results_latest\n" + ] + } + ], + "source": [ + "from env import TestEnv\n", + "\n", + "te = TestEnv(my_conf, force_new=True)\n", + "target = te.target" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample 1: 342.110\n", + "Sample 2: 325.660\n", + "Sample 3: 324.120\n", + "Sample 4: 369.300\n", + "Sample 5: 331.140\n", + "Sample 6: 315.130\n", + "Sample 7: 326.100\n", + "Sample 8: 345.180\n", + "Sample 9: 328.730\n", + "Sample 10: 328.510\n" + ] + } + ], + "source": [ + "for i in xrange(1,11):\n", + " nrg_report = sample_energy(te.emeter, 1)\n", + " nrg_bat = float(nrg_report.channels['Device1'])\n", + " print \"Sample {:2d}: {:.3f}\".format(i, nrg_bat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Android Integration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A new Android library has been added which provides APIs to:\n", + " - simplify the interaction with a device\n", + " - execute interesting workloads and benchmarks\n", + " - make it easy the integration of new workloads and benchmarks\n", + " \n", + "Not intended to replace WA, but instead to provide a Python based
\n", + "programming interface to **automate reproducible experiments** on
\n", + "and Android device." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## System control APIs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Supported functions:\n", + " back\n", + " force_stop\n", + " gfxinfo_get\n", + " gfxinfo_reset\n", + " home\n", + " hswipe\n", + " list_packages\n", + " menu\n", + " monkey\n", + " packages_info\n", + " set_airplane_mode\n", + " start_action\n", + " start_activity\n", + " start_app\n", + " tap\n", + " vswipe\n" + ] + } + ], + "source": [ + "from android import System\n", + "\n", + "print \"Supported functions:\"\n", + "for f in dir(System):\n", + " if \"__\" in f:\n", + " continue\n", + " print \" \", f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Capturing main useful actions, for example:\n", + " - ensure we set AIRPLAIN_MODE before measuring scheduler energy\n", + " - provide simple support for input actions (relative swipes)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Example (use tab to complete)\n", + "System." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "System.menu(target)\n", + "System.back(target)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "youtube_apk = System.list_packages(target, 'YouTube')\n", + "if youtube_apk:\n", + " System.start_app(target, youtube_apk[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Screen control APIs" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Supported functions:\n", + " set_brightness\n", + " set_defaults\n", + " set_dim\n", + " set_orientation\n", + " set_timeout\n" + ] + } + ], + "source": [ + "from android import Screen\n", + "\n", + "print \"Supported functions:\"\n", + "for f in dir(Screen):\n", + " if \"__\" in f:\n", + " continue\n", + " print \" \", f" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Example (use TAB to complete)\n", + "Screen." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:55:19,490 INFO : Set brightness: 100%\n" + ] + } + ], + "source": [ + "Screen.set_brightness(target, auto=False, percent=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:55:19,494 INFO : Force manual orientation\n", + "2016-09-23 18:55:19,494 INFO : Set orientation: LANDSCAPE\n" + ] + } + ], + "source": [ + "Screen.set_orientation(target, auto=False, portrait=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Workloads Execution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A simple workload class allows to easily add a wrapper for the exection\n", + "of a specific Android application.\n", + "\n", + "**NOTE:** To keep things simple, LISA does not provide APKs installation support.\n", + "\n", + "*All the exposes APIs assume that the required packages are already installed
\n", + "in the target. Whenever a package is missing, LISA reports that and it's up
\n", + "to the user to install it before using it.*\n", + "\n", + "A wrapper class usually requires to specify:\n", + "- a package name
\n", + " which will be used to verify if the APK is available in the target\n", + "- a run method
\n", + " which usually exploits the other Android APIs to defined a **reproducible\n", + " exection** of the specified workload\n", + " \n", + "A reproducible experiment should take care of:\n", + "- setups wirelesse **connections status**\n", + "- setup **screen orientation and backlight** level\n", + "- properly collect **energy measurements** across the sensible part of the experiment\n", + "- possibly collect **frames statistics** whenever available" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example of YouTube integration" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Here is an example wrapper which allows to play a YouTube
\n", + "video for a specified number of seconds:\n", + "\n", + "https://github.com/ARM-software/lisa/blob/master/libs/utils/android/workloads/youtube.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example usage of the Workload API" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:55:25,384 WARNING : Workload - Package [com.android.benchmark] not installed\n", + "2016-09-23 18:55:25,385 WARNING : Workload - Workload [Jankbench] disabled\n", + "2016-09-23 18:55:25,385 INFO : Workload - Workloads available on target:\n", + "2016-09-23 18:55:25,385 INFO : Workload - ['YouTube', 'UiBench']\n" + ] + }, + { + "data": { + "text/plain": [ + "['YouTube', 'UiBench']" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from android import Workload\n", + "\n", + "# Get the list of available workloads\n", + "wloads = Workload(te)\n", + "wloads.availables(target)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:55:58,229 INFO : Workload - Workloads available on target:\n", + "2016-09-23 18:55:58,230 INFO : Workload - ['YouTube', 'UiBench']\n", + "2016-09-23 18:56:00,090 INFO : Force manual orientation\n", + "2016-09-23 18:56:00,091 INFO : Set orientation: LANDSCAPE\n", + "2016-09-23 18:56:05,068 INFO : Play video for 16 [s]\n", + "2016-09-23 18:56:27,121 INFO : Set orientation: AUTO\n" + ] + } + ], + "source": [ + "yt = Workload.get(te, name='YouTube')\n", + "\n", + "# Playback big bug bunny for 15s starting from 1:20s\n", + "video_id = 'XSGBVzeBUbk'\n", + "video_url = \"https://youtu.be/{}?t={}s\".format(video_id, 80)\n", + "\n", + "# Play video and measure energy consumption\n", + "results = yt.run(te.res_dir,\n", + " video_url, video_duration_s=16,\n", + " collect='energy')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/framestats.txt',\n", + " EnergyReport(channels={'Device1': 4363.82, 'Device0': 0.0}, report_file='/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/energy.json'))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applications Graphics Acceleration Info:\r\n", + "Uptime: 135646296 Realtime: 248599085\r\n", + "\r\n", + "** Graphics info for pid 23414 [com.google.android.youtube] **\r\n", + "\r\n", + "Stats since: 135590611534135ns\r\n", + "Total frames rendered: 342\r\n", + "Janky frames: 59 (17.25%)\r\n", + "50th percentile: 8ms\r\n", + "90th percentile: 21ms\r\n", + "95th percentile: 40ms\r\n", + "99th percentile: 125ms\r\n", + "Number Missed Vsync: 21\r\n", + "Number High input latency: 0\r\n", + "Number Slow UI thread: 27\r\n", + "Number Slow bitmap uploads: 2\r\n", + "Number Slow issue draw commands: 28\r\n", + "HISTOGRAM: 5ms=70 6ms=32 7ms=35 8ms=38 9ms=31 10ms=21 11ms=21 12ms=14 13ms=10 14ms=7 15ms=3 16ms=4 17ms=3 18ms=3 19ms=7 20ms=4 21ms=7 22ms=0 23ms=3 24ms=1 25ms=2 26ms=2 27ms=1 28ms=0 29ms=2 30ms=0 31ms=0 32ms=0 34ms=2 36ms=0 38ms=0 40ms=2 42ms=0 44ms=0 46ms=2 48ms=1 53ms=2 57ms=2 61ms=0 65ms=1 69ms=0 73ms=0 77ms=2 81ms=0 85ms=2 89ms=0 93ms=0 97ms=0 101ms=0 105ms=0 109ms=0 113ms=0 117ms=0 121ms=1 125ms=1 129ms=0 133ms=0 150ms=2 200ms=0 250ms=1 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0 650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0 1050ms=0 1100ms=0 1150ms=0 1200ms=0 1250ms=0 1300ms=0 1350ms=0 1400ms=0 1450ms=0 1500ms=0 1550ms=0 1600ms=0 1650ms=0 1700ms=0 1750ms=0 1800ms=0 1850ms=0 1900ms=0 1950ms=0 2000ms=0 2050ms=0 2100ms=0 2150ms=0 2200ms=0 2250ms=0 2300ms=0 2350ms=0 2400ms=0 2450ms=0 2500ms=0 2550ms=0 2600ms=0 2650ms=0 2700ms=0 2750ms=0 2800ms=0 2850ms=0 2900ms=0 2950ms=0 3000ms=0 3050ms=0 3100ms=0 3150ms=0 3200ms=0 3250ms=0 3300ms=0 3350ms=0 3400ms=0 3450ms=0 3500ms=0 3550ms=0 3600ms=0 3650ms=0 3700ms=0 3750ms=0 3800ms=0 3850ms=0 3900ms=0 3950ms=0 4000ms=0 4050ms=0 4100ms=0 4150ms=0 4200ms=0 4250ms=0 4300ms=0 4350ms=0 4400ms=0 4450ms=0 4500ms=0 4550ms=0 4600ms=0 4650ms=0 4700ms=0 4750ms=0 4800ms=0 4850ms=0 4900ms=0 4950ms=0\r\n", + "\r\n", + "Caches:\r\n", + "Current memory usage / total memory usage (bytes):\r\n", + " TextureCache 3484348 / 58720256\r\n", + " LayerCache 0 / 33554432 (numLayers = 0)\r\n", + " Layers total 0 (numLayers = 0)\r\n", + " RenderBufferCache 0 / 8388608\r\n", + " GradientCache 16384 / 1048576\r\n", + " PathCache 0 / 16777216\r\n", + " TessellationCache 2232 / 1048576\r\n", + " TextDropShadowCache 0 / 6291456\r\n", + " PatchCache 64 / 131072\r\n", + " FontRenderer A8 1048576 / 1048576\r\n", + " FontRenderer RGBA 0 / 0\r\n", + " FontRenderer total 1048576 / 1048576\r\n", + "Other:\r\n", + " FboCache 0 / 0\r\n", + "Total memory usage:\r\n", + " 4551604 bytes, 4.34 MB\r\n", + "\r\n", + "\r\n", + "Pipeline=FrameBuilder\r\n", + "Profile data in ms:\r\n", + "\r\n", + "\tcom.google.android.youtube/com.google.android.apps.youtube.app.WatchWhileActivity/android.view.ViewRootImpl@74c8306 (visibility=0)\r\n", + "View hierarchy:\r\n", + "\r\n", + " com.google.android.youtube/com.google.android.apps.youtube.app.WatchWhileActivity/android.view.ViewRootImpl@74c8306\r\n", + " 275 views, 271.73 kB of display lists\r\n", + "\r\n", + "\r\n", + "Total ViewRootImpl: 1\r\n", + "Total Views: 275\r\n", + "Total DisplayList: 271.73 kB\r\n", + "\r\n" + ] + } + ], + "source": [ + "framestats = results[0]\n", + "!cat $framestats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmarks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Android benchmarks can be integrated as standalone Notebook, like for example\n", + "what we provide for PCMark:\n", + " https://github.com/ARM-software/lisa/blob/master/ipynb/android/benchmarks/Android_PCMark.ipynb\n", + "\n", + "Alternatively we are adding other benchmarks as predefined Android workloads." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### UiBench support" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is an example of UiBench workload which can run a specified number\n", + "of tests:\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:56:28,488 INFO : Workload - Workloads available on target:\n", + "2016-09-23 18:56:28,489 INFO : Workload - ['YouTube', 'UiBench']\n", + "2016-09-23 18:56:30,765 WARNING : Failed to toggle airplane mode, permission denied.\n", + "2016-09-23 18:56:31,460 INFO : Force manual orientation\n", + "2016-09-23 18:56:31,461 INFO : Set orientation: PORTRAIT\n", + "2016-09-23 18:56:33,738 INFO : adb -s 00b43d0b08a8a4b8 logcat ActivityManager:* System.out:I *:S BENCH:*\n", + "2016-09-23 18:56:35,453 INFO : Benchmark [.GlTextureViewActivity] started, waiting 5 [s]\n", + "2016-09-23 18:56:46,364 INFO : Set orientation: AUTO\n" + ] + } + ], + "source": [ + "from android import Workload\n", + "\n", + "ui = Workload.get(te, name='UiBench')\n", + "\n", + "# Play video and measure energy consumption\n", + "results = ui.run(te.res_dir,\n", + " ui.test_GlTextureView,\n", + " duration_s=5,\n", + " collect='energy')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/framestats.txt',\n", + " EnergyReport(channels={'Device1': 1479.17, 'Device0': 0.0}, report_file='/home/derkling/Code/lisa/results/ReleaseNotes_v16.09/energy.json'))" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applications Graphics Acceleration Info:\r\n", + "Uptime: 135665445 Realtime: 248618234\r\n", + "\r\n", + "** Graphics info for pid 23836 [com.android.test.uibench] **\r\n", + "\r\n", + "Stats since: 135653517039151ns\r\n", + "Total frames rendered: 620\r\n", + "Janky frames: 580 (93.55%)\r\n", + "50th percentile: 19ms\r\n", + "90th percentile: 21ms\r\n", + "95th percentile: 22ms\r\n", + "99th percentile: 26ms\r\n", + "Number Missed Vsync: 2\r\n", + "Number High input latency: 0\r\n", + "Number Slow UI thread: 3\r\n", + "Number Slow bitmap uploads: 1\r\n", + "Number Slow issue draw commands: 574\r\n", + "HISTOGRAM: 5ms=11 6ms=2 7ms=3 8ms=1 9ms=4 10ms=2 11ms=1 12ms=1 13ms=3 14ms=3 15ms=5 16ms=8 17ms=45 18ms=109 19ms=192 20ms=147 21ms=49 22ms=14 23ms=8 24ms=3 25ms=1 26ms=3 27ms=0 28ms=1 29ms=2 30ms=1 31ms=0 32ms=0 34ms=0 36ms=0 38ms=0 40ms=0 42ms=0 44ms=0 46ms=0 48ms=1 53ms=0 57ms=0 61ms=0 65ms=0 69ms=0 73ms=0 77ms=0 81ms=0 85ms=0 89ms=0 93ms=0 97ms=0 101ms=0 105ms=0 109ms=0 113ms=0 117ms=0 121ms=0 125ms=0 129ms=0 133ms=0 150ms=0 200ms=0 250ms=0 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0 650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0 1050ms=0 1100ms=0 1150ms=0 1200ms=0 1250ms=0 1300ms=0 1350ms=0 1400ms=0 1450ms=0 1500ms=0 1550ms=0 1600ms=0 1650ms=0 1700ms=0 1750ms=0 1800ms=0 1850ms=0 1900ms=0 1950ms=0 2000ms=0 2050ms=0 2100ms=0 2150ms=0 2200ms=0 2250ms=0 2300ms=0 2350ms=0 2400ms=0 2450ms=0 2500ms=0 2550ms=0 2600ms=0 2650ms=0 2700ms=0 2750ms=0 2800ms=0 2850ms=0 2900ms=0 2950ms=0 3000ms=0 3050ms=0 3100ms=0 3150ms=0 3200ms=0 3250ms=0 3300ms=0 3350ms=0 3400ms=0 3450ms=0 3500ms=0 3550ms=0 3600ms=0 3650ms=0 3700ms=0 3750ms=0 3800ms=0 3850ms=0 3900ms=0 3950ms=0 4000ms=0 4050ms=0 4100ms=0 4150ms=0 4200ms=0 4250ms=0 4300ms=0 4350ms=0 4400ms=0 4450ms=0 4500ms=0 4550ms=0 4600ms=0 4650ms=0 4700ms=0 4750ms=0 4800ms=0 4850ms=0 4900ms=0 4950ms=0\r\n", + "\r\n", + "Caches:\r\n", + "Current memory usage / total memory usage (bytes):\r\n", + " TextureCache 0 / 58720256\r\n", + " LayerCache 0 / 33554432 (numLayers = 0)\r\n", + " Layer size 1080x1584; isTextureLayer()=1; texid=4 fbo=0; refs=1\r\n", + " Layers total 6842880 (numLayers = 1)\r\n", + " RenderBufferCache 0 / 8388608\r\n", + " GradientCache 0 / 1048576\r\n", + " PathCache 0 / 16777216\r\n", + " TessellationCache 0 / 1048576\r\n", + " TextDropShadowCache 0 / 6291456\r\n", + " PatchCache 0 / 131072\r\n", + " FontRenderer A8 1048576 / 1048576\r\n", + " FontRenderer RGBA 0 / 0\r\n", + " FontRenderer total 1048576 / 1048576\r\n", + "Other:\r\n", + " FboCache 0 / 0\r\n", + "Total memory usage:\r\n", + " 7891456 bytes, 7.53 MB\r\n", + "\r\n", + "\r\n", + "Pipeline=FrameBuilder\r\n", + "Profile data in ms:\r\n", + "\r\n", + "\tcom.android.test.uibench/com.android.test.uibench.MainActivity/android.view.ViewRootImpl@abf726f (visibility=8)\r\n", + "\tcom.android.test.uibench/com.android.test.uibench.GlTextureViewActivity/android.view.ViewRootImpl@31bc075 (visibility=0)\r\n", + "View hierarchy:\r\n", + "\r\n", + " com.android.test.uibench/com.android.test.uibench.MainActivity/android.view.ViewRootImpl@abf726f\r\n", + " 24 views, 23.25 kB of display lists\r\n", + "\r\n", + " com.android.test.uibench/com.android.test.uibench.GlTextureViewActivity/android.view.ViewRootImpl@31bc075\r\n", + " 14 views, 17.86 kB of display lists\r\n", + "\r\n", + "\r\n", + "Total ViewRootImpl: 2\r\n", + "Total Views: 38\r\n", + "Total DisplayList: 41.11 kB\r\n", + "\r\n" + ] + } + ], + "source": [ + "framestats = results[0]\n", + "!cat $framestats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Improved Trace Analysis support" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Trace module is a wrapper around the TRAPpy library which has been\n", + "updated to:\n", + "\n", + "- support parsing of **systrace** file format
\n", + " requires catapult locally installed
\n", + " https://github.com/catapult-project/catapult\n", + "- parsing and DataFrame generation for **custom events**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create an example trace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**NOTE:** the cells in this sections are required just to create\n", + " a trace file to be used by the following sections" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# The following examples uses an HiKey board\n", + "ADB_DEVICE = '607A87C400055E6E'" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [], + "source": [ + "# Unified configuration dictionary\n", + "my_conf = {\n", + " \n", + " # Tools required\n", + " \"tools\" : ['rt-app', 'trace-cmd'],\n", + " \n", + " # RTApp calibration\n", + " #\"modules\" : ['cpufreq'],\n", + " \"rtapp-calib\" : {\n", + " \"0\": 254, \"1\": 252, \"2\": 252, \"3\": 251,\n", + " \"4\": 251, \"5\": 252, \"6\": 251, \"7\": 251\n", + " },\n", + " \n", + " # FTrace configuration\n", + " \"ftrace\" : {\n", + " \n", + " # Events to trace\n", + " \"events\" : [\n", + " \"sched_switch\",\n", + " \"sched_wakeup\",\n", + " \"sched_wakeup_new\",\n", + " \"sched_wakeup_tracking\", \n", + " \"sched_stat_wait\",\n", + " \"sched_overutilized\",\n", + " \"sched_contrib_scale_f\",\n", + " \"sched_load_avg_cpu\",\n", + " \"sched_load_avg_task\",\n", + " \"sched_tune_config\",\n", + " \"sched_tune_filter\",\n", + " \"sched_tune_tasks_update\",\n", + " \"sched_tune_boostgroup_update\",\n", + " \"sched_boost_cpu\",\n", + " \"sched_boost_task\",\n", + " \"sched_energy_diff\",\n", + " \"cpu_capacity\",\n", + " \"cpu_frequency\",\n", + " \"cpu_idle\",\n", + " \"walt_update_task_ravg\",\n", + " \"walt_update_history\",\n", + " \"walt_migration_update_sum\",\n", + " ],\n", + " \n", + "# # Kernel functions to profile\n", + "# \"functions\" : [\n", + "# \"pick_next_task_fair\",\n", + "# \"select_task_rq_fair\",\n", + "# \"enqueue_task_fair\",\n", + "# \"update_curr_fair\",\n", + "# \"dequeue_task_fair\",\n", + "# ],\n", + " \n", + " # Per-CPU buffer configuration\n", + " \"buffsize\" : 10 * 1024,\n", + " },\n", + " \n", + " # Target platform\n", + " \"platform\" : 'android',\n", + " \"board\" : 'hikey',\n", + " \"device\" : ADB_DEVICE,\n", + " \"results_dir\" : \"ReleaseNotes_v16.09\",\n", + " \"ANDROID_HOME\" : \"/opt/android-sdk-linux\",\n", + " \"CATAPULT_HOME\" : \"/home/derkling/Code/catapult\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:57:53,914 INFO : Target - Using base path: /home/derkling/Code/lisa\n", + "2016-09-23 18:57:53,914 INFO : Target - Loading custom (inline) target configuration\n", + "2016-09-23 18:57:53,914 INFO : Target - External tools using:\n", + "2016-09-23 18:57:53,915 INFO : Target - ANDROID_HOME: /opt/android-sdk-linux\n", + "2016-09-23 18:57:53,915 INFO : Target - CATAPULT_HOME: /home/derkling/Code/lisa/tools/catapult\n", + "2016-09-23 18:57:53,915 INFO : Platform - Loading board:\n", + "2016-09-23 18:57:53,915 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:57:53,916 INFO : Target - Devlib modules to load: [u'bl', u'cpufreq']\n", + "2016-09-23 18:57:53,916 INFO : Target - Connecting Android target [607A87C400055E6E]\n", + "2016-09-23 18:57:53,916 INFO : Target - Connection settings:\n", + "2016-09-23 18:57:53,917 INFO : Target - {'device': '607A87C400055E6E'}\n", + "2016-09-23 18:57:54,188 INFO : Target - Initializing target workdir:\n", + "2016-09-23 18:57:54,189 INFO : Target - /data/local/tmp/devlib-target\n", + "2016-09-23 18:57:56,401 INFO : Target - Topology:\n", + "2016-09-23 18:57:56,401 INFO : Target - [[0, 1, 2, 3], [4, 5, 6, 7]]\n", + "2016-09-23 18:57:56,601 INFO : Platform - Loading default EM:\n", + "2016-09-23 18:57:56,602 INFO : Platform - /home/derkling/Code/lisa/libs/utils/platforms/hikey.json\n", + "2016-09-23 18:57:56,985 WARNING : Event [sched_wakeup_tracking] not available for tracing\n", + "2016-09-23 18:57:56,993 INFO : FTrace - Enabled tracepoints:\n", + "2016-09-23 18:57:56,993 INFO : FTrace - sched_switch\n", + "2016-09-23 18:57:56,993 INFO : FTrace - sched_wakeup\n", + "2016-09-23 18:57:56,994 INFO : FTrace - sched_wakeup_new\n", + "2016-09-23 18:57:56,994 INFO : FTrace - sched_wakeup_tracking\n", + "2016-09-23 18:57:56,995 INFO : FTrace - sched_stat_wait\n", + "2016-09-23 18:57:56,995 INFO : FTrace - sched_overutilized\n", + "2016-09-23 18:57:56,995 INFO : FTrace - sched_contrib_scale_f\n", + "2016-09-23 18:57:56,996 INFO : FTrace - sched_load_avg_cpu\n", + "2016-09-23 18:57:56,996 INFO : FTrace - sched_load_avg_task\n", + "2016-09-23 18:57:56,997 INFO : FTrace - sched_tune_config\n", + "2016-09-23 18:57:56,997 INFO : FTrace - sched_tune_filter\n", + "2016-09-23 18:57:56,997 INFO : FTrace - sched_tune_tasks_update\n", + "2016-09-23 18:57:56,998 INFO : FTrace - sched_tune_boostgroup_update\n", + "2016-09-23 18:57:56,998 INFO : FTrace - sched_boost_cpu\n", + "2016-09-23 18:57:56,999 INFO : FTrace - sched_boost_task\n", + "2016-09-23 18:57:56,999 INFO : FTrace - sched_energy_diff\n", + "2016-09-23 18:57:56,999 INFO : FTrace - cpu_capacity\n", + "2016-09-23 18:57:57,000 INFO : FTrace - cpu_frequency\n", + "2016-09-23 18:57:57,000 INFO : FTrace - cpu_idle\n", + "2016-09-23 18:57:57,000 INFO : FTrace - walt_update_task_ravg\n", + "2016-09-23 18:57:57,001 INFO : FTrace - walt_update_history\n", + "2016-09-23 18:57:57,001 INFO : FTrace - walt_migration_update_sum\n", + "2016-09-23 18:57:57,002 WARNING : Target - Using configuration provided RTApp calibration\n", + "2016-09-23 18:57:57,002 INFO : Target - Using RT-App calibration values:\n", + "2016-09-23 18:57:57,002 INFO : Target - {\"0\": 254, \"1\": 252, \"2\": 252, \"3\": 251, \"4\": 251, \"5\": 252, \"6\": 251, \"7\": 251}\n", + "2016-09-23 18:57:57,003 WARNING : TestEnv - Wipe previous contents of the results folder:\n", + "2016-09-23 18:57:57,003 WARNING : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:57:57,004 INFO : AEP - AEP configuration\n", + "2016-09-23 18:57:57,004 INFO : AEP - {'instrument': 'aep', 'channel_map': {'LITTLE': 'LITTLE'}, 'conf': {'resistor_values': [0.033], 'device_entry': '/dev/ttyACM0'}}\n", + "2016-09-23 18:57:57,011 INFO : AEP - Channels selected for energy sampling:\n", + "[CHAN(LITTLE_current), CHAN(LITTLE_power), CHAN(LITTLE_voltage)]\n", + "2016-09-23 18:57:57,012 INFO : TestEnv - Set results folder to:\n", + "2016-09-23 18:57:57,012 INFO : TestEnv - /home/derkling/Code/lisa/results/ReleaseNotes_v16.09\n", + "2016-09-23 18:57:57,013 INFO : TestEnv - Experiment results available also in:\n", + "2016-09-23 18:57:57,013 INFO : TestEnv - /home/derkling/Code/lisa/results_latest\n" + ] + } + ], + "source": [ + "from env import TestEnv\n", + "\n", + "te = TestEnv(my_conf, force_new=True)\n", + "target = te.target" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:57:58,066 INFO : WlGen - Setup new workload ramp\n", + "2016-09-23 18:57:58,067 INFO : RTApp - Workload duration defined by longest task\n", + "2016-09-23 18:57:58,067 INFO : RTApp - Default policy: SCHED_OTHER\n", + "2016-09-23 18:57:58,067 INFO : RTApp - ------------------------\n", + "2016-09-23 18:57:58,068 INFO : RTApp - task [ramp], sched: using default policy\n", + "2016-09-23 18:57:58,068 INFO : RTApp - | calibration CPU: 4\n", + "2016-09-23 18:57:58,068 INFO : RTApp - | loops count: 1\n", + "2016-09-23 18:57:58,068 INFO : RTApp - + phase_000001: sleep 1.000000 [s]\n", + "2016-09-23 18:57:58,068 INFO : RTApp - + phase_000002: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,069 INFO : RTApp - | period 100000 [us], duty_cycle 10 %\n", + "2016-09-23 18:57:58,069 INFO : RTApp - | run_time 10000 [us], sleep_time 90000 [us]\n", + "2016-09-23 18:57:58,069 INFO : RTApp - + phase_000003: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,069 INFO : RTApp - | period 100000 [us], duty_cycle 20 %\n", + "2016-09-23 18:57:58,070 INFO : RTApp - | run_time 20000 [us], sleep_time 80000 [us]\n", + "2016-09-23 18:57:58,070 INFO : RTApp - + phase_000004: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,070 INFO : RTApp - | period 100000 [us], duty_cycle 30 %\n", + "2016-09-23 18:57:58,070 INFO : RTApp - | run_time 30000 [us], sleep_time 70000 [us]\n", + "2016-09-23 18:57:58,070 INFO : RTApp - + phase_000005: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,071 INFO : RTApp - | period 100000 [us], duty_cycle 40 %\n", + "2016-09-23 18:57:58,071 INFO : RTApp - | run_time 40000 [us], sleep_time 60000 [us]\n", + "2016-09-23 18:57:58,071 INFO : RTApp - + phase_000006: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,071 INFO : RTApp - | period 100000 [us], duty_cycle 50 %\n", + "2016-09-23 18:57:58,072 INFO : RTApp - | run_time 50000 [us], sleep_time 50000 [us]\n", + "2016-09-23 18:57:58,072 INFO : RTApp - + phase_000007: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,072 INFO : RTApp - | period 100000 [us], duty_cycle 60 %\n", + "2016-09-23 18:57:58,072 INFO : RTApp - | run_time 60000 [us], sleep_time 40000 [us]\n", + "2016-09-23 18:57:58,072 INFO : RTApp - + phase_000008: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,073 INFO : RTApp - | period 100000 [us], duty_cycle 70 %\n", + "2016-09-23 18:57:58,073 INFO : RTApp - | run_time 70000 [us], sleep_time 30000 [us]\n", + "2016-09-23 18:57:58,073 INFO : RTApp - + phase_000009: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,073 INFO : RTApp - | period 100000 [us], duty_cycle 80 %\n", + "2016-09-23 18:57:58,073 INFO : RTApp - | run_time 80000 [us], sleep_time 20000 [us]\n", + "2016-09-23 18:57:58,074 INFO : RTApp - + phase_000010: duration 1.000000 [s] (10 loops)\n", + "2016-09-23 18:57:58,074 INFO : RTApp - | period 100000 [us], duty_cycle 90 %\n", + "2016-09-23 18:57:58,074 INFO : RTApp - | run_time 90000 [us], sleep_time 10000 [us]\n", + "2016-09-23 18:57:58,074 INFO : RTApp - + phase_000011: batch 1.000000 [s]\n" + ] + } + ], + "source": [ + "from wlgen import RTA,Ramp\n", + "\n", + "# Let's run a simple RAMP task\n", + "rta = RTA(target, 'ramp')\n", + "rta.conf(\n", + " kind='profile',\n", + " params = {\n", + " 'ramp' : Ramp().get()\n", + " }\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:00,939 INFO : WlGen - Workload execution START:\n", + "2016-09-23 18:58:00,939 INFO : WlGen - /data/local/tmp/bin/rt-app /data/local/tmp/devlib-target/ramp_00.json 2>&1\n" + ] + } + ], + "source": [ + "te.ftrace.start()\n", + "\n", + "target.execute(\"echo 'my_marker: label=START' > /sys/kernel/debug/tracing/trace_marker\",\n", + " as_root=True)\n", + "rta.run(out_dir=te.res_dir)\n", + "target.execute(\"echo 'my_marker: label=STOP' > /sys/kernel/debug/tracing/trace_marker\",\n", + " as_root=True)\n", + "\n", + "te.ftrace.stop()\n", + "\n", + "trace_file = os.path.join(te.res_dir, 'trace.dat')\n", + "te.ftrace.get_trace(trace_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DataFrame namespace" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:17,976 INFO : Parsing FTrace format...\n", + "2016-09-23 18:58:20,633 WARNING : Cluster Frequency is not coherent! Failure in [cpu_frequency] events at:\n", + "2016-09-23 18:58:20,634 WARNING : __comm __cpu __pid cpu frequency\n", + "Time \n", + "10.619162 shutils 1 10380 4 1200000\n", + "10.619241 shutils 1 10380 5 1200000\n", + "10.619319 shutils 1 10380 6 1200000\n", + "10.619397 shutils 1 10380 7 960000\n", + "2016-09-23 18:58:20,638 INFO : Collected events spans a 10.725 [s] time interval\n", + "2016-09-23 18:58:20,639 INFO : Overutilized time: 5.322431 [s] (49.626% of trace time)\n", + "2016-09-23 18:58:20,639 INFO : Set plots time range to (0.000000, 10.725080)[s]\n", + "2016-09-23 18:58:20,639 INFO : Registering trace analysis modules:\n", + "2016-09-23 18:58:20,643 INFO : perf\n", + "2016-09-23 18:58:20,644 INFO : latency\n", + "2016-09-23 18:58:20,644 INFO : eas\n", + "2016-09-23 18:58:20,645 INFO : tasks\n", + "2016-09-23 18:58:20,645 INFO : cpus\n", + "2016-09-23 18:58:20,646 INFO : functions\n", + "2016-09-23 18:58:20,646 INFO : status\n", + "2016-09-23 18:58:20,646 INFO : stune\n", + "2016-09-23 18:58:20,647 INFO : frequency\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum estimated system energy: 5584\n" + ] + } + ], + "source": [ + "from trace import Trace\n", + "\n", + "events_to_parse = my_conf['ftrace']['events']\n", + "events_to_parse += ['my_marker'] \n", + "\n", + "trace = Trace(te.platform, trace_file, events=events_to_parse)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['sched_load_avg_task',\n", + " 'cpu_capacity',\n", + " 'cpu_idle',\n", + " 'sched_wakeup_new',\n", + " 'sched_contrib_scale_f',\n", + " 'cpu_frequency',\n", + " 'sched_boost_cpu',\n", + " 'sched_boost_task',\n", + " 'sched_switch',\n", + " 'sched_energy_diff',\n", + " 'sched_stat_wait',\n", + " 'sched_load_avg_cpu',\n", + " 'my_marker',\n", + " 'sched_overutilized',\n", + " 'sched_wakeup']" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trace.available_events" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Use TAB to complete\n", + "trace.data_frame." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
priocomm
pid
100migration/0
110watchdog/0
120watchdog/1
130migration/1
170watchdog/2
\n", + "
" + ], + "text/plain": [ + " prio comm\n", + "pid \n", + "10 0 migration/0\n", + "11 0 watchdog/0\n", + "12 0 watchdog/1\n", + "13 0 migration/1\n", + "17 0 watchdog/2" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rt_tasks = trace.data_frame.rt_tasks()\n", + "rt_tasks.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_cpu__cpucurr_statenext_statet_startt_delta
Time
0.326839NaN1AS0.3268390.000204
0.327043NaN1SW0.3270431.000443
1.3274861NaNWA1.3274860.000068
1.327554NaN1AR1.3275540.000776
1.328330NaN1RA1.3283300.000154
\n", + "
" + ], + "text/plain": [ + " target_cpu __cpu curr_state next_state t_start t_delta\n", + "Time \n", + "0.326839 NaN 1 A S 0.326839 0.000204\n", + "0.327043 NaN 1 S W 0.327043 1.000443\n", + "1.327486 1 NaN W A 1.327486 0.000068\n", + "1.327554 NaN 1 A R 1.327554 0.000776\n", + "1.328330 NaN 1 R A 1.328330 0.000154" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lat_df = trace.data_frame.latency_df('ramp')\n", + "lat_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
__comm__cpu__pidlabel
Time
0.155194sh210362START
10.546818sh110375STOP
\n", + "
" + ], + "text/plain": [ + " __comm __cpu __pid label\n", + "Time \n", + "0.155194 sh 2 10362 START\n", + "10.546818 sh 1 10375 STOP" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_df = trace.data_frame.trace_event('my_marker')\n", + "custom_df" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
__comm__cpu__pidnext_commnext_pidnext_prioprev_commprev_pidprev_prioprev_state
Time
0.000045<idle>10shell srvc 103410345120swapper/101200
0.000166<idle>20adbd1843120swapper/201200
0.000200shell110345swapper/10120shell srvc 1034103451201
0.000256<idle>00rcu_preempt7120swapper/001200
0.000267<idle>10rcu_sched8120swapper/101200
\n", + "
" + ], + "text/plain": [ + " __comm __cpu __pid next_comm next_pid next_prio \\\n", + "Time \n", + "0.000045 1 0 shell srvc 1034 10345 120 \n", + "0.000166 2 0 adbd 1843 120 \n", + "0.000200 shell 1 10345 swapper/1 0 120 \n", + "0.000256 0 0 rcu_preempt 7 120 \n", + "0.000267 1 0 rcu_sched 8 120 \n", + "\n", + " prev_comm prev_pid prev_prio prev_state \n", + "Time \n", + "0.000045 swapper/1 0 120 0 \n", + "0.000166 swapper/2 0 120 0 \n", + "0.000200 shell srvc 1034 10345 120 1 \n", + "0.000256 swapper/0 0 120 0 \n", + "0.000267 swapper/1 0 120 0 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ctxsw_df = trace.data_frame.trace_event('sched_switch')\n", + "ctxsw_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis namespace" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Use TAB to complete\n", + "trace.analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false, + "run_control": { + "marked": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:32,103 INFO : Plotting 10366: ramp, rt-app...\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6YAAALUCAYAAAAYHy+VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trace.analysis.tasks.plotTasks(tasks='ramp',\n", + " signals=['util_avg', 'boosted_util',\n", + " 'sched_overutilized', 'residencies'])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:32,990 INFO : Found: 80 WAKEUP latencies\n", + "2016-09-23 18:58:33,019 INFO : Found: 371 PREEMPT latencies\n", + "2016-09-23 18:58:33,021 INFO : Total: 451 latency events\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6QAAAHpCAYAAACV5vFGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lat_data = trace.analysis.latency.plotLatency('ramp')" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countmeanstdmin50%95%99%max
latency4510.000120.0003470.0000190.0000310.0005390.0021320.003023
\n", + "
" + ], + "text/plain": [ + " count mean std min 50% 95% 99% \\\n", + "latency 451 0.00012 0.000347 0.000019 0.000031 0.000539 0.002132 \n", + "\n", + " max \n", + "latency 0.003023 " + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lat_data.T" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:34,935 INFO : LITTLE cluster average frequency: 0.916 GHz\n", + "2016-09-23 18:58:34,935 INFO : big cluster average frequency: 0.915 GHz\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.91643081506625346, 0.91532341938266315)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7UAAAISCAYAAAATN+jXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3X+cJHV94P/XW3A34KgL7jerDcYN6iAQ0Ys/Qy5xEpRw\nOU7hbk9iQsJeuKw5zEWMOYF4xD1NCJIYYy5HLmtW3bhK4BLl4i8CGieRG13iD5SA7Ajs4i4tq7uy\nuiOwi/L5/lHV0zU93TPdM9PTn959PR+PeWx/6vOpqk9Vvbu631v1qY6UEpIkSZIkDaPHDboDkiRJ\nkiQtlEmtJEmSJGlomdRKkiRJkoaWSa0kSZIkaWiZ1EqSJEmShpZJrSRJkiRpaJnUSpIWJSJ+IiKu\nj4j7I+JgROyNiJsi4pcj4nFlm/UR8VhE/Egf1j8WEW+JiFjqZS9Uua3t/v5q0H3LRT9jQpJ0ZDl6\n0B2QJA2viLgEeAfwKeBNwH3AccDPAf8b2A98pM/dGAN+F3gbkNOPr78X+IuWad8aREcy9VHgpcAD\ng+6IJGm4mdRKkhYkIn4a+GPgT1NKl7RUfyQi/gh44nJ2ackWFLEypXRwkYu5P6V0a5frOwogpfSD\nRa5zaKSU9gJ7B90PSdLw8/ZjSdJCXUqRlLypXWVKaWdK6fZOM5e3nr6lZdracvqFlWkvioiby9ua\nH4qIeyLif5V1Gymu0gI82rjNtzLvsRHx9ojYUd4afW9E/E71VuXy9uXHIuK8iHh3RHyL8uphRIxG\nxIcjYk9EPBwR95W3Wh/V685qs+2/FxGXRcQO4CDwY2XdyyLiUxHx3YiYiogbI+K0lvmPKuf/RkR8\nLyI+HRGnte7TiHhfufzW9Y9HxKdbpv1/EfG/I2J3RDwSEV+NiF9radO4ZfglEfGBiPhOedv5uyJi\nZUvbJ0TEVeXxeqTs699ExA+3LOtHWubbEBFfLvf3tyLiLyPiuJY2ry/791BEfDsi/jkizu3lGEiS\nDh9eqZUk9axM6n4G+FBK6dAiFtXpduFUrmcE+Hvgc8CFwAHgR4GfKNu9GzgBuAj4SWD6SmdEHF3O\newrwVuD2cr4rgOOB325Z5/8EPg78EvBD5bSPAfuAX6dI4E8E/g3FfwrPd1X1cWUfmhuV0vcrxfXA\nPcBvAd8DvhER/xb4vxS3bP8SxdXnS4HPRMTpKaXd5bwbgcspbv2+CXgR8HeN1bT0o90+TtXpEfEk\n4BZgJfAWYAdwNvDn5VXrP2uZ//3AB4HzgDPK/jxY/ktErABuBk4H/oDi+K0Czir//WabPhERV5X7\n413AGyn29+8BPxYRZ6SUHouIXwL+CPgfwGeAY4DnUdz2Lkk6ApnUSpIWYjVF4ndfn9fzHIok6E0p\npX8pp/0TsAUgpXR/RNxfTt+WUnqsMu9rKBLdn04p3VJO+3R5kfYtEXFVeQsslfk3NAoRsRp4JvCG\nlNJHK+2u7bLvv1P+TYuIZ6WU7q1MOqt6m3NEvAv4dErpvMq0TwP3UiR5byivWr4B+IuUUuMq+Scj\n4gfAVW360e627GBmsvt64EeAH0sp3VNO+4eIWEWxr65p2bcfSCn9j0q7l1Ds743ltAsoxsu+smXf\n/W2bvjS2cy3FfzRsTCn9XmX6JEXC/e8oEv6fAL5SbQPc2Gm5kqTDn7cfS5Jy9jWKh01tiohfioin\n9zDv2RRJ92cj4ujGH8UVxMdTJF1VH64WyoT3XuDtEfGfI+LZPfZ9M/DClr/dlfobWxLaZwMnAR9s\n6e/DFFc6f7ps+lzgWOD6lvX9dY/9qzq7XMfOlnXfBDwFOLWl/cdayv9CkRQ3nAV8oyWhnc8rKL6X\ntG7/rcAU8FNlu1uB50fEn0bEyyPi2B7WIUk6DJnUSpIWYh9FsvWMfq4kpfQdituc68A1wH0RcXtE\n/PsuZv/hsn+PAocqf9sorlI+paX9N9os4xXA5yluod1ejg/99S67/42U0hdb/qq3areu74fLfze3\n9PcQ8G8pbpkGeFr5756W+dve0tulHwZexux9dT3t99W3W8oHKW5dbngKcD+9aWz/3cze/ic0+pBS\n+ivgvwAvobhCuy8i/jYi+hqLkqR8efuxJKlnKaXvR8Q4cFZErFjguNqDwIqWaa3JEymlLwProvjN\n2xdRjCW9PiKel1K6Y47l76UYG/ofO9S33jo9a+xpSmkHxVheIuJ5wG8A10TEzpTSYm95bV3fvvLf\ny4BPtmnf2MeNZHgN8NVK/Zo28zzC7H0MxX6u/rzQXoqHY72+Q18nO0zvZC9w2rytZmps/ysoxud2\nqieltIni6v2TKX4+6h3Adcy++i5JOgKY1EqSFuoqYBy4Gmj9SR8i4keBkTmegHwfxa20Vf+208rK\nMZ3bIuJ3gVdSjLe9gyI5huKW3KnKLDcC/wH4Xkpp+3wbM5+U0pcj4o0UD6U6jSUex5lSuisidlKM\na716jqZfoXiw1PkU+7/hF9q0vQ9YExGrG+OHI+KZwMnMTGpvBP4rsCultBS/pfv3wPkRcU4PtyDf\nBDwGPCOl9KluZiiv5F8fES8FNszXXpJ0eDKplSQtSErpMxHxW8AfR8SpwPuAXRRPoT2TIvl7DcVT\nh9v5a+C/R8TvUNwS/FO0JGYRcQ5FsvJhYCfFbai/CXwX+GzZrHG19o0RcSPwg5TS54EPAP8J+FRE\nvIMiGVxB8fCnfwecm1J6uNP2RcTpFE/h/WuKpxQfRfHE4keBf5hz5yzc64D/Wz49+P9QXPFcQ/GE\n4ftSSu9MKe2PiHcCb46IAxRjhF8E/Gqb5V1P8eTnreU8qymuBH+LmQ+QeidFkvyZst0kxb5+DvCv\nU0q9/lzOVuDXgGsj4g8oxsE+kWKs7Z+0+0+GlNK9EfF24M8i4mSKB4I9AjwdeDnwlyml8YjYRHH8\nP0dxy/UoxYOp/r7HPkqSDhMmtZKkBUspvSsibqV4Gu8fUSRNB4B/pkhGq1fpWm+3/QOKJxv/BkWi\n9THglykS3IZJ4CGKn+F5WrnsW4FXpJTqZZuPUoy3vZjmb9YeVd4i/XPlsjdQ/BTQ9yjGbH6M5u28\n7foGxW2+91H8xMyJFAnWV4BzUkpfmmu/LFRK6RMR8dPAmyl+rugYituCP8vMpy5vpEhK/zPF/vsc\nRaJ+R8vy7omIdRQ/i/NhYDvFsXozlW1OKX03Is6g2H+XUvxM0n7gLmY/sXjenwgq9/1ZFD8PtKH8\ndx/FU4z3tcxX7e+bI+KrFMn968r6XRS3Yzdugb6F4j8rfhl4MsV46/eX65AkHYEipU4/EShJkoZJ\nRDxG8ZM4bx10XyRJWi4+/ViSJEmSNLRMaiVJkiRJQ8vbjyVJkiRJQ8srtZIkSZKkoWVSK0mSJEka\nWia1kiRJkqShZVIrSZIkSRpaJrWSJEmSpKFlUitJkiRJGlomtZIkSZKkoWVSK0mSJEkaWia1kiRJ\nkqShZVIrSZIkSRpaJrWSJC1QROyMiDM71P1URNzVx3U/FhEn9Wv5kiQNC5NaSZIWLpV/sytS+kxK\n6TkLXXBEPC0iNkdEPSK+GxFfjYiNEXHsgns7ex3vi4i3LdXyJEkaBJNaSZIyExHHA58FVgIvTSk9\nCXgF8GQgm6uzEXHUoPsgSZJJrSRJi/PiiLgjIr4dEe+JiJUAETEWEbsajSLixyPiS+VV1+sj4ro5\nrpL+FvCdlNIFKaWvA6SUdqeU3pBS+pfWxhExHhEXVcrrI+Iz5euIiHdGxJ6I+E5EfCUiTouIDcAv\nAm+KiAMR8X/L9rWI+NuI+GZE3BsR/7Wy3I0R8TcR8f6I+A5w4aL3niRJi2RSK0nSwgVFYngW8Exg\nFPjvsxpFrAA+DLwHOA64FjiXDrcuAy8HPtRDPzreBl327aeAZ6eUngz8R2BfSmkT8AHg7SmlJ6aU\nXhURjwM+AnwJqAFnApdExFmV5b0S+D/lsj7YQx8lSeoLk1pJkhYuAX+WUro/pfQg8PvAa9q0eylw\nVErpf6aUfpBS+jBw6xzLPR74xhL18VHgicApEfG4lNL2lNIDlfqovH4RsDql9Hsppe+nlHYAfwn8\nQqXNRErp7wBSSo8sUR8lSVqwowfdAUmShtyuyuuvU1zhbFUD7m8zX7RpC7Cvw3J6llL6h4j4M+B/\nAc+IiA8Bv51SOtCm+TOAWkQ8WJl2FPBPlfLupeiXJElLxSu1kiQtzo+0vK63afMN4IQ283W6ZfiT\nwHkR0SnpbfU94AmV8lOrleUV4hcCp1LcIv3fGlUty/k6sCOldFzl70kppXMq7Tv1WZKkgTCplSRp\n4QJ4XUScUD6x+M3AX7dp91ngBxHxGxFxdES8iuJW307+GHgSsCUifgSgXMc7IuLH2rS/Dfj3EXFM\nRDwLuIgy+YyIF0bESyLi8cBDwCPAD8r59jDzacq3Agci4k3lso6KiB+LiBdWtleSpKyY1EqStHCJ\n4mFLNwH3AF8Dfq+lnpTSIeDfUySbDwK/BHwUONR2ocX43DMoxsNui4jvUly93Q/cXV126Z3lsvYA\n7wW2VuqeBGwCvg3sBPYCf1jWbQZOjYgHI+JDKaXHgHOA5wP3At8q531SZZ1eqZUkZSVS8rNJkqTl\nFhHbgGtSSlsG3RdJkoaZV2olSVoGEfHTEfHU8vbjC4EfA24cdL8kSRp2Pv1YkqTlcTJwPcUDne4B\n1qWU9gy2S5IkDT9vP5YkSZIkDa3D5kptRJidS5IkSdJhLKU060n8h01SC1C96lyfnASgNjpKfXKS\n2sgI9akpaqOjRX29Tq0283ftG+0WorpsLY1ejkeu+3/jxo1s3Lhx0N0YSgt5P+YaBznqNTZbj0fr\nvp7vePXj2FTP8wuZt7W/vfRxOc5Pi/lMWqxu+tyP/m18xzvY+MY3LukyO2m3jUu5Te2+c3Qbd4M8\n9gsxY1vn6Pt87RZbX20zX32v66jGZr/W0ct2LFZ9agpgqOJMsy3nObNVI4ag98/hTp/frTlbvV78\n7HutVps+j3b6+XYfFCX10c6dOwfdBaktY1M52rlr16C7ILVlbCpHxmWTSa0kSZIkaWiZ1Ep9tH79\n+kF3QWrL2FSO1r/61YPugtSWsakcGZdNJrVSH42NjQ26C1JbxqZyNHbGGYPugtSWsakcGZdNJrVS\nH42Pjw+6C1JbxqZyND4xMeguSG0Zm8qRcdlkUitJkiRJGlomtVIfeYuncmVsKkfeSqdcGZvKkXHZ\nZFIrSZIkSRpaJrVSHzluUbkyNpUjx4cpV8amcmRcNpnUSpIkSZKGlkmt1EeOW1SujE3lyPFhypWx\nqRwZl019S2oj4j0RsScibq9M+8OI+GpEfDkiPhQRT67UXR4RX4uIuyLirMr0F0TE7WXdu/rVX0mS\nJEnS8Onnldr3Ame3TLsJOC2l9DxgErgcICJOBc4HTi3nuSYiopznz4GLUkrPBp4dEa3LlLLluEXl\nythUjhwfplwZm8qRcdnUt6Q2pfQZ4MGWaTenlB4ri9uAE8vXrwKuTSk9mlLaCdwNvCQingY8MaV0\na9nur4Bz+9VnSZIkSdJwGeSY2l8FPl6+rgG7K3W7gRPaTL+/nC4NBcctKlfGpnLk+DDlythUjozL\npqMHsdKIeDNwKKX0waVc7vr161m7dm2xjkOHOO2UU1g3OgoUl+enPv5xai99KQBf/MIXmBwZYezk\nk4v67duZevBBas95TlG+5x4Axp75zPblr38dxsamg2li2zZW1+vTXxQbt/ZZXkB5yxbGv/KVno7H\nF+6+m8lf/MU8+m+5KN94I2MnnVSUt2+Hxz+esauumtn+vvvg4MGiHhb+fizLzzvpJLj00jy2f5jL\nl10Gjz4643gcOHCA2saNRXliggM33UTthS+crp/veB1IidqmTUvav+evWlWU9+9fkvjqKn56PT+t\nWMHEU57S2+dDdftWruw6/peyPOt4tb6fYaD9W4ryrON9330c+/WvM75795Is//knnghr1hTxNjVF\n7QUv4Ng9e2Ytf8bn1wI+/3IoTz36aPP71ec+x+TjH9+2/TEpMf7ggx3je7H10/vz+ON5/hOeMGf9\n2EkndT4ec9RXt7dT/YGUqP3kT8LBg233x3z11fiZa38upvy8xvv53nv7Hh+WD8/ysQcPcsuOHQDT\n7/92n7ftyjM+vyv1X/j855k86yxGTz+9KF95Jf9y330cBB555BEemJqik0gpdaxcrIhYC3wkpfTc\nyrT1wK8BZ6aUHimnXQaQUrqqLN8IvAW4D/h0SumUcvprgJellH69zbpSdVvqk5MA1EZHqU9OUhsZ\noT41Ra1Mcuv1OrVarbmATZuoj41RGxnpbuO2boULLmiur7JsLdKmTbBhw/Rx68b+zZtZdcUVfe5Y\n78bHx6e/qB5xyuPYsdxpWqmX49+QaxzkaM7YbHNc9r/tbay66KJmuWVf1ycnqd1ww4zz4oz5l/LY\nVM4RUJznu46vOc4vXfWx1/PT1q3Uzz23t8+HBZwDl9qsfdFmX/ajf+MTE8t25aHdNvb0PaCH5Te+\nc8wbdxkc+4WYsa2Nvrd8T5put2bN3O/BRdRX23Q6lgtdRzU2G9s7Xx8WvR1zrGOx9m/eDDDjvD5L\nm2OovCznOXOG8rOtoePncAf1yUmOve66WZ+5je8ajbxq/9VX89AFFxTnz/I8GhGklKJ1mct6+3H5\nkKf/BryqkdCW/g74hYhYERE/CjwbuDWl9ADw3Yh4SfngqF8GbljOPkuSJEmS8tW3248j4lrgZcDq\niNhFceX1cmAFcHP5cOPPppQuTindGRHXA3cC3wcurlx2vRh4H3AM8PGU0o396rO01I7Yq7TKnrGp\nHDk+TLkyNpUj47Kpb0ltSuk1bSa/Z472VwJXtpn+BeC5s+eQJEmSJB3pBvn0Y+mw13gAiZQbY1M5\n8jcXlStjUzkyLptMaiVJkiRJQ8ukVuojxy0qV8amcuT4MOXK2FSOjMsmk1pJkiRJ0tAyqZX6yHGL\nypWxqRw5Pky5MjaVI+OyyaRWkiRJkjS0TGqlPnLconJlbCpHjg9TroxN5ci4bDKplSRJkiQNLZNa\nqY8ct6hcGZvKkePDlCtjUzkyLptMaiVJkiRJQ8ukVuojxy0qV8amcuT4MOXK2FSOjMsmk1pJkiRJ\n0tAyqZX6yHGLypWxqRw5Pky5MjaVI+OyyaRWkiRJkjS0TGqlPnLconJlbCpHjg9TroxN5ci4bDKp\nlSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLptMaiVJkiRJQ8ukVuojxy0qV8amcuT4MOXK2FSO\njMsmk1pJkiRJ0tAyqZX6yHGLypWxqRw5Pky5MjaVI+OyyaRWkiRJkjS0TGqlPnLconJlbCpHjg9T\nroxN5ci4bDKplSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLpv6ltRGxHsiYk9E3F6ZdnxE3BwR\nkxFxU0SsqtRdHhFfi4i7IuKsyvQXRMTtZd27+tVfSZIkSdLw6eeV2vcCZ7dMuwy4OaU0CnyqLBMR\npwLnA6eW81wTEVHO8+fARSmlZwPPjojWZUrZctyicmVsKkeOD1OujE3lyLhs6ltSm1L6DPBgy+RX\nAlvK11uAc8vXrwKuTSk9mlLaCdwNvCQingY8MaV0a9nuryrzSJIkSZKOcMs9pnZNSmlP+XoPsKZ8\nXQN2V9rtBk5oM/3+cro0FBy3qFwZm8qR48OUK2NTOTIum44e1IpTSiki0lIuc/369axduxaAOHSI\n0045hXWjo0Bx0Pc+/PB0eWJigtWrV0/fgje+fTt7jzmGdWeeOd0empf1Z5XvuQcmJqbLE9u2sbpe\nby6v/MJoeeHlvbt2dX08btmxg5Hx8az6X5VLf5a1vH07Y9Xtby3D7PICj3+j/Pw5lmd5Zvm2227r\nXL99O7S8n6Z27OAcCuMTEzPLjeNVqYeZx6e1/aL6X/ZvtFZr1i9BfPUSP73EZ8+fD63b12X8L2V5\n1vFqs38H2b+lKM863o1yH5a/d+9e1q1b17Z9u8+vhZz/BlmuxsvEtm2sPuaYzvtzvvheZP0tO3Yw\nsn8/o4392aG+U/861VMpt54P2+6PNWtm7o8e6qEZP53qlyw+M4gfywsv33bHHYNZP4WJbdsAmvlW\nl5/nMz6/K/W37NjByMQEo6efXpTvuYcvvPvdpJQ4cOAA+/bto5NIaUnzypkLj1gLfCSl9NyyfBcw\nllJ6oLy1+NMppedExGUAKaWrynY3Am8B7ivbnFJOfw3wspTSr7dZV6puS31yEoDa6Cj1yUlqIyPU\np6aolTu9Xq9TK3coAJs2UR8bozYy0t3Gbd0KF1zQXF9l2VqkTZtgw4bp49aN/Zs3s+qKK/rcMfWk\nPI4dy52mlXo5/g3GwRJpc1z2v+1trLrooma5ZV/XJyep3XDDjPPijPmX8thUzhFQnOe7jq85zi9d\n9bHX89PWrdTPPbe3z4cFnAOX2qx90WZfDrJ/S6HdNvb0PaCH5Te+c8wbdxkc+4WYsa2Nvrd8T5pu\nt2bN3O/BRdRX23Q6lku2jiuumLcP/VzHYu3fvBlgxnl9ljbHUAKmP9saOn4Od1CfnOTY666b9Znb\n+K7RyKv2X301D11wQXH+LM+jEUFKKVqXudy3H/8dcGH5+kLghsr0X4iIFRHxo8CzgVtTSg8A342I\nl5QPjvrlyjySJEmSpCNcP3/S51pgAjg5InZFxH8CrgJeERGTwM+WZVJKdwLXA3cCnwAurlx2vRj4\nS+BrwN0ppRv71WdpqTVuq5ByY2wqR44PU66MTeXIuGzq25jalNJrOlS9vEP7K4Er20z/AvDcJeya\nJEmSJOkwsdy3H0tHlMbAdyk3xqZy5G8uKlfGpnJkXDaZ1EqSJEmShtbAftJHWnJbtsDBgzOnrVwJ\nF17Yvv0yGK/8TMNQ6ce+XLmyeDJe6zQNRK+xmVasKJ6EWS33ql1cNXQbX1u2dBc33bbrNO9c/VwK\ny7GOxar2cZn6ND4x4ZUHZcnYVI4Ot7hsfNc49uBBWLOmp+8aJrU6fBw82P7nO9S7fuzLAf7nghbv\n4fPO47jKz0o8PDXFcb0upF1cNXQbX3MtYyHtlnrenNaxWMPQR0nSYaPxXeOhqSlWjY7ycL3e9bze\nfiz10VBepdURwdhUjg6nKw46vBibypFx2WRSK0mSJEkaWia1Uh/5W6DKlbGpHPmbi8qVsakcGZdN\nJrWSJEmSpKFlUiv1keMWlStjUzlyfJhyZWwqR8Zl0+H19OOI6Ze1xouU2jatnXDC7GkA99/fftlt\n2nPppZ3bV/oyQ4f+2H6e9u32P3S3/1/72qXvz5Havrov+9G+ouf3I8Bb39r18nvtzxHX/rWvnfP9\nWGuZVAN4+9s7tl9VXe5C+tNN+9Z46/Tk3ohZ/Qd6ip9e4rN26aXFi163d/v2rpY/rdf3yxztezpe\ny9CfvrZv991hiZffWG5Xy+8Un0OyP2snn9wsNGK/y+XPiLtO8f/a18JrXzt7H3XZ/+l1dDg/rPrd\n351ez0LjYRXAX/xFx/bV7ZxeRzf7c4H9sb3t+9V+Vnw2PjPm+bybjvvG+62LfK3tebHCK7VSHzlu\nUbkyNpUjx4cpV8amcjQ+6A5k5PC6UlvJ8uuTk0DnrL5+//3UapXaTZuoj411/l+A1v+h2LoVLrig\nq750xfZz6/Q/SvMtf9Om7n5nMbftzbF9t/tyoe1b1Ccnu38/Nmze3PXye+3PEdV+vmN3//3Up6ao\njY5OT6pPTlK74YaO7fdv3syqNWv6935s7fNcv3ubUtHfyu/uAj3FT9fxuXUr9XPPnbGvulk+AOXn\n2JzL78YC2vd0vJahP31tX/m8qI+NzY6LJVh+vV6nVqu1j7t27btpt9D+9Ll9ffv2ou/zfU9qs/wZ\ncdcp/v/iL2DDhu73UUv/p9fRwf63vnW6DzPW0SmpbbN/9m/e3Lwa26Z9dTvn247p/dmtzOLB9n1u\nPzEBc92CvAzvd6D4jOvme195vq1PTnLsddex6oor5l5+2Z9arTZ9Hu10d5NXaqU+ctyicmVsKkeO\nD1OujE3lyLhsMqmVJEmSJA0tk1qpjxy3qFwZm8qR4xaVK2NTOTIum0xqJUmSJElDy6RW6iPHLSpX\nxqZy5Pgw5crYVI6MyyaTWkmSJEnS0DKplfrIcYvKlbGpHDk+TLkyNpUj47LJpFaSJEmSNLRMaqU+\nctyicmVsKkeOD1OujE3lyLhsMqmVJEmSJA0tk1qpjxy3qFwZm8qR48OUK2NTOTIum0xqJUmSJElD\ny6RW6iPHLSpXxqZy5Pgw5crYVI6My6aBJLURcXlE3BERt0fEByNiZUQcHxE3R8RkRNwUEata2n8t\nIu6KiLMG0WdJkiRJUn6WPamNiLXArwE/nlJ6LnAU8AvAZcDNKaVR4FNlmYg4FTgfOBU4G7gmIrzC\nrKHguEXlythUjhwfplwZm8qRcdk0iOTwu8CjwLERcTRwLFAHXglsKdtsAc4tX78KuDal9GhKaSdw\nN/DiZe2xJEmSJClLy57UppS+DbwD+DpFMrs/pXQzsCaltKdstgdYU76uAbsri9gNnLBM3ZUWxXGL\nypWxqRw5Pky5MjaVI+OyaRC3Hz8TuARYS5GwjkTEBdU2KaUEpDkWM1edJEmSJOkIcfQA1vlCYCKl\ntA8gIj4E/ATwQEQ8NaX0QEQ8Dfhm2f5+4OmV+U8sp82yfv161q5dC0AcOsRpp5zCutFRoLjnfO/D\nD0+XJyYmWL169fTVivHt29l7zDGsO/PM6fbQ/B+QWeV77oGJienyxLZtrK7Xm8srx6tZXnh5765d\nXR+PW3bsYGT/foq5K8trLS/z9jSm5bA/eypv3w7j4zPrt2/vbX/22p6FH/9G+fmLWN+RVr7tttu4\n5JJL2te3Of6tx6N6Pp2uh+l6mHl8pnbs4Jw1azr3bwHxMlqrdZ5/nuW1i6/p+GkX/13M3yk+234+\ndLG909vXZfwvZXne49Wn/lXHh/V7e2edLxrlPix/7969rFu3rm37W3bsYGSe99ty7I9Fx0u5vRPb\ntrH6mGM678/y/dUxfhZZ3/g+MNrYnx3qO/WvU32jTev2zvf+md4fPdRDM3461S9ZfGYQP5YXXv6T\nd7+b558tcmRQAAAgAElEQVR22vKvn8LEtm0AM74PQI+f35X6RryPnn56UZ6Y4I477iClxIEDB9i3\nbx+dRHFRdPlExPOADwAvAh4B3gfcCjwD2JdSentEXAasSildVj4o6oMU42hPAD4JPCu1dDwiZkyq\nT04CUBsdpT45SW1khPrUFLVyp9frdWrlDgVg0ybqY2PURka625CtW+GC5gXm6rK1SJs2wYYN08et\nG/s3b2bVmjWwYUPbZQ3KeOWLylBpt9963ZeL3Pe9HP+G/Zs3s+qKKxa8ziPJnLHZ5ti1Ho/Wc159\ncpLaDTfMOC9WdXyPzrHO+dpVz/Oz5u+0vDnOL9Px00Vfuo7PrVupn3vu7M+HpVxHH8x7vOhP/8Yn\nmv9Z3G+zzhe9fg/oYfmN7xxzxl3Zh14//3IwY1sbfW/5njTdroyrjvtiEfXVNp2O5ULXUY3NxvbO\n14dFb8cc61is/Zs3A7Dqoos6N2pzDJWX5TxnzlB+tjW0/RyeQ31ykmOvu27Wd7bWnK1erxfLr9Wm\nz6MRQUopWpe57FdqU0pfjoi/Aj4PPAZ8EdgEPBG4PiIuAnYCry7b3xkR1wN3At8HLm5NaKVcDWVC\nqyOCsakcOT5MuTI2lSPjsmkQtx+TUroauLpl8reBl3dofyVwZb/7JUmSJEkaLv7eq9RHjbECUm6M\nTeXI31xUroxN5ci4bDKplSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLpvmTWoj4t6I+C8t0z7a\nvy5JkiRJktSdbq7UPgqMRcR7I2JlOe2EPvZJOmw4blG5MjaVI8eHKVfGpnJkXDZ1k9Q+lFI6H/gq\n8E8R8Yw+90mSJEmSpK50/ZM+KaWrI+KLwE3A8f3rknT4cNyicmVsKkeOD1OujE3lyLhs6iap/d3G\ni5TSJyPiLODC/nVJkiRJkqTudExqI+IFQALqEfHjLdUf62uvdOTasgVWrpy/3ZAYHx/P84rYli1w\n8GDn+l6PwXzLy1Wnfq9cCRdeOHe7Xtsstn6J1zG+fTtjJ5/cfh2Deg92E0dz9W3Tpu7aLbNjPvxh\nOO645oSM+pab8YmJ5b3yUI25QR6XRuwaG9la9tiUumBcNs11pfYdFEktwAuBz7fU/0xfeqQj28GD\nsGHDoHtx+Fvq/dxuedUEI1ed9kNr37vZvvnaLLZ+qdcxPg5jY92tY7ksdt2Znjvi0KGZfRuG98aR\nojXmJicH049MY1eShkXHpDalNNZ4HRFfSimZxEo9yvIqrYSxqTx5xUG5MjaVI+OyqZunH0uSJEmS\nlCWTWqmP/C1Q5crYVI78zUXlythUjozLprkeFPU/K8UTIuJPgSjLKaX0m33tmSRJkiRJ85jrQVFf\noHhQVJSvq9Ls5pJaOW5RuTI2lSPHhylXxqZyZFw2zfWgqPctYz8kSZIkSepZxzG1EfGRiPi78t/W\nv79bzk5Kw8pxi8qVsakcOT5MuTI2lSPjsmmu249fCuwGrgW2ldOmx9T2s1OSJEmSJHVjrqT2acAr\ngNeUfx8Drk0p3bEcHZMOB45bVK6MTeXI8WHKlbGpHBmXTR1vP04pfT+l9ImU0q9QXLW9G/jHiPiN\nZeudJEmSJElzmPN3aiPihyLiPwBbgdcB7wI+vBwdkw4HjltUroxN5cjxYcqVsakcGZdNc/1O7fuB\n04CPA29NKd2+bL2SJEmSJKkLc42p/SXge8DrgddHRLUupZSe1M+OSYcDxy0qV8amcuT4MOXK2FSO\njMumuX6nds5bkyVJkiRJGjQTV6mPHLeoXBmbypHjw5QrY1M5Mi6bBpLURsSqiPibiPhqRNwZES+J\niOMj4uaImIyImyJiVaX95RHxtYi4KyLOGkSfJUmSJEn5GdSV2ncBH08pnQKcDtwFXAbcnFIaBT5V\nlomIU4HzgVOBs4FrIsIrzBoKjltUroxN5cjxYcqVsakcGZdNy54cRsSTgZ9KKb0Hpn8P9zvAK4Et\nZbMtwLnl61cB16aUHk0p7aT4vdwXL2+vJUmSJEk5GsQVzx8FvhUR742IL0bEuyPiCcCalNKess0e\nYE35ugbsrsy/Gzhh+borLZzjFpUrY1M5cnyYcmVsKkfGZdMgktqjgR8Hrkkp/TjFzwZdVm2QUkpA\nmmMZc9VJkiRJko4Qc/1Obb/sBnanlP65LP8NcDnwQEQ8NaX0QEQ8DfhmWX8/8PTK/CeW02ZZv349\na9euBSAOHeK0U05h3egoUPxPxt6HH54uT0xMsHr16ulxZePbt7P3mGNYd+aZ0+2hea/6rPI998DE\nxHR5Yts2VtfrzeWVV0Es91iG6fLeXbu6Ph637NjByP79M+ZvXV4W25dLeft2GB/vbf7t2zvvz3bL\nm6t9F+Vejn+j/Pxe19ft9nSzfe22dynr5+rvAuuZr/0cx6N6Pp2ubyyvzfGZ2rGDc9as6by+7dsZ\nO/nkrvsDMFqrzZx/EdsDlfjp4v3R8/mpNZ6Y/3hNb1+X8b+U5XmPV5/6N3bGGcu2vR3PF31Y/t69\ne1m3bl3b9rPiY4Hnv0GWp3bs4Jxyeye2bWP1Mcc047u1ffn+6hg/i6xvfB8Y7XA8Z31f6LG+dXvn\ne/9M748e6qEZP53qlyw+M4gfywsvN6Yt+/rLdU9s2wYw4/sA9Pj5XalvxPvo6acX5YkJ7rjjDlJK\nHDhwgH379tFJFBdFl1dE/BPwn1NKkxGxETi2rNqXUnp7RFwGrEopXVY+KOqDFONoTwA+CTwrtXQ8\nImZMqk9OAlAbHaU+OUltZIT61BS1cqfX63Vq5Q4FYNMm6mNj1EZGutuIrVvhggua66ssW4uwaRNs\n2AAwfdy6sX/zZlatWTM9b7vlqWIh+2WuedrVLXLf93L8G/Zv3syqK67ofoZOfWyd3s32zddmsfWD\nXAezj0frOa8+OUnthhtmnBerOr5Hq+uFnmKmep7vOt7Kdu3iazp+ulhW1/G5dSv7Dx6cGZddbutC\n3gNLZd7jxWD7txTabeNSblP1fNT4zjFn3FUM276dsa2Nvrd8T5puV+7zjvtiEfXVNp2+0y3ZOq64\nYt4+9HMdi7V/82YAVl10UedGbY6hBMDWrdTPPXe62NPnMMV54tjrrut47mt8x6jX68Xya7Xp82hE\nkFKK1mUO6inC/xX4QER8meLpx78PXAW8IiImgZ8ty6SU7gSuB+4EPgFc3JrQSrlqvSIm5cLYVI4c\nH6ZcGZvKkXHZNIjbj0kpfRl4UZuql3dofyVwZV87JUmSJEkaOv7eq9RHjTECUm6MTeXI31xUroxN\n5ci4bDKplSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLptMaiVJkiRJQ8ukVuojxy0qV8amcuT4\nMOXK2FSOjMsmk1pJkiRJ0tAyqZX6yHGLypWxqRw5Pky5MjaVI+OyyaRWkiRJkjS0TGqlPnLconJl\nbCpHjg9TroxN5ci4bDKplSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLptMaiVJkiRJQ8ukVuoj\nxy0qV8amcuT4MOXK2FSOjMsmk1pJkiRJ0tAyqZX6yHGLypWxqRw5Pky5MjaVI+OyyaRWkiRJkjS0\nTGqlPnLconJlbCpHjg9TroxN5ci4bDKplSRJkiQNLZNaqY8ct6hcGZvKkePDlCtjUzkyLptMaiVJ\nkiRJQ8ukVuojxy0qV8amcuT4MOXK2FSOjMsmk1pJkiRJ0tAyqZX6yHGLypWxqRw5Pky5MjaVI+Oy\nyaRWkiRJkjS0jh50B4bWihWwdet08ZiU4NJLB9ihIbdlCxw8CCtX9n8dVStXwoUXdm4zX31rm5b6\nMYD77uvrOrpeRmv7heq0/hwtdj90E5fztel2Gcu8jlljapfjPSjNw/Fhh7e0YsWc55jF1vdzHb3E\n5lJsh9QNz5lNA0tqI+Io4PPA7pTSv4uI44HrgGcAO4FXp5T2l20vB34V+AHwmymlm5a8Qxs2wORk\n9+1f/eoZxdi8eYk7dIQ5eLA4Bsu9jk2b5m4zX31rm1zXsZSW41gtlcX2tZv552uzHMtYrn5K0iI8\nfN55HDc62rf6GW06fKdbinU8dP75rOqmD31ch6SZBnn78euBO4FUli8Dbk4pjQKfKstExKnA+cCp\nwNnANRHhbdMaCo5bVK6MTeXI8WHKlbGpHBmXTQNJDiPiRODngb8Eopz8SmBL+XoLcG75+lXAtSml\nR1NKO4G7gRcvX28lSZIkSbka1BXPdwL/DXisMm1NSmlP+XoPsKZ8XQN2V9rtBk7oew+lJeBvgSpX\nxqZy5Pgw5crYVI6My6ZlT2oj4hzgmymlL9G8SjtDSinRvC25bZN+9E2SJEmSNFwG8aCoM4BXRsTP\nAz8EPCki3g/siYinppQeiIinAd8s298PPL0y/4nltFnWr1/P2rVrAYhDhzjtlFNYVw7EH5+YYO/D\nD0+XJyYmWL169fTVivHxcfbu2sW6M8+cbg/N/wGZr3zLjh2MjI/PWB5gudvy9u3Qsv96OR637NjB\nyP79xdOGq8uvlrdvn7t+IeXW7Wmpb0zrx/6Zs36+9gspt9t/S9m+pbyQ9+PzW9e30PU39t9c83ez\nfd3Wdzpe89X3crxb+nvbbbdxySWXdL09rcejej6drm/M3+b4TO3YwTlr1szdv5NPnnt/tZRHa7Wu\n+z/f9kAlfrrYnz2fn1rfn8wfH9Pb1+Pn0VKU5z1efepfdXxYv7d31vmisX19WP7evXtZt25d2/bt\nvj8s5vvIwOKl3N6JbdtYfcwxzfhubT9f/CyyfmLbNlbX6/PWdzreneobbWad/9rsjxnfNxv7o4d6\ngNHTT5+zfsniM4P4sbzw8p+8+908/7TTln/9FCa2bQOY8X0Aevz8rtQ34n06/icmuOOOO0gpceDA\nAfbt20cnUVwUHYyIeBnw2+XTj68G9qWU3h4RlwGrUkqXlQ+K+iDFONoTgE8Cz0otHY+IGZPq5VPv\naqOj1CcnqY2MUJ+aolbu9Hq9Tq3codV5aiMjC9qW/Zs3s+qKKxY0ryie3tvy5NVejsf+zZtZtWZN\n+6cCN6a1Wcesab2W51nH+Pg4Y5OTfV1H18tYrMYyu132IvuwkPfjrPfhQvvQzbZ22wYWvow+rmO8\n8SW6y+Paejyq59Pp+htugAsuaDt/x/dot9vRoU9QnOd7jct28TUdP10sq+v43LqV/QcPzo5LWLp1\n9MG8x4v+9G98YmLZbqdrt41LuU3V81HjO8eccVcxyGO/EDO2tdH3rVtnnQ9mfA9rs42Lra+2ma++\n13VUY7Nf6+hlOxZrf/mrHasuuqhzozbHUHlZznPmDFu3Uj/33OliT5/DFHF/7HXXdTz3Tcd/vV4s\nv1abPo9GBCmlWXf75vAU4UYmehXwioiYBH62LJNSuhO4nuJJyZ8ALm5NaKVcNf7nScqNsakcOT5M\nuTI2lSPjsmlgv1MLkFL6R+Afy9ffBl7eod2VwJXL2DVJkiRJ0hDI4UqtdNhqjBWQcmNsKkf+5qJy\nZWwqR8Zlk0mtJEmSJGlomdRKfeS4ReXK2FSOHB+mXBmbypFx2WRSK0mSJEkaWia1Uh85blG5MjaV\nI8eHKVfGpnJkXDaZ1EqSJEmShpZJrdRHjltUroxN5cjxYcqVsakcGZdNJrWSJEmSpKFlUiv1keMW\nlStjUzlyfJhyZWwqR8Zlk0mtJEmSJGlomdRKfeS4ReXK2FSOHB+mXBmbypFx2WRSK0mSJEkaWia1\nUh85blG5MjaVI8eHKVfGpnJkXDaZ1EqSJEmShpZJrdRHjltUroxN5cjxYcqVsakcGZdNJrWSJEmS\npKFlUiv1keMWlStjUzlyfJhyZWwqR8Zlk0mtJEmSJGlomdRKfeS4ReXK2FSOHB+mXBmbypFx2WRS\nK0mSJEkaWia1Uh85blG5MjaVI8eHKVfGpnJkXDaZ1EqSJEmShpZJrdRHjltUroxN5cjxYcqVsakc\nGZdNJrWSJEmSpKFlUiv1keMWlStjUzlyfJhyZWwqR8Zl07IntRHx9Ij4dETcERH/EhG/WU4/PiJu\njojJiLgpIlZV5rk8Ir4WEXdFxFnL3WdJkiRJUp4GcaX2UeANKaXTgJcCr4uIU4DLgJtTSqPAp8oy\nEXEqcD5wKnA2cE1EeIVZQ8Fxi8qVsakcOT5MuTI2lSPjsmnZk8OU0gMppdvK11PAV4ETgFcCW8pm\nW4Bzy9evAq5NKT2aUtoJ3A28eFk7LUmSJEnK0tGDXHlErAX+FbANWJNS2lNW7QHWlK9rwOcqs+2m\nSIKzklasgE2bBt2N4bVy5aJmTytWtF/GypXN4zJffbs289XPs47x8XHG+ryOrpexWI119GPZS2TW\n+3Chfe1mW7tts5j19HEd4+PjxdXaZTquHd+j1X4O2HT8LGVfVqwgpTRzWgbbOp95j1efjE9MLNuV\nh0Fto4bTcsbmckgrVgy6C1oCh1tcLsbAktqIGAH+Fnh9SulAREzXpZRSRKSOM8NcdQPx8Hnncdzo\n6KC7ccTquP8vvHDuGRdbPyzrWAq9rmPDhv70Yw5L9j5cimPSTZscYmMpY+eCCzpWzXtsFtuPbuNt\njnZ9OY+/+tU8PDXFcdVpy/F+XaQj4TOt39v40Pnns2r+Zl23y1nbbZjjfKDBe/i88wBmnptaeQzV\nyQUXwNTUzGk9fu9b6nPfQJLaiHg8RUL7/pTSDeXkPRHx1JTSAxHxNOCb5fT7gadXZj+xnDbL+vXr\nWbt2bbGOQ4c47ZRTWFd+YI1PTLD34YenyxMTE6xevXp6XNn4+Dh7d+1i3ZlnTreH5r3q85Untm1j\ndb0+Y3mA5UWUezke7v/Dr7yQ9+Po6adn0/9hKDcs5HhUz6fdHK/W9kvR/9FabcHzt+tvL/GzHOen\n6e3r8fNoKcrdHK9+9G/sjDOWbXs7Hu8+LH/v3r2sW7eubft28bGY7yODjpeJbdtYfcwxndvPFz+L\nrG/sz/nqOx3v+epnvT8WsD+62V+N+Jl3fy42PjOIH8sLLzemDWr9E9u2AfT8+d7p87sR79PxPzHB\nHXfcQUqJAwcOsG/fPjqJWbdF9VkUl2S3APtSSm+oTL+6nPb2iLgMWJVSuqx8UNQHKcbRngB8EnhW\naul4RMyYVJ+cBKA2Okp9cpLayAj1qSlq5U6v1+vUyh1anac2MrKg7aouW0ujl+Ph/j/8LOT9aBz0\nT+vxaN3X8x2vfhyb6nl+IfO29reXPi7H+Wkxn0mL1U2fB9m/pdBuG5dym9p95+g27oZt387Y1jn6\nPl+7xdZX28xXP+zrWKx6eZVtmOJMealXrtT2+hnX6fO7NWer1+tFu1pt+jwaEaSUonWZg3iK8E8C\nFwA/ExFfKv/OBq4CXhERk8DPlmVSSncC1wN3Ap8ALm5NaKVctV4Rk3JhbCpH/uaicmVsKkfGZdOy\n336cUrqFzsn0yzvMcyVwZd86JUmSJEkaSv7eq9RHjTECUm6MTeXIp3gqV8amcmRcNpnUSpIkSZKG\nlkmt1EeOW1SujE3lyPFhypWxqRwZl00mtZIkSZKkoWVSK/WR4xaVK2NTOXJ8mHJlbCpHxmWTSa0k\nSZIkaWiZ1Ep95LhF5crYVI4cH6ZcGZvKkXHZZFIr9dFtt9026C5IbRmbytFtd9wx6C5IbRmbypFx\n2WRSK/XR/v37B90FqS1jUzna/93vDroLUlvGpnJkXDaZ1EqSJEmShpZJrdRHO3fuHHQXpLaMTeVo\n565dg+6C1JaxqRwZl02RUhp0H5ZERBweGyJJkiRJaiulFK3TDpukVpIkSZJ05PH2Y0mSJEnS0DKp\nlSRJkiQNLZNaSZIkSdLQMqmVJEmSJA0tk1pJkiRJ0tAyqZUkSZIkDS2TWkmSJEnS0DKplSRJkiQN\nLZNaSZIkSdLQMqmVJEmSJA0tk1pJkiRJ0tAyqZUkSZIkDS2TWkmSJEnS0DKplSRJkiQNLZNaSZIk\nSdLQMqmVJEmSJA0tk1pJkiRJ0tAyqZUkSZIkDS2TWkmSJEnS0DKplSRJkiQNLZNaSZIkSdLQMqmV\nJEmSJA0tk1pJkiRJ0tAyqZUkSZIkDS2TWkmSDlMRsTMizhx0PyRJ6ieTWkmSKjolghExFhG7ytd3\nRMSB8u/7EfFwpfxY5fWhiDhYKV9TXU6bdbyvpf2BiPjSHH19UkT8SUTcV7a9OyLeGRFPKZuk8m8x\n+2NjRLx/McuQJKmfTGolSZpp3kQwpXRaSumJKaUnAp8BXtcop5QeV6n7APD2St3FXay72v6JKaV/\n1a5hRKwAPgWcAvxcub6fAPYCL+ppi/soIo4adB8kSYc3k1pJkhYvFli3GL8CPB04L6V0F0BK6Vsp\npd9PKd04qxPFVeC3VcozrhhHxKURsTsivhsRd0XEz0bE2cDlwPnVq8YR8eSI2BwR9XKet0XE48q6\n9RHx/yLijyNiL/CWPm2/JEkAHD3oDkiSdBhY1C2+LbpNgl8OfCKl9FCX7TtegY6Ik4HXAS9MKT0Q\nET8CHJ1SujcirgSemVL6lcos7wMeAJ4JjAAfBXYBm8r6FwMfBH4YWNFl/yRJWhCv1EqSlI8Afjsi\nHqz8vbdD2+OBbyxg+e38AFgJnBYRj08pfT2ldG9lnun5ImIN8G+AN6SUHk4pfQv4E+AXKsurp5T+\nV0rpsZTSIz32UZKknnilVpKkfCTgD1NKv9tF231AbUlWmtLdEXEJsJEisf174LdSSu2S5mcAjwe+\nETGd6z4O+HqlTdsHYUmS1A9eqZUkaTh9Evi5iDi2y/bfA6ptn1qtTCldm1L6KYqkNQFvb1S1LGcX\ncBB4SkrpuPLvySml51YX1+1GSJK0WCa1kiTNtiIifqjyN98TfDvd1ttxfGxErKyuo9K+2zG176dI\nMP82Ik6OiMdFxFMi4nci4t+0aX8b8PMRcVxEPBW4pNKX0fLBUCspEtZHKG5JhmLs7NooL8uWV29v\nAv44Ip5YrveZEfHTXfZbkqQlZVIrSdJsHwceqvy9hbl/6meu6a11CTgBeLiy/O9FxDPLuje1/E7t\nN9suOKVDFA+Lugu4GfgOsI1irO3n2szyfuDLwE7gRuCvK31bCfwB8C2KcbqrKZ56DPB/yn/3RcTn\ny9e/QvEAqDuBb5dtGld+F/3buJIk9SJS8nNHkiRJkjScvFIrSZIkSRpaJrWSJEmSpKFlUitJkiRJ\nGlomtZIkSZKkoXX0oDuwVCLCJ15JkiRJ0mEspTTrp+8Om6QWoPok5/rkJAC10VHqk5PURkaoT01R\nGx0t6ut1arXajPkb7RaiumwtjV6OR677f+PGjWzcuHHQ3RhKC3k/5hoHOeo1NluPR+u+nu949ePY\nVM/zC5m3tb+99HE5zk+L+UxarG763I/+bXzHO9j4xjcu6TI7abeNS7lN7b5zdBt3gzz2CzFjW+fo\n+3ztFltfbTNffa/rqMZmv9bRy3YsVn1qCmCo4kyzLec5s1UjhqD3z+FOn9+tOVu9Xi/a1WrT59Hy\nJ9Nn8fZjqY927tw56C5IbRmbytHOXbsG3QWpLWNTOTIum0xqJUmSJElDy6RW6qP169cPugtSW8am\ncrT+1a8edBektoxN5ci4bDKplfpobGxs0F2Q2jI2laOxM84YdBektoxN5ci4bDKplfpofHx80F2Q\n2jI2laPxiYlBd0Fqy9hUjozLJpNaSZIkSdLQMqmV+shbPJUrY1M58lY65crYVI6MyyaTWkmSJEnS\n0DKplfrIcYvKlbGpHDk+TLkyNpUj47LJpFaSJEmSNLT6ltRGxHsiYk9E3F6Z9ocR8dWI+HJEfCgi\nnlypuzwivhYRd0XEWZXpL4iI28u6d/Wrv1I/OG5RuTI2lSPHhylXxqZyZFw29fNK7XuBs1um3QSc\nllJ6HjAJXA4QEacC5wOnlvNcExFRzvPnwEUppWcDz46I1mVKkiRJko5QfUtqU0qfAR5smXZzSumx\nsrgNOLF8/Srg2pTSoymlncDdwEsi4mnAE1NKt5bt/go4t199lpaa4xaVK2NTOXJ8mHJlbCpHxmXT\nIMfU/irw8fJ1DdhdqdsNnNBm+v3ldEmSJEmSBpPURsSbgUMppQ8OYv3ScnHconJlbCpHjg9TroxN\n5ci4bDp6uVcYEeuBnwfOrEy+H3h6pXwixRXa+2neotyYfn+nZa9fv561a9cW6zl0iNNOOYV1o6NA\ncXn+2o8/jhe8tCh/4QtfZGRkkpNPHgNg+/Zxph78Ni94zs8W5XtuAeDkZ/7rtuV7v/4Zzh47OB1M\nE9u2sbpen/6i2Li1z3Lv5S1b4Ctf6e14fOXuz7HuF93/OZVvvBFOOqkob98+zuMfD1ddNbP9ffeN\ncfBgUQ8s+P3YKD/9pBdyyaV5bP8wly+7bJxHH515PA4e+DZ/tvGlRfuJCf7mpsdx+gtHp+vnO14H\n0yH+bNPokvZvzapTANizf2niq5v46fX8tHJF4glP+VRPnw/V7Vu1cmXX8b+U5dbj1fp+hsH2bynK\nrcf7vvvG2PP1J7Nn9z8vyfLXnPgiVq0p421qihe8oMb+PbOXX/38WsjnXw7lqUcPNb9ffe5fGHn8\nirbtH0qP44EHO8f3Yusb+3Pk+DrHP2Hu+pNOGut4POaqr25vp/qD6RAv+slRDh5svz/mq6/Gz1z7\nczHlp5/0QgB23fv5vseH5cOzvP/gUdyz4/8BTL//233etitXP7+r9Y14n47/L3yRev124CCPPPII\nU1MP0EmklDpWLlZErAU+klJ6blk+G3gH8LKU0t5Ku1OBDwIvpri9+JPAs1JKKSK2Ab8J3Ap8DPjT\nlNKNbdaVqttSn5wEoDY6Sn1yktrICPWpKWplkluv16nVatPtN22Cc8aKdt3YtPVYNlzwUHN9lWVr\ncTZtgg0bmD5u3bh681G86Yo1fe5Z78bHx6e/qB5pGsexU7nTtIZejn9DrnGQo7lis91xufpte3jT\nRT9ollv2dX1yko/e8MMzzosz5l/CY1M9R0Bxnu82vuY6v3TTx17PT5u2Hss5536zp8+HhZwDl1rr\nvou8asIAACAASURBVGi3L/vRv/GJiWW78tBuG3v5HtDL8hvfOeaLuxyO/ULM2Nay763fkxrtVq1Z\nM+d7cDH11TadjuVC11GNzcb2zteHxW7HXOtYrKs3HwUw47zeqt0xVF6W85xZ1fhsa+j0OdxJfXKS\nrdc9edZnbuO7RiOvqtfrxfJrtenzaESQUorWZfbtSm1EXAu8DFgdEbuAt1A87XgFcHP5cOPPppQu\nTindGRHXA3cC3wcurmSoFwPvA44BPt4uoZUkSZIkHZn6ltSmlF7TZvJ75mh/JXBlm+lfAJ67hF2T\nls2RepVW+TM2lSPHhylXxqZyZFw2DfLpx5IkSZIkLYpJrdRHjQeQSLkxNpUjf3NRuTI2lSPjssmk\nVpIkSZI0tExqpT5y3KJyZWwqR44PU66MTeXIuGwyqZUkSZIkDS2TWqmPHLeoXBmbypHjw5QrY1M5\nMi6bTGolSZIkSUPLpFbqI8ctKlfGpnLk+DDlythUjozLJpNaSZIkSdLQMqmV+shxi8qVsakcOT5M\nuTI2lSPjssmkVpIkSZI0tExqpT5y3KJyZWwqR44PU66MTeXIuGwyqZUkSZIkDS2TWqmPHLeoXBmb\nypHjw5QrY1M5Mi6bTGolSZIkSUPLpFbqI8ctKlfGpnLk+DDlythUjozLJpNaSZIkSdLQMqmV+shx\ni8qVsakcOT5MuTI2lSPjssmkVpIkSZI0tExqpT5y3KJyZWwqR44PU66MTeXIuGwyqZUkSZIkDS2T\nWqmPHLeoXBmbypHjw5QrY1M5Mi6bTGolSZIkSUPLpFbqI8ctKlfGpnLk+DDlythUjozLJpNaSZIk\nSdLQ6ltSGxHviYg9EXF7ZdrxEXFzRExGxE0RsapSd3lEfC0i7vr/27v/IDnK+87jny/CUqSTjU63\n54URKtYJHltQVs5gE+IU5c3BUZQjA+a2wK4okXJcRB1JjF11AXFV+FJOHWVU8SV2Ulx5ExnLluGg\nSELF+BeCy/gHU7UOMfKPFewanZRImkPKigikIEtgvvfH9EzPjOZHz4+efkb7flVRzNPPM91Pd3+m\nZx71PjNmdm3N8svN7EdR3WfS6i+QBuYtIlRkEyFifhhCRTYRInIZS/NO7QOSrmtYtlXSLnfPS3oq\nKsvMLpF0i6RLoufcb2YWPed/SbrV3d8u6e1m1rhOAAAAAMAildqg1t2/I+mfGxZfL2lH9HiHpBuj\nxzdIesjdX3P3/ZJekPRLZnaBpDe7+/eidl+seQ4QPOYtIlRkEyFifhhCRTYRInIZG/ac2nF3Pxw9\nPixpPHqck3Swpt1BSWuaLD8ULQcAAAAAILsvinJ3l+RZbR8YBuYtIlRkEyFifhhCRTYRInIZO3fI\n2ztsZue7+4vRnxYfiZYfkrS2pt2FKt+hPRQ9rl1+qNXKN2/erImJCUmSnT6tS9et01Q+L6l80hdO\nnqyWi8WixsbGqn+CNzdX0OrlBzR19dXV9lJ8W7+xPLf3uyoUf1otF2dmNFYqVddX+cBIuffywoHk\n52PvvqdVKKwOqv+1QunPMMtzc5LUulzW+vndnP/4on5VMPsfenn37t0t6+fmCioU6tvv3feSpCvL\n5WJRe/edI+mmav3CgQOSPlitl+rPT2P7fvpf6V8+l6vWDyJf3eSnm3x2+/5wxv4lzP8gy43nq9nx\nzbJ/gyg3nu/q/qWw/oWFBU1NTTVt3+z9q5frX5bl2rwUZ2Y0tny5pGuatu+U737r9+57WiuPrdaG\nyfb1rc53q/qKM14fLY7H5eP1x6Ob+rKr2tYPLJ8B5Idy7+Xds7OZbL/y+i7OzEhSPN5K+H5e+/5d\nW79339MqFN9Qfv368vqLRc3Ozsrddfz4cR09elStWPmGaTrMbELSV9z9XVF5m6Sj7n6fmW2VtMrd\nt0ZfFPWgpCtU/vPiJyVd7O5uZjOSPirpe5K+Kumz7v6NJtvy2n0pzc9LknL5vErz88qtXKnSiRPK\nRQe9VCopFx1QSZqeljZMltslMb1zhbZsfDXeXs260Z/paWnLFlXPWxLbti/RnfeMd26Ioamcx1bl\nVssqujn/FeRgMJqdl21/eFh33vqzuNxwrEvz83r8sbfWXRfrnj/Ac1N7jZDK1/mk+Wp3fUnSx26v\nT9M7V2jDjUe6en/o5Ro4aI3HotmxzLJ/g9BsH7v5HNDN+iufOTrlLoRz34u6fY363vg5qdJu1fh4\n29dgP/W1bVqdy0Ft4857xjv2Ic1t9Gvb9iWSVHddb9TsHAJS/N5W0ep9uJXS/Lx2PnzeGe+5lc8a\nlXFVqVQqrz+Xq15HzUzubo3rTO1OrZk9JOn9ksbM7ICkT0j6lKRHzOxWSfsl3SxJ7r7HzB6RtEfS\n65Jurxmh3i7pC5KWS/paswEtAAAAAGBxSvPbjz/i7jl3X+rua939AXd/yd2vcfe8u1/r7sdq2t/r\n7he7+zvd/Zs1y//e3d8V1X00rf4CaYj/rA0IC9lEiJgfhlCRTYSIXMYy+6IoAAAAAAD6xaAWSFFl\n4jsQGrKJEPGbiwgV2USIyGWMQS0AAAAAYGQN+yd9gNTs2CGdOlW/bNkyadOmbPojlectjuIdsTSO\n5bJl5W/2bFyGbHSbzaVLXdM7V9SUf9r1NpvlqiJpvnbsSJabpO1aPbddPwdhGNvoV20fh9WnQrHI\nnQcEiWwiROQyxqAWZ41Tp5r/fAe6l8axzPIfF9C/mz/0inIr36iWSydOSDq/q3U0y1VF0ny1W0cv\n7Qb93JC20a9R6CMA4Oyx8ZaXJfX2E1b8+TGQolG8S4vFgWwiRNxxQKjIJkJELmMMagEAAAAAI4tB\nLZAifgsUoSKbCBG/uYhQkU2EiFzGGNQCAAAAAEbWWfVFUWa1pbwkyb152zVrck2W5uWHSs3X3aT9\nbXetat3emi5u2R/ad2jf9Hwp0fG/7bYU+pOwfWXeYnDHs8f2tccyjfb1uns9StJ9nzzcxfqzP55Z\ntq+dU9us/W23dft6zOtz9x3r2D7N12Nj3lp9yVG5ff6M5d3lp4t83rVKUvf7e2iuRftur4d9tE90\nvgbYn2bzw1Lf3yafHQa//spzEqy/RT7TOL9ptF/zjrjvt0XZ73b9t93WOv+33VbJZf0x6rb/ra4P\nd31ivLqd+vPVfO5iq/V/7nPN13/m6yv6vJrgeNYalTzQPu32U5n2pzGflfeMzu935efd9Yn27evH\na837VsGdWgAAAADAyDqr7tTWjvJL8/PRo+b/wnXoUEm5XDzin56WNkzOq9XXSDf+C8X0zhXasvHV\nRH1JgvYd2rf4F6JO65+eTvaTFGn1v/JboMEdzx7aJz2WvbZvVH4NJ3s9VmzbviTx+rvtz9nWvvZ3\nahvbdzp3fqik0okTyuXj62tpfl6PP/bWlu23bV+iVePjqb0eG/vc7ieC3Mv9za2sz1c3+Umaz+md\nK7ThxiN1xyrJ+svbaNG+2+thD+27Ol8D7E+z31xMfX9r3i82TJ6Zi0Gsv1Qqf+Zolrum7RO067k/\nKbc/NFfue6fPSc3WX5u7Vvn/3OcU1Sc7Ro39r2yjlfs+ebimD/E2Wv0eaLPjU76WNN9G4+ur035U\njmdSoeWB9um27/Q7tcN4vUtSLp9P9Lmvcr0tzc9r58Pn6c57Wr8WpfJ4TVL5+hldR1v9dRN3agEA\nAAAAI4tBLZAifgsUoSKbCBG/uYhQkU2EiFzGGNQCAAAAAEYWg1ogRfwWKEJFNhEifnMRoSKbCBG5\njDGoBQAAAACMLAa1QIqYt4hQkU2EiPlhCBXZRIjIZYxBLQAAAABgZDGoBVLEvEWEimwiRMwPQ6jI\nJkJELmMMagEAAAAAI4tBLZAi5i0iVGQTIWJ+GEJFNhEichljUAsAAAAAGFkMaoEUMW8RoSKbCBHz\nwxAqsokQkcsYg1oAAAAAwMjKZFBrZneb2ayZ/cjMHjSzZWa22sx2mdm8mT1hZqsa2v/EzJ43s2uz\n6DPQC+YtIlRkEyFifhhCRTYRInIZG/qg1swmJP22pMvc/V2Slkj6sKStkna5e17SU1FZZnaJpFsk\nXSLpOkn3mxl3mAEAAAAAmdypfUXSa5JWmNm5klZIKkm6XtKOqM0OSTdGj2+Q9JC7v+bu+yW9IOmK\nofYY6BHzFhEqsokQMT8MoSKbCBG5jA19UOvuL0n6tKR/VHkwe8zdd0kad/fDUbPDksajxzlJB2tW\ncVDSmiF1FwAAAAAQsCz+/PgXJH1M0oTKA9aVZraxto27uyRvs5p2dUAwmLeIUJFNhIj5YQgV2USI\nyGXs3Ay2+R5JRXc/Kklm9leSflnSi2Z2vru/aGYXSDoStT8kaW3N8y+Mlp1h8+bNmpiYkCTZ6dO6\ndN06TeXzksq35xdOnqyWi8WixsbGqh/s5uYKWr38gKauvrraXorD0lie2/tdFYo/rZaLMzMaK5Wq\n66v8aR/l3ssLB5Kfj737ntbKY6sl1a+vsRzS/oVcnpsrqFCor5+bk7o5nt22byx3c/7jP7+5aijH\n52wvNzv/jeej9npaqZc+WK2X6s/P3n3n6PLxm1puv5e85HO5ls/vtL5m+arkp9n+J3l+q3w2e39I\nsr/V/UuY/0GWO52vrPs3iHLj9aJ6PlJY/8LCgqamppq237vvaRUKq/u+/mVZ3rvvHEnlvBRnZjS2\nfLmka5q2r7y+WuWn3/rK54ENk+3rW53vTvWN+9vp9VM5Ht3Ul13Vtn5g+QwgP5RHr1x5fRdnZiSp\n7vOA1N37d219Je/59evL5WJRs7OzcncdP35cR48eVStWvik6PGb2i5K+LOm9kn4q6QuSvifpIklH\n3f0+M9sqaZW7b42+KOpBlefRrpH0pKSLvaHjZla3qDQ/L0nK5fMqzc8rt3KlSidOKBcd9FKppFx0\nQCVpelraMFlul8T0zhXasvHVeHs160Z/pqelLVtUPW9JbNu+RKvGx7VlS/N1ZaVQKFRfqKOk2XHr\n9lj2e+y7Of8V27Yv0Z33jHduiLbZbHbuGs9H4zWvND+vxx97a911sVar12i7bXZqV3udb3x+q/W1\nu75U8pOkL0nzOb1zhTbceOSM94dBbiMNnc6XlE7/CsXi0O48NF4vuv0c0M36K5852uWu0odu3/9C\nULevUd8bPydV2lVy1epY9FNf26bVuex1G7XZrOxvpz70ux/tttGvbduXSJLuvPVnLds0O4cIyzCv\nmbUq720Vzd6H2ynNz2vnw+ed8ZmtccxWKpXK68/lqtdRM5O7W+M6h36n1t1/YGZflPSMpDckfV/S\ntKQ3S3rEzG6VtF/SzVH7PWb2iKQ9kl6XdHvjgBYAAAAAsDhl8efHcvdtkrY1LH5JlXvZZ7a/V9K9\nafcLGLRRvEuLxYFsIkTMD0OoyCZCRC5j/N4rAAAAAGBkMagFUhR/AQkQFrKJEPGbiwgV2USIyGWM\nQS0AAAAAYGR1HNSa2f81s//SsOzx9LoEnD2Yt4hQkU2EiPlhCBXZRIjIZSzJndrXJE2a2QNmtixa\ntibFPgEAAAAAkEiSQe2r7n6LpOckfdvMLkq5T8BZg3mLCBXZRIiYH4ZQkU2EiFzGEv+kj7tvM7Pv\nS3pC0ur0ugQAAAAAQDJJBrWfqDxw9yfN7FpJm9LrEnD2YN4iQkU2ESLmhyFUZBMhIpexloNaM7tc\nkksqmdllDdVfTbVXWLR27JCWLevcDv3ZsUM6dap1fbfnoNP6QtWq38uWSZs2tW/XbZt+64e5jaxe\ng0ly1K5v09PJ2g3bI3/9Fq3413E5pL4tdrWZy/K8VLJLNgCgN+3u1H5a5UGtJL1H0jMN9b+aSo+w\nqJ06JW3ZknUvBqdQKAR5R2zQx7nZ+moHGKFqdRwa+55k/zq16bd+0NuoZDPJNoal322Heu04fdr0\nsZq+jcJrIyuFYnGodx4aM1eaH9qm64SaXcSGnU0gCXIZazmodffJymMze9bdGcQCAAAAAIKS5NuP\nAfQoxLu0gEQ2ESbuOCBUZBMhIpcxBrUAAAAAgJHVclBrZn9a+U/SGjP7bM2yzw6xj8DI4rdAESqy\niRDxm4sIFdlEiMhlrN0XRf29yl8UZdHjWn5mcwAAAAAAhqvdF0V9YYj9AM5KzFtEqMgmQsT8MISK\nbCJE5DLW7ndqv6L4Tm0jd/frU+sVAAAAAAAJtPuiqCslrZX0HUl/FP336Zr/AHTAvEWEimwiRMwP\nQ6jIJkJELmPt5tReIOk/SPpI9N9XJT3k7rPD6BgAAAAAAJ20vFPr7q+7+9fd/TdVvmv7gqRvmdnv\nDq13wIhj3iJCRTYRIuaHIVRkEyEil7F2d2plZj8n6dckfVjShKTPSPrr9LsFAAAAAEBn7X6n9kuS\nipLeLemT7v5ed/9Ddz80tN4BI455iwgV2USImB+GUJFNhIhcxtrdqf11Sf8i6Q5Jd5jVfQmyu/tb\n0uwYAAAAAACdtPud2nbfjAwgAeYtIlRkEyFifhhCRTYRInIZY+AKAAAAABhZmQxqzWyVmT1qZs+Z\n2R4z+yUzW21mu8xs3syeMLNVNe3vNrOfmNnzZnZtFn0GesG8RYSKbCJEzA9DqMgmQkQuY1ndqf2M\npK+5+zpJ6yU9L2mrpF3unpf0VFSWmV0i6RZJl0i6TtL9ZsYdZgAAAADA8Ae1ZnaepKvc/fNS9fdw\nX5Z0vaQdUbMdkm6MHt8g6SF3f83d96v8e7lXDLfXQG+Yt4hQkU2EiPlhCBXZRIjIZSyLO55vk/RP\nZvaAmX3fzP7czP6VpHF3Pxy1OSxpPHqck3Sw5vkHJa0ZXncBAAAAAKHKYlB7rqTLJN3v7pep/LNB\nW2sbuLtL8jbraFcHBIN5iwgV2USImB+GUJFNhIhcxtr9Tm1aDko66O5/F5UflXS3pBfN7Hx3f9HM\nLpB0JKo/JGltzfMvjJadYfPmzZqYmJAk2enTunTdOk3l85LKJ33h5MlquVgsamxsrPoneHNzBa1e\nfkBTV19dbS/Ft/Uby3N7v6tC8afVcnFmRmOlUnV9lQ+MlLsrS3F54UDy87F339NaeWx13fMb15fN\n/ijT7bcqz80VVCh09/y5OanV8Wy2vnbtk5S7Of/xRf2qrraXdH+S7F+z/R1kfbv+9lK/e/fuvs5H\n7fW0Ui99sFov1Z+fvfvO0eXjN7Vc/9yc9I53JO+PJOVzubrnd5O3Zvmq5CfJ66Pb61OhsLouT2UJ\n9y9h/gdZ7nS+su7fIMotrxcprH9hYUFTU1NN2zfmo9frX5blvfvOkVTOS3FmRmPLl0u6pmn7yuur\nVX76ra98Htgw2b6++vpLWF/RuL+dXj+V49FNfdlVbesHls8A8kO59/Lu2dlMtl95fRdnZiSp7vOA\n1N37d219Je/59evL5WJRs7OzcncdP35cR48eVStWvik6XGb2bUn/2d3nzewPJK2Iqo66+31mtlXS\nKnffGn1R1IMqz6NdI+lJSRd7Q8fNrG5RaX5ekpTL51Wan1du5UqVTpxQLjropVJJueiAStL0tLRh\nstwuiemdK7Rl46vx9mrWjd5NT0tbtpQfV85bEtu2L9Gq8fHqc5utD7Fejku75zSr6/fYd3P+K7Zt\nX6I77xnv3DDSqo+Ny5PsX6c2/dZnuQ3pzPPReM0rzc/r8cfeWnddrNXqNVq7Xam7zNRe55PmrdKu\nWb4q+UmyrqT5nN65QsdOnarLZdJ97eU1MCidzpeUbf8Godk+DnKfaq9Hlc8c7XJXa9SObd2+Rn1v\n/JxUaVc55q2ORT/1tW1afaYb1DbuvGe8Yx/S3Ea/tm1fIkm689aftWzT7BwCUjkbG248Ui138z4s\nlXO/8+HzWl77Kp8xSqVSef25XPU6amZyd2tcZxZ3aiXp9yR92cyWStor6bckLZH0iJndKmm/pJsl\nyd33mNkjkvZIel3S7Y0DWgAAAADA4pTJT+O4+w/c/b3u/ovufpO7v+zuL7n7Ne6ed/dr3f1YTft7\n3f1id3+nu38ziz4DvYj/7BMIC9lEiJgfhlCRTYSIXMb4vVcAAAAAwMhiUAukqDLxHQgN2USI+M1F\nhIpsIkTkMsagFgAAAAAwshjUAili3iJCRTYRIuaHIVRkEyEilzEGtQAAAACAkcWgFkgR8xYRKrKJ\nEDE/DKEimwgRuYwxqAUAAAAAjCwGtUCKmLeIUJFNhIj5YQgV2USIyGWMQS0AAAAAYGQxqAVSxLxF\nhIpsIkTMD0OoyCZCRC5jDGoBAAAAACOLQS2QIuYtIlRkEyFifhhCRTYRInIZY1ALAAAAABhZDGqB\nFDFvEaEimwgR88MQKrKJEJHLGINaAAAAAMDIYlALpIh5iwgV2USImB+GUJFNhIhcxhjUAgAAAABG\nFoNaIEXMW0SoyCZCxPwwhIpsIkTkMsagFgAAAAAwshjUAili3iJCRTYRIuaHIVRkEyEilzEGtQAA\nAACAkcWgFkgR8xYRKrKJEDE/DKEimwgRuYwxqAUAAAAAjCwGtUCKmLeIUJFNhIj5YQgV2USIyGWM\nQS0AAAAAYGSdm9WGzWyJpGckHXT3D5rZakkPS7pI0n5JN7v7sajt3ZL+k6SfSfqouz+RTa9jy5a6\npneuqJZf9XP0sbsy7NCI27FDOnVKWrYs/W3UWrZM2rSpdZtO9Y1tzqyf1D/8Q9rbSLaOxva9arX9\nEPV7HJLkslObpOsY9jYa59QO4zUIdML8sLPb0qXe9hrTb32a2+gmm4PYDyAJrpmxzAa1ku6QtEfS\nm6PyVkm73H2bmd0Vlbea2SWSbpF0iaQ1kp40s7y7vzHIzmzZIpXmk7ffdPPJuvK27UsG2Z1F59Sp\n8jkY9jamp9u36VTf2CbUbQzSMM7VoPTb1yTP79RmGOsYVj8BoB83f+gV5fLnp1Zf26bVZ7pBbGPj\nLS9LGu95HYPYBoB6mfz5sZldKOkDkv5CkkWLr5e0I3q8Q9KN0eMbJD3k7q+5+35JL0i6Yni9BXrH\nvEWEimwiRMwPQ6jIJkJELmNZzan9Y0m/L6n2buu4ux+OHh9W/M9TOUkHa9odVPmOLQAAAABgkRv6\noNbMNkg64u7PKr5LW8fdXZK3WU27OiAY/BYoQkU2ESLmhyFUZBMhIpexLObUvk/S9Wb2AUk/J+kt\nZvYlSYfN7Hx3f9HMLpB0JGp/SNLamudfGC07w+bNmzUxMSFJstOndem6dZrK5yWVb88vnDxZLReL\nRY2NjVU/2BUKBS0cOKCpq6+utpfisHQq7933tAqF1XXrk0Q5YXlurqBCob6+m/Oxd9/TWnlstaT6\n9deW5+bUtr6XcuP+dKof5PFpV9+pfS/lZsdvkO0by728HqWr6tbX6/Yrx6/d85PsX9L6VuerU303\n57tTfzvVN56P2utppV76YLVeqj8/e/edo8vHb2q7/Xe8o/3xaiznc7nE/e+0P2VXJT6e3V6fat8f\n5uYK0fYS7l+X70eDKHc6X1n3bxDlxutFdf9SWP/CwoKmpqaatm/2+aGfzyNZ5UUq56U4M6Ox5csl\nXdO8faf89FlfnJnRWKnUsb7V+e5Uf8b1r0N95Xh0Uy9J+fXr29YPLJ8B5Ify6JUrr+/izIwk1X0e\nkLp7/66tr+S9mv9iUbOzs3J3HT9+XEePHlUrVr4pmg0ze7+k/xp9+/E2SUfd/T4z2ypplbtXvijq\nQZXn0a6R9KSki72h42ZWt6g0X/6GgFw+r9L8vHIrV6p04oRy0UEvlUrKRQe09jm5lSt72pdt25fo\nznuY0N+r6ekzv6Smm/OxbfsSrRofb/oFSpVlzbbRuKzbcqdtFAoFzc9PprqNpOvoV2WdSdfdbx96\neT02vg577UOSfU3aRup9HWluo1AoaHJyMvF5bTwftdfTSv3jj71VWza+2vT5rV6jSfejVZ+k8nW+\n21w2y1clP0nWlTSf0ztX6NipU2fkUhrcNtLQ6XxJ6fSvUCwO7c5Ds30c5D7VXo8qnzna5a5Wlue+\nF3X7GvV9eueKM64HdZ/Dmuxjv/W1bTrVd7uN2mymtY1u9qNflS84vfPWn7Vs0+wcIizDvGbWmt65\nQhtuPFItd/M+LJVzv/Ph81pe+6r5L5XK68/lqtdRM5O7n/HXvll++3FFZST6KUmPmNmtin7SR5Lc\nfY+ZPaLyNyW/Lun2xgEtAAAAAGBxynRQ6+7fkvSt6PFLqtzLPrPdvZLuHWLXgIGYnJxUdDMJCErl\nT32AkDA/DKEimwgRuYxl9e3HAAAAAAD0jUEtkKL4C3+AsJBNhIjfXESoyCZCRC5jDGoBAAAAACOL\nQS2QIuYtIlRkEyFifhhCRTYRInIZY1ALAAAAABhZDGqBFDFvEaEimwgR88MQKrKJEJHLGINaAAAA\nAMDIYlALpIh5iwgV2USImB+GUJFNhIhcxhjUAgAAAABGFoNaIEXMW0SoyCZCxPwwhIpsIkTkMsag\nFgAAAAAwshjUAili3iJCRTYRIuaHIVRkEyEilzEGtQAAAACAkcWgFkgR8xYRKrKJEDE/DKEimwgR\nuYwxqAUAAAAAjCwGtUCKmLeIUJFNhIj5YQgV2USIyGWMQS0AAAAAYGQxqAVSxLxFhIpsIkTMD0Oo\nyCZCRC5jDGoBAAAAACOLQS2QIuYtIlRkEyFifhhCRTYRInIZY1ALAAAAABhZDGqBFDFvEaEimwgR\n88MQKrKJEJHLGINaAAAAAMDIYlALpIh5iwgV2USImB+GUJFNhIhcxhjUAgAAAABG1tAHtWa21sz+\n1sxmzezHZvbRaPlqM9tlZvNm9oSZrap5zt1m9hMze97Mrh12n4FeMW8RoSKbCBHzwxAqsokQkctY\nFndqX5P0cXe/VNKVkn7HzNZJ2ippl7vnJT0VlWVml0i6RdIlkq6TdL+ZcYcZAAAAADD8Qa27v+ju\nu6PHJyQ9J2mNpOsl7Yia7ZB0Y/T4BkkPuftr7r5f0guSrhhqp4EeMW8RoSKbCBHzwxAqsokQkctY\npnc8zWxC0rslzUgad/fDUdVhSePR45ykgzVPO6jyIBgAAAAAsMidm9WGzWylpL+UdIe7HzezfVh7\nEgAACYNJREFUap27u5l5m6e3q8vE0qWu6emsezG6li3r7/lLl3rTdSxbpup56VTfrE2n+k7bKBQK\nWrZsMtVtJF1HvyrbSGPdg9L4Ouy1r0n2NWmbfraT5jYKhYImJyeHdl5bvUZr+5m1Sn4G2ZdlS11L\nvf4tK4R97aTT+UpLoVgc2p2HrPYRo2mY2RyGpUuD+yiNHpxtuexHJoNaM3uTygPaL7n7Y9Hiw2Z2\nvru/aGYXSDoSLT8kaW3N0y+Mlp1h8+bNmpiYKG/j9Gldum6dpvJ5SeWTvnDyZLVcLBY1NjZW/RO8\nQqGghQMHNHX11dX2Unxbv1P5wtwuja1dW7c+SZS7KBcK9eVuzkfl+Ev169+0qb7cqb6xf53qJycn\ntWlT6/ryOnp/fqV80UXd1zcez3bPT1K+6KLu2pdfar1vr5fX480fWq9c/vy+97fT8U56PLrJV7Pz\n1am+Nj+d6svi+t27d7etb+xv4/movZ5W6rdsbH2+Lsyd1NRv/EZfx7OxnM/lquWkeduypXW+avPT\n6fWTNJ+bbj6pR596SoVC/P5QyVen/lb3r8v3o0GUO52vrPs3iHLL68WA1r/xlvWSxst5WVjQ1NRU\n0/Y/P/FEXT56vf5lWf75iZOSynkpzsxobPlybdnYon2n/PRZX5yZ0Vip1LG+1fluVV9xxvWvyfGo\n+7wZHY9u6iUpv3592/pB5L9c/mHL9ls2vhpEvii3Lu+enc1k+1s2vk+lE+V8StJUPl99f5WSvX9v\nvOVlFQrP1dVX8l7Nf7Go2dlZubuOHz+uo0ePqhVzH+6/1Fj5luwOSUfd/eM1y7dFy+4zs62SVrn7\n1uiLoh5UeR7tGklPSrrYGzpuZnWLSvPzkqRcPq/S/LxyK1eqdOKEctFFpFQqKRdd8Gqfk1u5sqf9\nql03BqOb88HxP/v08nokB+lpPB+Nx7rT+Urj3NRe53t5bmN/u+njMK5P/bwn9StJn7Ps3yA028dB\n7lOzzxxJczdqx7ZuX9v0vVO7futr23SqH/Vt9Kt04oQkjVTOEJZKhqTu34dbvX83jtlKpVK5XS5X\nvY6amdzdGteZxZ3aX5G0UdIPzezZaNndkj4l6REzu1XSfkk3S5K77zGzRyTtkfS6pNsbB7QAAAAA\ngMUpi28//q67n+Pu/87d3x399w13f8ndr3H3vLtf6+7Hap5zr7tf7O7vdPdvDrvPQK/iP+sEwkI2\nESJ+cxGhIpsIEbmM8XuvAAAAAICRxaAWSFFl4jsQGrKJEPEtnggV2USIyGWMQS0AAAAAYGQxqAVS\nxLxFhIpsIkTMD0OoyCZCRC5jDGoBAAAAACOLQS2QIuYtIlRkEyFifhhCRTYRInIZY1ALAAAAABhZ\nDGqBFDFvEaEimwgR88MQKrKJEJHLGINaIEW7d+/OugtAU2QTIdo9O5t1F4CmyCZCRC5jDGqBFB07\ndizrLgBNkU2E6Ngrr2TdBaApsokQkcsYg1oAAAAAwMhiUAukaP/+/Vl3AWiKbCJE+w8cyLoLQFNk\nEyEilzFz96z7MBBmdnbsCAAAAACgKXe3xmVnzaAWAAAAALD48OfHAAAAAICRxaAWAAAAADCyRn5Q\na2bXmdnzZvYTM7sr6/4AkmRma83sb81s1sx+bGYfzbpPQIWZLTGzZ83sK1n3Bagws1Vm9qiZPWdm\ne8zsyqz7BJjZ3dF7+Y/M7EEzW5Z1n7A4mdnnzeywmf2oZtlqM9tlZvNm9oSZrcqyj1ka6UGtmS2R\n9GeSrpN0iaSPmNm6bHsFSJJek/Rxd79U0pWSfodsIiB3SNojiS9VQEg+I+lr7r5O0npJz2XcHyxy\nZjYh6bclXebu75K0RNKHs+wTFrUHVB7z1NoqaZe75yU9FZUXpZEe1Eq6QtIL7r7f3V+T9L8l3ZBx\nnwC5+4vuvjt6fELlD2e5bHsFSGZ2oaQPSPoLSWd8eyCQBTM7T9JV7v55SXL319395Yy7Bbyi8j9S\nrzCzcyWtkHQo2y5hsXL370j654bF10vaET3eIenGoXYqIKM+qF0jqfYHmg5Gy4BgRP/S+25JM9n2\nBJAk/bGk35f0RtYdAWq8TdI/mdkDZvZ9M/tzM1uRdaewuLn7S5I+LekfJZUkHXP3J7PtFVBn3N0P\nR48PSxrPsjNZGvVBLX86h6CZ2UpJj0q6I7pjC2TGzDZIOuLuz4q7tAjLuZIuk3S/u18m6V+0iP+M\nDmEws1+Q9DFJEyr/tdVKM/v1TDsFtODl32ldtGOjUR/UHpK0tqa8VuW7tUDmzOxNkv5S0k53fyzr\n/gCS3ifpejPbJ+khSf/ezL6YcZ8AqfzefdDd/y4qP6ryIBfI0nskFd39qLu/LumvVL6OAqE4bGbn\nS5KZXSDpSMb9ycyoD2qfkfR2M5sws6WSbpH0Nxn3CZCZmaTtkva4+59k3R9Aktz9v7n7Wnd/m8pf\ndvJ/3P03s+4X4O4vSjpgZvlo0TWSZjPsEiBJz0u60syWR+/r16j8JXtAKP5G0qbo8SZJi/YmyrlZ\nd6Af7v66mf2upG+q/I10292db0tECH5F0kZJPzSzZ6Nld7v7NzLsE9Bo0f6ZEoL0e5K+HP0j9V5J\nv5Vxf7DIufsPor9meUbl7yH4vqTpbHuFxcrMHpL0fkljZnZA0ickfUrSI2Z2q6T9km7OrofZsvKf\nXwMAAAAAMHpG/c+PAQAAAACLGINaAAAAAMDIYlALAAAAABhZDGoBAAAAACOLQS0AAAAAYGQxqAUA\nAAAAjCwGtQAABMDM/o2ZPRv99//M7GD0+LiZ/VnW/QMAIFT8Ti0AAIExs/8u6bi7/8+s+wIAQOi4\nUwsAQJhMksxs0sy+Ej3+AzPbYWbfNrP9ZnaTmf2Rmf3QzL5uZudG7S43s4KZPWNm3zCz87PcEQAA\n0sSgFgCA0fI2Sb8q6XpJOyXtcvf1kk5K+jUze5OkP5X0H939PZIekPQ/suosAABpOzfrDgAAgMRc\n0tfd/Wdm9mNJ57j7N6O6H0makJSXdKmkJ81MkpZIKmXQVwAAhoJBLQAAo+W0JLn7G2b2Ws3yN1R+\nXzdJs+7+viw6BwDAsPHnxwAAjA5L0GZO0r81syslyczeZGaXpNstAACyw6AWAIAwec3/mz1Ww2NJ\ncnd/TdKUpPvMbLekZyX9cpodBQAgS/ykDwAAAABgZHGnFgAAAAAwshjUAgAAAABGFoNaAAAAAMDI\nYlALAAAAABhZDGoBAAAAACOLQS0AAAAAYGQxqAUAAAAAjCwGtQAAAACAkfX/ASY/XLCoV9+/AAAA\nAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trace.analysis.frequency.plotClusterFrequencies()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:35,119 WARNING : Cluster frequency is not coherent, plot DISABLED!\n" + ] + } + ], + "source": [ + "trace.analysis.frequency.plotClusterFrequencyResidency(pct=True, active=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2016-09-23 18:58:35,289 WARNING : Cluster frequency is not coherent, plot DISABLED!\n" + ] + } + ], + "source": [ + "trace.analysis.frequency.plotClusterFrequencyResidency(pct=True, active=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebooks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## New collection of examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each new API introduced in LISA has an associated notebook which shows a\n", + "complete example of its usage.
\n", + "Examples are usually defined to:\n", + "\n", + " - setup the connection to a target (usually a JUNO board)\n", + " - configure a workload (usually using RTApp)\n", + " - run workload and collect required measures\n", + " - show the most common functions exposed by the new API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Energy meters APIs:
\n", + " https://github.com/ARM-software/lisa/tree/master/ipynb/examples/energy_meter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Trace analysis APIs:
\n", + " https://github.com/ARM-software/lisa/tree/master/ipynb/examples/trace_analysis" + ] + } + ], + "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.9" + }, + "toc": { + "toc_cell": false, + "toc_number_sections": true, + "toc_threshold": 6, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} -- GitLab