sigmod.10.30.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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.30/*')\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": 3,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': [defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 2360559011, 'buffered_count': 367, 0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 19023487768,\n               'buffered_count': 1213,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 62469935881,\n               'buffered_count': 2200,\n               0: 0})],\n 'trAcker': [defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 15768652515,\n               'buffered_count': 460,\n               0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 1005844325, 'buffered_count': 71, 0: 0}),\n  defaultdict(<function __main__.Result.snapshots.<locals>.<lambda>>,\n              {'buffering_duration': 52593899349,\n               'buffered_count': 233,\n               0: 0})]}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 3
    }
   ],
   "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": 4,
   "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": 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": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8VOX5///XJVvCGoKIQkAQFQVFwAgq1q/WImrdqn4UtG5Yaftza61arXWj1mK1rlWrVcEVVETFlUUWt8omEZAdRQioRRCospiE6/fHORMmIcsJySSTmffz8ZjHzFnmzDXjkLf3Offct7k7IiIiyWa3ui5ARESkLAooERFJSgooERFJSgooERFJSgooERFJSgooERFJSgooERFJSgooERFJSgooERFJSg3ruoCasvvuu3vnzp3rugwREanE7Nmzv3X3tpXtlzIB1blzZ2bNmlXXZYiISCXM7Mso++kUn4iIJCUFlIiIJCUFlIiIJKWUuQZVloKCAvLz89m6dWtdl1IvZGRkkJOTQ6NGjeq6FBGR1A6o/Px8WrRoQefOnTGzui4nqbk769atIz8/ny5dutR1OSIiqR1QW7duVThFZGa0adOGtWvX1nUpIpKkXp2zmrvGL2bNhi20z8rk2oHdOL13h4S9XkoHFKBwqgJ9ViJSnlfnrOaGsfPYUlAEwOoNW7hh7DyAhIWUOkmIiEil7hq/uDicYrYUFHHX+MUJe82Ub0FV17p16zjuuOMA+Prrr2nQoAFt2wY/gJ4xYwaNGzfepeM+/vjjzJ8/n/vuu6/E+oceeoisrCzOO++86hUuIlKD1mzYUqX1NUEBVYk2bdqQl5cHwK233krz5s255pprSuzj7rg7u+1W/QbpZZddVu1jiIjUJHenWZMGfL+taKdt7bMyE/a6OsW3i5YtW0b37t0577zz6NGjB1999RVDhw4lNzeXHj16MGzYsOJ9p0+fzhFHHMEhhxxCv3792Lx5c4ljjRs3jv79+7N+/Xr+/Oc/F7eqjjrqKK6//nr69u1Lt27d+OijjwD44YcfOPPMM+nevTtnnXUWubm5xSEqIlKT3J073lrI99uKaLBbyevUmY0acO3Abgl7bbWgqmHRokU8/fTT5ObmAjB8+HCys7MpLCzk2GOP5ayzzmKfffZh0KBBvPzyy/Tp04eNGzfSpEmT4mOMGTOGBx98kLfeeotWrVrt9BruzowZMxg3bhzDhg3jnXfe4cEHH2TPPffk5Zdf5tNPP6VPnz619p5FJH3Ewunf73/BBUfsTe+OWdw9YYl68dUHXbt2LQ4ngFGjRvHEE09QWFjImjVrWLBgAdu2baNTp07FIRIfQhMnTmTGjBlMmDCB5s2bl/kaZ5xxBgCHHnooK1asAOCDDz7gj3/8IwCHHHIIPXr0SMTbE5E05u787e1FxeF026k9MDN+0Sen1mrQKb5qaNasWfHjpUuXcv/99zN58mTmzp3LCSecUOkIFvvuuy8bN25k6dKl5e4Ta201aNCAwsLCmilcRKQC7s7wtxfx2Hufc/7hO8KptimgasimTZto0aIFLVu25KuvvmL8+PEAdO/enZUrV/LJJ58U71dUFFxo7NKlCy+99BLnnXceCxcujPxa/fv358UXXwRg3rx5LFiwoIbfjYikq1g4PRqG07DT6iacQKf4akyfPn3o3r07BxxwAHvvvTf9+/cHghbQqFGj+O1vf8vWrVvJzMxk8uTJxc/r3r07zzzzDGeeeSZvvvlmpNe64ooruOCCC+jevXvxrazrVyIiVeHuDH8nCKdfHt6pTsMJwNy9zl68JuXm5nrpCQsXLlzIgQceWEcVJU5hYSGFhYVkZGSwdOlSjj/+eJYuXUrDhtX//41U/cxEpGLF4TQtDKdTD2K33RITTmY2291zK9tPLah66Pvvv+e4446jsLAQd+fRRx+tkXASkfTk7tz5zmIenfY55/VLbDhVhf6q1UNZWVnMnj27rssQkRQQC6d/TVvOef068ZfTkiOcQJ0kRETSlrvz9/FBOJ2bZOEECigRkbQUC6dHpgbhdHuShRMooERE0o67c1cYToP7Jmc4gQJKRCStxMLp4TCc/np6coYTKKBKeHXOavoPn0yX69+k//DJvDpndbWPuWHDBh5++OGKX/fVVzEzFi1aVOnxjjnmGEp3pxcRicLduXtCLJw6JnU4gQKqWGy2yNUbtuDsmC2yuiFVXkDFD1s0atQojjrqKEaNGlWt16pMbAQLEUk/sXB6aEosnA5O6nCCNOpmftvrn7FgzaZyt89ZuYEfi7aXWLeloIjrxsxl1IyVZT6ne/uW3HJKxQO1Xn/99SxfvpxevXrRqFEjMjIyaN26NYsWLWLJkiV8//33fPDBB0yZMoVTTjmF2267rfi5d955J88++yy77bYbJ554IsOHDy/etn37doYMGUJOTg633347EyZM4JZbbmHbtm107dqVESNG0Lx5czp37sw555zDxIkTue666xg0aFCUj0tEUoi7848JS3hoynIGHVY/wgnSKKAqUzqcKlsf1fDhw5k/fz55eXlMnTqVn//858yfP58uXboA8Nprr3HCCSew//7706ZNG2bPns2hhx7K22+/zWuvvcb06dNp2rQp69evLz5mYWEh5513HgcddBA33ngj3377LbfffjuTJk2iWbNm3Hnnndxzzz3cfPPNQDDpYmwsQBFJL7Fw+ueUZQw6rCN3/KJ+hBOkUUBV1tLpP3wyq8uYurhDViYv/PqIGqujb9++xeEEwem9q666CoBBgwYxatQoDj30UCZNmsTFF19M06ZNAcjOzi5+zq9//WvOPvtsbrzxRgA+/vhjFixYUDz+348//sgRR+yo+Zxzzqmx+kWk/nB37plYP8MJ0iigKnPtwG7cMHYeWwp2XKdJxGyR8VN0rF+/nsmTJzNv3jzMjKKiIsyMu+66q8JjHHnkkUyZMoU//OEPZGRk4O4MGDCg3GtY8a8pIunB3bl34hIenLyMc3LrXziBOkkUO713B/52xsF0yMrECFpOfzvj4GrPFtmiRQv+97//lbltzJgxnH/++Xz55ZesWLGCVatW0aVLF95//30GDBjAiBEjiqeHjz/Fd8kll3DSSSdx9tlnU1hYyOGHH86HH37IsmXLgGBK+CVLllSrbhGpv2Lh9EAYTn87o/6FEyS4BWVmJwD3Aw2Ax919eKntVwO/AgqBtcAQd/8y3HYh8Odw19vd/alE1gpBSNX09MVt2rShf//+HHTQQWRmZtKuXbvibaNGjSqeGTfmzDPPZNSoUTzyyCPk5eWRm5tL48aNOemkk7jjjjuK97v66qvZuHEj559/Ps899xwjR45k8ODBbNu2DYDbb7+d/fffv0bfi4gkP3fn3klLeWDyMs7Ozam34QQJnG7DzBoAS4ABQD4wExjs7gvi9jkWmO7um83st8Ax7n6OmWUDs4BcwIHZwKHu/l15r5dO020kkj4zkfrtnolLeODdpZydm8PwM3omZThFnW4jkaf4+gLL3P1zd/8RGA2cFr+Du09x983h4sdAbLL7gcBEd18fhtJE4IQE1ioiUu/dG4bT/x2avOFUFYkMqA7Aqrjl/HBdeS4B3q7Kc81sqJnNMrNZa9eurWa5IiL1170Tl3B/GE53nln/wwmSpJOEmf2S4HRexd3XSnH3x9w9191z27Ztm5jiRESSXCyczkqhcILEBtRqoGPcck64rgQz+xlwI3Cqu2+rynNFRNLdfZNSM5wgsQE1E9jPzLqYWWNgEDAufgcz6w08ShBO/43bNB443sxam1lr4PhwnYiIhO6btIT7Ji3lzD5BODVIoXCCBHYzd/dCM7ucIFgaAE+6+2dmNgyY5e7jCE7pNQdeMjOAle5+qruvN7O/EIQcwDB3X1/Gy4iIpKX7Jy0tDqe/n5V64QQJvgbl7m+5+/7u3tXd/xquuzkMJ9z9Z+7ezt17hbdT4577pLvvG95GJLLOYnNfhHsPgluzgvu5L1b7kGbGL3/5y+LlwsJC2rZty8knn1yl40ydOrXKzxGR1HT/pKXcO2kJZ/TpkLLhBEnSSSIpzH0RXr8SNq4CPLh//cpqh1SzZs2YP38+W7YE4/xNnDiRDh2q9mPg+Kk5dkV1ny8iyeOBd3eE011nHZKy4QRVOMVnZs2Are5ePycVevt6+Hpe+dvzZ0LRtpLrCrbAa5fD7HIGsdjzYDhxeNnb4px00km8+eabnHXWWYwaNYrBgwfz/vvvAzBjxgyuuuoqtm7dSmZmJiNGjKBbt26MHDmSsWPH8v3331NUVFRiGo6ZM2cydOhQxowZw5577skVV1zB/PnzKSgo4NZbb+W0007b6fmjR4/mnHPOYdOmTRQWFvLII4/wk5/8pNLaRSR5PPjuUu6ZuIQzeqd+OEEFLSgz283MzjWzN83sv8Ai4CszW2Bmd5nZvrVXZi0oHU6Vra+CQYMGMXr0aLZu3crcuXPp169f8bYDDjiA999/nzlz5jBs2DD+9Kc/FW/75JNPGDNmDNOmTSte99FHH/Gb3/yG1157ja5du/LXv/6Vn/70p8yYMYMpU6Zw7bXX8sMPP+z0/Oeff56BAweSl5fHp59+Sq9evar9vkSk9jz47lL+EQun/0v9cIKKW1BTgEnADcB8d98OEA5DdCxwp5m94u7PJr7MGlBZS+feg8LTe6W06ggXv1mtl+7ZsycrVqxg1KhRnHTSSSW2bdy4kQsvvJClS5diZhQUFBRvGzBgQIlpNhYuXMjQoUOZMGEC7du3B2DChAmMGzeOu+++G4CtW7eycuXKnZ5/2GGHMWTIEAoKCjj99NMVUCL1yD8np184QcXXoH7m7n9x97mxcAIIhx962d3PBF5IfIm15LiboVFmyXWNMoP1NeDUU0/lmmuuYfDgwSXW33TTTRx77LHMnz+f119/na1btxZvKz1Nxl577UVGRgZz5swpXufuvPzyy+Tl5ZGXl8fKlSuLx9KLf/7RRx/Ne++9R4cOHbjooot4+umna+R9iUhi/XPyUu6esIRfpFk4QQUB5e4FAGbW1cyahI+PMbMrzSwrfp+U0PNsOOWBoMWEBfenPBCsrwFDhgzhlltu4eCDDy6xfuPGjcWdJkaOHFnhMbKysnjzzTe54YYbmDp1KgADBw7kwQcfJDbob3x4xfvyyy9p164dl156Kb/61a80w65IPfDQlGXF4XR3moUTROvF9zJQFF5zeoxghIfnE1pVXel5Nvx+Pty6IbivoXACyMnJ4corr9xp/XXXXccNN9xA7969I/W2a9euHW+88QaXXXYZ06dP56abbqKgoICePXvSo0cPbrrppjKfN3XqVA455BB69+7NCy+8UDyLr4gkp4emLOOu8Ys5vVf7tAwniDDdhpl94u59zOxagl58D5rZHHfvXTslRqPpNmqGPjORuhcfTv84u1fKhVNNTrdRYGaDgQuBN8J1japTnIiIlC0WTqelaDhVRZSAuhg4Aviru39hZl2AZxJblohI+nl4alw4pelpvXiV/lA3nAH3yrjlL4A7E1lUTXJ3wnH+pBKJml1ZRCr38NRl/P2dxZx6SBBODRtooJ+Kfqj7upmdYmY7nc4zs33MbJiZDUlsedWTkZHBunXr9Ic3Andn3bp1ZGRk1HUpImnnkanLi8PpnrMVTjEVtaAuBa4G7jOz9cBaIAPoDCwH/unuryW8wmrIyckhPz8fzbYbTUZGBjk5OXVdhkhaeWTqcu58ZxGnKJx2Um5AufvXwHXAdWbWGdgL2AIscffNtVJdNTVq1IguXbrUdRkiImX617Qd4XSvwmknkQaLdfcVwIqEViIikkYenbac4W8rnCqiT0REpJY9Om05f3t7ESf33EvhVAF9KiIiteix93aE033n9FI4VUCfjIhILXnsveXc8dYifq5wiqTSa1Bm1h+4Fdg73N8Ad/d9EluaiEjq+Pd7nxeH0/0Kp0iidJJ4Avg9MBuon7PpiojUoX+/9zl/fWshPz9Y4VQVUQJqo7u/nfBKRERS0OPvx4XTIIVTVUQJqClmdhcwFiie/9zdNaGQiEgFHn//c25/Mwin+xROVRYloPqF9/FDozvw05ovR0QkNcTC6aSD9+S+Qb1opHCqsiiDxR5bG4WIiKSK+HC6f1BvhdMuqvRTM7NWZnaPmc0Kb/8ws1a1UZyISH0TC6cTD1I4VVeUT+5J4H/A2eFtEzAikUWJiNRHT3zwRXE4PTBY4VRdUa5BdXX3M+OWbzOzvEQVJCJSHz3xwRf85Y0FnNBD4VRTonyCW8zsqNhC+MPdLYkrSUSkfnkyLpwePFfhVFOitKB+CzwVXncyYD1wUSKLEhGpL0Z8+AXD3ljAwB7tFE41LEovvjzgEDNrGS5vSnhVIiL1wIgPv+C214Nw+ue5fRRONazcgDKzX7r7s2Z2dan1ALj7PQmuTUQkaY2MC6cHByucEqGiFlSz8L5FGds8AbWIiNQLIz/8gltfX8Dx3YNwatxQ4ZQIFU35/mj4cJK7fxi/LewoISKSdp76aEVxOP3zXIVTIkX5ZB+MuE5EJKU99dEKbhn3GQMUTrWiomtQRwBHAm1LXYdqCTRIdGEiIsnk6f/sCKeHFE61oqJrUI2B5uE+8dehNgFnJbIoEZFk8vR/VnDzawqn2lbRNahpwDQzG+nuX9ZiTSIiSSMWTj87UOFU26L8UHdzOB9UDyAjttLdNd2GiKS0Z/6zI5wePk/hVNuifNrPAYuALsBtwApgZgJrEhGpc8/8ZwU3vfYZPztwD4VTHYnyibdx9yeAAnef5u5DiDhZoZmdYGaLzWyZmV1fxvajzewTMys0s7NKbSsys7zwNi7SuxERqQHPfPxlXDgdqnCqI1FO8RWE91+Z2c+BNUB2ZU8yswbAQ8AAIB+YaWbj3H1B3G4rCcb1u6aMQ2xx914R6hMRqTHPfPwlN706n58duAcPqeVUp6IE1O3hQLF/IPj9U0vg9xGe1xdY5u6fA5jZaOA0oDig3H1FuG171coWEal5z4bhdNwBQTg1aahf1NSlCv/XIGwF7efuG919vrsf6+6HunuUU24dgFVxy/nhuqgywhl8Pzaz08upb2hspt+1a9dW4dAiIiU9N/1L/vzqfH56wB48/EuFUzKoMKDcvQgYXEu1lLa3u+cC5wL3mVnX0ju4+2PunuvuuW3btq39CkUkJTw3/UtufCUIp0cUTkkjyim+D83sn8ALwA+xle7+SSXPWw10jFvOCddF4u6rw/vPzWwq0BtYHvX5IiJRPD99pcIpSUUJqFhHhWFx65zKe/LNBPYzsy4EwTSIoDVUKTNrDWx2921mtjvQH/h7lOeKiET1/PSV/OmVeRzbra3CKQlFmbDw2F05sLsXmtnlwHiCsfuedPfPzGwYMMvdx5nZYcArQGvgFDO7zd17AAcCj4adJ3YDhpfq/SciUi3x4fSv8w9VOCUhc694aiczu7ms9e4+rKz1dSU3N9dnzZpV12WISD0wasZKbhgbazkdSkYjhVNtMrPZYR+DCkU5xfdD3OMM4GRg4a4WJiJSl2LhdIzCKelFOcX3j/hlM7ub4LSdiEi9MjounP6lcEp6u/IT6aYEPfJEROqN0TNWcv3Yefy//RVO9UWlLSgzm0fQaw+Czg5tKdmjT0Qkqb0wc0c4PXq+wqm+iHIN6uS4x4XAN+5emKB6RERq1AszV/LHlxVO9VFFU77HBoT9X6lNLc0Md1+fuLJERKrvxZmruH7sPI5WONVLFbWgZhOc2jOgE/Bd+DiLYBTyLgmvTkRkF704cxV/HDuXn+zXlscUTvVSuZ0k3L2Lu+8DTAJOcffd3b0NwSm/CbVVoIhIVb04S+GUCqL04jvc3d+KLbj728CRiStJRGTXvThrFX98eS5H7bu7wqmei9JJYo2Z/Rl4Nlw+j2DSQhGRpPJSXDj9+4JchVM9F6UFNZiga/krwNjwcV1NwSEiUqaXZq3iOoVTSokyksR64KpaqEVEZJeMmZ2vcEpBuzKShIhI0hgzO59rx3xK/64Kp1SjgBKReis+nB6/UOGUahRQIlIvvayWU8qLMhbfA2Ws3kgw6eBrNV+SiEjFXp6dzzVjPuXIrm349wW5ZDZWOKWiKC2oDIJp35eGt54Eo5lfYmb3JbA2EZGdjP1kRzg9fsFhCqcUFuV3UD2B/u5eBGBmjwDvA0cB8xJYm4hICWM/yecPL33KEfsonNJBlBZUa6B53HIzIDsMrG0JqUpEpJRX5uwIpycuVDilgygtqL8DeWY2lWCw2KOBO8ysGcE4fSIiCfXKnHyuflHhlG6i/FD3CTN7C+gbrvqTu8eGOro2YZWJiACvzlnNH178lMO7KJzSTdRu5rsBawmm3NjXzI5OXEkiIoFX56zm6hfz6NelDU9epHBKN1G6md8JnAN8BmwPVzvwXgLrEpE091rejnB64iJ1JU9HUa5BnQ50c3d1iBCRWvFa3mp+/0Iefbtk88RFuTRtHOVPlaSaKKf4PgcaJboQEREoGU5PXnSYwimNRfkvv5mgF9+7xHUrd/crE1aViKQlhZPEi/Jff1x4ExFJmFg4HdZZ4SSBKN3Mn6qNQkQkfY37dA2/fyGP3M7ZjLhY4SSBcr8FZvaiu59tZvMIeu2V4O49E1qZiKSFcZ+u4Xej55DbOZuRCieJU9E3ITaL7sm1UYiIpJ/X48JphE7rSSnlfhvc/SszawCMdPdja7EmEUkDr3+6hqtGzyF37yCcmjVROElJFXYzDweE3W5mrWqpHhFJA69/uobfvZAXhNPFCicpW5RvxffAPDObCPwQW6lu5iKyK96YG4TToZ1aK5ykQlG+GWPDm4hItbw59yuuGp1Hn05ZCiepVKRu5maWCXRy98W1UJOIpKA3537FlaPn0KdTFiMv7qtwkkpVOtSRmZ0C5AHvhMu9zEw/3BWRyOLDaYTCSSKKMhbfrQRzQW0AcPc8YJ8E1iQiKeSteUE49e4YhFNzhZNEFCWgCtx9Y6l128vcU0QkzlvzvuKKUUE4jRyicJKqifJt+czMzgUamNl+wJXAR4ktS0Tqu7cVTlJNUVpQVwA9CEYyfx7YCPwuysHN7AQzW2xmy8zs+jK2H21mn5hZoZmdVWrbhWa2NLxdGOX1RCQ5vD3vKy4fNYdeCiephorG4nvG3c8HLnX3G4Ebq3LgcBSKh4ABQD4w08zGufuCuN1WAhcB15R6bjZwC5BLMA7g7PC531WlBhGpfbGWU6+OWTylcJJqqKgFdaiZtQeGmFlrM8uOv0U4dl9gmbt/7u4/AqOB0+J3cPcV7j6Xna9pDQQmuvv6MJQmAidEflciUifemR+EU8+cVoy8+DCFk1RLRd+efwHvEvTYmw1Y3Dan8p58HYBVccv5QL+IdZX13A6ldzKzocBQgE6dOkU8tIgkwjvzv+Ly54NwempIX1pkaCJuqZ6KWlCvu/uBwJPuvo+7d4m7JUU3c3d/zN1z3T23bdu2dV2OSNp6Z/7XCiepcRUF1Jjwfv9dPPZqoGPcck64LtHPFZFaFITTJxyscJIaVtEpvt3M7E/A/mZ2demN7n5PJceeCexnZl0IwmUQcG7EusYDd5hZ63D5eOCGiM8VkVoSH05PK5ykhlXUghoEFBGEWIsybhVy90LgcoKwWQi86O6fmdkwMzsVwMwOM7N84P+AR83ss/C564G/EITcTGBYuE5EksT4z9RyksQy951mcy+5g9mJ7v52LdWzy3Jzc33WrFl1XYZIWhj/2ddc9twnHNShFU9f0peWCiepAjOb7e65le0XpQ9oXzM7rPRKdx+2S5WJSL02QeEktSTqhIUxGcDJBKfsRCTNTPjsay57XuEktSPKfFD/iF82s7sJriuJSBqZuOAbLnv+E7q3VzhJ7YgyFl9pTQm6fYtImpi44Bv+v+dm0719K55ROEktqbQFZWbzCEaOAGgAtAV0/UkkTUyKC6enhyicpPZEuQZ1ctzjQuCbsAu5iKS4SQu+4bfPzab7Xi15ekhfWmUqnKT2RLkG9aWZ9QGOImhJfQDMSXRhIlK3SoTTJf0UTlLrKr0GZWY3A08BbYDdgZFm9udEFyYidefdhQonqXtRTvGdBxzi7lsBzGw4kAfcnsjCRKRuvLvwG37z7GwOVDhJHYvSi28Nwe+fYpqggVtFUtK7C7/ht89+woF7teQZhZPUsYpm1H2Q4JrTRuAzM5sYLg8AZtROeSJSWyYvCsKp254teGaIwknqXkWn+GID280GXolbPzVh1YhInZi86Bt+80wQTs9e0o9WTRVOUvfKDSh3f6o2CxGRujFl0X8VTpKUdmUkCRFJEVMW/ZdfPzOb/fdsrnCSpKOAEklTUxbvCKfnLjlc4SRJJ3JAmVnTRBYiIrVnyuL/8uun1XKS5Bblh7pHmtkCYFG4fIiZPZzwykQkIaaGLaf92gXhlNW0cV2XJFKmKC2oe4GBwDoAd/8UODqRRYlIYkxd/F+GPjOb/fZoznO/UjhJcot0is/dV5VaVZSAWkQkgRROUt9EGepolZkdCbiZNQKuQjPqitQr05asVThJvROlBfUb4DKgA8EQR73CZRGpB6YtWculT89i37YKJ6lfoky38S3BgLEiUs8onKQ+izKj7gNlrN4IzHL312q+JBGpCe+VCqfWzRROUr9EOcWXQXBab2l46wnkAJeY2X0JrE1EdtF7S9byq6dn0VXhJPVYlE4SPYH+7l4EYGaPAO8TzLA7L4G1icguiLWcurZtzvMKJ6nHorSgWgPN45abAdlhYG1LSFUiskveXxqEU5fdm6nlJPVelBbU34E8M5sKGMGPdO8ws2bApATWJiJV8MHSb/nVU0E4PX/p4WQrnKSei9KL7wkzewvoG676k7uvCR9fm7DKRCSyD5Z+yyVPzVQ4SUqJOljsVuAr4DtgXzPTUEciSULhJKkqSjfzXxGMHpED5AGHA/8BfprY0kSkMh8uUzhJ6orSgroKOAz40t2PBXoDGxJalYhU6sNl3zJk5MziDhEKJ0k1UQJqq7tvBTCzJu6+COiW2LJEpCLxLafnftWPNs2b1HVJIjUuSi++fDPLAl4FJprZd8CXiS1LRMrzURhOe2crnCS1RenF94vw4a1mNgVoBbyT0KpEpEzOoRA7AAATrklEQVQfLfuWIWE4PX+pwklSW4UBZWYNgM/c/QAAd59WK1WJyE7iw+k5hZOkgQqvQYWjRSw2s061VI+IlOGj5UE4dcpuynOX9mN3hZOkgSjXoFoDn5nZDOCH2Ep3PzVhVYlIsY+WB731OmU35flLD1c4SdqIElA3JbwKESnTf5avUzhJ2orSSWKame0N7Ofuk8ysKdAg8aWJpLf/LF/HxSNn0LG1wknSU6W/gzKzS4ExwKPhqg4EXc4rZWYnmNliM1tmZteXsb2Jmb0Qbp9uZp3D9Z3NbIuZ5YW3f0V9QyKpINZy6ti6KaOGKpwkPUU5xXcZwUCx0wHcfamZ7VHZk8IegA8BA4B8YKaZjXP3BXG7XQJ85+77mtkg4E7gnHDbcnfvFf2tiKSGjz8PwimndaZaTpLWoowksc3df4wtmFlDwCM8ry+wzN0/D58/Gjit1D6nAU+Fj8cAx5mZRTi2SEr6+PN1XDxiRzi1baFwkvQVJaCmmdmfgEwzGwC8BLwe4XkdgFVxy/nhujL3cfdCYCPQJtzWxczmmNk0M/tJWS9gZkPNbJaZzVq7dm2EkkSS1/QwnDoonESAaAF1PbCWYHr3XwNvAX9OZFEEU3t0cvfewNXA82bWsvRO7v6Yu+e6e27btm0TXJJI4kz/fB0XFYdTP4WTCNGuQZ0OPO3u/67isVcDHeOWc8J1Ze2TH546bAWsc3cnnE7e3Web2XJgf2BWFWsQSXrTP1/HxSNn0j4rg+cv7cceLTLquiSRpBClBXUKsMTMnjGzk8MgiWImsJ+ZdTGzxsAgYFypfcYBF4aPzwImu7ubWduwkwVmtg+wH/B5xNcVqTdmfLGei0fOZK9WGYwaerjCSSROpQHl7hcD+xJcexoMLDezxyM8rxC4HBgPLARedPfPzGyYmcVGoXgCaGNmywhO5cW6oh8NzDWzPILOE79x9/VVe2siyW3GF+u5aMQMhZNIOSw4mxZhR7NGwAnAxcDR7r57IgurqtzcXJ81S2cApX4oEU6XHs4eLRVOkj7MbLa751a2X5Qf6p5oZiOBpcCZwOPAntWuUCRNzVwRhNOeCieRCkW5nnQB8ALwa3ffluB6RFLazBXrufDJIJxGK5xEKhRlLL7B8ctmdhQw2N0vS1hVIilo5or1XKRwEoksUo88M+sNnAv8H/AFMDaRRYmkmllhOLVrqXASiarcgDKz/Ql67Q0GviU4zWfufmwt1SaSEmaFp/Xatcxg9FCFk0hUFbWgFgHvAye7+zIAM/t9rVQlkiLiw2mUwkmkSioKqDMIflw7xczeIRjsVQO5ilTg1TmruWv8YtZs2EKb5o3ZtKWAnHDKjHYKJ5EqKbebubu/6u6DgAOAKcDvgD3M7BEzO762ChSpL16ds5obxs5j9YYtOPDt9z9SUORceOTeCieRXRBlJIkf3P15dz+FYDy9OcAfE16ZSD1z1/hFbCkoKrHOgcfe+6JuChKp56KOqweAu38HPBbeRNLOlh+LyP9uMyvXB7dV67eE95tZvWFrmc9Zs2FLLVcpkhqqFFAiqa5ou/PNpq2sKg6g8P67IIjW/q/kb9WbNm5Ap+ymdMxuSv6GzfywrWinY7bPyqyt8kVSigJK0s6mrQWsXBeEz6ri1tAW8tdvJv+7LfxYtL14390M9mqVSafsphzbrW1xGMXu2zRrTGwS6Ng1qPjTfJmNGnDtwG61/h5FUoECSlLOj4XbWbNhS1z4bCY/PBW3cv1mNm4pKLF/VtNGdGzdlAP3asnxPfakY3YQSJ2ym7JXq0waN4wyKw2c3juYMDrWi699VibXDuxWvF6k3pv7Irw7DDbmQ6scOO5m6Hl2wl5OASX1jruz7ocfi0/BrSp1PeirjVvYHjdIf+MGu5HTOpOc7KYc0rFV0PppHbSAOmY3pVVmoxqr7fTeHRRIkprmvgivXwkF4TXVjauCZUhYSCmgJClV1Blh1Xeb2fxjyWs9bVs0oVN2U/p2yaZj68wSp+HatcygwW76CZ9IpbYXwdaNsOU72LoBtmzYcf/ubTvCKaZgS9CiUkBJKtm+3fm6VGeEWEeE8jojxFo9/ffdvcRpuJzWTcls3KCO3olIkqkoZMq7jz3etqnqr7cxv+bfQ0gBJQlTE50RYi2h+M4IIimvqDAImeIg+S5C0GyMFjINMyAjCzKzgvuW7WGP7juWy7t//GewqYwwapWTmM8ABZRUQ0FR0Bkh/jRcrEVUVmeEVpmN6JQddEYY0KNdcQuoqp0RROqFqoZM/OMf/1fxsXcKmQ6wR4+4UGldftA02sVRTX52S8lrUACNMoOOEgmigJJyVbUzQqMGRsfWTWulM4JIrSgqLCdQyjp9trGKIZNZMjxa5cCeB1XciqluyFRH7DqTevFJbdnVzgiHdW5Np+wOJU7DqTOCJKWigp3Do7yQKb3Pj99XfOwKQ6aCVkxmFjRsUjvvvyb1PDuhgVSaAirFqTOCpISigmgX+8u6ryxkGjUtGR5ZnWDPnpW3YupryNQjCqgUsCudETpmZ6ozgtSuKoVMqes1BT9UfOxyQ6aSVkxGK4VMElNA1QMVdUZY9d1mNmyO1hmhY+umtM9SZwSphsIfd60VEylkmpUMj9ado7ViMrKgYeNaeftSuxRQSWBXOiPkhKfhDunYio6tm5ZoCakzglQocsiU0eusYHPFxy4vZDJbVxwwGa0UMrITBVQtie+MsCo8Bbdy/ebideqMkCJqa6yywm27fk2mspBp3LxkeGTvE60Vo5CRGqaAqiFV7YyQ2WjHNA1HdG2z4zRcdlNyWmfStLH+09Q7VR2rLFLIlPPbmcJK5pgqK2R2CpayWjWtoIFa4JIc9FeQYJqEKCNQxzojxHfLVmeENLZ9e/Cr/W2bgm7M428se6yy16+C+WN3IWRalAyPNl0VMpJW0j6gSs/hs3rDFq4bM5cPl39Lm2ZNInVGOGCvFsWdEWLXg9QZoR4o2BoESyxgYrfi5U0VL2/7H8Gk7pW9zubglF9mFuy+bwWnyVqXPF3WIO3/eUqaS/t/AXeNX1xigjmAH4u289KsfHVGSGbbi4KAqDBQKgmcoh8rfg3bLQiKJi2D+4xWkN0lbrllye1vXg0/rN35OK06wm8/SMznIJLC0j6g1mwo+zSLAYv+cqI6IySCOxRuLRUaG3csR2nBRBl1uVHTkgHSNLucgGlVduA0bgZVOQ1buLXWxyoTSWVpH1DtszJZXUZItc/KVDiVZ3tRxNNgG8rfvr2g4tewBjsHRnaXUi2aluUsh49r+zpMHYxVJpLK0j6grh3YrcQ1KAh62F07sFsdVpVA7sH/4e8UKBsjBE64XNkgmBD8HiY+QJruHnZXLh0oWWUHTlVbL8milscqE0llaR9Qsd56UXrxJYWiwpI9x8oNlAoCJ1LrpVRgxMKl0hZMFjRpoV5kIlJtaR9QAKc3+JDTmwyDjHxokgMNbgYS8H/BsdbLToGyIXrPscoGvoSw9RIXIM3aQpt9ywiUcgKnUdP62XoRkZSigKrKjytjrZcKe4dV0oLZXlhxPbs13Dkw2nQNux6Xd82lZcmwUfdkEUkB+kv27rCyf1w57gqY+XjJkKlssEsIfsEfHyDN9whbL+UESunAUetFRARQQAW9rcpSuDUYhn/3/crvhlx6Wa0XEZEao7+mrXKC03o7re8IF75e+/WIiAgAGovnuJuDH1PG048rRUTqXEIDysxOMLPFZrbMzK4vY3sTM3sh3D7dzDrHbbshXL/YzAYmrMieZ8MpDwQtJiy4P+UB/ZZFRKSOJewUn5k1AB4CBgD5wEwzG+fuC+J2uwT4zt33NbNBwJ3AOWbWHRgE9ADaA5PMbH93LzloXk3RjytFRJJOIltQfYFl7v65u/8IjAZOK7XPacBT4eMxwHEWzEFxGjDa3be5+xfAsvB4IiKSJhIZUB2A+N4H+eG6Mvdx90JgI9Am4nMxs6FmNsvMZq1dW8Yo0iIiUm/V604S7v6Yu+e6e27btm3ruhwREalBiQyo1UDHuOWccF2Z+5hZQ6AVsC7ic0VEJIUlMqBmAvuZWRcza0zQ6WFcqX3GAReGj88CJru7h+sHhb38ugD7ATMSWKuIiCSZhPXic/dCM7scGA80AJ5098/MbBgwy93HAU8Az5jZMmA9QYgR7vcisAAoBC5LWA8+ERFJShY0WOo/M1sLfFnXdSTA7sC3dV1EktNnFI0+p8rpM4qmup/T3u5eaceBlAmoVGVms9w9t67rSGb6jKLR51Q5fUbR1NbnVK978YmISOpSQImISFJSQCW/x+q6gHpAn1E0+pwqp88omlr5nHQNSkREkpJaUCIikpQUUCIikpQUUHXIzDqa2RQzW2Bmn5nZVeH6bDObaGZLw/vW4XozswfCebLmmlmfun0HtcfMGpjZHDN7I1zuEs4htiycU6xxuL7cOcZSnZllmdkYM1tkZgvN7Ah9l0oys9+H/9bmm9koM8vQdwnM7Ekz+6+ZzY9bV+XvjpldGO6/1MwuLOu1qkIBVbcKgT+4e3fgcOCycC6s64F33X0/4N1wGeBEgmGf9gOGAo/Ufsl15ipgYdzyncC97r4v8B3B3GIQN8cYcG+4X7q4H3jH3Q8ADiH4vPRdCplZB+BKINfdDyIY4SY2D126f5dGAieUWlel746ZZQO3AP0Ipke6JRZqu8zddUuSG/AawQSPi4G9wnV7AYvDx48Cg+P2L94vlW8EgwW/C/wUeAMwgl+xNwy3HwGMDx+PB44IHzcM97O6fg+18Bm1Ar4o/V71XSrxWcSm8ckOvxtvAAP1XSr+fDoD83f1uwMMBh6NW19iv125qQWVJMLTB72B6UA7d/8q3PQ10C58HGmerBR0H3AdsD1cbgNs8GAOMSj5OZQ3x1iq6wKsBUaEp0IfN7Nm6LtUzN1XA3cDK4GvCL4bs9F3qTxV/e7U+HdKAZUEzKw58DLwO3ffFL/Ng/8VSdvfApjZycB/3X12XdeS5BoCfYBH3L038AM7TskA+i6Fp5tOIwjz9kAzdj6tJWWoq++OAqqOmVkjgnB6zt3Hhqu/MbO9wu17Af8N16fjPFn9gVPNbAUwmuA03/1AVjiHGJT8HMqbYyzV5QP57j49XB5DEFj6Lu3wM+ALd1/r7gXAWILvl75LZavqd6fGv1MKqDpkZkYw5chCd78nblP8PFkXElybiq2/IOxFcziwMa4JnpLc/QZ3z3H3zgQXtCe7+3nAFII5xGDnz6isOcZSmrt/Dawys27hquMIpqvRd2mHlcDhZtY0/LcX+4z0XSpbVb8744Hjzax12Fo9Ply36+r6wlw634CjCJrNc4G88HYSwXnud4GlwCQgO9zfgIeA5cA8gt5Idf4+avHzOgZ4I3y8D8EklsuAl4Am4fqMcHlZuH2fuq67Fj+fXsCs8Pv0KtBa36WdPqPbgEXAfOAZoIm+Sw4wiuC6XAFBa/ySXfnuAEPCz2sZcHF169JQRyIikpR0ik9ERJKSAkpERJKSAkpERJKSAkpERJKSAkpERJKSAkrShpndGI5kPdfM8sysXy297goz270K+x9jZkcm4thVeV0z+42ZXVATxxbZFQ0r30Wk/jOzI4CTgT7uvi38o964jssqzzHA98BHNX1gM2voO8adq/B13f1fNf36IlWhFpSki72Ab919G4C7f+vua6C4FXKbmX1iZvPM7IBwfV8z+084+OpHsVEazOwiM3vNzKaG897cEq5vZmZvmtmn4XxD58S9/hVlHD/bzF4NW3Qfm1nPcNDg3wC/D1t5P4l/E2bWxswmhC3Bxwl+NImZdS41l881ZnZr+Hiqmd1nZrOAq8zsFAvmN5pjZpPMrF1Zr2tmt5rZNeExeoU1zjWzV2zH3EBTzexOM5thZktK1ytSHQooSRcTgI7hH9GHzez/ldr+rbv3IZjb5ppw3SLgJx4MvnozcEfc/n2BM4GewP+ZWS7BwKNr3P0QD+YbeqeS498GzHH3nsCfgKfdfQXwL4L5iXq5+/ul6rwF+MDdewCvAJ0ivv/G7p7r7v8APgAOD9/XaOC6CK/7NPDHsNZ5YR0xDd29L/C7UutFqkUBJWnB3b8HDiWYYG0t8IKZXRS3S2yg3tkE8+JAMDjoS2HL5F6gR9z+E919nbtvCZ97FMEf7gFhi+In7r6xkuMfRTDcDu4+GWhjZi0reStHA8+Gz3mTYIK9KF6Ie5wDjDezecC1pd7XTsysFZDl7tPCVU+FdcSU9d5Eqk0BJWnD3Yvcfaq73wJcTtACitkW3hex49rsX4ApYWvoFIKx2YoPt/PhfQnBCOLzgNvN7OZKjl+TCin57zmj1PYf4h4/CPzT3Q8Gfl3GvlWV6PcmaUoBJWnBzLqZ2X5xq3oBX1bytFbsmC7golLbBoTXkDKB04EPzaw9sNndnwXuIgirirwPnBfWdwzBacBNwP+AFuU85z3g3PA5JxIMCAvwDbBHeI2qCUGHkCjv68K49WW+btgS/C7u+tL5wLTS+4nUNAWUpIvmwFNmtsDM5gLdgVsrec7fgb+Z2Rx2bhnMIJjHay7wsrvPAg4GZphZHsG1mNsrOf6twKFhPcPZERavA78oq5MEwXWro83sM+AMgikk8GB+o2FhXRMJrp9V9LovmdlsgmnMYyp63QuBu8Jae4WvJZJQGs1cpIrCa1e57n55XdciksrUghIRkaSkFpSIiCQltaBERCQpKaBERCQpKaBERCQpKaBERCQpKaBERCQp/f+kaKjPHWvTEgAAAABJRU5ErkJggg==\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": 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",
    "    (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": 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": [
    "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": 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['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",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 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'] == 500\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'] == 1000\n",
    "])\n",
    "None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.051396631,\n  0.75: 0.055046001,\n  0.9: 0.0584287235,\n  0.99: 0.06711787780000002},\n 'trAcker': {0.5: 0.0483103845,\n  0.75: 0.051373501,\n  0.9: 0.05480480310000001,\n  0.99: 0.06177725545}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 12
    }
   ],
   "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": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "{}"
     },
     "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'] == 250\n",
    "}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "{}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 14
    }
   ],
   "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": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "{'Markers': {0.5: 0.050495621500000004,\n  0.75: 0.054076400499999996,\n  0.9: 0.0576610903,\n  0.99: 0.06895699106000001},\n 'trAcker': {0.5: 0.048287900999999994,\n  0.75: 0.051292553500000004,\n  0.9: 0.0548800459,\n  0.99: 0.06718466802000003}}"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 15
    }
   ],
   "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
}