201908_uclamp_rtapp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"9\">UtilClamp v13 - JunoR2 - RTApp Validation</font><br>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "* [CFS Tasks Clamping](#CFS-Tasks-Clamping)\n",
    "* [RT Tasks Clamping](#RT-Tasks-Clamping)\n",
    "* [Per-Task API](#Per-Task-API)\n",
    "* [CGroups v1 - Delegation Model](#CGroups-v1---Delegation-Model)\n",
    "* [CGroups v2 - Delegation Model](#CGroups-v2---Delegation-Model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:04:45,757 INFO    : root         : Using LISA logging configuration:\n",
      "2019-08-13 11:04:45,758 INFO    : root         :   /data/Code/lisa/logging.conf\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "from lisa.utils import setup_logging\n",
    "setup_logging()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "# Generate plots inline\n",
    "%pylab inline\n",
    "%config IPCompleter.use_jedi = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# Utility Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test environment setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:04:46,349 INFO    : root         : Generating grammar tables from /usr/lib/python3.5/lib2to3/Grammar.txt\n",
      "2019-08-13 11:04:46,385 INFO    : root         : Generating grammar tables from /usr/lib/python3.5/lib2to3/PatternGrammar.txt\n",
      "2019-08-13 11:04:46,827 INFO    : lisa.target.Target : Creating result directory: /data/Code/lisa/results/Target-juno-20190813_110446.827733\n",
      "2019-08-13 11:04:46,830 INFO    : lisa.target.Target : linux juno target connection settings:\n",
      "2019-08-13 11:04:46,831 INFO    : lisa.target.Target :   password : None\n",
      "2019-08-13 11:04:46,831 INFO    : lisa.target.Target :       host : 192.168.90.1\n",
      "2019-08-13 11:04:46,832 INFO    : lisa.target.Target :   username : root\n",
      "2019-08-13 11:04:46,833 INFO    : lisa.target.Target :       port : 22\n",
      "2019-08-13 11:04:46,843 INFO    : lisa.target.Target : Devlib modules to load: bl, cgroups, cpufreq, cpuidle, devfreq, fastboot, gem5stats, gpufreq, hotplug, hwmon, mbed-fan, odroidxu3-fan, sched, thermal\n",
      "2019-08-13 11:04:52,013 WARNING : LinuxTarget  : Module devfreq is not supported by the target\n",
      "2019-08-13 11:04:52,016 WARNING : LinuxTarget  : Module fastboot is not supported by the target\n",
      "2019-08-13 11:04:52,017 WARNING : LinuxTarget  : Module gem5stats is not supported by the target\n",
      "2019-08-13 11:04:52,193 WARNING : LinuxTarget  : Module gpufreq is not supported by the target\n",
      "2019-08-13 11:04:58,479 WARNING : LinuxTarget  : Module odroidxu3-fan is not supported by the target\n",
      "2019-08-13 11:05:01,457 INFO    : CGroups      : Available controllers:\n",
      "2019-08-13 11:05:02,410 INFO    : CGroups      :   cpuset       : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:02,956 INFO    : CGroups      :   cpu          : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:03,502 INFO    : CGroups      :   cpuacct      : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:04,046 INFO    : CGroups      :   blkio        : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:04,598 INFO    : CGroups      :   memory       : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:05,151 INFO    : CGroups      :   devices      : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:05,702 INFO    : CGroups      :   freezer      : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:06,246 INFO    : CGroups      :   perf_event   : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:06,800 INFO    : CGroups      :   hugetlb      : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:07,345 INFO    : CGroups      :   pids         : /home/root/devlib-target/cgroups/devlib_cgh0\n",
      "2019-08-13 11:05:07,533 WARNING : lisa.target.Target : Failed to initialized \"devfreq\" devlib Module\n",
      "2019-08-13 11:05:07,535 WARNING : lisa.target.Target : Failed to initialized \"fastboot\" devlib Module\n",
      "2019-08-13 11:05:07,536 WARNING : lisa.target.Target : Failed to initialized \"gem5stats\" devlib Module\n",
      "2019-08-13 11:05:07,537 WARNING : lisa.target.Target : Failed to initialized \"gpufreq\" devlib Module\n",
      "2019-08-13 11:05:07,538 WARNING : lisa.target.Target : Failed to initialized \"mbed-fan\" devlib Module\n",
      "2019-08-13 11:05:07,540 WARNING : lisa.target.Target : Failed to initialized \"odroidxu3-fan\" devlib Module\n",
      "2019-08-13 11:05:07,541 INFO    : lisa.target.Target : Tools to install: ['rt-app', 'rt-app_uclamp']\n",
      "2019-08-13 11:05:08,461 INFO    : lisa.platforms.platinfo.PlatformInfo : Attempting to read energy model from target\n",
      "2019-08-13 11:05:09,177 INFO    : lisa.energy_model.EnergyModel.EMReader : Attempting to load EM using from_debugfsEM_target\n",
      "2019-08-13 11:05:14,823 INFO    : lisa.target.Target : Effective platform information:\n",
      "|- abi from target (str): arm64\n",
      "|- cpu-capacities from target (dict): {0: 383, 1: 1024, 2: 1024, 3: 383, 4: 383, 5: 383}\n",
      "|- cpus-count from target (int): 6\n",
      "|- freq-domains from target (list): [[0, 3, 4, 5], [1, 2]]\n",
      "|- freqs from target (dict): {0: [450000, 800000, 950000], 1: [600000, 1000000, 1200000], 2: [600000, 1000000, 1200000], 3: [450000, 800000, 950000], 4: [450000, 800000, 950000], 5: [450000, 800000, 950000]}\n",
      "+- kernel:\n",
      "    |- config from target (TypedKernelConfig): <kernel config>\n",
      "    |- version from target (KernelVersion): 5.3.0-rc1-00117-g7c4d3a669b63 20 SMP PREEMPT Tue Aug 13 09:55:26 BST 2019\n",
      "|- name from target-conf (str): juno\n",
      "|- nrg-model from target (EnergyModel): <lisa.energy_model.EnergyModel object at 0x7fb34acc7f60>\n",
      "|- os from target (str): linux\n",
      "+- rtapp:\n",
      "    |- calib from target (DeferredValue): <lazy value of RTA.get_cpu_calibrations>\n",
      "|- capacity-classes from target(platform-info/cpu-capacities) (list): [[0, 3, 4, 5], [1, 2]]\n"
     ]
    }
   ],
   "source": [
    "from lisa.target import Target, TargetConf\n",
    "\n",
    "target = Target(\n",
    "    name='juno',\n",
    "    kind='linux',\n",
    "    host='192.168.90.1',\n",
    "    username='root',\n",
    "    tools = ['rt-app', 'rt-app_uclamp'],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:05:15,230 INFO    : root         : CPUFreq governors:\n",
      "{'5': 'schedutil', '3': 'schedutil', '4': 'schedutil', '2': 'schedutil', '1': 'schedutil', '0': 'schedutil'}\n"
     ]
    }
   ],
   "source": [
    "target.cpufreq.set_all_governors('schedutil');\n",
    "logging.info(\"CPUFreq governors:\\n%s\", target.cpufreq.get_all_governors())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|- abi from target (str): arm64\n",
      "|- cpu-capacities from target (dict): {0: 383, 1: 1024, 2: 1024, 3: 383, 4: 383, 5: 383}\n",
      "|- cpus-count from target (int): 6\n",
      "|- freq-domains from target (list): [[0, 3, 4, 5], [1, 2]]\n",
      "|- freqs from target (dict): {0: [450000, 800000, 950000], 1: [600000, 1000000, 1200000], 2: [600000, 1000000, 1200000], 3: [450000, 800000, 950000], 4: [450000, 800000, 950000], 5: [450000, 800000, 950000]}\n",
      "+- kernel:\n",
      "    |- config from target (TypedKernelConfig): <kernel config>\n",
      "    |- version from target (KernelVersion): 5.3.0-rc1-00117-g7c4d3a669b63 20 SMP PREEMPT Tue Aug 13 09:55:26 BST 2019\n",
      "|- name from target-conf (str): juno\n",
      "|- nrg-model from target (EnergyModel): <lisa.energy_model.EnergyModel object at 0x7fb34acc76d8>\n",
      "|- os from target (str): linux\n",
      "+- rtapp:\n",
      "    |- calib from target (DeferredValue): <lazy value of RTA.get_cpu_calibrations>\n",
      "|- capacity-classes from target(platform-info/cpu-capacities) (list): [[0, 3, 4, 5], [1, 2]]\n"
     ]
    }
   ],
   "source": [
    "print(target.plat_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:05:15,462 INFO    : root         : Avaialble capacities at each frequency:\n",
      "2019-08-13 11:05:15,464 INFO    : root         : LITTLEs: {450000: 384, 800000: 682, 950000: 810}\n",
      "2019-08-13 11:05:15,466 INFO    : root         :    bigs: {600000: 512, 1000000: 853, 1200000: 1024}\n"
     ]
    }
   ],
   "source": [
    "# Maximum available frequency\n",
    "big_cpus = [cpu for cpu,cap\n",
    "            in target.plat_info['cpu-capacities'].items()\n",
    "            if cap==1024]\n",
    "big_cpu = big_cpus[-1]\n",
    "big_max_freq = target.cpufreq.list_frequencies(big_cpu)[-1]\n",
    "\n",
    "# Compute capacity levels for each CPU and frequency\n",
    "caps = {}\n",
    "for cpu in target.list_online_cpus():\n",
    "    caps[cpu] = {f: int(1024. * f/big_max_freq) for f in target.cpufreq.list_frequencies(cpu)}\n",
    "logging.info(\"Avaialble capacities at each frequency:\")\n",
    "logging.info(\"LITTLEs: %s\", caps[target.core_cpus(target.little_core)[0]])\n",
    "logging.info(\"   bigs: %s\", caps[target.core_cpus(target.big_core)[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:05:16,217 WARNING : LinuxTarget  : Event [cpu_util] not available for tracing\n",
      "2019-08-13 11:05:16,220 WARNING : LinuxTarget  : Event [uclamp_task_update] not available for tracing\n",
      "2019-08-13 11:05:16,222 WARNING : LinuxTarget  : Event [update_util_se] not available for tracing\n",
      "2019-08-13 11:05:16,225 WARNING : LinuxTarget  : Event [update_util_rq] not available for tracing\n",
      "2019-08-13 11:05:16,227 WARNING : LinuxTarget  : Event [sugov_next_freq_shared] not available for tracing\n"
     ]
    }
   ],
   "source": [
    "from lisa.trace import Trace, FtraceCollector\n",
    "import os\n",
    "\n",
    "events = [\n",
    "    \"sched_switch\",\n",
    "    \"sched_wakeup\",\n",
    "    \"cpu_frequency\",\n",
    "    \"cpu_idle\",\n",
    "    \"cpu_util\",\n",
    "    \"uclamp_task_update\",\n",
    "    \"update_util_se\",\n",
    "    \"update_util_rq\",\n",
    "    \"sugov_next_freq_shared\",\n",
    "    \"uclamp_se\",\n",
    "    \"uclamp_cfs\",\n",
    "    \"uclamp_rt\",\n",
    "]\n",
    "ftrace_coll = FtraceCollector(target, events=events, buffer_size=10240)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CGroups setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "cpu_ctr = target.cgroups.controller('cpu')\n",
    "cpuset_ctr = target.cgroups.controller('cpuset')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def checkGroups(cgroups):\n",
    "    data = []\n",
    "    for cg_name in cgroups:\n",
    "        cg = cpu_ctr.cgroup(cg_name)\n",
    "        cg = cg.get()\n",
    "        rmin = cg.get('uclamp.min', None)\n",
    "        if rmin is None:\n",
    "            rmin = float(target.execute('cat /proc/sys/kernel/sched_util_clamp_min').strip()) / 10.\n",
    "        if rmin == 1024:\n",
    "            rmin = 'max'\n",
    "        emin = cg['uclamp.min.effective']\n",
    "        rmax = cg.get('uclamp.max', None)\n",
    "        if rmax is None:\n",
    "            rmax = float(target.execute('cat /proc/sys/kernel/sched_util_clamp_max').strip()) / 10.\n",
    "        if rmax == 1024:\n",
    "            rmax = 'max'\n",
    "        emax = cg['uclamp.max.effective']        \n",
    "        data.append((cg_name, rmin, emin, rmax, emax))\n",
    "    df = pd.DataFrame(data, columns=['cg_name', 'uclamp.min', 'uclamp.min.effective', 'uclamp.max', 'uclamp.max.effective'])\n",
    "    df.set_index('cg_name', inplace=True)\n",
    "    return df\n",
    "\n",
    "def assertValue(attrib, value):\n",
    "    attrib = attrib.split('/')\n",
    "    task_group = '/'.join(attrib[:-1])\n",
    "    attrib = attrib[-1]\n",
    "    \n",
    "    uclamp = df[task_group:][attrib].values[0]\n",
    "    if uclamp == 'max':\n",
    "        uclamp = 100\n",
    "    uclamp = float(uclamp)\n",
    "    \n",
    "    if value == 'max':\n",
    "        value = 100.0\n",
    "\n",
    "    logging.info(\"Assert %s/%-24s == %6.2f: %8s (measured: %6.2f%%)\",\n",
    "            task_group, attrib, value,\n",
    "            \"PASS\" if value == uclamp else \"FAILED\",\n",
    "            uclamp)\n",
    "    \n",
    "def assertAttribute(attrib, op, value):\n",
    "    value = float(value)\n",
    "    values = [100.0 if v == 'max' else float(v) for v in df[attrib]]\n",
    "    \n",
    "    result = op(values)\n",
    "\n",
    "    logging.info(\"Assert %s(%-32s) == %6.2f: %8s (measured: %6.2f%%)\",\n",
    "            op, attrib, value,\n",
    "            \"PASS\" if value == result else \"FAILED\",\n",
    "            result)\n",
    "    \n",
    "def assertAttributeValues(attrib, allowed):\n",
    "    values = [100.0 if v == 'max' else float(v) for v in df[attrib]]\n",
    "    \n",
    "    passed = True\n",
    "    for v in values:\n",
    "        if v not in allowed:\n",
    "            passed = False\n",
    "            break\n",
    "\n",
    "    logging.info(\"Assert %-32s in %-16s: %8s\",\n",
    "            attrib, allowed,\n",
    "            \"PASS\" if passed else \"FAILED\")\n",
    "\n",
    "def assertClamps(task_group, op, value):\n",
    "    value = float(value)\n",
    "    values = [100.0 if v == 'max' else float(v) for v in df[task_group:].values[0]]\n",
    "    \n",
    "    result = op(values)\n",
    "\n",
    "    logging.info(\"Assert %s(%-32s) == %6.2f: %8s (measured: %6.2f%%)\",\n",
    "            op, task_group, value,\n",
    "            \"PASS\" if value == result else \"FAILED\",\n",
    "            result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tests Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import trappy\n",
    "\n",
    "def test(cgname):\n",
    "    \n",
    "    logging.info('#### Start RTApp execution')\n",
    "    with ftrace_coll:\n",
    "        rta.run(cgroup=cgname)\n",
    "\n",
    "    trace_file = os.path.join(rta.res_dir, 'trace.dat')\n",
    "    logging.info('#### Save FTrace: %s', trace_file)\n",
    "    ftrace_coll.get_trace(trace_file)\n",
    "\n",
    "    plat_info_file = os.path.join(rta.res_dir, 'plat_info.yml')\n",
    "    logging.info('#### Save platform description: %s', plat_info_file)\n",
    "    target.plat_info.to_yaml_map(plat_info_file)\n",
    "    logging.info('LITTLE cluster max capacity: %d',\n",
    "                 min(target.plat_info['cpu-capacities'].values()))\n",
    "\n",
    "    trappy.ftrace.FTrace.disable_cache = True\n",
    "    trace = Trace(trace_file, plat_info=target.plat_info, events=events)\n",
    "\n",
    "    return trace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lisa.trace import TraceView\n",
    "from trappy.utils import listify\n",
    "\n",
    "def get_view(trace, tasks):\n",
    "    tasks = listify(tasks)\n",
    "    pids = [trace.get_task_by_name(task)[0] for task in tasks]\n",
    "    \n",
    "    _df = trace.df_events('sched_switch')\n",
    "    t_start = _df[_df.next_pid.isin(pids)].index[0]-0.5\n",
    "    t_end = _df[_df.prev_pid.isin(pids)].index[-1]+0.5\n",
    "    \n",
    "    return TraceView(trace, (t_start, t_end))\n",
    "\n",
    "def getData(trace, rta):\n",
    "    df = {}\n",
    "    \n",
    "    task = rta.tasks[0]\n",
    "    logfile = os.path.join(rta.res_dir, \"rt-app-{name}-0.log\".format(name=task))\n",
    "  \n",
    "    tv = get_view(trace, task)\n",
    "    \n",
    "    # Get task's PID and CPU\n",
    "    pid = tv.get_task_by_name(task)[0]\n",
    "    sw_df = tv.df_events('sched_switch')\n",
    "    cpu = int(sw_df[sw_df.next_pid == pid].iloc[-1].__cpu)\n",
    "    logging.info(\"Events collected in range (%d, %d) on cpu%d\",\n",
    "                 tv.start, tv.end, cpu)\n",
    "    \n",
    "    # Append UClamp signals\n",
    "    for event in ['uclamp_se', 'uclamp_cfs', 'uclamp_rt']:\n",
    "        _df = tv.df_events(event)\n",
    "        if pid and event == 'uclamp_se':\n",
    "            df[event] = _df[_df.pid == pid]\n",
    "        if cpu and event == 'uclamp_cfs':\n",
    "            df[event] = _df[_df.cpu == cpu]\n",
    "        if cpu and event == 'uclamp_rt':\n",
    "            df[event] = _df[_df.cpu == cpu]\n",
    "    \n",
    "    # Append RTApp execution log. RTApp header can have a variable number of\n",
    "    # rows depending on the configuration.\n",
    "    # Let's skip all the lines starting by # and assigne columns a name by hand.\n",
    "    logging.info(\"Loading RTApp stats from [{logfile}]...\".format(logfile=logfile))\n",
    "    col_names=['idx', 'perf', 'run', 'period', 'start', 'end', 'rel_st', 'slack', 'c_duration', 'c_period', 'wu_lat']\n",
    "    df['rtapp'] = pd.read_csv(logfile, delimiter='\\s+', comment='#', names=col_names, index_col='start')\n",
    "    # Re-align index to trace time\n",
    "    df['rtapp'].reset_index(inplace=True)\n",
    "    t_log = df['rtapp'].start[0]\n",
    "    df['rtapp']['timestamp'] = (df['rtapp'].start - t_log)/1e6 + tv.start\n",
    "    df['rtapp'].set_index('timestamp', inplace=True)\n",
    "\n",
    "    # Append frequency residencies\n",
    "    logging.info(\"Frequency residency [%]:\")\n",
    "    df['opp_res'] = tv.analysis.frequency.df_cpu_frequency_residency(cpu=cpu).T\n",
    "    df['opp_res'] = df['opp_res'].apply(lambda v : v/tv.time_range)\n",
    "    \n",
    "    return df, tv, pid, cpu\n",
    "\n",
    "def doPlot(trace, rta, plot=\"cfs_util rq_util freqs rtapp\"):\n",
    "\n",
    "    # Default lines colors\n",
    "    lines = [\n",
    "        ('uclamp_min',      'y',  '-'),\n",
    "        ('uclamp_max',      'r',  '-'),\n",
    "        ('util_avg',        'b',  ':'),\n",
    "        ('uclamp_avg',      'b',  '-'),\n",
    "    ]\n",
    "    columns = [l for l,_,_ in lines]\n",
    "    colors  = [c for _,c,_ in lines]\n",
    "    style   = [s for _,_,s in lines]\n",
    "\n",
    "    df, tv, pid, cpu = getData(trace, rta)\n",
    "    \n",
    "    # Setup plots\n",
    "    plots_count = len(plot.split())\n",
    "    fig, ax = tv.analysis.frequency.setup_plot(ncols=1, nrows=plots_count, height=plots_count)\n",
    "    ax_id = 0\n",
    "    \n",
    "    if 'cfs_util' in plot:\n",
    "        _ax = ax[ax_id]\n",
    "        ax_id += 1\n",
    "        _df = df['uclamp_se'][tv.start:tv.end]\n",
    "        _df[columns].plot(\n",
    "            ax=_ax, drawstyle='steps-post',\n",
    "            color=colors, style=style, xlim=(tv.start, tv.end),\n",
    "            title=\"SE Clamped Utilization\", grid=True);\n",
    "        _ax.set_ylabel(\"Utilization\")\n",
    "\n",
    "    if 'rq_util' in plot:\n",
    "        _ax = ax[ax_id]\n",
    "        ax_id += 1\n",
    "        _df = df['uclamp_rt'][tv.start:tv.end]\n",
    "        _df[columns].plot(\n",
    "            ax=_ax, drawstyle='steps-post',\n",
    "            color=colors, style=style, xlim=(tv.start, tv.end),\n",
    "            title=\"RQ Clamped Utilization\", grid=True);\n",
    "        _ax.set_ylabel(\"Utilization\")\n",
    "\n",
    "    if 'freqs' in plot:\n",
    "        _ax = ax[ax_id]\n",
    "        ax_id += 1\n",
    "        logging.info(\"CPU capacity levels: %s\", caps[cpu])\n",
    "        # Ensure we injext first and last events\n",
    "        tv.analysis.frequency.plot_cpu_frequencies(cpu, axis=_ax);\n",
    "        \n",
    "    if 'rtapp' in plot:\n",
    "        _ax = ax[ax_id]\n",
    "        ax_id += 1\n",
    "        _df = df['rtapp']\n",
    "        _df.slack.plot(\n",
    "            ax=_ax,drawstyle='steps-post',\n",
    "            xlim=(tv.start, tv.end),\n",
    "            title=\"RTApp Slack\", grid=True);\n",
    "        _ax.set_ylabel(\"Slack\")\n",
    "\n",
    "    \n",
    "    return df\n",
    "\n",
    "def getResidency(freq):\n",
    "    try:\n",
    "        return float(df['opp_res'][freq][0])\n",
    "    except:\n",
    "        # Requested frquency never used\n",
    "        return 0\n",
    "\n",
    "def assertResidency(freq, expected_pct, err_pct):\n",
    "    ok = True\n",
    "    res = getResidency(freq)\n",
    "    pct_min = expected_pct/100 - err_pct/100\n",
    "    pct_max = expected_pct/100 + err_pct/100\n",
    "    if res < pct_min or res > pct_max:\n",
    "            ok = False\n",
    "    if (res > pct_max):\n",
    "        err =  100*(res-expected_pct/100)\n",
    "    else:\n",
    "        err = -100*(expected_pct/100-res)\n",
    "    logging.info(\"Assert OPP@%9d in [%2d,%2d]: %8s (measured: %2d%%, error: %7.3f%%)\",\n",
    "                freq, 100*pct_min, 100*pct_max,\n",
    "                \"PASS\" if ok else \"FAILED\", 100*res,\n",
    "                 err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "[Back to Table of Contents](#Table-of-Contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# Per-Task API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure app clamp groups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>uclamp.min</th>\n",
       "      <th>uclamp.min.effective</th>\n",
       "      <th>uclamp.max</th>\n",
       "      <th>uclamp.max.effective</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cg_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>/</th>\n",
       "      <td>102.4</td>\n",
       "      <td>max</td>\n",
       "      <td>102.4</td>\n",
       "      <td>max</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>/uclamp</th>\n",
       "      <td>44.00</td>\n",
       "      <td>44.04</td>\n",
       "      <td>66.00</td>\n",
       "      <td>66.02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        uclamp.min uclamp.min.effective uclamp.max uclamp.max.effective\n",
       "cg_name                                                                \n",
       "/            102.4                  max      102.4                  max\n",
       "/uclamp      44.00                44.04      66.00                66.02"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cpu_ctr = target.cgroups.controller('cpu')\n",
    "cpuset_ctr = target.cgroups.controller('cpuset')\n",
    "\n",
    "# Setup a child clamp group\n",
    "uclamp_cg = cpuset_ctr.cgroup('/uclamp')\n",
    "uclamp_cg.set(dict(cpus=target.bl.bigs[-1], mems=0))\n",
    "uclamp_cg = cpu_ctr.cgroup('/uclamp')\n",
    "uclamp_cg.set({'uclamp.max': 66}, False)\n",
    "uclamp_cg.set({'uclamp.min': 44}, False)\n",
    "checkGroups(['/', '/uclamp'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure app with per task clamp values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:06:00,223 INFO    : lisa.wlgen.rta.RTA : Creating target's run_dir: /home/root/devlib-target/lisa/wlgen/test_ramp_20190813_110600_DABcZj\n",
      "2019-08-13 11:06:00,225 INFO    : lisa.target.Target : Creating result directory: /data/Code/lisa/results/Target-juno-20190813_110446.827733/RTA-test_ramp-20190813_110600.225450\n",
      "2019-08-13 11:06:01,129 INFO    : lisa.wlgen.rta.RTA : Calibration value: 218\n",
      "2019-08-13 11:06:01,131 INFO    : lisa.wlgen.rta.RTA : Default policy: SCHED_OTHER\n",
      "2019-08-13 11:06:01,132 INFO    : lisa.wlgen.rta.RTA : ------------------------\n",
      "2019-08-13 11:06:01,134 INFO    : lisa.wlgen.rta.RTA : task [test_task], sched: OTHER\n",
      "2019-08-13 11:06:01,135 INFO    : lisa.wlgen.rta.RTA :  | start delay: 0.000000 [s]\n",
      "2019-08-13 11:06:01,136 INFO    : lisa.wlgen.rta.RTA :  | loops count: 1\n",
      "2019-08-13 11:06:01,137 INFO    : lisa.wlgen.rta.RTA :  + phase_000001\n",
      "2019-08-13 11:06:01,139 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,140 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  10 %\n",
      "2019-08-13 11:06:01,141 INFO    : lisa.wlgen.rta.Phase :  |  run_time   1600 [us], sleep_time  14400 [us]\n",
      "2019-08-13 11:06:01,142 INFO    : lisa.wlgen.rta.RTA :  + phase_000002\n",
      "2019-08-13 11:06:01,143 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,144 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  20 %\n",
      "2019-08-13 11:06:01,145 INFO    : lisa.wlgen.rta.Phase :  |  run_time   3200 [us], sleep_time  12800 [us]\n",
      "2019-08-13 11:06:01,149 INFO    : lisa.wlgen.rta.RTA :  + phase_000003\n",
      "2019-08-13 11:06:01,151 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,152 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  30 %\n",
      "2019-08-13 11:06:01,153 INFO    : lisa.wlgen.rta.Phase :  |  run_time   4800 [us], sleep_time  11200 [us]\n",
      "2019-08-13 11:06:01,154 INFO    : lisa.wlgen.rta.RTA :  + phase_000004\n",
      "2019-08-13 11:06:01,156 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,157 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  40 %\n",
      "2019-08-13 11:06:01,162 INFO    : lisa.wlgen.rta.Phase :  |  run_time   6400 [us], sleep_time   9600 [us]\n",
      "2019-08-13 11:06:01,164 INFO    : lisa.wlgen.rta.RTA :  + phase_000005\n",
      "2019-08-13 11:06:01,165 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,166 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  50 %\n",
      "2019-08-13 11:06:01,167 INFO    : lisa.wlgen.rta.Phase :  |  run_time   8000 [us], sleep_time   8000 [us]\n",
      "2019-08-13 11:06:01,168 INFO    : lisa.wlgen.rta.RTA :  + phase_000006\n",
      "2019-08-13 11:06:01,170 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,171 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  60 %\n",
      "2019-08-13 11:06:01,172 INFO    : lisa.wlgen.rta.Phase :  |  run_time   9600 [us], sleep_time   6400 [us]\n",
      "2019-08-13 11:06:01,173 INFO    : lisa.wlgen.rta.RTA :  + phase_000007\n",
      "2019-08-13 11:06:01,174 INFO    : lisa.wlgen.rta.Phase :  | duration 1.000000 [s] (62 loops)\n",
      "2019-08-13 11:06:01,175 INFO    : lisa.wlgen.rta.Phase :  |  period    16000 [us], duty_cycle  70 %\n",
      "2019-08-13 11:06:01,177 INFO    : lisa.wlgen.rta.Phase :  |  run_time  11200 [us], sleep_time   4800 [us]\n"
     ]
    }
   ],
   "source": [
    "from lisa.wlgen.rta import RTA, Ramp\n",
    "import json\n",
    "\n",
    "rtapp_profile = {\n",
    "  'test_task': Ramp(period_ms=16, start_pct=10, end_pct=70,\n",
    "                    delta_pct=10, cpus=[big_cpu], sched_policy='OTHER')\n",
    "}\n",
    "\n",
    "def provide_calibration(calibration):\n",
    "    target.plat_info[\"rtapp\"].add_src(\"user\", {\"calib\" : calibration})\n",
    "# Uncomment if you want to use this\n",
    "provide_calibration({0: 580, 1: 218, 2: 218, 3: 579, 4: 579, 5: 579})    \n",
    "\n",
    "rta = RTA.by_profile(target, \"test_ramp\", rtapp_profile, logstats=True)\n",
    "\n",
    "with open(rta.local_json, 'r') as fh:\n",
    "    conf = json.load(fh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:06:03,421 INFO    : root         : RT-App Configuration [/data/Code/lisa/results/Target-juno-20190813_110446.827733/RTA-test_ramp-20190813_110600.225450/test_ramp.json]:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'global': {'calibration': 218,\n",
       "  'default_policy': 'SCHED_OTHER',\n",
       "  'duration': -1,\n",
       "  'ftrace': 'main,task,loop,event,stats',\n",
       "  'logdir': '/home/root/devlib-target/lisa/wlgen/test_ramp_20190813_110600_DABcZj',\n",
       "  'logstats': True},\n",
       " 'tasks': {'test_task': {'delay': 0,\n",
       "   'loop': 1,\n",
       "   'phases': {'p000001': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 1600,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'}},\n",
       "    'p000002': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 3200,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'}},\n",
       "    'p000003': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 4800,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'},\n",
       "     'util_min': 200},\n",
       "    'p000004': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 6400,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'}},\n",
       "    'p000005': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 8000,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'},\n",
       "     'util_max': 440},\n",
       "    'p000006': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 9600,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'}},\n",
       "    'p000007': {'cpus': [2],\n",
       "     'loop': 62,\n",
       "     'run': 11200,\n",
       "     'timer': {'period': 16000, 'ref': 'test_task'}}},\n",
       "   'policy': 'SCHED_OTHER'}}}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reduce boost on PHASE_2: from 40% to 10%\n",
    "conf['tasks']['test_task']['phases']['p000003'][u'util_min']  = 200\n",
    "# cap PHASE_7: from 60% to 30%\n",
    "conf['tasks']['test_task']['phases']['p000005'][u'util_max']  = 440\n",
    "\n",
    "with open(rta.local_json, 'w') as fh:\n",
    "    json.dump(conf, fh, sort_keys=True)\n",
    "    \n",
    "# Push new configuration and prepare command\n",
    "target.push(rta.local_json, rta.remote_json)\n",
    "cmdline='{} {}  2>&1'.format(target.target.get_installed('rt-app'), rta.remote_json)\n",
    "rta.command = cmdline\n",
    "\n",
    "# Report the new confiuration here\n",
    "with open(rta.local_json, 'r') as fh:\n",
    "    conf = json.load(fh)\n",
    "logging.info(\"RT-App Configuration [%s]:\", rta.local_json)\n",
    "conf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## Run Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:06:42,877 INFO    : root         : #### Start RTApp execution\n",
      "2019-08-13 11:06:47,575 INFO    : lisa.wlgen.rta.RTA : Execution start: CGMOUNT=/home/root/devlib-target/cgroups /home/root/devlib-target/bin/shutils cgroups_run_into /uclamp /home/root/devlib-target/bin/rt-app /home/root/devlib-target/lisa/wlgen/test_ramp_20190813_110600_DABcZj/test_ramp.json  2>&1\n",
      "2019-08-13 11:06:54,845 INFO    : lisa.wlgen.rta.RTA : Execution complete\n",
      "2019-08-13 11:06:55,597 INFO    : root         : #### Save FTrace: /data/Code/lisa/results/Target-juno-20190813_110446.827733/RTA-test_ramp-20190813_110600.225450/trace.dat\n",
      "2019-08-13 11:07:02,910 INFO    : root         : #### Save platform description: /data/Code/lisa/results/Target-juno-20190813_110446.827733/RTA-test_ramp-20190813_110600.225450/plat_info.yml\n",
      "2019-08-13 11:07:03,038 INFO    : root         : LITTLE cluster max capacity: 383\n",
      "2019-08-13 11:07:05,157 INFO    : lisa.trace.Trace : Platform clusters verified to be Frequency coherent\n",
      "2019-08-13 11:07:05,168 INFO    : root         : Events collected in range (0, 8) on cpu2\n",
      "2019-08-13 11:07:05,172 INFO    : root         : Loading RTApp stats from [/data/Code/lisa/results/Target-juno-20190813_110446.827733/RTA-test_ramp-20190813_110600.225450/rt-app-test_task-0.log]...\n",
      "2019-08-13 11:07:05,179 INFO    : root         : Frequency residency [%]:\n",
      "2019-08-13 11:07:05,369 INFO    : root         : CPU capacity levels: {600000: 512, 1000000: 853, 1200000: 1024}\n",
      "2019-08-13 11:07:05,374 INFO    : lisa.analysis.frequency.FrequencyAnalysis : Average frequency for CPU2 : 0.874 GHz\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trace = test(cgname='/uclamp')\n",
    "df = doPlot(trace, rta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-08-13 11:07:12,714 INFO    : root         : Assert OPP@   600000 in [25,35]:     PASS (measured: 31%, error:   1.359%)\n",
      "2019-08-13 11:07:12,717 INFO    : root         : Assert OPP@  1000000 in [64,75]:     PASS (measured: 67%, error:  -2.080%)\n",
      "2019-08-13 11:07:12,719 INFO    : root         : Assert OPP@  1200000 in [-5, 5]:     PASS (measured:  0%, error:   0.593%)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>frequency</th>\n",
       "      <th>600000</th>\n",
       "      <th>1000000</th>\n",
       "      <th>1200000</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>total_time</th>\n",
       "      <td>0.313587</td>\n",
       "      <td>0.679203</td>\n",
       "      <td>0.005932</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>active_time</th>\n",
       "      <td>0.109349</td>\n",
       "      <td>0.391061</td>\n",
       "      <td>0.002273</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "frequency     600000    1000000   1200000\n",
       "total_time   0.313587  0.679203  0.005932\n",
       "active_time  0.109349  0.391061  0.002273"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "assertResidency( 600000, expected_pct=30, err_pct=5)\n",
    "assertResidency(1000000, expected_pct=70, err_pct=5)\n",
    "assertResidency(1200000, expected_pct=0,  err_pct=5)\n",
    "df['opp_res']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<os._wrap_close at 0x7fb348161ac8>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "[Back to Table of Contents](#Table-of-Contents)"
   ]
  }
 ],
 "metadata": {
  "_draft": {
   "nbviewer_url": "https://gist.github.com/d738edc3a5d3c6c54be3140982b7d48a"
  },
  "gist": {
   "data": {
    "description": "uclamp/validation/lkml_v5_junor2.ipynb",
    "public": false
   },
   "id": "d738edc3a5d3c6c54be3140982b7d48a"
  },
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "119px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}