result-analysis/Master Failure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics analysis - Master Failure\n",
    "This notebook analyzes master failures. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will use input factor: 3.166667\n",
      "Will use analyze exactly-once processing semantic: False\n"
     ]
    }
   ],
   "source": [
    "# selectivity per run. This is required to compute the input throughput\n",
    "NOTEBOOK_PHASE = 3\n",
    "\n",
    "if (NOTEBOOK_PHASE == 1):\n",
    "    inputfactor = 1\n",
    "elif(NOTEBOOK_PHASE == 2):\n",
    "    inputfactor = 2\n",
    "elif(NOTEBOOK_PHASE == 3):\n",
    "    inputfactor = 3.166667\n",
    "    \n",
    "EXACTLYONCE = False \n",
    "print(\"Will use input factor: \" + str(inputfactor))\n",
    "print(\"Will use analyze exactly-once processing semantic: \" + str(EXACTLYONCE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# settings for saving plots\n",
    "saveplots = True\n",
    "dpiResolution = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pyspark.sql.functions as F\n",
    "import numpy as np\n",
    "# Import to indent the plots in the notebook\n",
    "%matplotlib notebook\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.collections as collections\n",
    "import seaborn as sns\n",
    "from IPython.core.display import display, HTML\n",
    "from PIL import Image\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.ticker import AutoMinorLocator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Python imports\n",
    "import pandas as pd \n",
    "from collections import defaultdict\n",
    "from datetime import timedelta\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import pytz\n",
    "import math\n",
    "\n",
    "# SQL imports\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql import Window\n",
    "from pyspark.sql import functions\n",
    "from pyspark.sql.types import IntegerType, LongType, DoubleType, TimestampType, StringType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# settings to get plots in the right style\n",
    "plt.style.use('ggplot')\n",
    "plt.style.use('seaborn-deep')\n",
    "plt.rcParams['font.family'] = 'sans-serif'\n",
    "plt.rcParams['font.serif'] = 'Ubuntu'\n",
    "plt.rcParams['font.monospace'] = 'Ubuntu Mono'\n",
    "plt.rcParams['font.size'] = 20\n",
    "plt.rcParams['axes.labelsize'] = 20\n",
    "plt.rcParams['axes.labelweight'] = 'normal'\n",
    "plt.rcParams['axes.labelcolor'] = 'black'\n",
    "plt.rcParams['axes.facecolor'] = 'white'\n",
    "plt.rcParams['axes.edgecolor'] = 'lightgrey'\n",
    "plt.rcParams['axes.titlesize'] = 20\n",
    "plt.rcParams['axes.titleweight'] = 'normal'\n",
    "plt.rcParams['figure.edgecolor'] = 'lightgrey'\n",
    "plt.rcParams['xtick.labelsize'] = 20\n",
    "plt.rcParams['ytick.labelsize'] = 20\n",
    "plt.rcParams['xtick.color'] = 'black'\n",
    "plt.rcParams['ytick.color'] = 'black'\n",
    "plt.rcParams['legend.fontsize'] = 20\n",
    "plt.rcParams['legend.edgecolor'] = 'lightgrey'\n",
    "plt.rcParams['figure.titlesize'] = 20\n",
    "plt.rcParams['figure.titleweight'] ='bold'\n",
    "plt.rcParams['grid.color'] = 'grey'\n",
    "plt.rcParams['grid.linestyle'] = ':'\n",
    "plt.rcParams['figure.facecolor'] = 'white'\n",
    "plt.rcParams['axes.spines.top'] = False\n",
    "plt.rcParams['axes.spines.right'] = False\n",
    "plt.rcParams['axes.spines.left'] = False\n",
    "plt.rcParams['axes.spines.bottom'] = True\n",
    "plt.rcParams['xtick.direction'] = 'out'\n",
    "plt.rcParams['ytick.direction'] ='out'\n",
    "plt.rcParams[\"date.autoformatter.minute\"] = \"%H:%M\"\n",
    "plt.rcParams[\"font.family\"] = \"Times New Roman\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - hive</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://192.168.0.197:4049\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v2.3.0</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>local[*]</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>PySparkShell</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7f63d18586d8>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if Spark is running\n",
    "spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# List of which frameworks should be included in this comparison\n",
    "frameworks_that_could_be_in_the_data = [\"FLINK\", \"SPARK\", \"STRUCTUREDSTREAMING\"]\n",
    "frameworksPrintable = {\n",
    "    \"SPARK\": \"Spark Streaming\", \n",
    "    \"STRUCTUREDSTREAMING\":\"Structured Streaming\", \n",
    "    \"FLINK\": \"Flink\"\n",
    "}\n",
    "stages=[\"ingest\", \"parse\", \"join\", \"aggregate\", \"window\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dataPath = dict()\n",
    "for i in frameworks_that_could_be_in_the_data:\n",
    "    if EXACTLYONCE:\n",
    "        dataPath[i] =  \"./scalability-data/master-failure/\" + i + \"/stage\" + str(NOTEBOOK_PHASE) + \"/5x-4cpu-20gb/exactlyonce/*\"\n",
    "    else:\n",
    "        dataPath[i] =  \"./scalability-data/master-failure/\" + i + \"/stage\" + str(NOTEBOOK_PHASE) + \"/5x-4cpu-20gb/atleastonce/*\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The paths that will be read: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'FLINK': './scalability-data/master-failure/FLINK/stage3/5x-4cpu-20gb/atleastonce/*',\n",
       " 'SPARK': './scalability-data/master-failure/SPARK/stage3/5x-4cpu-20gb/atleastonce/*',\n",
       " 'STRUCTUREDSTREAMING': './scalability-data/master-failure/STRUCTUREDSTREAMING/stage3/5x-4cpu-20gb/atleastonce/*'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The paths that will be read: \")\n",
    "dataPath"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For printing the quantiles of a column:\n",
    "provide a list of quantiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def datetimeFromEpoch(epoch):\n",
    "    return datetime.utcfromtimestamp(epoch//1000).replace(microsecond=epoch%1000*1000)\n",
    "\n",
    "datetimeFromEpochUDF = functions.udf(datetimeFromEpoch, TimestampType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def save_img_colored_and_grayscale(path_colored_img):\n",
    "    if saveplots: \n",
    "        plt.savefig(path_colored_img + '.png', dpi=dpiResolution, bbox_inches=\"tight\", pad_inches = 0)\n",
    "        im = Image.open(path_colored_img + '.png').convert('L')\n",
    "        im.save(path_colored_img + '_grayscale.png', dpi=(300, 300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Latency \n",
    "Read in latency data and transform in the right format for plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Save the data in here\n",
    "completeResults = defaultdict(dict)\n",
    "\n",
    "# Save the frameworks present in the data in here\n",
    "frameworks = []\n",
    "\n",
    "for framework in frameworks_that_could_be_in_the_data:\n",
    "    try:\n",
    "        completeResults[framework] = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "         .csv(dataPath[framework] + \"/results.csv/*\")\n",
    "        if(completeResults[framework].count()>0): \n",
    "            frameworks.append(framework)\n",
    "    except:\n",
    "        print('framework ' + framework + \" not in data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all checks passed for FLINK\n",
      "+--------------+\n",
      "| containerName|\n",
      "+--------------+\n",
      "|spark-worker-3|\n",
      "|spark-worker-1|\n",
      "|spark-worker-5|\n",
      "|spark-worker-4|\n",
      "|spark-worker-2|\n",
      "+--------------+\n",
      "\n",
      "WARNING FOR SPARK volume: 3 amount of containers: 5\n",
      "+--------------+\n",
      "| containerName|\n",
      "+--------------+\n",
      "|spark-worker-3|\n",
      "|spark-worker-1|\n",
      "|spark-worker-5|\n",
      "|spark-worker-4|\n",
      "|spark-worker-2|\n",
      "+--------------+\n",
      "\n",
      "WARNING FOR STRUCTUREDSTREAMING volume: 3 amount of containers: 5\n"
     ]
    }
   ],
   "source": [
    "# Save the frameworks present in the data in here\n",
    "containerCheck = defaultdict(dict)\n",
    "for framework in frameworks:\n",
    "    try:\n",
    "        if framework == \"KAFKASTREAMS\":\n",
    "            requiredAmtContainers = 5 \n",
    "        elif framework == \"FLINK\": \n",
    "            requiredAmtContainers = 6\n",
    "        else:\n",
    "            requiredAmtContainers = 7\n",
    "            \n",
    "        containerCheckPhase = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/resources-per-container-timeseries.csv/*\")\n",
    "        amtOfContainers = containerCheckPhase.select(\"containerName\").distinct().count()\n",
    "        if amtOfContainers != requiredAmtContainers:\n",
    "            containerCheckPhase.select(\"containerName\").distinct().show()\n",
    "            print(\"WARNING FOR \" + framework + \" volume: \" + str(NOTEBOOK_PHASE) + \" amount of containers: \" + str(amtOfContainers))\n",
    "        else:\n",
    "            print(\"all checks passed for \" + framework)\n",
    "    except:\n",
    "        print('framework ' + framework + \" not in data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Phases that are present in the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "latencyTimeseriesDataWithoutStartup = dict()\n",
    "for framework in frameworks:\n",
    "    latencyTimeseriesDataPhase = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/latency-timeseries-data-without-startup.csv/*\") \\\n",
    "        .withColumn(\"time\", datetimeFromEpochUDF(col(\"outputBucketTime\")))\n",
    "\n",
    "    minTimeSec = int(latencyTimeseriesDataPhase.select(\"startTime\").collect()[0][0]) / 60000\n",
    "    latencyTimeseriesDataWithoutStartup[framework] = latencyTimeseriesDataPhase.withColumn(\"timeSec\", (col(\"outputBucketTime\")/60000.0)-minTimeSec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Throughput"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stage 0 throughput"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "throughputTimeseriesDataWithStartup = dict()\n",
    "for framework in frameworks:\n",
    "    throughputTimeseriesDataWithStartupPhase = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/output-throughput-timeseries-second-buckets.csv/*\") \\\n",
    "        .withColumn(\"time\", datetimeFromEpochUDF(col(\"outputBucketTime\")))    \n",
    "\n",
    "    minTimeSec = int(throughputTimeseriesDataWithStartupPhase.select(\"startTime\").collect()[0][0]) / 60000\n",
    "    throughputTimeseriesDataWithStartup[framework] = throughputTimeseriesDataWithStartupPhase.withColumn(\"timeSec\", (col(\"outputBucketTime\")/60000.0)-minTimeSec)\n",
    "\n",
    "inputThroughputTimeseriesDataWithStartup = dict()\n",
    "for framework in frameworks:\n",
    "    inputThroughputTimeseriesDataWithStartupPhase = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/input-throughput-timeseries-second-buckets.csv/*\") \\\n",
    "        .withColumn(\"time\", datetimeFromEpochUDF(col(\"inputBucketTime\")))    \n",
    "\n",
    "    minTimeSec = int(inputThroughputTimeseriesDataWithStartupPhase.select(\"startTime\").collect()[0][0]) / 60000\n",
    "    inputThroughputTimeseriesDataWithStartup[framework] = inputThroughputTimeseriesDataWithStartupPhase.withColumn(\"timeSec\", (col(\"inputBucketTime\")/60000.0)-minTimeSec)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# throughputTimeseriesDataWithoutStartup = dict()\n",
    "# for framework in frameworks:\n",
    "#     throughputTimeseriesDataPhase = throughputTimeseriesDataWithStartup[framework]\n",
    "#     startTime = throughputTimeseriesDataPhase.agg(F.min(\"outputBucketTime\")).collect()[0][0]\n",
    "#     throughputWithoutStartup = throughputTimeseriesDataPhase \\\n",
    "#         .filter(col(\"outputBucketTime\")>startTime + 120000)\n",
    "#     throughputTimeseriesDataWithoutStartup[framework] = throughputWithoutStartup              "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CPU "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cpuTimeseries = dict()\n",
    "for framework in frameworks:\n",
    "    try:\n",
    "        cpuTimeseries[framework] = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "            .csv(dataPath[framework] + \"/cpu-per-container-timeseries.csv/*\") \\\n",
    "            .withColumn(\"timeParsed\", datetimeFromEpochUDF(col(\"time\")))\n",
    "    except:\n",
    "        print(\"didnt work for \" + framework)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "containersPandas = dict()\n",
    "for framework in frameworks:\n",
    "    containersPandas[framework] = cpuTimeseries[framework].select(\"containerName\").distinct().toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Map label to RGB\n",
    "color_map = dict()\n",
    "for framework in frameworks:\n",
    "    #Assign different color to each container\n",
    "    rgb_values = sns.diverging_palette(255, 133, l=60, n=len(containersPandas[framework]), center=\"dark\")\n",
    "    color_map[framework] = dict(zip(containersPandas[framework]['containerName'], rgb_values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALwAAABLCAYAAADK3u0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n",
      "text/plain": [
       "<Figure size 216x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.palplot(sns.diverging_palette(255, 133, l=60, n=len(containersPandas), center=\"dark\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Map label to RGB\n",
    "color_map = defaultdict(dict)\n",
    "for framework in frameworks:\n",
    "    #Assign different color to each container:\n",
    "    rgb_values = sns.husl_palette(len(containersPandas[framework]), h=0.4, l=0.65, s=1) \n",
    "    color_map[framework] = dict(zip(containersPandas[framework]['containerName'], rgb_values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CPU usage distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# workerCpuTimeseriesDataWithStartup = dict()\n",
    "# for framework in frameworks:\n",
    "#     workerCpuTimeseriesDataWithStartup[framework] = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "#         .csv(dataPath[framework] + \"/cpu-total-timeseries.csv/*\") \\\n",
    "#         .withColumn(\"time\", datetimeFromEpochUDF(col(\"outputKafkaTimestampFiveSecondBucket\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CPU timeseries analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "workerCpuTimeseriesDataWithStartup = dict()\n",
    "for framework in frameworks:\n",
    "    cpuTimeseriesPerContainerPhase = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/cpu-total-timeseries.csv/*\") \\\n",
    "        .withColumn(\"time\", datetimeFromEpochUDF(col(\"outputKafkaTimestampFiveSecondBucket\")))\n",
    "\n",
    "    minTimeSec = int(cpuTimeseriesPerContainerPhase.select(\"startTime\").collect()[0][0]) / 60000\n",
    "    workerCpuTimeseriesDataWithStartup[framework] = cpuTimeseriesPerContainerPhase.withColumn(\"timeSec\", (col(\"outputKafkaTimestampFiveSecondBucket\")/60000.0)-minTimeSec)          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "workerCpuTimeseriesDataWithoutStartup = dict()\n",
    "for framework in frameworks:\n",
    "    cpuTimeseriesDataPhase = workerCpuTimeseriesDataWithStartup[framework]\n",
    "    if len(cpuTimeseriesDataPhase.head(1)) > 0:\n",
    "        startTime = cpuTimeseriesDataPhase.agg(F.min(\"outputKafkaTimestampFiveSecondBucket\")).collect()[0][0]\n",
    "        cpuWithoutStartup = cpuTimeseriesDataPhase \\\n",
    "            .filter(col(\"outputKafkaTimestampFiveSecondBucket\")>startTime + 120000)\n",
    "\n",
    "        minTimeSec = int(cpuWithoutStartup.select(\"startTime\").collect()[0][0]) / 60000\n",
    "        workerCpuTimeseriesDataWithoutStartup[framework] = cpuWithoutStartup.withColumn(\"timeSec\", (col(\"outputKafkaTimestampFiveSecondBucket\")/60000.0)-minTimeSec)          \n",
    "    else:\n",
    "        print(\"No data for stage \" + str(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cpuTimeseriesDataWithStartup = dict()\n",
    "for framework in frameworks:\n",
    "    cpuOfPhasePerContainer = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/cpu-per-container-timeseries.csv/*\") \\\n",
    "        .withColumn(\"timeParsed\", datetimeFromEpochUDF(col(\"time\")))\n",
    "\n",
    "    minTimeSec = int(cpuOfPhasePerContainer.select(\"startTime\").collect()[0][0]) / 60000\n",
    "    cpuTimeseriesDataWithStartup[framework] = cpuOfPhasePerContainer \\\n",
    "        .withColumn(\"timeSec\", (col(\"time\")/60000.0)-minTimeSec)\n",
    "cpuTimeseriesDataWithoutStartup = dict()\n",
    "for framework in frameworks:  \n",
    "    cpuTimeseriesDataPhase = cpuTimeseriesDataWithStartup[framework]\n",
    "    if len(cpuTimeseriesDataPhase.head(1)) > 0:\n",
    "        startTime = cpuTimeseriesDataPhase.agg(F.min(\"time\")).collect()[0][0]\n",
    "        cpuWithoutStartup = cpuTimeseriesDataPhase \\\n",
    "            .filter(col(\"time\")>startTime + 120000)\n",
    "\n",
    "        minTimeSec = int(cpuTimeseriesDataPhase.select(\"startTime\").collect()[0][0]) / 60000\n",
    "        cpuTimeseriesDataWithoutStartup[framework] = cpuWithoutStartup \\\n",
    "            .withColumn(\"timeSec\", (col(\"time\")/60000.0)-minTimeSec)\n",
    "    else:\n",
    "        print(\"No data for stage \" + str(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The times at which the container restarted in minutes of the run:\n",
      "{'FLINK': 12.576183330267668, 'SPARK': 12.63793333247304, 'STRUCTUREDSTREAMING': 12.630850002169609}\n"
     ]
    }
   ],
   "source": [
    "restartTime = dict()\n",
    "for framework in frameworks:\n",
    "    restartTime[framework] = cpuTimeseriesDataWithStartup[framework].filter((col(\"containerName\") == \"flink-jobmanager\") | (col(\"containerName\") == \"spark-master\"))\\\n",
    "    .groupBy(\"containerTaskId\").agg(min(\"timeSec\").alias(\"timeSec\")).agg(max(\"timeSec\").alias(\"timeSec\")).toPandas()[\"timeSec\"][0]\n",
    "\n",
    "print(\"The times at which the container restarted in minutes of the run:\")\n",
    "print(restartTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "cpuDistributionPerContainer = dict()\n",
    "for framework in frameworks:\n",
    "    cpuDistributionPerContainer[framework] = spark.read.option(\"header\", \"true\").option(\"inferSchema\", \"true\") \\\n",
    "        .csv(dataPath[framework] + \"/cpuUsagePct-histogram-with-startup-per-container.csv/*\")\\\n",
    "        .orderBy(\"cpuUsagePctBucket\")\n",
    "containersPandasPerPhase = dict()\n",
    "for framework in frameworks:\n",
    "    containersPandasPerPhase[framework] = cpuDistributionPerContainer[framework] \\\n",
    "        .select(\"containerName\").distinct().orderBy(\"containerName\").toPandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metric correlations\n",
    "Plotting different metrics for a certain stage together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For generating a chart of the four metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def generateMasterFailureChart(colNum, containersPandas, latencyPandas, throughputPandas, inputThroughputPandas, cpuPandas, start, end):\n",
    "    minor_x_locator = AutoMinorLocator(3) # how many minor grid lines in between two major grid lines for x axis\n",
    "    \n",
    "    pct01_line, = ax[0, colNum].plot(latencyPandas[\"timeSec\"], latencyPandas[\"percentile_01_second\"], color=\"#a8a8a8\", linestyle=\"--\", label = \"1p\")\n",
    "    pct50_line, = ax[0, colNum].plot(latencyPandas[\"timeSec\"], latencyPandas[\"percentile_50_second\"], color=\"#7e7e7e\", linestyle=\"solid\", label = \"50p\")\n",
    "    pct99_line, = ax[0, colNum].plot(latencyPandas[\"timeSec\"], latencyPandas[\"percentile_99_second\"], color=\"#151515\", linestyle=\"solid\", label = \"99p\")\n",
    "    ax[0, colNum].xaxis.set_minor_locator(minor_x_locator)\n",
    "    minor_y_locator_1 = AutoMinorLocator(2) # how many minor grid lines in between two major grid lines for y axis\n",
    "    ax[0, colNum].yaxis.set_minor_locator(minor_y_locator_1)\n",
    "    ax[0, colNum].grid(which='minor', color='black')\n",
    "    ax[0, colNum].get_yaxis().set_major_formatter(\n",
    "        matplotlib.ticker.FuncFormatter(lambda x, p: format(int(x/1000.0), ',').replace(',', ' ') + \" s\"))\n",
    "    ax[0, colNum].axvspan(restartTime[framework], end, facecolor='grey', alpha=0.5, label = 'restarted')\n",
    "    \n",
    "    tp_line1 = ax[1, colNum].plot(throughputPandas[\"timeSec\"], throughputPandas[\"outputMsgCount\"], label = \"output\", color=\"#151515\", linestyle =\"solid\")\n",
    "    tp_line2 = ax[1, colNum].plot(inputThroughputPandas[\"timeSec\"], inputThroughputPandas[\"inputMsgCount\"].multiply(inputfactor), label = \"input\", color=\"#7e7e7e\", linestyle = \"--\")\n",
    "    ax[1, colNum].get_yaxis().set_major_formatter(\n",
    "        matplotlib.ticker.FuncFormatter(lambda x, p: format(int(x/1000.0), ',').replace(',', ' ')))\n",
    "    ax[1, colNum].xaxis.set_minor_locator(minor_x_locator)\n",
    "    ax[1, colNum].grid(which='minor', color='black')\n",
    "    ax[1, colNum].axvspan(restartTime[framework], end, facecolor='grey', alpha=0.5, label = 'restarted')\n",
    "    \n",
    "\n",
    "    cpuTimeseriesDataWithStartupPhase = cpuTimeseriesDataWithStartup[framework]\\\n",
    "        .filter((col(\"timeSec\") >start) & (col(\"timeSec\")<end)).toPandas()\n",
    "    for contNum, containerId in enumerate(containersPandasPerPhase[framework]['containerName']):\n",
    "        if \"FLINK\" in framework: label = \"taskmanager-\" + str(contNum)\n",
    "        else: label = containerId\n",
    "        data = cpuTimeseriesDataWithStartupPhase.loc[cpuTimeseriesDataWithStartupPhase['containerName'] == containerId]\n",
    "        cpu_worker_line, = ax[2, colNum].plot(data['timeSec'], data['cpuUsagePct'], \n",
    "               c=\"black\", linestyle=\":\", label=\"cpu usage worker\")\n",
    "\n",
    "    ax[2, colNum].set_ylim(ymin=0, ymax=110)\n",
    "    ax[2, colNum].xaxis.set_minor_locator(minor_x_locator)\n",
    "    minor_y_locator_3 = AutoMinorLocator(2) # how many minor grid lines in between two major grid lines for y axis\n",
    "    ax[2, colNum].yaxis.set_minor_locator(minor_y_locator_3)\n",
    "    ax[2, colNum].grid(which='minor', color='black')\n",
    "    ax[2, colNum].get_yaxis().set_major_formatter(\n",
    "        matplotlib.ticker.FuncFormatter(lambda x, p: str(int(x)) + \" %\"))\n",
    "    ax[2, colNum].axvline(restartTime[framework], color = \"grey\")\n",
    "    ax[2, colNum].axvspan(restartTime[framework], end, facecolor='grey', alpha=0.5, label = 'restarted')\n",
    "\n",
    "    if (colNum == 0):\n",
    "        ax[0, colNum].set_ylabel(\"latency\")\n",
    "        ax[1, colNum].set_ylabel(\"throughput\\nx1000 msg/s\")\n",
    "        ax[2, colNum].set_ylabel(\"CPU\")\n",
    "    \n",
    "    if (colNum == len(frameworks)-1):\n",
    "        ax[0, colNum].legend(loc = \"upper right\", ncol=4, bbox_to_anchor=(1, 1.45), framealpha=1.0, frameon=False)\n",
    "        ax[1, colNum].legend(loc = \"upper right\", ncol=3, bbox_to_anchor=(1, 1.45), framealpha=0.5, frameon=False)\n",
    "        ax[2, colNum].legend([cpu_worker_line], [\"per worker\"], loc = \"upper right\", bbox_to_anchor=(1, 1.45), frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FLINK\n",
      "SPARK\n",
      "STRUCTUREDSTREAMING\n"
     ]
    }
   ],
   "source": [
    "stageLatencyPandasShortSample = dict()\n",
    "stageThroughputPandasShortSample = dict()\n",
    "stageInputThroughputPandasShortSample = dict()\n",
    "stageCpuPandasShortSample = dict()\n",
    "stageMemoryPandasShortSample = dict()\n",
    "start = 5\n",
    "end = 15\n",
    "for j, framework in enumerate(frameworks):\n",
    "    print(framework)\n",
    "    stageLatencyPandasShortSample[framework] = latencyTimeseriesDataWithoutStartup[framework].orderBy(\"timeSec\") \\\n",
    "        .filter((col(\"timeSec\") >start) & (col(\"timeSec\")<end)).toPandas()\n",
    "    stageThroughputPandasShortSample[framework] = throughputTimeseriesDataWithStartup[framework].orderBy(\"timeSec\") \\\n",
    "        .filter((col(\"timeSec\") >start) & (col(\"timeSec\")<end)).toPandas()\n",
    "    stageInputThroughputPandasShortSample[framework] = inputThroughputTimeseriesDataWithStartup[framework].orderBy(\"timeSec\") \\\n",
    "        .filter((col(\"timeSec\") >start) & (col(\"timeSec\")<end)).toPandas()\n",
    "    stageCpuPandasShortSample[framework] = workerCpuTimeseriesDataWithoutStartup[framework].orderBy(\"timeSec\") \\\n",
    "        .filter((col(\"timeSec\") >start) & (col(\"timeSec\")<end)).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGWCAYAAACkbP2FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<Figure size 648x432 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# frameworks=[\"FLINK\", \"KAFKASTREAMS\", \"SPARK\", \"STRUCTUREDSTREAMING\"]\n",
    "frameworksPrintable2 = {\n",
    "    \"SPARK\": \"Spark Str.\", \n",
    "    \"STRUCTUREDSTREAMING\":\"Structured Str.\", \n",
    "    \"FLINK\": \"Flink\", \n",
    "    \"KAFKASTREAMS\": \"Kafka Str.\"   \n",
    "}\n",
    "f, ax = plt.subplots(3, 3,figsize=(9, 6), sharey='row', sharex='col')\n",
    "pad = 5\n",
    "\n",
    "\n",
    "for j, framework in enumerate(frameworks):\n",
    "    generateMasterFailureChart(j, containersPandas=containersPandas, \\\n",
    "                           latencyPandas=stageLatencyPandasShortSample[framework], \\\n",
    "                           throughputPandas=stageThroughputPandasShortSample[framework], \\\n",
    "                           inputThroughputPandas=stageInputThroughputPandasShortSample[framework], \\\n",
    "                           cpuPandas=stageCpuPandasShortSample[framework], start=start, end=end)\n",
    "    ax[0, j].annotate(frameworksPrintable2[framework], xy=(0.5, 1.25), xytext=(0, pad),\n",
    "            xycoords='axes fraction', textcoords='offset points',\n",
    "            size='medium', ha='center', va='baseline')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.1, hspace=0.35)\n",
    "if EXACTLYONCE:\n",
    "    path_suffix = \"exactlyonce\"\n",
    "else:\n",
    "    path_suffix = \"atleastonce\"\n",
    "save_img_colored_and_grayscale(\"./figures/master-failure/overall/phase\" + str(NOTEBOOK_PHASE) + \"/master_failure_\" + path_suffix)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}