From 31e6ccc9434bc1a1fccd2bac6e43da8fb8bbd5e2 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Thu, 4 Feb 2016 18:55:15 +0000 Subject: [PATCH 01/13] README.md: added some tools dependencies --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index dca0bbc0e..46faaefcf 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ Debian system. ##### Install additional tools required for some tests and functionalities - $ sudo apt-get install nmap trace-cmd + $ sudo apt-get install nmap trace-cmd sshpass kernelshark ##### Install required python packages -- GitLab From 90b4f5e33f248bd3d6b074afeb8b8ad566a09995 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Thu, 4 Feb 2016 19:00:47 +0000 Subject: [PATCH 02/13] README.md: fixed link to quickstart tutorial --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 46faaefcf..2e287932d 100644 --- a/README.md +++ b/README.md @@ -134,9 +134,10 @@ An easy way to test your installation is to give a run to the EAS RFC tests. These are a set of experiments which allows to compare EAS performance and energy consumption with respect to standard kernel. -*NOTE:* The following [tutorial](Quickstart tutorial) is still recommended it -you want to get a better grasp on how the framework is organized and how to use -it at your best. +*NOTE:* The following +[tutorial](https://github.com/ARM-software/lisa#quickstart-tutorial) is still +recommended it you want to get a better grasp on how the framework is organized +and how to use it at your best. Let's assume your target is running an EAS enabled kernel, to run such tests just run these few steps: -- GitLab From 24a3b74812c1276b7d98820ba4e6968600c1bba0 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Fri, 5 Feb 2016 15:03:07 +0000 Subject: [PATCH 03/13] README.md: add note about ipython version to be installed Some IPython Notebooks from the Quickstart tutorials are written in JSON nbformat version 4. The problem is that if you install ipython and ipython-notebook using apt-get you will get version 1.2.1-2 (as of today) which does not support JSON nbformat version 4. Hence, the solution is to remove ipython and ipython-notebook and install them using pip instead. --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index 2e287932d..51c3376f4 100644 --- a/README.md +++ b/README.md @@ -87,6 +87,15 @@ Debian system. $ sudo pip install --upgrade trappy bart-py devlib +*NOTE:* TRAPpy and BART depend on *ipython* and *ipython-notebook*. Some IPython +Notebooks examples are written in JSON nbformat version 4 which might not be +supported by the IPython version installed by *apt-get* (current version is +1.2.1-2 which does not support such format). In this case, it is needed to +remove IPython and install it using *pip* instead: + + $ sudo apt-get remove ipython ipython-notebook + $ sudo pip install ipython ipython-notebook + ## Clone the repository The code of the LISA toolkit with all the supported tests and Notebooks can be -- GitLab From eb8362b7de1cc87536d9bbe64d910a8d6ae1b56c Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Tue, 26 Jan 2016 09:48:07 +0000 Subject: [PATCH 04/13] libs/utils/trace_analysis: report capacity thresholds when available When an energy model if available we can add big/LITTLE capacities and TIP thresholds in the task signals plot. Signed-off-by: Patrick Bellasi --- libs/utils/trace_analysis.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/libs/utils/trace_analysis.py b/libs/utils/trace_analysis.py index d3ea1fa12..07adadd8a 100644 --- a/libs/utils/trace_analysis.py +++ b/libs/utils/trace_analysis.py @@ -286,6 +286,20 @@ class TraceAnalysis(object): data = df2[df2.comm == task_name][['boosted_util']] if len(data): data.plot(ax=axes, style=['y-'], drawstyle='steps-post'); + + # Add Capacities data if avilable + if 'nrg_model' in self.trace.platform: + nrg_model = self.trace.platform['nrg_model'] + max_lcap = nrg_model['little']['cpu']['cap_max'] + max_bcap = nrg_model['big']['cpu']['cap_max'] + tip_lcap = 0.8 * max_lcap + tip_bcap = 0.8 * max_bcap + logging.info('%d %d %d %d', tip_lcap, max_lcap, tip_bcap, max_bcap) + axes.axhline(tip_lcap, color='g', linestyle='--', linewidth=1); + axes.axhline(max_lcap, color='g', linestyle='-', linewidth=2); + axes.axhline(tip_bcap, color='r', linestyle='--', linewidth=1); + axes.axhline(max_bcap, color='r', linestyle='-', linewidth=2); + axes.set_ylim(0, 1100); axes.set_xlim(self.x_min, self.x_max); axes.grid(True); -- GitLab From 0ac705a6384313e3d568f99747e87577819e4c03 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 27 Jan 2016 10:02:11 +0000 Subject: [PATCH 05/13] libs/utils/env: fix kernel/dtb deployment In case a "kernel" or "dtb" option is not specified for a certain test configuration the current code raise an exception. This patch make sure that we properly notify the user in case one of these options is not specified. Signed-off-by: Patrick Bellasi --- libs/utils/env.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/utils/env.py b/libs/utils/env.py index 9684a3d35..74125ff39 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -671,13 +671,13 @@ class TestEnv(ShareState): logging.info('%14s - Deply kernel via FTFP...', 'KernelSetup') # Deply kernel in FTFP folder (madatory) - if 'kernel' not in tc: + if 'kernel' not in tc or not tc['kernel']: raise ValueError('Missing "kernel" paramtere in conf: %s', 'KernelSetup', tc) self.tftp_deploy(tc['kernel']) # Deploy DTB in TFTP folder (if provided) - if 'dtb' not in tc: + if 'dtb' not in tc or not tc['dtb']: logging.debug('%14s - DTB not provided, using exising one', 'KernelSetup') logging.debug('%14s - Current conf:\n%s', 'KernelSetup', tc) -- GitLab From 9d0de749ddd63cc9ef8edd1f0ef0d4a179efd364 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 27 Jan 2016 15:48:17 +0000 Subject: [PATCH 06/13] libs/utils/env: speedup reboot time Once a target is rebooted, currently we wait for a time interval which is configured to be long enough to allows all boards the actually reboot. Sometimes that time can be too short or even unnecessary long. This patch adds the support for a PING based detection of the same target being back online. The maximum timeout is increased to be 2 minutes because in general we expect a proper detection of the target before this timeout. Signed-off-by: Patrick Bellasi --- libs/utils/env.py | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/libs/utils/env.py b/libs/utils/env.py index 74125ff39..94b118c72 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -626,7 +626,7 @@ class TestEnv(ShareState): 'HostResolver', host, ipaddr) return (host, ipaddr) - def reboot(self, reboot_time=60): + def reboot(self, reboot_time=120): # Send remote target a reboot command if self._feature('no-reboot'): logging.warning('%14s - Reboot disabled by conf features', 'Reboot') @@ -634,9 +634,22 @@ class TestEnv(ShareState): self.target.execute('sleep 2 && reboot -f &', as_root=True) # Wait for the target to complete the reboot - logging.info('%14s - Waiting %s [s]for target to reboot...', - 'Reboot', reboot_time) - time.sleep(reboot_time) + logging.info('%14s - Waiting up to %s[s] for target [%s] to reboot...', + 'Reboot', reboot_time, self.ip) + + ping_cmd = "ping -c 1 {} >/dev/null".format(self.ip) + elapsed = 0 + start = time.time() + while elapsed <= reboot_time: + time.sleep(5) + logging.debug('%14s - Trying to connect to [%s] target...', + 'Reboot', self.ip) + if os.system(ping_cmd) == 0: + break + elapsed = time.time() - start + if elapsed > reboot_time: + logging.warning('%14s - target [%s] not reposing to PINGs, trying to continue...', + 'Reboot', self.ip) # Force re-initialization of all the devlib modules force = True -- GitLab From d5a317ce04ac5146a130356b9568b4886cb7aac9 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Thu, 28 Jan 2016 11:26:53 +0000 Subject: [PATCH 07/13] tests/eas/rfc: fixup governor setup after reboot After a board reboot the target specified governor is not configured if we have: 1. multiple configurations all using the same governor 2. the governor required by these configurations is not the default one used by the board at boot time This patch fixes that issue by removing the "optimization" code which was used to track at host side the governor we (assume) be enabled in the target. Every time the cpufreq setup function is called we enforce the configuration of the governor required by the current target configuration. Signed-off-by: Patrick Bellasi --- tests/eas/rfc.py | 27 +++++++-------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/tests/eas/rfc.py b/tests/eas/rfc.py index 03e726c17..77a42ea7f 100644 --- a/tests/eas/rfc.py +++ b/tests/eas/rfc.py @@ -58,7 +58,6 @@ class TestBase(unittest.TestCase): # Initialize globals cls.kernel = None cls.dtb = None - cls.governor = None cls.cgroup = None cls.print_section('Main', 'Experiments configuration') @@ -222,18 +221,15 @@ class TestBase(unittest.TestCase): @classmethod def setup_cpufreq(cls, tc): if 'cpufreq' not in tc: - logging.debug('%14s - Configuration not provided', 'CPUFreq') - return - if cls.governor == tc['cpufreq']['governor']: - return - logging.info(r'%14s - Configuring all CPUs to use [%s] governor', - 'CPUFreq', tc['cpufreq']['governor']) - try: - cpufreq = tc['cpufreq'] - except KeyError: - logging.warning(r'%14s - Using currently configured governor', + logging.warning(r'%14s - governor not specified, '\ + 'using currently configured governor', 'CPUFreq') return + + cpufreq = tc['cpufreq'] + logging.info(r'%14s - Configuring all CPUs to use [%s] governor', + 'CPUFreq', cpufreq['governor']) + if cpufreq['governor'] == 'ondemand': try: sampling_rate = cpufreq['params']['sampling_rate'] @@ -255,8 +251,6 @@ class TestBase(unittest.TestCase): ' echo {} > $CPU/cpufreq/scaling_governor; '\ 'done'\ .format(cpufreq['governor'])) - # Keep track of currently configured governor - cls.governor = cpufreq['governor'] @classmethod def setup_cgroups(cls, tc): @@ -303,13 +297,6 @@ class TestBase(unittest.TestCase): # Configure each required attribute group.set(**tc['cgroups']['conf'][kind][name]) - - @classmethod - def target_reboot(cls): - # TODO: actually reboot the target and wait for it to be back online - cls.governor = None - - @classmethod def target_configure(cls, tc): cls.print_header('TargetConfig', -- GitLab From ad97b07dde4a648e021f91aafd56f5377d9ff85f Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 27 Jan 2016 09:59:42 +0000 Subject: [PATCH 08/13] tests/eas/rfc: keep track of kernel configuration and version info For each experiment configuration we generate a couple of files in the output folder which reports the kernel version string and the configuration used to build that kernel. NOTE: for a proper usage of that patch the kernel should be better build with the following options enabled: CONFIG_LOCALVERSION_AUTO CONFIG_IKCONFIG Signed-off-by: Patrick Bellasi --- tests/eas/rfc.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/eas/rfc.py b/tests/eas/rfc.py index 77a42ea7f..7426f120a 100644 --- a/tests/eas/rfc.py +++ b/tests/eas/rfc.py @@ -18,6 +18,7 @@ from bart.common.Analyzer import Analyzer import collections import datetime +import gzip import json import os import re @@ -480,6 +481,15 @@ class TestBase(unittest.TestCase): os.system('mkdir -p ' + cls.env.test_dir) cls.env.platform_dump(cls.env.test_dir) + # Keep track of kernel configuration and version + config = cls.env.target.config + with gzip.open(os.path.join(cls.env.test_dir, 'kernel.config'), 'wb') as fh: + fh.write(config.text) + output = cls.env.target.execute('{} uname -a'\ + .format(cls.env.target.busybox)) + with open(os.path.join(cls.env.test_dir, 'kernel.version'), 'w') as fh: + fh.write(output) + return wload @classmethod -- GitLab From c7693eb5040636a9053ed3af6d65f2820fa16462 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Tue, 26 Jan 2016 16:20:04 +0000 Subject: [PATCH 09/13] submodules: update to most recent -next branches Signed-off-by: Patrick Bellasi --- libs/devlib | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/devlib b/libs/devlib index 66c94a2b5..4db88ea03 160000 --- a/libs/devlib +++ b/libs/devlib @@ -1 +1 @@ -Subproject commit 66c94a2b562d5098c155cae510db5d39e67fd5aa +Subproject commit 4db88ea03767d55c8cee74179381dccece5565f4 -- GitLab From 45310c8915569d83b319a9b3fa5b22130a0863da Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Tue, 26 Jan 2016 17:01:03 +0000 Subject: [PATCH 10/13] ftrace: add support for function profiling This patch exploits the new support in devlib::FtraceCollector to support the profiling of kernel functions specified by a test configuration. This feature depends on a the last version of devlib being available. Signed-off-by: Patrick Bellasi --- libs/utils/env.py | 6 ++++++ tests/eas/rfc.py | 1 + 2 files changed, 7 insertions(+) diff --git a/libs/utils/env.py b/libs/utils/env.py index 94b118c72..86f75c3ff 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -434,6 +434,10 @@ class TestEnv(ShareState): if 'events' in ftrace: events = ftrace['events'] + functions = None + if 'functions' in ftrace: + functions = ftrace['functions'] + buffsize = FTRACE_BUFSIZE_DEFAULT if 'buffsize' in ftrace: buffsize = ftrace['buffsize'] @@ -441,6 +445,7 @@ class TestEnv(ShareState): self.ftrace = devlib.FtraceCollector( self.target, events = events, + functions = functions, buffer_size = buffsize, autoreport = False, autoview = False @@ -448,6 +453,7 @@ class TestEnv(ShareState): logging.info('%14s - Enabled events:', 'FTrace') logging.info('%14s - %s', 'FTrace', events) + logging.info('%14s - %s', 'FTrace', functions) return self.ftrace diff --git a/tests/eas/rfc.py b/tests/eas/rfc.py index 7426f120a..c5841c45b 100644 --- a/tests/eas/rfc.py +++ b/tests/eas/rfc.py @@ -524,6 +524,7 @@ class TestBase(unittest.TestCase): if cls.env.ftrace and cls.target_conf_flag(tc, 'ftrace'): cls.env.ftrace.stop() cls.env.ftrace.get_trace(cls.env.out_dir + '/trace.dat') + cls.env.ftrace.get_stats(cls.env.out_dir + '/trace_stat.json') @classmethod def wload_run_init(cls, run_idx): -- GitLab From 2e93ddafe6377b2b6a8dc2d317f4782b1f643d9c Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Fri, 29 Jan 2016 12:02:18 +0000 Subject: [PATCH 11/13] ipynb: add an example notebook to plot kernel function profiling data Kernel functions profiling support allows to collect statistics on time spend whiting a set of specified kernel function. Profiling data are collected into a JSON file "trace_stat.json" in the same output folder where the trace of an experiment is generated. This patch provides a simple notebook to process and plots all the profiling data collected during some experiments. This should be just good to have an initial visual representation of the overheads. However, a proper evaluation can require a specific setup of the experiments. For example it could be required to focus on a single CPU by pinning the workload there as well as to use the proper CPUFreq governor. All these details are left to the user expertise. Signed-off-by: Patrick Bellasi --- .../kernel_functions_profiling.ipynb | 271 ++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 ipynb/profiling/kernel_functions_profiling.ipynb diff --git a/ipynb/profiling/kernel_functions_profiling.ipynb b/ipynb/profiling/kernel_functions_profiling.ipynb new file mode 100644 index 000000000..858e081f5 --- /dev/null +++ b/ipynb/profiling/kernel_functions_profiling.ipynb @@ -0,0 +1,271 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Kernel Functions Profiling
\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import logging\n", + "reload(logging)\n", + "logging.basicConfig(\n", + " format='%(asctime)-9s %(levelname)-8s: %(message)s',\n", + " datefmt='%I:%M:%S')\n", + "\n", + "# Enable logging at INFO level\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "# Comment the follwing line to disable devlib debugging statements\n", + "logging.getLogger('ssh').setLevel(logging.DEBUG)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "# Generate plots inline\n", + "%pylab inline\n", + "\n", + "import json\n", + "import os\n", + "\n", + "import re\n", + "import collections\n", + "import pandas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define folder containgin profiling data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "11:50:08 INFO : Content of the output folder ../../results_latest/\n" + ] + } + ], + "source": [ + "# Base folder where tests folder are located\n", + "res_dir = '../../results_latest/'\n", + "logging.info('Content of the output folder %s', res_dir)\n", + "#!tree {res_dir}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load function profiling data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [], + "source": [ + "def autodict():\n", + " return collections.defaultdict(autodict)\n", + "\n", + "def parse_perf_stat(res_dir):\n", + " TEST_DIR_RE = re.compile(r'.*/([^:]*):([^:]*):([^:]*)')\n", + " profiling_data = autodict()\n", + "\n", + " for test_idx in sorted(os.listdir(res_dir)):\n", + " test_dir = os.path.join(res_dir, test_idx)\n", + " if not os.path.isdir(test_dir):\n", + " continue\n", + " match = TEST_DIR_RE.search(test_dir)\n", + " if not match:\n", + " continue\n", + " wtype = match.group(1)\n", + " tconf = match.group(2)\n", + " wload = match.group(3)\n", + "\n", + " #logging.info('Processing %s:%s:%s', wtype, tconf, wload)\n", + " trace_stat_file = os.path.join(test_dir, '1', 'trace_stat.json')\n", + " if not os.path.isfile(trace_stat_file):\n", + " continue\n", + " with open(trace_stat_file, 'r') as fh:\n", + " data = json.load(fh)\n", + " for cpu_id, cpu_stats in sorted(data.items()):\n", + " for fname in cpu_stats:\n", + " profiling_data[cpu_id][tconf][fname] = cpu_stats[fname]\n", + "\n", + " return profiling_data\n", + " \n", + "profiling_data = parse_perf_stat(res_dir)\n", + "#logging.info(\"Profiling data:\\n%s\", json.dumps(profiling_data, indent=4))\n", + "#profiling_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build Pandas DataFrame from profiling data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def get_df(profiling_data):\n", + " cpu_ids = []\n", + " cpu_frames = []\n", + " for cpu_id, cpu_data in sorted(profiling_data.items()):\n", + " cpu_ids.append(cpu_id)\n", + " conf_ids = []\n", + " conf_frames = []\n", + " for conf_id, conf_data in cpu_data.iteritems():\n", + " conf_ids.append(conf_id)\n", + " function_data = pandas.DataFrame.from_dict(conf_data, orient='index')\n", + " conf_frames.append(function_data)\n", + " df = pandas.concat(conf_frames, keys=conf_ids)\n", + " cpu_frames.append(df)\n", + " df = pandas.concat(cpu_frames, keys=cpu_ids)\n", + " #df.head()\n", + " return df\n", + "\n", + "stats_df = get_df(profiling_data)\n", + "#stats_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot profiling data per function and CPU" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def plot_stats(df, fname, axes=None):\n", + " func_data = df.xs(fname, level=2)\n", + " func_stats = func_data.xs(['avg', 's_2'], axis=1)\n", + " #func_stats\n", + " func_avg = func_stats.unstack(level=1)['avg']\n", + " func_std = func_stats.unstack(level=1)['s_2'].apply(numpy.sqrt)\n", + " func_avg.plot(kind='bar', title=fname, yerr=func_std, ax=axes);\n", + "\n", + "#plot_stats(stats_df, 'sched_group_energy')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "11:50:21 INFO : Plotting stats for [sched_group_energy] function\n", + "11:50:21 INFO : Plotting stats for [select_task_rq_fair] function\n", + "11:50:21 INFO : Plotting stats for [energy_diff] function\n", + "11:50:21 INFO : Plotting stats for [schedtune_dequeue_task] function\n", + "11:50:21 INFO : Plotting stats for [schedtune_enqueue_task] function\n", + "11:50:21 INFO : Plotting stats for [schedtune_task_boost] function\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6cAAAqeCAYAAABq8SPGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAACA7v4/WNEZI4XAvtUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_all_functions(df):\n", + " functions = df.index.get_level_values(2).unique()\n", + " fcount = len(functions)\n", + "\n", + " fig, pltaxes = plt.subplots(fcount, 1, figsize=(16, 8*fcount))\n", + "\n", + " fig_id = 0\n", + " for fname in functions:\n", + " logging.info(\"Plotting stats for [%s] function\", fname)\n", + " axes = pltaxes[fig_id]\n", + " plot_stats(df, fname, axes)\n", + " fig_id = fig_id + 1\n", + " \n", + "plot_all_functions(stats_df)" + ] + } + ], + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} -- GitLab From 3ca7a795282159cc5d02b5c6e494a858dd203815 Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 3 Feb 2016 11:25:15 +0000 Subject: [PATCH 12/13] libs/utils/env: add support to specify a test results folder Currently, each time we create TestEnv object we create a new results folder which has a timestamp based name. That approach is not flexible enough when for example we want to run multiple notebooks which produces experiments for the same "test case". Moreover, sometimes could be useful to have a more meaningful name for a set of tests. This patch adds the possibility to specify an "ID" for a test configuration. This ID, when specified, is used to name a sub-folder of "results" which will contains all the output of the test. Signed-off-by: Patrick Bellasi --- libs/utils/env.py | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/libs/utils/env.py b/libs/utils/env.py index 86f75c3ff..8d8ba5f42 100644 --- a/libs/utils/env.py +++ b/libs/utils/env.py @@ -170,16 +170,28 @@ class TestEnv(ShareState): self.calibration() # Initialize local results folder - res_dir = os.path.join(basepath, OUT_PREFIX) - self.res_dir = datetime.datetime.now()\ - .strftime(res_dir + '/%Y%m%d_%H%M%S') - os.makedirs(self.res_dir) + if self.test_conf and 'id' in self.test_conf: + res_dir = self.test_conf['id'] + if not os.path.isabs(res_dir): + res_dir = os.path.join(basepath, 'results', res_dir) + else: + res_dir = os.path.join(basepath, OUT_PREFIX) + res_dir = datetime.datetime.now()\ + .strftime(res_dir + '/%Y%m%d_%H%M%S') + self.res_dir = res_dir + if not os.path.exists(self.res_dir): + os.makedirs(self.res_dir) res_lnk = os.path.join(basepath, LATEST_LINK) if os.path.islink(res_lnk): os.remove(res_lnk) os.symlink(self.res_dir, res_lnk) + logging.info('%14s - Set results folder to:', 'TestEnv') + logging.info('%14s - %s', 'TestEnv', res_dir) + logging.info('%14s - Experiment results available also in:', 'TestEnv') + logging.info('%14s - %s', 'TestEnv', res_lnk) + self._initialized = True @staticmethod -- GitLab From 6ff584ec45e8b87e8da4501f658f4692687005aa Mon Sep 17 00:00:00 2001 From: Patrick Bellasi Date: Wed, 3 Feb 2016 16:09:25 +0000 Subject: [PATCH 13/13] libs/utils/trace: add support to specify a trace window Trappy allows to limit the parsing of a trace to a window of interest. This is a convenient support to speedup the analysis big traces by focusing on just a portion of interest. This patch exposes that interface via the ctor of the Trace object. Signed-off-by: Patrick Bellasi --- libs/utils/trace.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/libs/utils/trace.py b/libs/utils/trace.py index e7326d019..1df6cc98a 100644 --- a/libs/utils/trace.py +++ b/libs/utils/trace.py @@ -31,7 +31,7 @@ import logging class Trace(object): - def __init__(self, platform, datadir, events, tasks=None): + def __init__(self, platform, datadir, events, tasks=None, window=(0,None)): # The platform used to run the experiments self.platform = None @@ -45,6 +45,9 @@ class Trace(object): # TRAPpy run object self.run = None + # The time window used to limit trace parsing to + self.window = window + # Dynamically registered TRAPpy events self.trappy_cls = {} @@ -67,7 +70,7 @@ class Trace(object): self.platform = platform self.__registerTraceEvents(events) - self.__parseTrace(datadir, tasks) + self.__parseTrace(datadir, tasks, window) self.__computeTimeSpan() def __registerTraceEvents(self, events): @@ -80,10 +83,10 @@ class Trace(object): raise ValueError('Events must be a string or a list of strings') - def __parseTrace(self, datadir, tasks): + def __parseTrace(self, datadir, tasks, window): logging.debug('Loading [sched] events from trace in [%s]...', datadir) logging.debug("Parsing events: %s", self.events) - self.run = trappy.Run(datadir, scope="custom", events=self.events) + self.run = trappy.Run(datadir, scope="custom", events=self.events, window=window) # Check for events available on the parsed trace self.__checkAvailableEvents() -- GitLab