{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# RTA workload\n",
"\n",
"The RTA or RTApp workload represents a type of workload obtained using the rt-app test application.\n",
"More details on the test application can be found at https://github.com/scheduler-tools/rt-app."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-08 12:02:29,102 INFO : root : Using LISA logging configuration:\n",
"2016-12-08 12:02:29,103 INFO : root : /home/vagrant/lisa/logging.conf\n"
]
}
],
"source": [
"import logging\n",
"from conf import LisaLogging\n",
"LisaLogging.setup()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n"
]
}
],
"source": [
"# Generate plots inline\n",
"%pylab inline\n",
"\n",
"import json\n",
"import os\n",
"\n",
"# Support to initialise and configure your test environment\n",
"import devlib\n",
"from env import TestEnv\n",
"\n",
"# Support to configure and run RTApp based workloads\n",
"from wlgen import RTA, Periodic, Ramp, Step, Pulse\n",
"\n",
"# Suport for FTrace events parsing and visualization\n",
"import trappy\n",
"\n",
"# Support for performance analysis of RTApp workloads\n",
"from perf_analysis import PerfAnalysis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Test environment setup\n",
"\n",
"For more details on this please check out **examples/utils/testenv_example.ipynb**."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Setup a target configuration\n",
"my_target_conf = {\n",
" \n",
" # Define the kind of target platform to use for the experiments\n",
" \"platform\" : 'linux', # Linux system, valid other options are:\n",
" # android - access via ADB\n",
" # linux - access via SSH\n",
" # host - direct access\n",
" \n",
" # Preload settings for a specific target\n",
" \"board\" : 'juno', # juno - JUNO board with mainline hwmon\n",
" \n",
" # Define devlib module to load\n",
" \"modules\" : [\n",
" 'bl', # enable big.LITTLE support\n",
" 'cpufreq' # enable CPUFreq support\n",
" ],\n",
"\n",
" # Account to access the remote target\n",
" \"host\" : '192.168.0.1',\n",
" \"username\" : 'root',\n",
" \"password\" : 'juno',\n",
"\n",
" # Comment the following line to force rt-app calibration on your target\n",
" \"rtapp-calib\" : {\n",
" '0': 361, '1': 138, '2': 138, '3': 352, '4': 360, '5': 353\n",
" }\n",
"\n",
"}\n",
"\n",
"# Setup the required Test Environment supports\n",
"my_tests_conf = {\n",
" \n",
" # Binary tools required to run this experiment\n",
" # These tools must be present in the tools/ folder for the architecture\n",
" \"tools\" : ['rt-app', 'taskset', 'trace-cmd'],\n",
" \n",
" # FTrace events end buffer configuration\n",
" \"ftrace\" : {\n",
" \"events\" : [\n",
" \"sched_switch\",\n",
" \"cpu_frequency\"\n",
" ],\n",
" \"buffsize\" : 10240\n",
" },\n",
"\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false,
"scrolled": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:25:45,152 INFO : TestEnv : Using base path: /home/vagrant/lisa\n",
"2016-12-07 10:25:45,153 INFO : TestEnv : Loading custom (inline) target configuration\n",
"2016-12-07 10:25:45,153 INFO : TestEnv : Loading custom (inline) test configuration\n",
"2016-12-07 10:25:45,153 INFO : TestEnv : Devlib modules to load: ['bl', 'cpufreq', 'hwmon']\n",
"2016-12-07 10:25:45,154 INFO : TestEnv : Connecting linux target:\n",
"2016-12-07 10:25:45,154 INFO : TestEnv : username : root\n",
"2016-12-07 10:25:45,155 INFO : TestEnv : host : 192.168.0.1\n",
"2016-12-07 10:25:45,155 INFO : TestEnv : password : juno\n",
"2016-12-07 10:25:45,156 INFO : TestEnv : Connection settings:\n",
"2016-12-07 10:25:45,156 INFO : TestEnv : {'username': 'root', 'host': '192.168.0.1', 'password': 'juno'}\n",
"2016-12-07 10:26:02,855 INFO : TestEnv : Initializing target workdir:\n",
"2016-12-07 10:26:02,856 INFO : TestEnv : /root/devlib-target\n",
"2016-12-07 10:26:23,640 INFO : TestEnv : Topology:\n",
"2016-12-07 10:26:23,643 INFO : TestEnv : [[0, 3, 4, 5], [1, 2]]\n",
"2016-12-07 10:26:28,585 INFO : TestEnv : Enabled tracepoints:\n",
"2016-12-07 10:26:28,587 INFO : TestEnv : sched_switch\n",
"2016-12-07 10:26:28,589 INFO : TestEnv : cpu_frequency\n",
"2016-12-07 10:26:28,591 WARNING : TestEnv : Using configuration provided RTApp calibration\n",
"2016-12-07 10:26:28,591 INFO : TestEnv : Using RT-App calibration values:\n",
"2016-12-07 10:26:28,592 INFO : TestEnv : {\"0\": 361, \"1\": 138, \"2\": 138, \"3\": 352, \"4\": 360, \"5\": 353}\n",
"2016-12-07 10:26:28,592 INFO : EnergyMeter : Scanning for HWMON channels, may take some time...\n",
"2016-12-07 10:26:28,594 INFO : EnergyMeter : Channels selected for energy sampling:\n",
"2016-12-07 10:26:28,595 INFO : EnergyMeter : BOARDBIG_energy\n",
"2016-12-07 10:26:28,595 INFO : EnergyMeter : BOARDLITTLE_energy\n",
"2016-12-07 10:26:28,596 INFO : TestEnv : Set results folder to:\n",
"2016-12-07 10:26:28,596 INFO : TestEnv : /home/vagrant/lisa/results/20161207_102628\n",
"2016-12-07 10:26:28,597 INFO : TestEnv : Experiment results available also in:\n",
"2016-12-07 10:26:28,597 INFO : TestEnv : /home/vagrant/lisa/results_latest\n"
]
}
],
"source": [
"# Initialize a test environment using\n",
"# - the provided target configuration (my_target_conf)\n",
"# - the provided test configuration (my_test_conf)\n",
"te = TestEnv(target_conf=my_target_conf, test_conf=my_tests_conf)\n",
"target = te.target"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Workload configuration\n",
"\n",
"To create an instance of an RTApp workload generator you need to provide the following:\n",
"- target: target device configuration\n",
"- name: name of workload. This is the name of the JSON configuration file reporting the generated RTApp configuration.\n",
"- calibration: CPU load calibration values, measured on each core.\n",
"\n",
"An RTApp workload is defined by specifying a **kind**, provided below through **rtapp.conf**, which represents the way we want to define the behavior of each task.\n",
"The possible kinds of workloads are **profile** and **custom**. It's very important to notice that **periodic** is no longer considered a \"kind\" of workload but a \"class\" within the **profile** kind.\n",
"
\n",
"As you see below, when \"kind\" is \"profile\", the tasks generated by this workload have a profile which is defined by a sequence of phases. These phases are defined according to the following grammar:
\n",
" - params := {task, ...}
\n",
" - task := NAME : {SCLASS, PRIO, [phase, ...]}
\n",
" - phase := (PTIME, PERIOD, DCYCLE)
\n",
" \n",
"There are some pre-defined task classes for the **profile** kind:\n",
" - **Step**: the load of this task is a step with a configured initial and final load. \n",
" - **Pulse**: the load of this task is a pulse with a configured initial and final load.The main difference with the 'step' class is that a pulse workload is by definition a 'step down', i.e. the workload switches from an initial load to a final one which is always lower than the initial one. Moreover, a pulse load does not generate a sleep phase in case of 0[%] load, i.e. the task ends as soon as the non null initial load has completed.\n",
" - **Ramp**: the load of this task is a ramp with a configured number of steps determined by the input parameters.\n",
" - **Periodic**: the load of this task is periodic with a configured period and duty-cycle.
\n",
"The one below is a workload mix having all types of workloads described above, but each of them can also be specified serapately in the RTApp parameters. "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:27:16,946 INFO : Workload : Setup new workload simple\n",
"2016-12-07 10:27:16,947 INFO : Workload : Workload duration defined by longest task\n",
"2016-12-07 10:27:16,947 INFO : Workload : Default policy: SCHED_OTHER\n",
"2016-12-07 10:27:16,948 INFO : Workload : ------------------------\n",
"2016-12-07 10:27:16,948 INFO : Workload : task [task_per20], sched: {'policy': 'FIFO'}\n",
"2016-12-07 10:27:16,949 INFO : Workload : | calibration CPU: 1\n",
"2016-12-07 10:27:16,949 INFO : Workload : | loops count: 1\n",
"2016-12-07 10:27:16,949 INFO : Workload : + phase_000001: duration 5.000000 [s] (50 loops)\n",
"2016-12-07 10:27:16,950 INFO : Workload : | period 100000 [us], duty_cycle 20 %\n",
"2016-12-07 10:27:16,950 INFO : Workload : | run_time 20000 [us], sleep_time 80000 [us]\n",
"2016-12-07 10:27:16,951 INFO : Workload : ------------------------\n",
"2016-12-07 10:27:16,951 INFO : Workload : task [task_pls5-80], sched: using default policy\n",
"2016-12-07 10:27:16,952 INFO : Workload : | start delay: 0.500000 [s]\n",
"2016-12-07 10:27:16,952 INFO : Workload : | calibration CPU: 1\n",
"2016-12-07 10:27:16,952 INFO : Workload : | loops count: 1\n",
"2016-12-07 10:27:16,953 INFO : Workload : + phase_000001: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,953 INFO : Workload : | period 100000 [us], duty_cycle 65 %\n",
"2016-12-07 10:27:16,954 INFO : Workload : | run_time 65000 [us], sleep_time 35000 [us]\n",
"2016-12-07 10:27:16,954 INFO : Workload : + phase_000002: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,955 INFO : Workload : | period 100000 [us], duty_cycle 5 %\n",
"2016-12-07 10:27:16,955 INFO : Workload : | run_time 5000 [us], sleep_time 95000 [us]\n",
"2016-12-07 10:27:16,955 INFO : Workload : ------------------------\n",
"2016-12-07 10:27:16,956 INFO : Workload : task [task_rmp20_5-60], sched: using default policy\n",
"2016-12-07 10:27:16,956 INFO : Workload : | calibration CPU: 1\n",
"2016-12-07 10:27:16,957 INFO : Workload : | loops count: 1\n",
"2016-12-07 10:27:16,957 INFO : Workload : | CPUs affinity: 0\n",
"2016-12-07 10:27:16,958 INFO : Workload : + phase_000001: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,958 INFO : Workload : | period 100000 [us], duty_cycle 5 %\n",
"2016-12-07 10:27:16,958 INFO : Workload : | run_time 5000 [us], sleep_time 95000 [us]\n",
"2016-12-07 10:27:16,959 INFO : Workload : + phase_000002: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,959 INFO : Workload : | period 100000 [us], duty_cycle 25 %\n",
"2016-12-07 10:27:16,960 INFO : Workload : | run_time 25000 [us], sleep_time 75000 [us]\n",
"2016-12-07 10:27:16,960 INFO : Workload : + phase_000003: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,961 INFO : Workload : | period 100000 [us], duty_cycle 45 %\n",
"2016-12-07 10:27:16,961 INFO : Workload : | run_time 45000 [us], sleep_time 55000 [us]\n",
"2016-12-07 10:27:16,962 INFO : Workload : + phase_000004: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,962 INFO : Workload : | period 100000 [us], duty_cycle 65 %\n",
"2016-12-07 10:27:16,963 INFO : Workload : | run_time 65000 [us], sleep_time 35000 [us]\n",
"2016-12-07 10:27:16,963 INFO : Workload : ------------------------\n",
"2016-12-07 10:27:16,964 INFO : Workload : task [task_stp10-50], sched: using default policy\n",
"2016-12-07 10:27:16,964 INFO : Workload : | start delay: 0.500000 [s]\n",
"2016-12-07 10:27:16,964 INFO : Workload : | calibration CPU: 1\n",
"2016-12-07 10:27:16,965 INFO : Workload : | loops count: 1\n",
"2016-12-07 10:27:16,965 INFO : Workload : + phase_000001: sleep 1.000000 [s]\n",
"2016-12-07 10:27:16,966 INFO : Workload : + phase_000002: duration 1.000000 [s] (10 loops)\n",
"2016-12-07 10:27:16,966 INFO : Workload : | period 100000 [us], duty_cycle 50 %\n",
"2016-12-07 10:27:16,967 INFO : Workload : | run_time 50000 [us], sleep_time 50000 [us]\n"
]
}
],
"source": [
"# Create a new RTApp workload generator using the calibration values\n",
"# reported by the TestEnv module\n",
"rtapp = RTA(target, 'simple', calibration=te.calibration())\n",
"\n",
"# Configure this RTApp instance to:\n",
"rtapp.conf(\n",
"# 1. generate a \"profile based\" set of tasks\n",
" kind='profile',\n",
" \n",
" # 2. define the \"profile\" of each task\n",
" params={\n",
"\n",
" # 3. PERIODIC task\n",
" # \n",
" # This class defines a task which load is periodic with a configured\n",
" # period and duty-cycle.\n",
" # \n",
" # This class is a specialization of the 'pulse' class since a periodic\n",
" # load is generated as a sequence of pulse loads.\n",
" # \n",
" # Args:\n",
" # cuty_cycle_pct (int, [0-100]): the pulses load [%]\n",
" # default: 50[%]\n",
" # duration_s (float): the duration in [s] of the entire workload\n",
" # default: 1.0[s]\n",
" # period_ms (float): the period used to define the load in [ms]\n",
" # default: 100.0[ms]\n",
" # delay_s (float): the delay in [s] before ramp start\n",
" # default: 0[s]\n",
" # sched (dict): the scheduler configuration for this task\n",
" # cpus (list): the list of CPUs on which task can run\n",
" 'task_per20': Periodic(\n",
" period_ms=100, # period\n",
" duty_cycle_pct=20, # duty cycle\n",
" duration_s=5, # duration\n",
" cpus=None, # run on all CPUS\n",
" sched={\n",
" \"policy\": \"FIFO\", # Run this task as a SCHED_FIFO task\n",
" },\n",
" delay_s=0 # start at the start of RTApp\n",
" ).get(),\n",
"\n",
" # 4. RAMP task\n",
" #\n",
" # This class defines a task which load is a ramp with a configured number\n",
" # of steps according to the input parameters.\n",
" # \n",
" # Args:\n",
" # start_pct (int, [0-100]): the initial load [%], (default 0[%])\n",
" # end_pct (int, [0-100]): the final load [%], (default 100[%])\n",
" # delta_pct (int, [0-100]): the load increase/decrease [%],\n",
" # default: 10[%]\n",
" # increase if start_prc < end_prc\n",
" # decrease if start_prc > end_prc\n",
" # time_s (float): the duration in [s] of each load step\n",
" # default: 1.0[s]\n",
" # period_ms (float): the period used to define the load in [ms]\n",
" # default: 100.0[ms]\n",
" # delay_s (float): the delay in [s] before ramp start\n",
" # default: 0[s]\n",
" # loops (int): number of time to repeat the ramp, with the\n",
" # specified delay in between\n",
" # default: 0\n",
" # sched (dict): the scheduler configuration for this task\n",
" # cpus (list): the list of CPUs on which task can run\n",
" 'task_rmp20_5-60': Ramp(\n",
" period_ms=100, # period\n",
" start_pct=5, # intial load\n",
" end_pct=65, # end load\n",
" delta_pct=20, # load % increase...\n",
" time_s=1, # ... every 1[s]\n",
" cpus=\"0\" # run just on first CPU\n",
" ).get(),\n",
" \n",
" # 5. STEP task\n",
" # \n",
" # This class defines a task which load is a step with a configured\n",
" # initial and final load.\n",
" # \n",
" # Args:\n",
" # start_pct (int, [0-100]): the initial load [%]\n",
" # default 0[%])\n",
" # end_pct (int, [0-100]): the final load [%]\n",
" # default 100[%]\n",
" # time_s (float): the duration in [s] of the start and end load\n",
" # default: 1.0[s]\n",
" # period_ms (float): the period used to define the load in [ms]\n",
" # default 100.0[ms]\n",
" # delay_s (float): the delay in [s] before ramp start\n",
" # default 0[s]\n",
" # loops (int): number of time to repeat the ramp, with the\n",
" # specified delay in between\n",
" # default: 0\n",
" # sched (dict): the scheduler configuration for this task\n",
" # cpus (list): the list of CPUs on which task can run\n",
" 'task_stp10-50': Step(\n",
" period_ms=100, # period\n",
" start_pct=0, # intial load\n",
" end_pct=50, # end load\n",
" time_s=1, # ... every 1[s]\n",
" delay_s=0.5 # start .5[s] after the start of RTApp\n",
" ).get(),\n",
" \n",
" # 6. PULSE task\n",
" #\n",
" # This class defines a task which load is a pulse with a configured\n",
" # initial and final load.\n",
" # \n",
" # The main difference with the 'step' class is that a pulse workload is\n",
" # by definition a 'step down', i.e. the workload switch from an finial\n",
" # load to a final one which is always lower than the initial one.\n",
" # Moreover, a pulse load does not generate a sleep phase in case of 0[%]\n",
" # load, i.e. the task ends as soon as the non null initial load has\n",
" # completed.\n",
" # \n",
" # Args:\n",
" # start_pct (int, [0-100]): the initial load [%]\n",
" # default: 0[%]\n",
" # end_pct (int, [0-100]): the final load [%]\n",
" # default: 100[%]\n",
" # NOTE: must be lower than start_pct value\n",
" # time_s (float): the duration in [s] of the start and end load\n",
" # default: 1.0[s]\n",
" # NOTE: if end_pct is 0, the task end after the\n",
" # start_pct period completed\n",
" # period_ms (float): the period used to define the load in [ms]\n",
" # default: 100.0[ms]\n",
" # delay_s (float): the delay in [s] before ramp start\n",
" # default: 0[s]\n",
" # loops (int): number of time to repeat the ramp, with the\n",
" # specified delay in between\n",
" # default: 0\n",
" # sched (dict): the scheduler configuration for this task\n",
" # cpus (list): the list of CPUs on which task can run\n",
" 'task_pls5-80': Pulse(\n",
" period_ms=100, # period\n",
" start_pct=65, # intial load\n",
" end_pct=5, # end load\n",
" time_s=1, # ... every 1[s]\n",
" delay_s=0.5 # start .5[s] after the start of RTApp\n",
" ).get(),\n",
" \n",
" \n",
" },\n",
" \n",
" # 7. use this folder for task logfiles\n",
" run_dir=target.working_directory\n",
" \n",
");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The output of the previous cell reports the main properties of the generated\n",
"tasks. Thus for example we see that the first task is configure to be:\n",
" - named **task_per20**\n",
" - executed as a **SCHED_FIFO** task\n",
" - generating a load which is **calibrated** with respect to the **CPU 1**\n",
" - with one single \"phase\" which defines a peripodic load for the **duration** of **5[s]**\n",
" - that periodic load consistes of **50 cycles**\n",
" - each cycle has a **period** of **100[ms]** and a **duty-cycle** of **20%**,\n",
" which means that the task, for every cycle, will **run** for **20[ms]** and then sleep for **80[ms]** \n",
"\n",
"All these properties are translated into a JSON configuration file for RTApp which you can see in **Collected results** below.
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Workload composition\n",
"\n",
"Another way of specifying the phases of a task is through workload composition, described in the next cell.
\n",
"**NOTE:** We are just giving this as an example of specifying a workload, but this configuration won't be the one used for the following execution and analysis cells. You need to uncomment these lines if you want to use the composed workload."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Initial phase and pinning parameters\n",
"ramp = Ramp(period_ms=100, start_pct=5, end_pct=65, delta_pct=20, time_s=1, cpus=\"0\")\n",
"\n",
"# Following phases\n",
"medium_slow = Periodic(duty_cycle_pct=10, duration_s=5, period_ms=100)\n",
"high_fast = Periodic(duty_cycle_pct=60, duration_s=5, period_ms=10)\n",
"medium_fast = Periodic(duty_cycle_pct=10, duration_s=5, period_ms=1)\n",
"high_slow = Periodic(duty_cycle_pct=60, duration_s=5, period_ms=100)\n",
"\n",
"#Compose the task\n",
"complex_task = ramp + medium_slow + high_fast + medium_fast + high_slow\n",
"\n",
"# Configure this RTApp instance to:\n",
"# rtapp.conf(\n",
"# # 1. generate a \"profile based\" set of tasks\n",
"# kind='profile',\n",
"# \n",
"# # 2. define the \"profile\" of each task\n",
"# params={\n",
"# 'complex' : complex_task.get()\n",
"# },\n",
"#\n",
"# # 6. use this folder for task logfiles\n",
"# run_dir='/tmp'\n",
"#)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Workload execution"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:27:30,511 INFO : root : #### Setup FTrace\n",
"2016-12-07 10:27:38,104 INFO : root : #### Start energy sampling\n",
"2016-12-07 10:27:38,723 INFO : root : #### Start RTApp execution\n",
"2016-12-07 10:27:38,726 INFO : Workload : Workload execution START:\n",
"2016-12-07 10:27:38,728 INFO : Workload : /root/devlib-target/bin/rt-app /root/devlib-target/simple_00.json 2>&1\n",
"2016-12-07 10:27:54,778 INFO : root : #### Read energy consumption: /home/vagrant/lisa/results/20161207_102628/energy.json\n",
"2016-12-07 10:27:55,401 INFO : root : #### Stop FTrace\n",
"2016-12-07 10:27:57,663 INFO : root : #### Save FTrace: /home/vagrant/lisa/results/20161207_102628/trace.dat\n",
"2016-12-07 10:28:03,718 INFO : root : #### Save platform description: /home/vagrant/lisa/results/20161207_102628/platform.json\n"
]
}
],
"source": [
"logging.info('#### Setup FTrace')\n",
"te.ftrace.start()\n",
"\n",
"logging.info('#### Start energy sampling')\n",
"te.emeter.reset()\n",
"\n",
"logging.info('#### Start RTApp execution')\n",
"rtapp.run(out_dir=te.res_dir, cgroup=\"\")\n",
"\n",
"logging.info('#### Read energy consumption: %s/energy.json', te.res_dir)\n",
"nrg_report = te.emeter.report(out_dir=te.res_dir)\n",
"\n",
"logging.info('#### Stop FTrace')\n",
"te.ftrace.stop()\n",
"\n",
"trace_file = os.path.join(te.res_dir, 'trace.dat')\n",
"logging.info('#### Save FTrace: %s', trace_file)\n",
"te.ftrace.get_trace(trace_file)\n",
"\n",
"logging.info('#### Save platform description: %s/platform.json', te.res_dir)\n",
"(plt, plt_file) = te.platform_dump(te.res_dir)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Collected results"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:29:04,768 INFO : root : Generated RTApp JSON file:\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" \"global\": {\n",
" \"calibration\": 138, \n",
" \"default_policy\": \"SCHED_OTHER\", \n",
" \"duration\": -1, \n",
" \"logdir\": \"/root/devlib-target\"\n",
" }, \n",
" \"tasks\": {\n",
" \"task_per20\": {\n",
" \"loop\": 1, \n",
" \"phases\": {\n",
" \"p000001\": {\n",
" \"loop\": 50, \n",
" \"run\": 20000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_per20\"\n",
" }\n",
" }\n",
" }, \n",
" \"policy\": \"SCHED_FIFO\"\n",
" }, \n",
" \"task_pls5-80\": {\n",
" \"loop\": 1, \n",
" \"phases\": {\n",
" \"p000000\": {\n",
" \"delay\": 500000\n",
" }, \n",
" \"p000001\": {\n",
" \"loop\": 10, \n",
" \"run\": 65000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_pls5-80\"\n",
" }\n",
" }, \n",
" \"p000002\": {\n",
" \"loop\": 10, \n",
" \"run\": 5000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_pls5-80\"\n",
" }\n",
" }\n",
" }, \n",
" \"policy\": \"SCHED_OTHER\"\n",
" }, \n",
" \"task_rmp20_5-60\": {\n",
" \"cpus\": [\n",
" 0\n",
" ], \n",
" \"loop\": 1, \n",
" \"phases\": {\n",
" \"p000001\": {\n",
" \"loop\": 10, \n",
" \"run\": 5000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_rmp20_5-60\"\n",
" }\n",
" }, \n",
" \"p000002\": {\n",
" \"loop\": 10, \n",
" \"run\": 25000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_rmp20_5-60\"\n",
" }\n",
" }, \n",
" \"p000003\": {\n",
" \"loop\": 10, \n",
" \"run\": 45000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_rmp20_5-60\"\n",
" }\n",
" }, \n",
" \"p000004\": {\n",
" \"loop\": 10, \n",
" \"run\": 65000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_rmp20_5-60\"\n",
" }\n",
" }\n",
" }, \n",
" \"policy\": \"SCHED_OTHER\"\n",
" }, \n",
" \"task_stp10-50\": {\n",
" \"loop\": 1, \n",
" \"phases\": {\n",
" \"p000000\": {\n",
" \"delay\": 500000\n",
" }, \n",
" \"p000001\": {\n",
" \"loop\": 1, \n",
" \"sleep\": 1000000\n",
" }, \n",
" \"p000002\": {\n",
" \"loop\": 10, \n",
" \"run\": 50000, \n",
" \"timer\": {\n",
" \"period\": 100000, \n",
" \"ref\": \"task_stp10-50\"\n",
" }\n",
" }\n",
" }, \n",
" \"policy\": \"SCHED_OTHER\"\n",
" }\n",
" }\n",
"}\n"
]
}
],
"source": [
"# Inspect the JSON file used to run the application\n",
"with open('{}/simple_00.json'.format(te.res_dir), 'r') as fh:\n",
" rtapp_json = json.load(fh, )\n",
"logging.info('Generated RTApp JSON file:')\n",
"print json.dumps(rtapp_json, indent=4, sort_keys=True)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:29:06,513 INFO : root : Content of the output folder /home/vagrant/lisa/results/20161207_102628\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"total 3592\r\n",
"drwxrwxr-x 2 user user 4096 Dec 7 10:28 .\r\n",
"drwxrwxr-x 22 user user 4096 Dec 7 10:26 ..\r\n",
"-rw-rw-r-- 1 user user 68 Dec 7 10:27 energy.json\r\n",
"-rw-rw-r-- 1 user user 705 Dec 7 10:27 output.log\r\n",
"-rw-rw-r-- 1 user user 673 Dec 7 10:28 platform.json\r\n",
"-rw-r--r-- 1 user user 6360 Dec 7 10:27 rt-app-task_per20-0.log\r\n",
"-rw-r--r-- 1 user user 2764 Dec 7 10:27 rt-app-task_pls5-80-1.log\r\n",
"-rw-r--r-- 1 user user 5120 Dec 7 10:27 rt-app-task_rmp20_5-60-2.log\r\n",
"-rw-r--r-- 1 user user 1648 Dec 7 10:27 rt-app-task_stp10-50-3.log\r\n",
"-rw-r--r-- 1 user user 3104 Dec 7 10:27 simple_00.json\r\n",
"-rw-r--r-- 1 user user 3629056 Dec 7 10:28 trace.dat\r\n"
]
}
],
"source": [
"# All data are produced in the output folder defined by the TestEnv module\n",
"logging.info('Content of the output folder %s', te.res_dir)\n",
"!ls -la {te.res_dir}"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:29:09,792 INFO : root : Energy: /home/vagrant/lisa/results/20161207_102628/energy.json\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" \"LITTLE\": 1.8224460000000136, \n",
" \"big\": 0.5827259999999796\n",
"}\n"
]
}
],
"source": [
"# Dump the energy measured for the LITTLE and big clusters\n",
"logging.info('Energy: %s', nrg_report.report_file)\n",
"print json.dumps(nrg_report.channels, indent=4, sort_keys=True)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2016-12-07 10:29:14,705 INFO : root : Platform description: /home/vagrant/lisa/results/20161207_102628/platform.json\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" \"clusters\": {\n",
" \"big\": [\n",
" 1, \n",
" 2\n",
" ], \n",
" \"little\": [\n",
" 0, \n",
" 3, \n",
" 4, \n",
" 5\n",
" ]\n",
" }, \n",
" \"cpus_count\": 6, \n",
" \"freqs\": {\n",
" \"big\": [\n",
" 450000, \n",
" 625000, \n",
" 800000, \n",
" 950000, \n",
" 1100000\n",
" ], \n",
" \"little\": [\n",
" 450000, \n",
" 575000, \n",
" 700000, \n",
" 775000, \n",
" 850000\n",
" ]\n",
" }, \n",
" \"nrg_model\": null, \n",
" \"topology\": [\n",
" [\n",
" 0, \n",
" 3, \n",
" 4, \n",
" 5\n",
" ], \n",
" [\n",
" 1, \n",
" 2\n",
" ]\n",
" ]\n",
"}\n"
]
}
],
"source": [
"# Dump the platform descriptor, which could be useful for further analysis\n",
"# of the generated results\n",
"logging.info('Platform description: %s', plt_file)\n",
"print json.dumps(plt, indent=4, sort_keys=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Trace inspection\n",
"\n",
"More information on visualization and trace inspection can be found in **examples/trappy**."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"