eval/max_rate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation: Max. supported user request rate\n",
    "* Generate measurements with OMNeT++, using the prepared `omnet-test` simulation code\n",
    "* Convert them to csv using `scavetool x omnet-test/results/*.vec -o eval/measurements/max_rate.csv`\n",
    "* Read and analyze using Python: https://docs.omnetpp.org/tutorials/pandas/\n",
    "\n",
    "Evaluated service: Video streaming service (see below). \n",
    "* 30 repetitions á 10min\n",
    "* Cache hit ratio: 70%\n",
    "* User request rates: 0.25, 0.5, 0.75, 1, 1.25 (requests/s)\n",
    "    * Translates to intervals of: 4s, 2s, 1.333s, 1s, 0.8s\n",
    "* VNF processing times:\n",
    "    * Cache (upstream): exp(0.5s)\n",
    "    * Server: exp(3s)\n",
    "    * Video optimizer: exp(0.5s)\n",
    "    * Ad insertion: exp(0.5s)\n",
    "    * Cache (downstream): exp(0.5s)\n",
    "\n",
    "![omnet](../docs/omnet.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from subprocess import call\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>run</th>\n",
       "      <th>type</th>\n",
       "      <th>module</th>\n",
       "      <th>name</th>\n",
       "      <th>attrname</th>\n",
       "      <th>attrvalue</th>\n",
       "      <th>value</th>\n",
       "      <th>vectime</th>\n",
       "      <th>vecvalue</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>VideoFixed-121-20180809-15:53:57-13604</td>\n",
       "      <td>runattr</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>configname</td>\n",
       "      <td>VideoFixed</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>VideoFixed-121-20180809-15:53:57-13604</td>\n",
       "      <td>runattr</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>datetime</td>\n",
       "      <td>20180809-15:53:57</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>VideoFixed-121-20180809-15:53:57-13604</td>\n",
       "      <td>runattr</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>experiment</td>\n",
       "      <td>VideoFixed</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>VideoFixed-121-20180809-15:53:57-13604</td>\n",
       "      <td>runattr</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>inifile</td>\n",
       "      <td>omnetpp.ini</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>VideoFixed-121-20180809-15:53:57-13604</td>\n",
       "      <td>runattr</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>iterationvars</td>\n",
       "      <td>$0=0.8s</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                      run     type module name       attrname  \\\n",
       "0  VideoFixed-121-20180809-15:53:57-13604  runattr    NaN  NaN     configname   \n",
       "1  VideoFixed-121-20180809-15:53:57-13604  runattr    NaN  NaN       datetime   \n",
       "2  VideoFixed-121-20180809-15:53:57-13604  runattr    NaN  NaN     experiment   \n",
       "3  VideoFixed-121-20180809-15:53:57-13604  runattr    NaN  NaN        inifile   \n",
       "4  VideoFixed-121-20180809-15:53:57-13604  runattr    NaN  NaN  iterationvars   \n",
       "\n",
       "           attrvalue  value vectime vecvalue  \n",
       "0         VideoFixed    NaN    None     None  \n",
       "1  20180809-15:53:57    NaN    None     None  \n",
       "2         VideoFixed    NaN    None     None  \n",
       "3        omnetpp.ini    NaN    None     None  \n",
       "4            $0=0.8s    NaN    None     None  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convenience functions for parsing numbers and arrays in csv correctly\n",
    "def parse_if_number(s):\n",
    "    try: \n",
    "        return float(s)\n",
    "    except: \n",
    "        return True if s==\"true\" else False if s==\"false\" else s if s else None\n",
    "\n",
    "def parse_ndarray(s):\n",
    "    return np.fromstring(s, sep=' ') if s else None\n",
    "\n",
    "# load measurements from results folder\n",
    "results = pd.read_csv('measurements/max_rate.csv', converters = {\n",
    "                    'attrvalue': parse_if_number,\n",
    "                    'binedges': parse_ndarray,\n",
    "                    'binvalues': parse_ndarray,\n",
    "                    'vectime': parse_ndarray,\n",
    "                    'vecvalue': parse_ndarray})\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>module</th>\n",
       "      <th>name</th>\n",
       "      <th>vectime</th>\n",
       "      <th>vecvalue</th>\n",
       "      <th>param</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4350</th>\n",
       "      <td>VideoFixed.U_T0</td>\n",
       "      <td>processingDelay</td>\n",
       "      <td>[0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, ...</td>\n",
       "      <td>[0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, ...</td>\n",
       "      <td>$0=0.8s</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4351</th>\n",
       "      <td>VideoFixed.C_T3</td>\n",
       "      <td>queueLength0</td>\n",
       "      <td>[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...</td>\n",
       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, ...</td>\n",
       "      <td>$0=0.8s</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4352</th>\n",
       "      <td>VideoFixed.C_T3</td>\n",
       "      <td>queueLength1</td>\n",
       "      <td>[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...</td>\n",
       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...</td>\n",
       "      <td>$0=0.8s</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4353</th>\n",
       "      <td>VideoFixed.S_T0</td>\n",
       "      <td>queueLength0</td>\n",
       "      <td>[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...</td>\n",
       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, ...</td>\n",
       "      <td>$0=0.8s</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4354</th>\n",
       "      <td>VideoFixed.V_T0</td>\n",
       "      <td>queueLength0</td>\n",
       "      <td>[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...</td>\n",
       "      <td>[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, ...</td>\n",
       "      <td>$0=0.8s</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               module             name  \\\n",
       "4350  VideoFixed.U_T0  processingDelay   \n",
       "4351  VideoFixed.C_T3     queueLength0   \n",
       "4352  VideoFixed.C_T3     queueLength1   \n",
       "4353  VideoFixed.S_T0     queueLength0   \n",
       "4354  VideoFixed.V_T0     queueLength0   \n",
       "\n",
       "                                                vectime  \\\n",
       "4350  [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, ...   \n",
       "4351  [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...   \n",
       "4352  [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...   \n",
       "4353  [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...   \n",
       "4354  [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, ...   \n",
       "\n",
       "                                               vecvalue    param  \n",
       "4350  [0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, ...  $0=0.8s  \n",
       "4351  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, ...  $0=0.8s  \n",
       "4352  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...  $0=0.8s  \n",
       "4353  [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, ...  $0=0.8s  \n",
       "4354  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, ...  $0=0.8s  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return transformed data frame only containing the recorded vectors\n",
    "# replace run number with the corresponding parameter values, saved as iterationvars\n",
    "def vectors(results):\n",
    "    # select matching parameters per row based on 'run' \n",
    "    itervars = results[results.attrname == 'iterationvars'] \n",
    "    params = []\n",
    "    for index, row in results.iterrows():\n",
    "        params.append(itervars.loc[itervars.run == row.run].iloc[0].attrvalue)\n",
    "       \n",
    "    # add param column\n",
    "    results['param'] = pd.Series(params, index=results.index)\n",
    "    \n",
    "    # return filtered results (only vectors, only relevant columns)\n",
    "    return pd.DataFrame(data=results[results.type == 'vector'], columns=['module', 'name', 'vectime', 'vecvalue', 'param'])\n",
    "        \n",
    "vecs = vectors(results)\n",
    "vecs.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# return df with separate rows for each vector element of vec_name (columns module, param, time, <vec_name>)\n",
    "# select only rows of 'only_modules'\n",
    "def vector_values(vectors, vec_name, only_modules=None):\n",
    "    vec_values = {'module': [], 'request_interval': [], 'rate': [], 'time': [], vec_name: []}\n",
    "    selected_vecs = vectors[vectors['name'] == vec_name]\n",
    "    for index, row in selected_vecs.iterrows():     \n",
    "        # unroll vector into separate rows\n",
    "        if only_modules is None or row['module'][11:] in only_modules:               \n",
    "            for i in range(row['vectime'].size):\n",
    "                vec_values['module'].append(row['module'][11:])      # drop \"VideoFixed.\" prefix\n",
    "                vec_values['request_interval'].append(row['param'][3:])     # transform '$0=0.5s' into '0.5s'\n",
    "                vec_values['rate'].append(round(1.0/float(row['param'][3:-1]), 2))\n",
    "                vec_values['time'].append(row['vectime'][i])\n",
    "                vec_values[vec_name].append(row['vecvalue'][i])\n",
    "            \n",
    "    return pd.DataFrame(data=vec_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### End-to-end delay with increasing rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>module</th>\n",
       "      <th>request_interval</th>\n",
       "      <th>rate</th>\n",
       "      <th>time</th>\n",
       "      <th>tokenInDelay</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>66066</th>\n",
       "      <td>U_P0</td>\n",
       "      <td>4s</td>\n",
       "      <td>0.25</td>\n",
       "      <td>580.050285</td>\n",
       "      <td>0.050285</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66067</th>\n",
       "      <td>U_P0</td>\n",
       "      <td>4s</td>\n",
       "      <td>0.25</td>\n",
       "      <td>584.212802</td>\n",
       "      <td>0.212802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66068</th>\n",
       "      <td>U_P0</td>\n",
       "      <td>4s</td>\n",
       "      <td>0.25</td>\n",
       "      <td>588.345066</td>\n",
       "      <td>0.345066</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66069</th>\n",
       "      <td>U_P0</td>\n",
       "      <td>4s</td>\n",
       "      <td>0.25</td>\n",
       "      <td>592.561201</td>\n",
       "      <td>0.561201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66070</th>\n",
       "      <td>U_P0</td>\n",
       "      <td>4s</td>\n",
       "      <td>0.25</td>\n",
       "      <td>596.334914</td>\n",
       "      <td>0.334914</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      module request_interval  rate        time  tokenInDelay\n",
       "66066   U_P0               4s  0.25  580.050285      0.050285\n",
       "66067   U_P0               4s  0.25  584.212802      0.212802\n",
       "66068   U_P0               4s  0.25  588.345066      0.345066\n",
       "66069   U_P0               4s  0.25  592.561201      0.561201\n",
       "66070   U_P0               4s  0.25  596.334914      0.334914"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get tokenInDelays but only at user U_P0\n",
    "end2end_delays = vector_values(vecs, 'tokenInDelay', only_modules=['U_P0'])\n",
    "end2end_delays.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHEZJREFUeJzt3XuYHXWd5/H3JxeUAGNuHQxgJuHqoItRW5aVEUEnGcIK6MysA+No4zobndEwDu4+6uqjLosM62XdQddLHFmP+ygyCmjYpEkyeMkzCkoHYnM1NNhoS0zSCSAQBvry3T9OtTndVHfX6T5VdU7n83qeevr8flXn1LcqJ/U9v1/9qkoRgZmZ2Vizyg7AzMyakxOEmZmlcoIwM7NUThBmZpbKCcLMzFI5QZiZWSonCDMzS+UEYWZmqZwgzMws1ZyyA5iOxYsXx/Lly8sOw8yspWzfvr0/ItomWy63BCHpGuANwJ6IeGlSdx1wSrLIfOCxiFgpaTlwH/DzZN5tEfGuydaxfPlyurq6Gh26mdmMJunhLMvl2YL4KvA54GsjFRHx5yOvJX0aeLxm+QcjYmWO8ZiZWR1ySxARsS1pGTyHJAFvBl6X1/rNzGx6yjpJ/Rpgd0Q8UFO3QtKdkn4o6TUlxWVmZomyTlJfDFxbU94FLIuIfZJeCXxH0ksi4rdj3yhpLbAWYNmyZYUEa2Z2KCq8BSFpDvAnwHUjdRHxTETsS15vBx4ETk57f0Ssj4j2iGhva5v0JLyZWdPo7+9n3bp17Nu3r+xQMimji+mPgPsjom+kQlKbpNnJ6+OBk4CHSojNzCw3lUqF7u5uKpVK2aFkkluCkHQtcCtwiqQ+Se9IZl3E6O4lgLOAbkk/A74NvCsi9ucVm5lZ0fr7++ns7CQi6OzsbIlWRJ6jmC4ep/6SlLrrgevzisXMrGyVSoWRRzwPDw9TqVS47LLLSo5qYr7VhplZAbZu3crAwAAAAwMDbNmypeSIJucEYWZWgFWrVjF79mwAZs+ezerVq0uOaHJOEGZmBejo6GBoaAiAoaEhOjo6So5ock4QZmYF2L9/9LibRx99tKRIsnOCMDMrwBVXXDGqfPnll5cUSXZOEGZmBejt7Z2w3IycIMzMCrB06dJR5WOOOaakSLJzgjAzK8DICerxys3ICcLMrAB79uwZVd69e3dJkWTnBGFmZqmcIMzMLJUThJmZpXKCMDOzVE4QZmYFWLJkyYTlZuQEYWZWgCuvvHJU+aqrriopkuycIMzMCnDyySf/rtWwZMkSTjzxxJIjmpwThJlZQa688kqOOOKIlmg9QI5PlDMzs9FOPvlkOjs7yw4jM7cgzMwK0t/fz7p161riedTgBGFmVphKpUJ3dzeVSqXsUDLJLUFIukbSHkl319R9TNKvJe1IpvNq5n1QUo+kn0v647ziMjMrQ39/P52dnUQEnZ2dLdGKyLMF8VXg3JT6z0TEymTaBCDpVOAi4CXJez4vaXaOsZmZFapSqRARAAwPD7dEKyK3BBER24D9ky5YdSHwzYh4JiJ+AfQAp+cVm5lZ0bZu3crAwAAAAwMDbNmypeSIJlfGOYj3SOpOuqAWJHXHAr+qWaYvqTMzmxFWrVrF3LlzAZg7dy6rV68uOaLJFZ0gvgCcAKwEdgGfTuqVsmykfYCktZK6JHXt3bs3nyjNzBqso6MDqXqomzVrFh0dHSVHNLlCE0RE7I6IoYgYBr7MwW6kPuBFNYseBzwyzmesj4j2iGhva2vLN2AzswZZvHgxa9asQRJr1qxh0aJFZYc0qUIThKTah7K+CRgZ4bQBuEjS8yStAE4CflpkbGZmeevo6OC0005ridYD5HgltaRrgbOBxZL6gI8CZ0taSbX7qBd4J0BE3CPpn4B7gUHg3RHR/A9sNTOrw+LFi/nsZz9bdhiZaWTYVStqb2+Prq6ussMwM2spkrZHRPtky/lKajMzS+UEYWZmqZwgzMwslROEmZmlcoIwM7NUThBmZpbKCcLMzFI5QZiZFcRPlDMzs1R+opyZmT1H7RPlNm3a1BKtCCcIM7MCVCqVUQ8MaoVWhBOEmVkBtmzZ8rtHjkYEmzdvLjmiyTlBmJkVYP78+aPKCxYsGGfJ5uEEYWZWgF27do0qP/JI6jPRmooThJmZpXKCMDOzVE4QZmYFWLhw4YTlZuQEYWZWgP37909YbkZOEGZmlsoJwszMUuWWICRdI2mPpLtr6j4p6X5J3ZJulDQ/qV8u6WlJO5Lpi3nFZWZm2eTZgvgqcO6Yuq3ASyPiNGAn8MGaeQ9GxMpkeleOcZmZWQa5JYiI2AbsH1O3JSIGk+JtwHF5rd/MzKanzHMQ/xHorCmvkHSnpB9Kek1ZQZmZWdWcMlYq6UPAIPD1pGoXsCwi9kl6JfAdSS+JiN+mvHctsBZg2bJlRYVsZnbIKbwFIakDeAPwlkhubRgRz0TEvuT1duBB4OS090fE+ohoj4j2tra2osI2MzvkFJogJJ0LvB+4ICIO1NS3SZqdvD4eOAl4qMjYzMxstNy6mCRdC5wNLJbUB3yU6qil5wFbJQHcloxYOgu4XNIgMAS8KyKa/zJDM7MZLLcEEREXp1R/ZZxlrweuzysWMzOrn6+kNjOzVE4QZmaWygnCzMxSOUGYmVkqJwgzM0vlBGFmZqmcIMzMLJUThJmZpXKCMDOzVE4QZmaWatIEIel6Sf9ekpOJmdkhJMtB/wvAXwAPSLpK0otzjsnMzJrApAkiIv45It4CvALopXon1h9LerukuXkHaGZm5cjUbSRpEXAJ8FfAncA/UE0YW3OLzMzMSjXp7b4l3QC8GPi/wPkRsSuZdZ2krjyDMzOz8mR5HsTnIuJ7aTMior3B8ZiZWZOYNEFExPckvRQ4FXh+Tf3X8gzMzMzKlaWL6aNUHx16KrAJWAP8C+AEYWY2g2U5Sf1nwOuB30TE24GXUX2utJmZzWBZEsTTETEMDEr6PWAPcHy+YZmZWdmyJIguSfOBLwPbgTuAn2b5cEnXSNoj6e6auoWStkp6IPm7IKmXpKsl9UjqlvSKKWyPmZk1SJYL5f4mIh6LiC8Cq4COpKspi68C546p+wBwS0ScBNySlKF6buOkZFpL9QpuMzMrybgnqSf6BS/pFRFxx2QfHhHbJC0fU30h1ZPeABXgB8D7k/qvRUQAt0maL2lpzXUXZmZWoIlGMX16gnkBvG6K6zx65KAfEbskLUnqjwV+VbNcX1LnBGFmVoJxE0REnFNkIIDSwnjOQtJaql1QLFu2LO+YzMwOWVlu9z1P0oclrU/KJ0l6wzTWuVvS0uSzllIdFQXVFsOLapY7Dnhk7JsjYn1EtEdEe1tb2zTCMDOziWQZxfR/gGeBVyflPuCKaaxzA9CRvO4AvltT/7ZkNNMZwOM+/2BmVp4sCeKEiPgEMAAQEU+T3h30HJKuBW4FTpHUJ+kdwFXAKkkPUB0VdVWy+CbgIaCH6pDav6lnQ8zMrLGy3KzvWUmHk5wPkHQC8EyWD4+Ii8eZ9fqUZQN4d5bPNTOz/GVJEB8FbgZeJOnrwJlUnw1hZmYzWJa7uW6VdAdwBtWupb+NiP7cIzMzs1JNmCAkzaF6hfPIc6jvAx7LOygzMyvfuCepJR0D3AO8DziG6kVr/wW4J5lnZmYz2EQtiCuBL0TE/6qtlHQp8PccHKpqZmYz0EQJ4oyIuGRsZURcLenn+YVkZmbNYKLrIJ6eYN6BRgdiZmbNZaIWxAsk/UlKvYDfyykeMzNrEhO1IH4InJ8yvQHYln9oZjYT9Pf3s27dOvbt21d2KFanie7mmvWhQGZm46pUKnR3d1OpVLjsssvKDsfqMOmFcpKeB/wpsLx2+Yi4PL+wzGwm6O/vZ+PGjUQEGzdupKOjg0WLFpUdlmWU5WZ936X6tLdB4KmaycxsQpVKhcHBQQAGBgaoVColR2T1yHIvpuMiYuxzpc3MJrV58+ZR5ZtvvtndTC0kSwvix5L+Te6RmNmMM2fOnAnL1tyy/Gv9IXCJpF9Qvc23qN6d+7RcIzOzlvfkk09OWLbmliVBrMk9CjObkY488shRSeHII48sMRqr17gJQtLC5OUTBcViZjPMwMDAhGVrbhO1ILZTfYpc2uNFAzg+l4jMbMZYunQpvb29o8rWOia6UG5FkYGY2cyze/fuCcvW3LKMYkLSsZJeLemskSnvwMys9Z111uhDxWtf+9qSIrGpyHIl9f8A/hy4FxhKqoMp3o9J0inAdTVVxwMfAeYD/wnYm9T/14jYNJV1mFlz2LVr16jyb37zm5IisanIMorpjcApEfFMI1YYET8HVgJImg38GrgReDvwmYj4VCPWY2bl6+7uHlXesWNHSZHYVGTpYnoImJvT+l8PPBgRD+f0+WZmNkVZWhAHgB2SbqF6oRwAEXFpA9Z/EXBtTfk9kt4GdAHvi4hHG7AOMzObgiwtiA3Afwd+THXo68g0LZIOAy4AvpVUfQE4gWr30y7g0+O8b62kLklde/fuTVvEzMwaYNIWRERUJB0OLEvOHzTKGuCOiNidrOd3498kfRn4f+PEsx5YD9De3h4NjMfMzGpM2oKQdD6wA7g5Ka+UtKEB676Ymu4lSbVX0LwJuLsB6zAzsynKcg7iY8DpwA8AImKHpGldRCdpHrAKeGdN9SckraQ6hLZ3zDwzMytYlgQxGBGPS6PuuDGtrp2IOAAsGlP31ul8ppmZNVaWBHG3pL8AZks6CbiU6glrMzObwbKMYloHvITqENdvAL8F3ptnUGZmVr4sLYglEfEh4EMjFZJeBdyeW1RmZla6LC2IGyQdO1JIbtR3TX4hmZlZM8iSIN4JfEfSCyWdB1wNnJdvWGZmVrYsF8rdLulSYAvwr8CqiPAlzGZmM9xEjxy9idHDWecBjwNfkUREXJB3cGZmVp6JWhC+7baZ2SFsokeO/nDktaSjgVclxZ9GxJ68AzMzs3JluRfTm4GfAv8BeDPwE0l/lndgZmZWrizXQXwIeNVIq0FSG/DPwLfzDMzMzMqVZZjrrDFdSvsyvs/skNXf38+6devYt29f2aGYTVmWA32npM2SLpF0CbAR2JRvWGatrVKp0N3dTaVSKTsUsynLkiAC+BJwGvAykof1mFm6/v5+Ojs7iQg6OzvdirCWlSVBrIqIGyLisoj4u4i4kerT4MwsRaVSIaJ6CdHw8LBbEdayxk0Qkv5a0l3AKZK6a6ZfAN3FhWjWWrZu3crAwAAAAwMDbNmypeSIzKZmohbEN4DzgQ3J35HplRHxlwXEZtaSVq1axZw51QGCc+bMYfXq1SVHZDY14yaIiHg8Inoj4uKIeLhm2l9kgGatpqOjg8HBQQAGBwfp6OgoOSKzqfFwVTMzS+UEYdZgH//4xycsm7WKLFdS50JSL/AEMAQMRkS7pIXAdcByoBd4c0Q8WlaMZlOxffv2UeWurq6SIjGbnrJbEOdExMqIaE/KHwBuiYiTgFuSspmZlaDsBDHWhcDIoPEK8MYSYzGbktmzZ09YNmsVZSaIALZI2i5pbVJ3dETsAkj+LiktOrMpWrFixajyCSecUFIkZtNT2jkI4MyIeETSEmCrpPuzvClJJmsBli1blmd8ZlPS09Mzqrxz586SIjGbntJaEBHxSPJ3D3AjcDqwW9JSgOTvcx5MFBHrI6I9Itrb2tqKDNnM7JBSSoKQdISko0ZeA6uBu6letT1yVVEH8N0y4jMzs/K6mI4GbpQ0EsM3IuJmSbcD/yTpHcAvqT7FzszMSlBKgoiIh6jeOnxs/T7g9cVHZGZmYzXbMFczM2sSThBmZpbKCcLMzFI5QZiZWSonCDMzS+UEYWZmqZwgrGF27tzJmjVrnnOrCTNrTU4Q1jBXXHEFTz31FJdffnnZoZhZAzhBWEPs3LmT3t5eAHp7e92KMJsBnCCsIa644opRZbcizFqfE4Q1xEjrYbyymbUeJwhriOXLl09YNrPW4wRhDfHhD394VPkjH/lISZGYWaM4QVhDLFy4cFR5wYIFJUViZo3iBGEN8clPfnJU+VOf+lRJkZhZozhBTFN/fz/r1q1j3759ZYdSqltvvXVU+Uc/+lFJkZhZozhBTFOlUqG7u5tKpVJ2KGZmDeUEMQ39/f10dnYSEXR2dh7yrQgzm1mcIKahUqkQEQAMDw+7FWFmM4oTxDRs3bqVgYEBAAYGBtiyZUvJEZXntNNOG1V+2cue88hxM2sxhScISS+S9H1J90m6R9LfJvUfk/RrSTuS6byiY6vXqlWrmDt3LgBz585l9erVJUdUngceeGBUeefOnSVFYmaNUkYLYhB4X0T8AXAG8G5JpybzPhMRK5NpUwmx1aWjowNJAMyaNYuOjo6SIyrP008/PWHZzFpP4QkiInZFxB3J6yeA+4Bji46jERYvXsyaNWuQxJo1a1i0aFHZIZmZNUyp5yAkLQdeDvwkqXqPpG5J10hqiUtxzz//fObNm8cFF1xQdihmZg1VWoKQdCRwPfDeiPgt8AXgBGAlsAv49DjvWyupS1LX3r17C4t3PDfddBMHDhxgw4YNZYdiZtZQpSQISXOpJoevR8QNABGxOyKGImIY+DJwetp7I2J9RLRHRHtbW1txQafo7+9n48aNRAQbN270dRBmNqOUMYpJwFeA+yLif9bUL61Z7E3A3UXHVq9KpcLg4CBQHebq6yDMbCYpowVxJvBW4HVjhrR+QtJdkrqBc4C/KyG2umzevHlU+eabby4pEjOzxptT9Aoj4l8Apcxq+mGtY82ZM2fCsplZK/OV1NPw5JNPTlg2M2tlThDTMHKR3HhlM7NW5gQxDSM36huvbGbWypwgzMwslROEmZmlcoIwM7NUHpdpZlanq6++mp6enml/zqWXXpppuRNPPDHzso3kFoSZmaVyC8LMrE5T+TV/1llnPafu6quvbkQ4uXELwsysAEcdddSo8gte8IKSIsnOLQgzy+RQ6XfPy8aNG0e1Im666aYSo8nGLQgzs4K1QusB3IIws4wOlX73PK1cuRJonX3gFoSZmaVyC8JsAu53n55t27aNakVs27atxGisXk4Q9hw+KJoZOEGYTcj97tPX7P3ujfpBlMUDDzwATO17Va9G/PBygkj4V/NBPijaoaSnp4d77rqP+fOW5L6u4Werz4z59YP7cl3PYwf2NORznCDMGqwV+t39q3m0+fOWcM6LL8ohonJ8//5vNuRznCAS/tU8PT4ojq8ZD4w9PT3cv2MHL8wxphEjQyUf27Ej1/X8JtdPPzQ1XYKQdC7wD8Bs4B8j4qp6P6OsAwHkfzCo90Dgg+JBPT093HnPnTA/x6BGHJ78PRLu/PWd+a7rsam97YXAO5g5j8n9Cn6iY6M1VYKQNBv438AqoA+4XdKGiLi3ns/p6enhzrvuZXjewjzCPOioFzLriYO/W4aPeiHbH8zvd8ysA/vrfk9PTw87776DZUcO5RDRaAsOq/5WPHreMP/ae3uu6/rlk7On9sb5MHz2cGODKdmsH/hyJstHUyUI4HSgJyIeApD0TeBCoK4E0dfXBwX9mhim2oQu5pATybZl19fXR1GPyj56XnEH3gimtC94fAYeUB+Dvqh/XzzBzPrVvQt4ss7vBFT3xeMHnmhYv30zeOzAHqLv6Wl/TrMliGOBX9WU+4B/O6VPGhpk1oE6RgoMDzG1I2m1iT4L4InddbxNMKvOX8FDg/Utn3hmSDz8RPZ1DQyL4QKPG7MEc2fVt8JnhsQRU1nZIPV1yQxR1G+NKlHtXK3H1L4WPEv1oFrPaopse82ivgPUs9NY1+DQs3WN/BkaHiCK+uUFSGL2rLmZlx8cms7eOKjZEkRah+iofwVJa4G1AMuWLUv9kLPPPrvufve+vj6efnr6GTerww8/nOOOO67u95144ol1Le99cZD3xUEzdV/Uux/A+2IiKjILTkbSvwM+FhF/nJQ/CBARf5+2fHt7e3R1dRUYoZlZ65O0PSLaJ1uu2TpjbwdOkrRC0mHARcCGkmMyMzskNVUXU0QMSnoPsJlqT+w1EXFPyWGZmR2SmipBAETEJmBT2XGYmR3qmq2LyczMmoQThJmZpXKCMDOzVE4QZmaWygnCzMxSNdWFcvWStBd4uOw4gMVAf9lBNAnvi4O8Lw7yvjioGfbF70dE22QLtXSCaBaSurJclXgo8L44yPviIO+Lg1ppX7iLyczMUjlBmJlZKieIxlhfdgBNxPviIO+Lg7wvDmqZfeFzEGZmlsotCDMzS+UEMQFJ50r6uaQeSR9ImX+ZpHsldUu6RdLv18wbkrQjmWbULcsz7JdLJO2t2f6/KiPOvGTY/s/UbPtOSY/VzJvJ34trJO2RdPc48yXp6mS/dUt6RdEx5inD9r8l2e5uST+W9LKaeb2S7kq+F83zkJuI8JQyUb3d+IPA8cBhwM+AU8cscw4wL3n918B1NfOeLHsbStwvlwCfKzvWsrZ/zPLrqN62fkZ/L5JtOwt4BXD3OPPPAzqpPjnyDOAnZcdc8Pa/GliQvF5Tu/1AL7C47G0YO7kFMb7TgZ6IeCgingW+CVxYu0BEfD8iDiTF24D6nxXZeibdLzNcvdt/MXBtIZGVLCK2AfsnWORC4GtRdRswX9LSYqLL32TbHxE/johHk2JLHC+cIMZ3LPCrmnJfUjeed1D9dTTi+ZK6JN0m6Y15BFiSrPvlT5Om9LclvaiY0AqR+XuRdDmuAL5XUz1TvxdZ1Pt/aiYbe7wIYIuk7ZLWlhTTczTdA4OaiFLqUod8SfpLoB14bU31soh4RNLxwPck3RURD+YQZ9Gy7JebgGsj4hlJ7wIqwOtyj6wYmb8XVB+Z++2IGKqpm6nfiyzq2XczlqRzqCaIP6ypPjP5XiwBtkq6P2mRlMotiPH1AbW/fI8DHhm7kKQ/Aj4EXBARz4zUR8Qjyd+HgB8AL88z2AJNul8iYl/Nvvgy8MqCYitCpu9F4iLGdC/N4O9FFvXsuxlJ0mnAPwIXRsS+kfqa78Ue4EaqXZmlc4IY3+3ASZJWSDqM6n/2UaNOJL0c+BLV5LCnpn6BpOclrxcDZwL3FhZ5vrLsl9p+5QuA+wqML2+Tbj+ApFOABcCtNXUz+XuRxQbgbclopjOAxyNiV9lBFUXSMuAG4K0RsbOm/ghJR428BlYDqSOhiuYupnFExKCk9wCbqY5cuSYi7pF0OdAVERuATwJHAt+SBPDLiLgA+APgS5KGqSbhqyJiRhwIMu6XSyVdAAxSPWl3SWkBN1jG7YfqyelvRjJEJTFjvxcAkq4FzgYWS+oDPgrMBYiIL1J91vx5QA9wAHh7OZHmI8P2fwRYBHw+OV4MRvWmfUcDNyZ1c4BvRMTNhW9ACl9JbWZmqdzFZGZmqZwgzMwslROEmZmlcoIwM7NUThBmZpbKCcIsJ5LeK2le2XGYTZWHuZpNg6qD1xURwynzeoH2iOgvPDCzBnALwqxOkpZLuk/S54E7gK8kN+C7R9J/S5a5FDgG+L6k7yd1qyXdKukOSd+SdGR5W2E2ObcgzOokaTnwEPDqiLhN0sKI2C9pNnALcGlEdNe2IJJba9wArImIpyS9H3heRFxe0maYTcq32jCbmoeTZxoAvDm5RfMcYClwKtA9ZvkzkvofJbdUOIya+zSZNSMnCLOpeQpA0grgPwOviohHJX0VeH7K8gK2RsTFxYVoNj0+B2E2Pb9HNVk8Luloqo+SHPEEcFTy+jbgTEknAkiaJ+nkQiM1q5NbEGbTEBE/k3QncA/V8xI/qpm9HuiUtCsizpF0CXDtyC2/gQ8DOzFrUj5JbWZmqdzFZGZmqZwgzMwslROEmZmlcoIwM7NUThBmZpbKCcLMzFI5QZiZWSonCDMzS/X/AavhaWnMUpIiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.boxplot('rate', 'tokenInDelay', data=end2end_delays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x29b39398898>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.barplot('rate', 'tokenInDelay', data=end2end_delays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Queue lengths\n",
    "For different VNFs to identify the bottleneck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>module</th>\n",
       "      <th>request_interval</th>\n",
       "      <th>rate</th>\n",
       "      <th>time</th>\n",
       "      <th>queueLength0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  module request_interval  rate  time  queueLength0\n",
       "0   S_T0             0.8s  1.25   0.0           0.0\n",
       "1   S_T0             0.8s  1.25   1.0           0.0\n",
       "2   S_T0             0.8s  1.25   2.0           0.0\n",
       "3   S_T0             0.8s  1.25   3.0           0.0\n",
       "4   S_T0             0.8s  1.25   4.0           0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qlengths = vector_values(vecs, 'queueLength0', only_modules=['C_T0', 'S_T0', 'V_T0', 'A_T0'])\n",
    "qlengths.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>module</th>\n",
       "      <th>request_interval</th>\n",
       "      <th>rate</th>\n",
       "      <th>time</th>\n",
       "      <th>queueLength0</th>\n",
       "      <th>VNF</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>server</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>server</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>server</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>server</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>S_T0</td>\n",
       "      <td>0.8s</td>\n",
       "      <td>1.25</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>server</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  module request_interval  rate  time  queueLength0     VNF\n",
       "0   S_T0             0.8s  1.25   0.0           0.0  server\n",
       "1   S_T0             0.8s  1.25   1.0           0.0  server\n",
       "2   S_T0             0.8s  1.25   2.0           0.0  server\n",
       "3   S_T0             0.8s  1.25   3.0           0.0  server\n",
       "4   S_T0             0.8s  1.25   4.0           0.0  server"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map module names to proper VNF names\n",
    "mapping = {\n",
    "    'C_T0': 'cache',\n",
    "    'S_T0': 'server',\n",
    "    'V_T0': 'vid. opt.',\n",
    "    'A_T0': 'ad ins.'\n",
    "}\n",
    "qlengths['VNF'] = qlengths['module'].map(lambda x: mapping[x])\n",
    "qlengths.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x29b397ea0b8>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# mean queue length per request rate and module\n",
    "sns.barplot('rate', 'queueLength0', hue='module', hue_order=['C_T0', 'S_T0', 'V_T0', 'A_T0', 'C_T3'], data=qlengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 5)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.barplot('rate', 'queueLength0', hue='module', hue_order=['C_T0', 'S_T0', 'V_T0', 'A_T0', 'C_T3'], data=qlengths)\n",
    "g.set(ylim=(0, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[None]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.barplot('rate', 'queueLength0', hue='module', hue_order=['C_T0', 'S_T0', 'V_T0', 'A_T0', 'C_T3'], data=qlengths)\n",
    "g.set(yscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Paper plot: Delay and queue lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# global seaborn settings\n",
    "sns.set(font_scale=1.5)\n",
    "sns.set_style(\"white\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.barplot(\n",
    "    'rate', 'queueLength0', data=qlengths,\n",
    "    hue='VNF', hue_order=['cache', 'server', 'vid. opt.', 'ad ins.'],\n",
    "    palette='gray', errcolor='black'\n",
    ")\n",
    "sns.despine()\n",
    "g.set(\n",
    "    xlabel='User request rate [request/s]',\n",
    "    ylabel='Avg. queue length',\n",
    ")\n",
    "\n",
    "fig = g.get_figure()\n",
    "fig.savefig('plots/queue-length.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\stefan\\git-repos\\work\\venv\\qpn\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 5), Text(0,0.5,'Avg. queue length')]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## delay and qlengths in once. too complicated and hard to read...\n",
    "# plot delay\n",
    "g1 = sns.lineplot('rate', 'tokenInDelay', data=end2end_delays,\n",
    "                err_style='bars', color='black')\n",
    "g1.set(\n",
    "    xlabel='User request rate [request/s]',\n",
    "    ylabel='Avg. end-to-end delay [s]',\n",
    "    ylim=(0,15)\n",
    ")\n",
    "\n",
    "# plot queue length\n",
    "# ax2 = plt.twinx()\n",
    "g2 = sns.lineplot(\n",
    "    'rate', 'queueLength0', data=qlengths,\n",
    "    hue='VNF', hue_order=['cache', 'server', 'vid. opt.', 'ad ins.'], \n",
    "    style='VNF', markers=True, dashes=False\n",
    ")\n",
    "g2.set(\n",
    "    ylabel='Avg. queue length',\n",
    "    ylim=(0, 5),\n",
    ")\n",
    "\n",
    "# export\n",
    "#fig = g.get_figure()\n",
    "#fig.savefig('plots/bottleneck.pdf', bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv-qpn",
   "language": "python",
   "name": "venv-qpn"
  },
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}