sigmod.10.22.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",
    "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 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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.22/*')\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",
    "    (\"Distributed\" if distributed_acker else \"Centralized\") + \" \" +\n",
    "      (\"with local acker\" if local_acker_flush_count > 0 else \"without local acker\"):\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": 42,
   "outputs": [
    {
     "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": [
    "plt.legend([\n",
    "  plt.plot(*zip(*sorted([\n",
    "    (\n",
    "      1 / result.vars()['rate'],\n",
    "      np.median(result.lat_data()),\n",
    "    )\n",
    "    for result in results\n",
    "    if result.vars()['iterations'] == 20\n",
    "        and result.vars()['parallelism'] == 20\n",
    "  ])), marker='o') and False or legend\n",
    "  for legend, results in tracking_results.items()\n",
    "  if legend in ['Centralized with local acker', 'Disabled', 'Watermarks']\n",
    "], title='Tracking')\n",
    "plt.xlabel('Input elements per millisecond')\n",
    "plt.ylabel('Median processing latency, ms')\n",
    "None\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "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
}