sigmod.10.27.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import Counter, defaultdict\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import numpy as np\n",
    "import probscale\n",
    "import itertools\n",
    "import csv\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "plt.rcParams.update({'font.size': 14, 'figure.autolayout': True})\n",
    "\n",
    "class Result:\n",
    "    def __init__(self, path):\n",
    "        self.path = Path(\"results\").joinpath(path, \"flamestream\")\n",
    "    \n",
    "    def lat_data(self):\n",
    "        with open(self.path.joinpath(\"latency/lat.data\"), 'r') as file:\n",
    "            return list(filter(lambda x: x > 0, map(lambda x: int(x) / 1E9, file.read().split(\", \"))))\n",
    "    \n",
    "    def notification_await_times(self):\n",
    "        with open(self.path.joinpath(\"notification_await_times.csv\"), 'r') as file:\n",
    "            return list(map(lambda row: int(row[0]) / 1E6, csv.reader(file)))\n",
    "        \n",
    "    def duration(self):\n",
    "        with open(self.path.joinpath(\"duration.txt\"), 'r') as file:\n",
    "            return int(file.read())\n",
    "        \n",
    "    def durations(self):\n",
    "        with open(self.path.joinpath(\"durations.txt\"), 'r') as file:\n",
    "            return list(map(int, file.read().split(\", \")))\n",
    "    \n",
    "    def throughput_hz(self, skip=0):\n",
    "        durations = self.durations()\n",
    "        return (len(durations) - skip) / (durations[-1] - durations[skip]) * 1E9\n",
    "\n",
    "    def plot_latencies_evolution(self, **kwargs):\n",
    "        plot_quantiles_evolution(self.lat_data(), **kwargs)\n",
    "        \n",
    "    def acker(self):\n",
    "        partitions = [\n",
    "            dict([line.split(\" = \") for line in Path(path).read_text().splitlines()])\n",
    "            for path in self.path.glob('acker/*')\n",
    "        ]\n",
    "        keys = sum(tuple(map(lambda partition: tuple(partition.keys()), partitions)), ())\n",
    "        return defaultdict(lambda: 0, {\n",
    "          key: sum(int(partition[key]) for partition in partitions)\n",
    "          for key in keys\n",
    "        })\n",
    "    \n",
    "    def min_time_updates_sent(self):\n",
    "      return self.acker()['minTimeUpdatesSent'] * self.vars()['parallelism']\n",
    "    \n",
    "    def traffic(self):\n",
    "        acker = self.acker()\n",
    "        vars = self.vars()\n",
    "        return acker.get('bufferedMessagesHandled', 0) + self.min_time_updates_sent() +\\\n",
    "          (acker['acksReceived'] + acker['heartbeatsReceived']\n",
    "           if vars['worker_environment']['LOCAL_ACKER_FLUSH_COUNT'] == 0\n",
    "           else 0)\\\n",
    "               + self.class_addressed_items_number().get('com.spbsu.flamestream.example.bl.WatermarksVsAckerGraph.Watermark', 0)\n",
    "    \n",
    "    def vars(self):\n",
    "      return json.loads(self.path.joinpath(\"../vars.json\").read_text())\n",
    "    \n",
    "    def class_addressed_items_number(self):\n",
    "        partitions = [\n",
    "            dict([line.split(\",\") for line in Path(path).read_text().splitlines()])\n",
    "            for path in self.path.glob('class_addressed_items_number/*')\n",
    "        ]\n",
    "        keys = sum(tuple(map(lambda partition: tuple(partition.keys()), partitions)), ())\n",
    "        return {\n",
    "          key: sum(int(partition.get(key, 0)) for partition in partitions)\n",
    "          for key in keys\n",
    "        }\n",
    "    \n",
    "    def snapshots(self):\n",
    "        partitions = [\n",
    "            dict([line.split(\",\") for line in Path(path).read_text().splitlines()])\n",
    "            for path in self.path.glob('snapshots/*.csv')\n",
    "        ]\n",
    "        keys = sum(tuple(map(lambda partition: tuple(partition.keys()), partitions)), ())\n",
    "        return defaultdict(lambda: 0, {\n",
    "          key: sum(int(partition[key]) for partition in partitions)\n",
    "          for key in keys\n",
    "        })\n",
    "    \n",
    "    def snapshot_duration(self):\n",
    "      return self.vars()['worker_environment']['SNAPSHOTS_DURATION_MS']\n",
    "        \n",
    "    def last_in_window_notification_await_times(self):\n",
    "      return [min(slice) for slice in each_slice(\n",
    "        self.notification_await_times(),\n",
    "        self.vars()['tracking_frequency'] * self.vars()['parallelism'],\n",
    "      )]\n",
    "        \n",
    "def plot_quantiles_evolution(data, window_size=100, q=0.95, stabilize=True):\n",
    "    quantiles = []\n",
    "    prev_quantile = None\n",
    "    is_stable = not stabilize\n",
    "    for window in each_slice(data, window_size):\n",
    "        quantile = np.quantile(window, q)\n",
    "        if is_stable:\n",
    "            quantiles.append(quantile)\n",
    "        elif prev_quantile and prev_quantile < quantile:\n",
    "            is_stable = True\n",
    "            quantiles.append(prev_quantile)\n",
    "            quantiles.append(quantile)\n",
    "        else:\n",
    "            prev_quantile = quantile\n",
    "        prev_window = window\n",
    "    if not is_stable:\n",
    "        raise \"has not stabilized\"\n",
    "    plt.plot(quantiles)\n",
    "        \n",
    "def results_path(parallelism=3, rate=5, watermarks=False):\n",
    "    return Path(f\"results/sigmod/parallelism={parallelism}/distributed_acker={False}/rate={rate}/watermarks={watermarks}/iterations=10/flamestream\")\n",
    "\n",
    "def plot_probabilities(results_by_legends, legend_title=None, plot_title=None):\n",
    "    fig, ax = plt.subplots(figsize=(10,10))\n",
    "    ax.legend(results_by_legends.keys(), title=legend_title)\n",
    "    for result in results_by_legends.values():\n",
    "        plt.plot(*probscale.plot_pos(result.lat_data()))\n",
    "    plt.xlabel('Percentile')\n",
    "    plt.ylabel('Latency, ns')\n",
    "    plt.title(plot_title)\n",
    "    plt.show()\n",
    "    \n",
    "def plot_percentile(percentile, results_by_rates):\n",
    "    fig, ax = plt.subplots(figsize=(10,10))\n",
    "    plt.plot(\n",
    "        results_by_rates.keys(),\n",
    "        [np.percentile(result.lat_data(), percentile) for result in results_by_rates.values()],\n",
    "        marker='o'\n",
    "    )\n",
    "    plt.xlabel('Rate')\n",
    "    plt.ylabel(f\"Latencies {percentile} percentile, ns\")\n",
    "    \n",
    "def plot_percentile_by_throughput(percentile, results):\n",
    "    plt.plot(*plottable_percentile_by_throughput(percentile, results))\n",
    "    \n",
    "def plottable_percentile_by_throughput(percentile, results):\n",
    "    return (\n",
    "        [result.throughput() for result in results],\n",
    "        [np.percentile(result.lat_data(), percentile) for result in results]\n",
    "    )\n",
    "\n",
    "def plot_throughput_by_number_of_iterations(results):\n",
    "    plt.plot(\n",
    "        [result.iterations for result in results],\n",
    "        [result.throughput() for result in results],\n",
    "    )\n",
    "    \n",
    "def show_max_throughput(result_factory, bad_rate, max_rate):\n",
    "    pass\n",
    "\n",
    "def plot_throughput_by_parallelism(results):\n",
    "    plt.plot(\n",
    "        [result.parallelism for result in results],\n",
    "        [result.throughput_hz() for result in results],\n",
    "    )\n",
    "    \n",
    "def plot_latencies_barh(results_by_labels, ax):\n",
    "    w = .70\n",
    "    ind_fs = [1, 2.0, 3.0]\n",
    "\n",
    "    def do_plot(q, c):\n",
    "        ax.barh(range(len(results_by_labels)), [np.percentile(result.lat_data(), q) for result in results_by_labels.values()], color=c, height=w, left=0)\n",
    "\n",
    "    do_plot(99, '.8')\n",
    "    do_plot(90, '.6')\n",
    "    do_plot(75, '.4')\n",
    "    do_plot(50, '.2')\n",
    "\n",
    "    plt.gca().invert_yaxis()\n",
    "\n",
    "    for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(60)\n",
    "\n",
    "    ax.set_yticklabels([])\n",
    "#     plt.xlim((0, np.percentile(latencies[8], 99) + 100))\n",
    "\n",
    "    ax.set_xlabel('Latency(ms)', fontsize=60)\n",
    "\n",
    "    for i, label in enumerate(results_by_labels):\n",
    "        ax.text(np.percentile(results_by_labels[label].lat_data(), 99) + 10, i, label, fontsize = 60)\n",
    "\n",
    "    patch_99 = mpatches.Patch(color='.8', label='99 %-ile')\n",
    "    patch_90 = mpatches.Patch(color='.6', label='95 %-ile')\n",
    "    patch_75 = mpatches.Patch(color='.4', label='75 %-ile')\n",
    "    patch_50 = mpatches.Patch(color='.2', label='50 %-ile')\n",
    "    ax.legend(handles=[patch_99, patch_90, patch_75, patch_50][::-1], fontsize = 60, frameon=False, bbox_to_anchor=(1, 1), ncol=1)\n",
    "\n",
    "    for spine in plt.gca().spines.values():\n",
    "        spine.set_visible(False)\n",
    "        \n",
    "def each_slice(generator, n):\n",
    "    group = []\n",
    "    for element in generator:\n",
    "        group.append(element)\n",
    "        if len(group) == n:\n",
    "            yield group\n",
    "            group = []\n",
    "\n",
    "    if group:\n",
    "        yield group\n",
    "\n",
    "fig = plt.gcf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import json\n",
    "from pathlib import Path\n",
    "\n",
    "all_results = [\n",
    "  Result(Path(path).absolute())\n",
    "  for path in glob('results/sigmod.10.27/*')\n",
    "  if Path(path).joinpath(\"vars.json\").exists()\n",
    "]\n",
    "\n",
    "def result_grouper_key(result):\n",
    "  return (\n",
    "    result.vars()['tracking'],\n",
    "    result.vars().get('distributed_acker'),\n",
    "    result.vars()['worker_environment']['LOCAL_ACKER_FLUSH_COUNT'],\n",
    "  )\n",
    "\n",
    "tracking_results = {\n",
    "  'Markers' if tracking == 'watermarking' else\n",
    "  'Disabled' if tracking == 'disabled' else\n",
    "    (\"trAcker\"):\n",
    "        list(results)\n",
    "    for (tracking, distributed_acker, local_acker_flush_count), results in itertools.groupby(\n",
    "      sorted([\n",
    "        result\n",
    "        for result in all_results\n",
    "      ], key=result_grouper_key),\n",
    "      key=result_grouper_key,\n",
    "    )\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': [defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 1727755422977,\n               'buffered_count': 13661,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 38708249297808,\n               'buffered_count': 71704,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 10541689923583,\n               'buffered_count': 36434,\n               0: 0})],\n 'trAcker': [defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 184460254173,\n               'buffered_count': 168,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 111849494379,\n               'buffered_count': 410,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 1105903192, 'buffered_count': 10, 0: 0})]}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 4
    }
   ],
   "source": [
    "{\n",
    "  legend: sorted([\n",
    "    (result.snapshots())\n",
    "    for result in results\n",
    "    # if result.vars()['iterations'] == 100\n",
    "    #     and result.vars()['parallelism'] == 15\n",
    "  ], key=lambda tuple: tuple[0])\n",
    "  for legend, results in tracking_results.items()\n",
    "}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 0 Axes>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plt.plot(*zip(*sorted([\n",
    "    (\n",
    "      result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'],\n",
    "      result.snapshots()['buffering_duration'] / 1E9,\n",
    "    )\n",
    "    for result in results\n",
    "    if result.vars()['iterations'] == 30\n",
    "        and result.vars()['parallelism'] == 15\n",
    "  ])), marker='o') and legend\n",
    "  for legend, results in tracking_results.items()\n",
    "], title='Tracking')\n",
    "plt.xlabel('Snapshot duration')\n",
    "plt.ylabel('Sum buffering duration (s)')\n",
    "plt.show()\n",
    "plt.draw()\n",
    "fig.savefig('buffering_sum_duration.png')\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 0 Axes>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plt.plot(*zip(*sorted([\n",
    "    (\n",
    "      result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'],\n",
    "      result.snapshots()['buffering_duration'] / result.snapshots()['buffered_count'] / 1E9,\n",
    "    )\n",
    "    for result in results\n",
    "    if result.vars()['iterations'] == 30\n",
    "        and result.vars()['parallelism'] == 15\n",
    "  ])), marker='o') and legend\n",
    "  for legend, results in tracking_results.items()\n",
    "], title='Tracking')\n",
    "plt.xlabel('Snapshot duration')\n",
    "plt.ylabel('Average buffering duration (s)')\n",
    "plt.show()\n",
    "plt.draw()\n",
    "fig.savefig('buffering_average_duration.png')\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 0 Axes>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plt.plot(*zip(*sorted([\n",
    "    (result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'], result.snapshots()['buffered_count'])\n",
    "    for result in results\n",
    "    if result.vars()['iterations'] == 30\n",
    "        and result.vars()['parallelism'] == 15\n",
    "  ])), marker='o') and legend\n",
    "  for legend, results in tracking_results.items()\n",
    "], title='Tracking')\n",
    "plt.xlabel('Snapshot duration')\n",
    "plt.ylabel('Buffered elements count')\n",
    "plt.show()\n",
    "plt.draw()\n",
    "fig.savefig('buffering_count.png')\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 0 Axes>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or result.snapshot_duration()\n",
    "  for result in sorted(tracking_results['trAcker'], key=lambda result: result.snapshot_duration())\n",
    "], title='Snapshot duration')\n",
    "plt.xticks([])\n",
    "plt.xlabel('Element number')\n",
    "plt.ylabel('Latencies (ms)')\n",
    "plt.show()\n",
    "plt.draw()\n",
    "fig.savefig('buffering_latencies_evolution_acker.png')\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or result.snapshot_duration()\n",
    "  for result in sorted(tracking_results['Markers'], key=lambda result: result.snapshot_duration())\n",
    "], title='Snapshot duration')\n",
    "plt.xticks([])\n",
    "plt.xlabel('Element number')\n",
    "plt.ylabel('Latencies (ms)')\n",
    "plt.show()\n",
    "plt.draw()\n",
    "fig.savefig('buffering_latencies_evolution_watermarks.png')\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or legend\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 100\n",
    "])\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or legend\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 250\n",
    "])\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or legend\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 500\n",
    "])\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:2366: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n  warnings.warn(\"This figure includes Axes that are not compatible \"\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.gcf()\n",
    "plt.legend([\n",
    "  plot_quantiles_evolution(result.lat_data(), q=0.5) or legend\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 500\n",
    "])\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.0558871955,\n  0.75: 0.06047116500000001,\n  0.9: 0.0661403857,\n  0.99: 3.1845822140600015},\n 'trAcker': {0.5: 0.0591097655,\n  0.75: 0.0643980445,\n  0.9: 0.0701683318,\n  0.99: 2.5599275175300034}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 13
    }
   ],
   "source": [
    "{\n",
    "  legend: {\n",
    "    quantile: np.quantile(result.lat_data(), quantile)\n",
    "      for quantile in [0.5, 0.75, 0.90, 0.99]\n",
    "  }\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 100\n",
    "}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.057424886,\n  0.75: 0.06270371749999999,\n  0.9: 0.198153286,\n  0.99: 8.667942117110004},\n 'trAcker': {0.5: 0.059218100999999995,\n  0.75: 0.06546039399999999,\n  0.9: 0.0826986819,\n  0.99: 7.70509515515}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 14
    }
   ],
   "source": [
    "{\n",
    "  legend: {\n",
    "    quantile: np.quantile(result.lat_data(), quantile)\n",
    "      for quantile in [0.5, 0.75, 0.90, 0.99]\n",
    "  }\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 250\n",
    "}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.059457731,\n  0.75: 0.07676080075,\n  0.9: 5.173851947199999,\n  0.99: 9.221705000130001},\n 'trAcker': {0.5: 0.0605321115,\n  0.75: 0.07077625074999999,\n  0.9: 4.358249239999998,\n  0.99: 8.266938227190002}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 15
    }
   ],
   "source": [
    "{\n",
    "  legend: {\n",
    "    quantile: np.quantile(result.lat_data()[4500:9000], quantile)\n",
    "      for quantile in [0.5, 0.75, 0.90, 0.99]\n",
    "  }\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 250\n",
    "}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.057224099,\n  0.75: 0.06643390824999999,\n  0.9: 8.120337971500003,\n  0.99: 17.126164741190003},\n 'trAcker': {0.5: 0.0615275,\n  0.75: 0.070247656,\n  0.9: 7.7411561843,\n  0.99: 16.60811271601}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 16
    }
   ],
   "source": [
    "{\n",
    "  legend: {\n",
    "    quantile: np.quantile(result.lat_data(), quantile)\n",
    "      for quantile in [0.5, 0.75, 0.90, 0.99]\n",
    "  }\n",
    "  for legend, results in tracking_results.items()\n",
    "  for result in results\n",
    "  if result.vars()['worker_environment']['SNAPSHOTS_DURATION_MS'] == 500\n",
    "}\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.8"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}