!Network data analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Required packages for processing\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pytz, time\n",
    "import matplotlib.pyplot as plt\n",
    "from multiprocessing import cpu_count\n",
    "from pandarallel import pandarallel\n",
    "import seaborn as sns\n",
    "from datetime import datetime\n",
    "from matplotlib.ticker import MultipleLocator, FixedLocator, LogLocator, NullFormatter, ScalarFormatter\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_parquet_to_df(name):\n",
    "    location_dataset = \"path/to/surf-dataset/\"\n",
    "    df = pd.read_parquet(os.path.join(location_dataset, name))\n",
    "    df = df.replace(-1, 0)\n",
    "    df = df.fillna(0)\n",
    "    df[\"dt\"] = pd.to_datetime(df.index, utc=True, unit=\"s\")\n",
    "    df[\"dt\"] = df[\"dt\"].dt.tz_convert(pytz.timezone('Europe/Amsterdam')).dt.tz_localize(None)\n",
    "    df = df.set_index(\"dt\")\n",
    "    df = df.sort_index()\n",
    "    df['Total']= df.sum(axis=1)\n",
    "    return(df)\n",
    "\n",
    "def preprocess_jobdata_to_df(name):\n",
    "    location_job_data_csv = \"path/to/surfsara-jobdata/\"\n",
    "    with open(os.path.join(location_job_data_csv, name),'r') as file:\n",
    "        filedata = file.read()\n",
    "        filedata = filedata.replace('None assigned','NoneAssigned')\n",
    "    with open(os.path.join(location_job_data_csv, str('processed_'+name)),'w') as file:\n",
    "        file.write(filedata)\n",
    "    jobdata = pd.read_fwf(os.path.join(location_job_data_csv, str('processed_'+name)), delimiter=r\"\\s+\", header=None)#, low_memory=False)\n",
    "    jobdata = jobdata.apply(lambda x: x.str.strip() if x.dtype == \"object\" else x)\n",
    "    jobdata = jobdata.rename(columns=jobdata.iloc[0]).drop(jobdata.index[0])\n",
    "    jobdata = jobdata.iloc[1:]\n",
    "    jobdata = jobdata.astype({\"ElapsedRaw\": int, \"CPUTimeRAW\": int, \"NCPUS\": int})\n",
    "    return(jobdata)\n",
    "\n",
    "def split_nodes(s):\n",
    "    if s is None or len(s) == 0:\n",
    "        return set()\n",
    "    \n",
    "    s = s.replace(\"\\r\\n\", \"\").replace(\"\\n\", \"\").replace(\"\\t\", \"\")\n",
    "\n",
    "    start = 0\n",
    "    index = 0\n",
    "    rack_chunks = []\n",
    "    in_bracket = False\n",
    "    while index < len(s):  # Separate them in parts like r12n[1-30,32] or r13n1\n",
    "        if s[index] == \"[\":\n",
    "            in_bracket = True\n",
    "        elif s[index] == \"]\":\n",
    "            in_bracket = False\n",
    "        elif s[index] == \",\" and not in_bracket:\n",
    "            rack_chunks.append(s[start: index])\n",
    "            start = index + 1\n",
    "        index += 1\n",
    "    rack_chunks.append(s[start: index])  # Add the last line\n",
    "    \n",
    "    node_names = set()\n",
    "\n",
    "    for rack_chunk in rack_chunks:\n",
    "        if \"[\" in rack_chunk:\n",
    "            prefix, postfix = rack_chunk.split(\"[\")\n",
    "            postfix = postfix[:-1]  # Remove the last bracket\n",
    "            nodes = postfix.split(\",\")\n",
    "            for node in nodes:\n",
    "                if \"-\" in node:\n",
    "                    start, end = node.split(\"-\")\n",
    "                    if not start.isnumeric() or not end.isnumeric():\n",
    "                        #print(\"???\", s)\n",
    "                        continue\n",
    "                    for i in range(int(start), int(end) + 1):\n",
    "                        node_names.add(\"{}{}\".format(prefix, i))\n",
    "                else:\n",
    "                    node_names.add(\"{}{}\".format(prefix, node))\n",
    "        else:\n",
    "            node_names.add(rack_chunk)\n",
    "\n",
    "    return node_names\n",
    "\n",
    "def calculate_perjob(row, data_type):\n",
    "    start = row[\"Start\"]\n",
    "    end = row[\"End\"]\n",
    "    nodes = row[\"NodeList\"]\n",
    "    selection = data_type.loc[start:end]\n",
    "\n",
    "    splitnodes = split_nodes(nodes)\n",
    "    intersection_nodes = set(selection.columns).intersection(splitnodes)\n",
    "\n",
    "    return selection[intersection_nodes].sum().sum()  # First is per column, second is summing the series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and preprocess data\n",
    "node_sockstat_TCP_mem = preprocess_parquet_to_df(\"node_sockstat_TCP_mem\")\n",
    "node_sockstat_UDP_mem = preprocess_parquet_to_df(\"node_sockstat_UDP_mem\")\n",
    "node_network_transmit_packets = preprocess_parquet_to_df(\"node_network_transmit_packets\")\n",
    "jobdata = preprocess_jobdata_to_df(\"jobdata.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if preprocessing was executed as expected\n",
    "filtered_jobdata = jobdata[(jobdata[\"Start\"] >= '2019-12-29 23:00:00') & (jobdata[\"Start\"] <= '2020-08-07 21:59:45')]\n",
    "filtered_jobdata = filtered_jobdata[(~filtered_jobdata[\"NodeList\"].str.contains(\"None\")) & (~filtered_jobdata[\"NodeList\"].str.contains(\"software\")) & (~filtered_jobdata[\"NodeList\"].str.contains(\"login\"))]\n",
    "filtered_jobdata[\"ElapsedRaw\"] = filtered_jobdata[\"ElapsedRaw\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_jobdata.to_pickle(\"filtered_jobdata.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Pandarallel will run on 6 workers.\n",
      "INFO: Pandarallel will use Memory file system to transfer data between the main process and workers.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aefe41f1e3954ea8aefb276a1d8b4714",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=374743), Label(value='0 / 374743')…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not os.path.exists(\"/cache/node_sockstat_TCP_mem_perjob.csv\"):\n",
    "    pandarallel.initialize(nb_workers=min(cpu_count(), 8), progress_bar=True)\n",
    "    node_sockstat_TCP_mem_perjob = filtered_jobdata\n",
    "    node_sockstat_TCP_mem_perjob[\"node_sockstat_TCP_mem\"] =  node_sockstat_TCP_mem_perjob.parallel_apply(calculate_perjob, axis=1, data_type=node_sockstat_TCP_mem)\n",
    "    node_sockstat_TCP_mem_perjob.to_csv('./cache/node_sockstat_TCP_mem_perjob.csv')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(\"/cache/node_sockstat_UDP_mem_perjob.csv\"):\n",
    "    pandarallel.initialize(nb_workers=min(cpu_count(), 8), progress_bar=True)\n",
    "    node_sockstat_UDP_mem_perjob = filtered_jobdata  # If cell above is executed, it will be essentially be node_sockstat_TCP_mem_perjob etc.\n",
    "    node_sockstat_UDP_mem_perjob[\"node_sockstat_UDP_mem\"] = node_sockstat_UDP_mem_perjob.parallel_apply(calculate_perjob, axis=1, data_type=node_sockstat_UDP_mem)\n",
    "    node_sockstat_UDP_mem_perjob.to_csv('./cache/node_sockstat_UDP_mem_perjob.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Pandarallel will run on 10 workers.\n",
      "INFO: Pandarallel will use Memory file system to transfer data between the main process and workers.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "12f21f2bf35e4f788c810ed4f4638596",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=224846), Label(value='0 / 224846')…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not os.path.exists(\"/cache/node_network_transmit_packets_perjob.csv\"):\n",
    "    pandarallel.initialize(nb_workers=min(cpu_count(), 10), progress_bar=True)\n",
    "    node_network_transmit_packets_perjob = filtered_jobdata\n",
    "    node_network_transmit_packets_perjob[\"node_network_transmit_packets\"] = node_network_transmit_packets_perjob.parallel_apply(calculate_perjob, axis=1, data_type=node_network_transmit_packets)\n",
    "    node_network_transmit_packets_perjob.to_csv('./cache/node_network_transmit_packets_perjob.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exclude 0 values, since in this instance we only want to analyze jobs with traffic\n",
    "node_sockstat_TCP_mem_perjob = pd.read_csv('./cache/node_sockstat_TCP_mem_perjob.csv')  \n",
    "node_sockstat_TCP_mem_perjob = node_sockstat_TCP_mem_perjob[(node_sockstat_TCP_mem_perjob[\"node_sockstat_TCP_mem\"] > 0)]\n",
    "# Transform runtime to hours\n",
    "node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] = node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] * 60  # Back to minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean_5min 96.32621363615068\n",
      "mean_1hr 4769.480238931925\n",
      "mean_6hrs 49707.708872564675\n",
      "mean_1day 133187.728128707\n",
      "mean_1to5days 2034087.5957803885\n"
     ]
    }
   ],
   "source": [
    "# Calculate averages for different time bins\n",
    "average_5min_TCP = (np.mean(node_sockstat_TCP_mem_perjob.loc[node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] < 5, \"node_sockstat_TCP_mem\"]))\n",
    "average_1hr_TCP = (np.mean(node_sockstat_TCP_mem_perjob.loc[(node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] >= 5) & (node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] < 60), \"node_sockstat_TCP_mem\"]))\n",
    "average_6hrs_TCP = (np.mean(node_sockstat_TCP_mem_perjob.loc[(node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] >= 60) & (node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] < 360), \"node_sockstat_TCP_mem\"]))\n",
    "average_1day_TCP = (np.mean(node_sockstat_TCP_mem_perjob.loc[(node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] >= 360) & (node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] < 1440), \"node_sockstat_TCP_mem\"]))\n",
    "average_1to5days_TCP = (np.mean(node_sockstat_TCP_mem_perjob.loc[(node_sockstat_TCP_mem_perjob[\"ElapsedRaw\"] >= 1440), \"node_sockstat_TCP_mem\"]))\n",
    "print(\"mean_5min\",average_5min_TCP)\n",
    "print(\"mean_1hr\",average_1hr_TCP)\n",
    "print(\"mean_6hrs\",average_6hrs_TCP)\n",
    "print(\"mean_1day\",average_1day_TCP)\n",
    "print(\"mean_1to5days\",average_1to5days_TCP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-6-ca4e7cdd28e7>:7: UserWarning: Attempting to set identical bottom == top == 1 results in singular transformations; automatically expanding.\n",
      "  plt.ylim(bottom=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxAAAAFgCAYAAAArRJ8VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3debhkVXn3/e/PFgQZVdoJ0EZEDSovSoc4i0YJRgWnV+0oTihRg0TzOJBHo43ROEUTURxAoR0IaBQIKIpRGQxONNBAA4L9Ih0aVFoRFFQQuN8/9j5QHM6wuvvUOdX093NddZ2qtfde+66qVXX2XXutvVJVSJIkSVKLu8x1AJIkSZLWHyYQkiRJkpqZQEiSJElqZgIhSZIkqZkJhCRJkqRmd53rANbVNttsUwsWLJjrMCRJktbaWWedxa73u99ch6ERseznP2e33Xab6zA466yzflVV88eXZ32/jOvChQtr6dKlcx2GJEnSWkvCNYsXz3UYGhFbL17MKByjJzmrqhaOL7cLkyRJkqRmJhCSJEmSmplASJIkSWpmAiFJkiSpmQmEJEmSpGYmEJIkSZKamUBIkiRJamYCIUmSJKmZCYQkSZKkZiYQkiRJkpqZQEiSJElqZgIhSZIkqZkJhCRJkqRmJhCSJEmSmplASJIkSWpmAiFJkiSpmQmEJEmSpGYmEJIkSZKamUBIkiRJamYCIUmSJKmZCYQkSZKkZiYQkiRJkpqZQEiSJElqZgIhSZIkqZkJhCRJkqRmJhCSJEmSmplASJIkSWpmAiFJkiSpmQmEJEmSpGYmEJIkSZKamUBIkiRJamYCIUmSJKmZCYQkSZKkZned6wAkSdrQLNhuO1ZeccVchyFJa8UEQpKkWbbyiiu4ZvHiuQ5DI2Rr24PWI3ZhkiRJktRspBKIJHsk+V6STyXZY67jkSRJknR7Q08gkhyR5Koky8eV75Xk4iQrkhzUFxdwHbAJsGrYsUmSJElaM7NxBmIJsNdgQZJ5wKHAM4CdgUVJdga+V1XPAN4GHDwLsUmSJElaA0NPIKrqdODqccW7Ayuq6tKquhE4Btinqm7pl/8GuNtkdSbZP8nSJEtXr149lLglSZIk3dFcjYHYFrh84PEqYNskz0vyaeALwMcn27iqDquqhVW1cP78+UMOVZIkSdKYubqMayYoq6o6Fjh2toORJEmS1GauzkCsArYfeLwdcOUcxSJJkiSp0VwlEGcCOyXZIcnGwIuBE+YoFkmSJEmNZuMyrkcDPwAemmRVkv2q6ibgAOBk4CLgy1V1wbBjkSRJkrRuhj4GoqoWTVJ+EnDSsPcvSZIkaeaM1EzUkiRJkkabCYQkSZKkZiYQkiRJkpqZQEiSJElqZgIhSZIkqZkJhCRJkqRmJhCSJEmSmplASJIkSWo29InkJGlDt2C77Vh5xRVzHYYkSTPCBEKShmzlFVdwzeLFcx2GRsjWtgdJ6zG7MEmSJElqZgIhSZIkqZkJhCRJkqRmJhCSJEmSmplASJIkSWpmAiFJkiSpmQmEJEmSpGYmEJIkSZKamUBIkiRJamYCIUmSJKmZCYQkSZKkZiYQkiRJkpqZQEiSJElqZgIhSZIkqZkJhCRJkqRmJhCSJEmSmplASJIkSWpmAiFJkiSpmQmEJEmSpGYmEJIkSZKamUBIkiRJanbXlpWS7AC8AVgwuE1V7T2csCRJkiSNoqYEAjge+CxwInDL8MKRJEmSNMpaE4g/VtUhQ41EkiRJ0shrTSA+muRdwLeAG8YKq+rsoUQlSZIkaSS1JhCPBPYFnsptXZiqfyxJkiRpA9GaQDwXeFBV3TjMYCRJkiSNttbLuJ4LbD3MQCRJkiSNvtYzEPcBfpLkTG4/BsLLuEqSJEkbkNYE4l1DjUKSJEnSeqGpC1NVnQZcBmzU3z8TGMoVmJJsluSsJM8aRv2SJEmS1l5TApHkNcBXgE/3RdvSTS7Xsu0RSa5Ksnxc+V5JLk6yIslBA4veBny5pW5JkiRJs6t1EPXfAY8HfgtQVT8F7t247RJgr8GCJPOAQ4FnADsDi5LsnORpwIXALxvrliRJkjSLWsdA3FBVNyYBIMld6eaBmFZVnZ5kwbji3YEVVXVpX98xwD7A5sBmdEnFH5KcVFW3jNuWJPsD+wM84AEPaHwKkiRJktZVawJxWpL/C2ya5OnA64ET12G/2wKXDzxeBfxFVR0AkOQVwK8mSh4Aquow4DCAhQsXNiUykiRJktZdawJxELAfcD7wt8BJwGfWYb+ZoOzWRKCqlqxD3ZIkSZKGpCmB6M8EHN7fZsIqYPuBx9sBV85Q3ZIkSZKGpPUqTM9Kck6Sq5P8Nsnvkvx2HfZ7JrBTkh2SbAy8GDhhHeqTJEmSNAtar8L078DLgXtV1ZZVtUVVbdmyYZKjgR8AD02yKsl+VXUTcABwMnAR8OWqumAt4pckSZI0i1rHQFwOLK+qNR6wXFWLJik/iW4shSRJkqT1RGsC8VbgpCSnATeMFVbVR4YSlSRJkqSR1JpAvBe4DtgE2Hh44UiSJEkaZa0JxD2ras+hRiJJkiRp5LUOov52EhMISZIkaQPXmkD8HfDNJH+Yocu4SpIkSVoPtU4kt8VUy5M83MuwSpIkSXd+rWcgpvOFGapHkiRJ0gibqQQiM1SPJEmSpBE2UwnEGk8wJ0mSJGn9M1MJhCRJkqQNQOs8ENO5cYbqke4UFmy3HSuvuGKuw5AkSZpxUyYQSe4N/F/gwcD5wPuq6g6Xb62qxwwnPGn9tPKKK7hm8eK5DkMjYmvbgiTpTmS6LkyfB64HPgZsDhwy9IgkSZIkjazpujDdt6re3t8/OcnZww5IkiRJ0uiaLoFIkntw22Va5w0+rqqrhxmcJEmSpNEyXQKxFXAWt5/nYewsRAEPGkZQkiRJkkbTlAlEVS2YpTgkSZIkrQemHESd5K+SvGCC8r9J8vThhSVJkiRpFE13FaaDgdMmKP8u8O6ZD0eSJEnSKJsugbh7Va0eX1hVvwA2G05IkiRJkkbVdAnEJknuME4iyUbApsMJSZIkSdKomi6BOBY4PMmtZxv6+5/ql0mSJEnagEyXQLwD+CWwMslZSc4CLgNW98skSZIkbUCmmwfipKraM8nBwIP7shVV9YchxyVJkiRpBE2XQMwH6BOG84cfjiRJkqRRNu1M1EmeN9nCqnIchCRJkrQBmTaBAJ4FZIJlhQOpJUmSpA3KdAnEyqp61axEIkmSJGnkTXcVponOPEiSJEnaQE2XQOzbUkmSH8xALJIkSZJG3JQJRFUtb6xnkxmIRZIkSdKIm+4MRKuaoXokSZIkjbCZSiAkSZIkbQBmKoFwsLUkSZK0AWhKIJJ8YJqypsHWkiRJktZvrWcgnj5B2TPG7qzBYGtJkiRJ67EpJ5JL8jrg9cCDkpw3sGgL4IxhBiZJkiRp9Ew3E/V/AN8A3gccNFD+u6q6emhRSZIkSRpJUyYQVXUtcC2wCCDJvenmfNg8yeZV9b/DD1GSJEnSqGgdRP3sJD8FfgacBlxGd2ZCkiRJ0gakdRD1e4DHAJdU1Q7AX+IYCEmSJGmD05pA/Kmqfg3cJcldquoUYNeZDibJnyX5VJKv9AO4JUmSJI2Q1gTimiSbA6cDRyX5KHBTy4ZJjkhyVZLl48r3SnJxkhVJDgKoqouq6rXAC4GF7U9DkiRJ0mxoTSD2AX4PvAn4JvD/Ac9q3HYJsNdgQZJ5wKF0c0nsDCxKsnO/bG/gf4DvNNYvSZIkaZa0JhDvrKpbquqmqvpcVR0CvK1lw6o6HRh/ydfdgRVVdWlV3QgcQ5ekUFUnVNXjgJdMVmeS/ZMsTbJ09erVjU9BkiRJ0rqakZmo18K2wOUDj1cB2ybZI8khST4NnDTZxlV1WFUtrKqF8+fPX4cwJEmSJK2J1pmod5zhmagzQVlV1anAqetQryRJkqQhmquZqFcB2w883g64ch3qkyRJkjQLpuzCVFXXVtVlwDuAX1TVSmAH4KVJtl6H/Z4J7JRkhyQbAy8GTliH+iRJkiTNgtYxEF8Fbk7yYOCzdEnEf7RsmORo4AfAQ5OsSrJfVd0EHACcDFwEfLmqLljj6CVJkiTNqum6MI25papuSvI84N+r6mNJzmnZsKoWTVJ+ElMMlJYkSZI0eppnok6yCHgZ8LW+bKPhhCRJkiRpVLUmEK8EHgu8t6p+lmQH4IvDC0uSJEnSKGrtwrRpVR049qBPIhyzIEmSJG1gWs9AHJ7kkWMP+u5M7xhOSJIkSZJGVesZiBcAX0nyEuAJdGMh9hxaVJIkSZJGUlMCUVWXJnkxcDxwObBnVf1hqJFJkiRJGjlTJhBJzgdqoOiewDzgR0moql2GGZwkSZKk0TLdGYhnzUoUkiRJktYLUw6irqqVVbUSuB9w9cDjq4H7zkaAkiRJkkZH61WYPglcN/D4+r5MkiRJ0gakNYFIVd06FqKqbqH9Ck6SJEmS7iRaE4hLkxyYZKP+9vfApcMMTJIkSdLoaU0gXgs8Driiv/0FsP+wgpIkSZI0mlrngbgKePGQY5EkSZI04prOQCTZLslxSa5K8sskX02y3bCDkyRJkjRaWrswHQmcANwf2BY4sS+TJEmStAFpTSDmV9WRVXVTf1sCzB9iXJIkSZJGUGsC8askL00yr7+9FPj1MAOTJEmSNHpaE4hXAS8EftHfXtCXSZIkSdqAtF6F6X+BvYcciyRJkqQR13oVpg8m2bKfRO47SX7Vd2OSJEmStAFp7cK0Z1X9FngWsAp4CPCWoUUlSZIkaSS1JhAb9X//Gji6qq4eUjySJEmSRljTGAjgxCQ/Af4AvD7JfOCPwwtLkiRJ0ihqOgNRVQcBjwUWVtWfgN8D+4wtT/L04YQnSZIkaZS0dmGiqn5TVTf396+vql8MLP7AjEcmSZIkaeQ0JxDTyAzVI0mSJGmEzVQCUTNUjyRJkqQRNlMJhCRJkqQNwEwlEJfNUD2SJEmSRljrTNR3T/JPSQ7vH++U5Fljy6vqecMKUJIkSdLoaD0DcSRwA92lXKGbjfo9Q4lIkiRJ0shqTSB2rKoPAn8CqKo/4JWXJEmSpA1OawJxY5JN6a+2lGRHujMSkiRJkjYgd21c713AN4HtkxwFPB54xbCCkiRJkjSamhKIqvrvJGcDj6HruvT3VfWroUYmSZIkaeRMmUAkefS4op/3fx+Q5AFVdfZwwpIkSZI0iqY7A/Hh/u8mwELgXLozELsAPwKeMLzQJEmSJI2aKQdRV9VTquopwErg0VW1sKp2Ax4FrJiNACVJkiSNjtarMD2sqs4fe1BVy4FdhxOSJEmSpFHVehWmi5J8Bvgi3aVcXwpcNNPBJHkO8Ezg3sChVfWtmd6HJEmSpLXXegbilcAFwN8DbwQu7MumleSIJFclWT6ufK8kFydZkeQggKo6vqpeQ3eJ2Bc1xiZJkiRplrRexvWPSQ4Fvk13BuLiqvpT4z6WAB8HPj9WkGQecCjwdGAVcGaSE6rqwn6Vd/TLJUmSJI2QpjMQSfYAfkqXCHwCuCTJk1q2rarTgavHFe8OrKiqS6vqRuAYYJ90PgB8Y6pLxCbZP8nSJEtXr17dEoYkSZKkGdA6BuLDwJ5VdTFAkocARwO7reV+twUuH3i8CvgL4A3A04Ctkjy4qj410cZVdRhwGMDChQtrLWOYMQu2246VV1wx12FIkiRJQ9eaQGw0ljwAVNUlSTZah/1mgrKqqkOAQ9ah3jmx8ooruGbx4rkOQyNka9uDJEm6k2pNIJYm+Szwhf7xS4Cz1mG/q4DtBx5vB1y5DvVJkiRJmgWtV2F6Hd1VmA6kuxLThcBr12G/ZwI7JdkhycbAi4ET1qE+SZIkSbOg9SpMNwAf6W9rJMnRwB7ANklWAe+qqs8mOQA4GZgHHFFVF6xp3ZIkSZJmV1MCkeTxwGLggYPbVNWDptu2qhZNUn4ScFJTlJIkSZJGQusYiM8Cb6Ib93Dz8MKRJEmSNMpaE4hrq+obQ41EkiRJ0shrTSBOSfIh4FjghrHCqSZ7kyRJknTn05pA/EX/d+FAWQFPndlwJEmSJI2y1qswPWXYgUiSJEkafa3zQEiSJEmSCYQkSZKkdiYQkiRJkpq1DqImyeOABdx+IrnPDyEmSZIkSSOqdSbqLwA7Asu4bSK5AkwgJEmSpA1I6xmIhcDOVVXDDEaSJEnSaGsdA7EcuO8wA5EkSZI0+lrPQGwDXJjkx9x+Juq9hxKVJEmSpJHUmkAsHmYQkiRJktYPrTNRnzbsQCRJkiSNvqYxEEkek+TMJNcluTHJzUl+O+zgJEmSJI2W1kHUHwcWAT8FNgVe3ZdJkiRJ2oA0TyRXVSuSzKuqm4Ejk3x/iHFJkiRJGkGtCcTvk2wMLEvyQeDnwGbDC0uSJEnSKGrtwrRvv+4BwPXA9sDzhxWUJEmSpNHUehWmlUk2Be5XVQcPOSZJkiRJI6r1KkzPBpYB3+wf75rkhGEGJkmSJGn0tHZhWgzsDlwDUFXLgAXDCUmSJEnSqGpNIG6qqmuHGokkSZKkkdd6FablSf4GmJdkJ+BAwMu4SpIkSRuY1jMQbwAeDtwAHA38FnjjsIKSJEmSNJpar8L0e+Dt/U2SJEnSBmrKBGK6Ky1V1d4zG44kSZKkUTbdGYjHApfTdVv6EZChRyRJkiRpZE2XQNwXeDqwCPgb4OvA0VV1wbADkyRJkjR6phxEXVU3V9U3q+rlwGOAFcCpSd4wK9FJkiRJGinTDqJOcjfgmXRnIRYAhwDHDjcsSZIkSaNoukHUnwMeAXwDOLiqls9KVJIkSZJG0nRnIPYFrgceAhyY3DqGOkBV1ZZDjE2SJEnSiJkygaiq1onmJEmSJG0ATBAkSZIkNTOBkCRJktTMBEKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1GykEogkD0ry2SRfmetYJEmSJN3R0BOIJEckuSrJ8nHleyW5OMmKJAcBVNWlVbXfsGOSJEmStHZm4wzEEmCvwYIk84BDgWcAOwOLkuw8C7FIkiRJWgdDTyCq6nTg6nHFuwMr+jMONwLHAPu01plk/yRLkyxdvXr1DEYrSZIkaSpzNQZiW+DygcergG2T3CvJp4BHJfnHyTauqsOqamFVLZw/f/6wY5UkSZLUu+sc7TcTlFVV/Rp47WwHI0mSJKnNXJ2BWAVsP/B4O+DKOYpFkiRJUqO5SiDOBHZKskOSjYEXAyfMUSySJEmSGs3GZVyPBn4APDTJqiT7VdVNwAHAycBFwJer6oJhxyJJkiRp3Qx9DERVLZqk/CTgpGHvX5IkSdLMGamZqCVJkiSNNhMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVIzEwhJkiRJzUwgJEmSJDUzgZAkSZLUzARCkiRJUjMTCEmSJEnNTCAkSZIkNTOBkCRJktTMBEKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVIzEwhJkiRJzUwgJEmSJDUzgZAkSZLUzARCkiRJUjMTCEmSJEnNTCAkSZIkNTOBkCRJktTMBEKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVIzEwhJkiRJzUwgJEmSJDUzgZAkSZLUzARCkiRJUjMTCEmSJEnNTCAkSZIkNTOBkCRJktTMBEKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVIzEwhJkiRJzUwgJEmSJDUzgZAkSZLUzARCkiRJUjMTCEmSJEnNTCAkSZIkNTOBkCRJktTMBEKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVKzu851AIOSbAZ8ArgROLWqjprjkCRJkiQNGPoZiCRHJLkqyfJx5XsluTjJiiQH9cXPA75SVa8B9h52bJIkSZLWzGx0YVoC7DVYkGQecCjwDGBnYFGSnYHtgMv71W6ehdgkSZIkrYGhJxBVdTpw9bji3YEVVXVpVd0IHAPsA6yiSyKmjC3J/kmWJlm6evXqYYQtSZIkaQJzNYh6W2470wBd4rAtcCzw/CSfBE6cbOOqOqyqFlbVwvnz5w83UkmSJEm3SlUNfyfJAuBrVfWI/vH/C/xVVb26f7wvsHtVvWEt6l4NrJy5aLUOtgF+NddBaKTYJjSebUKDbA8azzYxWh5YVXf4tX6ursK0Cth+4PF2wJVrU9FET0pzI8nSqlo413FodNgmNJ5tQoNsDxrPNrF+mKsuTGcCOyXZIcnGwIuBE+YoFkmSJEmNZuMyrkcDPwAemmRVkv2q6ibgAOBk4CLgy1V1wbBjkSRJkrRuht6FqaoWTVJ+EnDSsPevWXXYXAegkWOb0Hi2CQ2yPWg828R6YFYGUUuSJEm6c5irMRCSJEmS1kMmEJIkSZKamUBswJIsSfKzJMv6267rUNe7kzxtLbfdOsnr13bfml1JDkiyIkkl2WaSdV6R5OOzHZtmTzrvTXJJkouSHDjBOraDDVjLd8UE25yaxEt4jpgkRyS5KsnyKdZ5TpKd17DeVyRZPXAc8uqGbRYnefOa7EczzwRiA5Nk4ySbDRS9pap27W/L1rbeqnpnVX17LTffGjCBGGHj2s0ZwNOYgwkck8zV3DXiDu3gFXTz+Tysqv4MOGYW47AdjKhR+a7QjFsC7DXNOs8B1iiB6H1p4DjkM2uxveaACcQGIsmfJfkwcDHwkDXY7hVJjk9yYn+24oAk/5DknCQ/THLPfr0lSV7Q378sycFJzk5yfpKH9eW3+9UgyfJ+lvL3Azv2vz58qF/2liRnJjkvycF92WZJvp7k3H7bF83Mq6PJTNRuquqcqrqsYfP7J/lmkp8m+eBAnYv6drE8yQcGyq8buP+CJEv6+0uSfCTJKcAH0Kyb5PvjdcC7q+oWgKq6apLNh9IOkjx54FfLc5JsMaNPWmtkbb8rkmya5Jj+u/5LwKYDyz6ZZGmSCwb+D/xlkuMG1nl6kmOH8Zx0m6o6Hbh6suVJHgfsDXyo/0zumGTX/jjhvCTHJbnH2u4/yduTXJzk28BDB8pf0x8rnJvkq0nunmSL/nhlo36dLfvjko2SHJjkwj6mWfvR487IX3HuxPpfgV4I7AcEOBLYpap+N7Dae5O8E/gOcFBV3TBBVY8AHgVsAqwA3lZVj0ryb8DLgH+fYJtfVdWj03VNejMw1WnJg4BHVNWufdx7AjsBu/dxn5DkScB84Mqqema/3lYtr4PWTGO7abErXbu5Abg4yceAm+mSgN2A3wDfSvKcqjp+mroeAjytqm5ewxi0lhrawY7Ai5I8F1gNHFhVP52gqqG0gyQnAn9XVWck2Rz447o8X625GfqueB3w+6raJckuwNkDy95eVVcnmQd8p1/+XeDQJPOrajXwyn6/mkNV9f0kJwBfq6qvACQ5D3hDVZ2W5N3Au4A3TrD58/v/8ZcAb6qqywcXJtmNbsLhR9Edt54NnNUvPraqDu/Xew+wX1V9LMmpwDOB4/ttv1pVf0pyELBDVd2QZOuZfA02NJ6BuHP7Od0X+6ur6vFV9ZlxX+z/CDwM+HPgnsDbJqnnlKr6Xf9lfS1wYl9+PrBgkm3GfhE6a4p1JrNnfzuH7oviYXQJxfnA05J8IMkTq+raNaxXbaZrN62+U1XXVtUfgQuBB9K1tVOranU/oeRRwJMa6vpPk4dZN107uBvwx6paCBwOHDFJPcNqB2cAH0k39mLrvh7Nrpn4rngS8EWAqjoPOG9g2QuTnE33v+DhwM7VXXv+C8BL+wPAxwLfWMfnoRnW/8C3dVWd1hd9jok/4ycCC6pqF+Db/XrjPRE4rqp+X1W/BU4YWPaIJN9Lcj7wErp2AvAZuuQSbp9kngccleSlgN8Z68AE4s7tBcAVwHFJ3pnkgYMLq+rn1bmB7sO1+yT1DJ6VuGXg8S1MfhZrbJ2bB9a5idu3uU0m2TbA+wb6RD64qj5bVZfQ/WJ5PvC+/syJZt6U7WYNDLabsXaQKdYfnJRmfNu4fi1j0Nqbrh2sAr7a3z8O2GWSeobSDqrq/XRnNjcFfpi+q6Rm1Ux9V9xhQqokO9Cdvf7L/uDy69zWHo4EXgosoksqPRBcT1XVrwd6PhxO9z9+wlUnKV8CHFBVjwQOpm8jVXUGsCDJk4F5VTU2+PuZwKH9fs6K46nWmgnEnVhVfauqXgQ8ge7MwX8l+Xa6cQckuV//N3SDnya9usIMuQx4dL/PRwM79OW/Awb7L58MvKrvlkCSbZPcO8n96U51fxH417G6NLOmazfr6EfAk5Ns03dLWASM/UL1y74f9V2A587AvrQOGtrB8cBT+/tPput+0Gqd20GSHavq/Kr6ALCU7kylZtEMfVecTvfLMUkewW2J6JZ0CeO1Se4DPGNgv1cCVwLvoDuA1Gi49X9530PgN0me2C/bl9s+47caOw7p7Q1cNEG9pwPP7cfLbAE8e2DZFsDP+/EOLxm33eeBo+nPPvTfKdtX1SnAW+ku4LL5Gj1D3crMawNQVb8GPgp8NMnudL8CQncabz7dr4HLgNcOOZSvAi9Lsgw4k/6Ao6p+neSMdJeH+0ZVvSXJnwE/6HIbrqP7tenBdAO0bgH+RNd3VkMyWbvpu4y8FbgvcF6Sk6pq2kvv9XX+PMk/AqfQtbuTquq/+sUHAV8DLqdLZv1iHwFTfH+8n+475E10n9GmNtDXORPt4I1JntLHcyF2Y5kz6/hd8UngyL6//DLgx32d5yY5B7gAuJSuy9qgo4D5VXXhkJ6WBiQ5GtgD2CbJKuBdVfXZcasdAxzev+8vAF4OfCrJ3enew1dyRwcm2Zuuh8LVdFd3u52qOjvdAPtldFf0+t7A4n+i+0FiJV3vhMEfI48C3kOXRADMA77Yd68K8G9VdU3TC6A7SNedUJIkaf2Qbn6RcyY4iJWA7ipuwD5Vte9cx3Jn5BkISZK03khyFl33pv8z17FoNPVXe3sG8NdzHcudlWcgJEmSJDVzELUkSZKkZiYQkiRJkpqZQEiSJElqZgIh6Q6SXDfFsj2SfG0N61vjbaap7439pQHHHp/Uz0o7NElOTXJxkmX97StrWc+kr+2wJVmY5JC52v+gJFsnef1cxzEmyWuTvGyW97lGbWEtP3unJlk4Qflnkuy8hvt+3MDjJf1VbuZUkibUGHoAAAndSURBVFf0cwRJmkVehUnSyOknN0xV3TLJKm8Evgj8HqCqZutKGy+pqqWztK8pJZlXVTdPv+Zt+thHIn66SZxeD3ximDtJcteWmYqr6lPDjGPUtM7dMmAPuvk+vj/z0ayTV9DNF3LlHMchbVA8AyFpQul8KMnyJOcnedHA4i2THJfkwiSf6mf4HL/9Xkl+kuR/gOcNlC9O8uaBx8uTLOhvFyX5BHA2sH2STyZZmuSCJAf36x8I3B84JckpfdllSbbp7/9DX+fyJG/sy8bqPryv61tJNp2h1+nZSX6U5Jx+Ft779OWbJzmyf+3OS/L8gW3em+TcJD8cW39cnYuTfCHJd5P8NMlr+vI9kpyS5D+A85PM69+jM/t9/G2/3peS/PVAfUuSPH/wF+wk90xyfL/dD5PsMs37s1mSr/dxLx/XHsbWfXD/Gpyb5OwkO/avw3f6x+cn2adf/f3Ajv3ZnA/1279l4LkcPFDvP/Vt6b+THD0WX5Jd+9jP69vjPfryU5P8S5LTgLcn+Vm6mWpJsmXfXjaa4DUfq/fAvm2fl+SYCZ7nZK/7PyQ5or//yP51unuS+/TxndvfHjeuvtudWUjy8SSv6O9P9jnaLMkRfQznjL2u6WbrPaaP60vAhO08A2cmklw3VZtMN7P0a4E39e/X2OzCT0ry/SSXZuBsxGTv47g6J9xnkvlJvtpvf2aSx/fl/5X+DFGSv01yVL/PhXQTGi7LDH2mJTWoKm/evHm73Y3ul8bnA/9NN3vnfYD/Be5H90vkH4EH9cv+G3jBuO03oZtJeCe6GT+/DHytX7YYePPAusuBBf3tFuAxA8vu2f+dB5wK7NI/vgzYZmC9y4BtgN3oZiPdjG4G4wuAR/V13wTs2q//ZeCla/ianApcTDcb6jLgQ335PbjtktivBj7c3/8A8O8D29+j/1vAs/v7HwTeMcG+FgPn0h38bdO/lvfvX/vrgR369fYf2x64G93ZhR2A5wKf68s37rfftN9+7H34GN1ssgBPBZZN8/48Hzh8oHyrCeL+EfDcgTZwd7oz3Vv2ZdsAK/o2sQBYPrDtnsBh/bK70M1G/SS6A8RlffxbAD8diw84D3hyf//dY693/159YqDuI4HnDLxmH57kNR+r90rgbv39rSdYd7LX/S7A6f3rvxR4fL/Ol4A3DrTlrcY+Z/3fW9+X/vHH6X5Zn+pz9C/0bZjubM4ldO3+H4Aj+vJd6Nr9wkna88I1bJOD7WIJ8J/9c94ZWDHV+zhBfRPuE/gP4An9/QcAF/X370PXdp7YP9d7jn8e3rx5m72bXZgkTeYJwNHVdZP5Zf9r7p8DvwV+XFWXAiQ5ul93cEzAw4CfVdVP+3W+SHfQNZ2VVfXDgccvTLI/3UHo/egOVM6bJubjqur6fr/H0h1wnNDHs6xf7yy6A9g1NVEXpu2ALyW5H93B+s/68qcBLx5bqap+09+9ke6gaiyOp0+yr/+qqj8Af0h3pmV34Bq6135sH3sCuwz8+rsV3cHmN4BDktwN2As4var+kGSw/ifQJQVU1XeT3CvJVlM89/OBf03yAbqD2O8NLkyyBbBtVR3X1/nHvnwj4F+SPIkuQdyW7mBwvD372zn9483757LFwGtBkhP7v1vRHdyf1q//OboD2jFfGrj/GeCtwPHAK4HXTPE8oWtjRyU5vt9moljv8LpX1c/6MwfnAZ+uqjP65U8FXgbQf56unWb/Y6b6HO0J7J3bzhZtQnfA/STgkH5f5yWZ6vMyprVNjnd8dd0MLxw4azHZ+3h64z6fBuw80Fa3TLJFVf0yyTuBU+iS1KsbY5Q0BCYQkiaTKZaNn4FyohkpJ5ul8iZu331yk4H719+682QH4M3An1fVb5IsGbfuRKaK+YaB+zczrmtHknl0BzIAJ1TVO6fZ15iPAR+pqhOS7EH3S+1YLBO9Bn+qqrHym5n8e3iy1/j6gbIAb6iqk8dvnORU4K+AFwFHT1D/RK9VMcn7U1WXJNmNbmbX9yX5VlW9e5r6AF4CzAd2q6o/JbmMid/HAO+rqk+Pex5vmqTe6dz6OlXVGem6YT0ZmFdVy6fZ9pl0B+J7A/+U5OF1+3EUk77udAfL19GdMWo11Wdiss9RgOdX1cW3K+wOvNd0htjWNjne4GcqA3/v8D6uwT7vAjx2LGEc55HAr1mz11bSEDgGQtJkTgde1Pf3nk93QPXjftnuSXZIN/bhRcD/jNv2J8AOSXbsHy8aWHYZ8GiAJI+m6/oxkS3pDgKv7X/dfMbAst/R/TI9UczP6fudb0bXleR7E6x3B1V1c1Xt2t9akwfofn2+or//8oHybwEHjD1I3z9/DeyTZJMk96Lr4nLmBOucDLwut/Xvf0j/vAGOofu1/Yn9euOdTndwT5/4/Kqqfssk70+6K938vqq+CPzr2Dpj+m1XJXlOv/7d0l0payvgqj55eArwwH6T8e/hycCrkmzeb79tknvTta1n96/F5nQH91TVtcBvBvrj7wucxuQ+T5dIHTnFOvRtevuqOoXurMXWdL+iD5rwde/PinyU7rNyr4EzFN8BXtevOy/JluPqW0n3q/vd+jr+si+f6nN0MvCG9BlDkkf15YPv6yPoujHNhMk+c+NN9j62Gv+52bX/uzvdd8CjgDf3PzCsSVySZpAJhKTbSXJXul8Wj6PrinEu8F3grVX1i361H9ANgl1O12XnuME6+u4r+wNfTzf4c+XA4q8C90yyjO6g6pKJ4qiqc+m6QVwAHAGcMbD4MOAbfdeewW3Opuub/WO6/vifqapzmDljgzWXJfl2X7YY+M8k3wN+NbDue4B7pBtIey7wlDXc14+BrwM/BP65qia6ysxngAuBs5MsBz7Nbb/kfovuQPbbVXXjBNsuBhb2XVzez23Jz2TvzyOBH/flb++f33j7Agf2dX4fuC9wVL+fpXQHtj8BqKpfA2f0r8+HqupbdP3ff5DkfLoucVtU1Zl0XdDOBY6lG1sw1gXo5cCH+v3tSjcOYjJH0Y1XmehszKB5wBf7GM4B/q2qrhm3zmSv+7/Rjb24BNgPeH9/8Pz3wFP6Os8CHj5YWVVdTje+4bw+znP68qk+R/8MbASc18fwz335J4HN+9fkrdyW9K+rE4Hn5vaDqO9gsvdxDfZzIH27THIh8Nq+K97hwKv6z8H/AY7ok6clwKfiIGppVuW2M4iSBEn+H7rBsrvPdSwbqiSL6QbY/utcxzIKkmxeVdf1ZzROB/bvk8U1qeMFwD5Vte9QgpSkDYhjICTdKslr6X4BfONcxyINOCzdpGeb0F1dak2Th4/RdX+ZrflCJOlOzTMQkiRJkpo5BkKSJElSMxMISZIkSc1MICRJkiQ1M4GQJEmS1MwEQpIkSVKz/x9pyHAv8JszKQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize results\n",
    "cat = ['<5 minutes', '<1 hour', '<6 hours', '<1 day', '1 to 5 days']\n",
    "vals = [average_5min_TCP, average_1hr_TCP, average_6hrs_TCP, average_1day_TCP, average_1to5days_TCP]\n",
    "\n",
    "fig = plt.figure(figsize=(11, 5))\n",
    "plt.yscale(\"symlog\")\n",
    "plt.ylim(bottom=1)\n",
    "plt.ylim(top=10**5.8)\n",
    "plt.locator_params(axis='y', numticks=12)\n",
    "plt.bar(cat, vals, width=1, edgecolor=\"black\", color=\"lightcoral\")\n",
    "plt.xlabel(\"Job duration - Each previous category is excluded in the next\")\n",
    "plt.ylabel(\"Mean node_sockstat_TCP_mem\")\n",
    "plt.tight_layout()\n",
    "fig.savefig(\"TCP_mem_job_duration.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exclude 0 values, since in this instance we only want to analyze jobs with traffic\n",
    "node_sockstat_UDP_mem_perjob = pd.read_csv('./cache/node_sockstat_UDP_mem_perjob.csv')  \n",
    "node_sockstat_UDP_mem_perjob = node_sockstat_UDP_mem_perjob[(node_sockstat_UDP_mem_perjob[\"node_sockstat_UDP_mem\"] > 0)]\n",
    "# Transform runtime to hours\n",
    "node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] = node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] * 60  # Back to minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean_5min 673.0314142300242\n",
      "mean_1hr 14003.964082551885\n",
      "mean_6hrs 107392.76522516768\n",
      "mean_1day 484650.8459741993\n",
      "mean_1to5days 3092752.448493567\n"
     ]
    }
   ],
   "source": [
    "# Calculate averages for different time bins\n",
    "average_5min_UDP = (np.mean(node_sockstat_UDP_mem_perjob.loc[node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] < 5, \"node_sockstat_UDP_mem\"]))\n",
    "average_1hr_UDP = (np.mean(node_sockstat_UDP_mem_perjob.loc[(node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] >= 5) & (node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] < 60), \"node_sockstat_UDP_mem\"]))\n",
    "average_6hrs_UDP = (np.mean(node_sockstat_UDP_mem_perjob.loc[(node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] >= 60) & (node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] < 360), \"node_sockstat_UDP_mem\"]))\n",
    "average_1day_UDP = (np.mean(node_sockstat_UDP_mem_perjob.loc[(node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] >= 360) & (node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] < 1440), \"node_sockstat_UDP_mem\"]))\n",
    "average_1to5days_UDP = (np.mean(node_sockstat_UDP_mem_perjob.loc[(node_sockstat_UDP_mem_perjob[\"ElapsedRaw\"] >= 1440), \"node_sockstat_UDP_mem\"]))\n",
    "print(\"mean_5min\",average_5min_UDP)\n",
    "print(\"mean_1hr\",average_1hr_UDP)\n",
    "print(\"mean_6hrs\",average_6hrs_UDP)\n",
    "print(\"mean_1day\",average_1day_UDP)\n",
    "print(\"mean_1to5days\",average_1to5days_UDP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-9-680db6a99ee0>:7: UserWarning: Attempting to set identical bottom == top == 1 results in singular transformations; automatically expanding.\n",
      "  plt.ylim(bottom=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize results\n",
    "cat = ['<5 minutes', '<1 hour', '<6 hours', '<1 day', '1 to 5 days']\n",
    "vals = [average_5min_UDP, average_1hr_UDP, average_6hrs_UDP, average_1day_UDP, average_1to5days_UDP]\n",
    "\n",
    "fig = plt.figure(figsize=(11, 5))\n",
    "plt.yscale(\"symlog\")\n",
    "plt.ylim(bottom=1)\n",
    "plt.ylim(top=10**6.8)\n",
    "plt.locator_params(axis='y', numticks=12)\n",
    "plt.bar(cat, vals, width=1, edgecolor=\"black\", color=\"lightcoral\")\n",
    "plt.xlabel(\"Job duration - Each previous category is excluded in the next\")\n",
    "plt.ylabel(\"Mean node_sockstat_UDP_mem\")\n",
    "plt.tight_layout()\n",
    "fig.savefig(\"UDP_mem_job_duration.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exclude 0 values, since in this instance we only want to analyze jobs with traffic\n",
    "node_network_transmit_packets_perjob = pd.read_csv('./cache/node_network_transmit_packets_perjob.csv')  \n",
    "node_network_transmit_packets_perjob = node_network_transmit_packets_perjob[(node_network_transmit_packets_perjob[\"node_network_transmit_packets\"] > 0)]\n",
    "# Transform runtime to hours\n",
    "node_network_transmit_packets_perjob[\"ElapsedRaw\"] = node_network_transmit_packets_perjob[\"ElapsedRaw\"] / 3600  # Back to minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean_5min 15400013744.566414\n",
      "mean_1hr 532543409387.8179\n",
      "mean_6hrs 3367186471092.3037\n",
      "mean_1day 16417011785666.332\n",
      "mean_1to5days 82785903601585.69\n"
     ]
    }
   ],
   "source": [
    "# Calculate averages for different time bins\n",
    "average_5min_transmit = (np.mean(node_network_transmit_packets_perjob.loc[node_network_transmit_packets_perjob[\"ElapsedRaw\"] < 5, \"node_network_transmit_packets\"]))\n",
    "average_1hr_transmit = (np.mean(node_network_transmit_packets_perjob.loc[(node_network_transmit_packets_perjob[\"ElapsedRaw\"] >= 5) & (node_network_transmit_packets_perjob[\"ElapsedRaw\"] < 60), \"node_network_transmit_packets\"]))\n",
    "average_6hrs_transmit = (np.mean(node_network_transmit_packets_perjob.loc[(node_network_transmit_packets_perjob[\"ElapsedRaw\"] >= 60) & (node_network_transmit_packets_perjob[\"ElapsedRaw\"] < 360), \"node_network_transmit_packets\"]))\n",
    "average_1day_transmit = (np.mean(node_network_transmit_packets_perjob.loc[(node_network_transmit_packets_perjob[\"ElapsedRaw\"] >= 360) & (node_network_transmit_packets_perjob[\"ElapsedRaw\"] < 1440), \"node_network_transmit_packets\"]))\n",
    "average_1to5days_transmit = (np.mean(node_network_transmit_packets_perjob.loc[(node_network_transmit_packets_perjob[\"ElapsedRaw\"] >= 1440), \"node_network_transmit_packets\"]))\n",
    "print(\"mean_5min\",average_5min_transmit)\n",
    "print(\"mean_1hr\",average_1hr_transmit)\n",
    "print(\"mean_6hrs\",average_6hrs_transmit)\n",
    "print(\"mean_1day\",average_1day_transmit)\n",
    "print(\"mean_1to5days\",average_1to5days_transmit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-12-56e58ad3f512>:7: UserWarning: Attempting to set identical bottom == top == 1 results in singular transformations; automatically expanding.\n",
      "  plt.ylim(bottom=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize results\n",
    "cat = ['<5 minutes', '<1 hour', '<6 hours', '<1 day', '1 to 5 days']\n",
    "vals = [average_5min_transmit, average_1hr_transmit, average_6hrs_transmit, average_1day_transmit, average_1to5days_transmit]\n",
    "\n",
    "fig = plt.figure(figsize=(11, 5))\n",
    "plt.yscale(\"symlog\")\n",
    "plt.ylim(bottom=1)\n",
    "plt.ylim(top=10**14.2)\n",
    "plt.locator_params(axis='y', numticks=12)\n",
    "plt.bar(cat, vals, width=1, edgecolor=\"black\", color=\"lightcoral\")\n",
    "plt.xlabel(\"Job duration - Each previous category is excluded in the next\")\n",
    "plt.ylabel(\"Mean transmitted packets\")\n",
    "plt.tight_layout()\n",
    "fig.savefig(\"node_network_transmit_packets_job_duration.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate scatterplot\n",
    "plot_df = node_network_transmit_packets_perjob.copy()\n",
    "fig, ax = plt.subplots(figsize=(11, 4))\n",
    "ax.set_xlim(-1, 121)\n",
    "sns.regplot(x=\"ElapsedRaw\", y=\"node_network_transmit_packets\", \n",
    "            data=plot_df, \n",
    "            scatter=True,\n",
    "            fit_reg=True,\n",
    "            ax=ax,\n",
    "            marker='o',\n",
    "            color=\"lightcoral\",\n",
    "            line_kws={\"color\": \"steelblue\", \"label\": \"Linear model fit\"},\n",
    "            scatter_kws={\"rasterized\": True})\n",
    "\n",
    "plot_df['ElapsedRaw'] = plot_df['ElapsedRaw'].astype(np.int)\n",
    "p95_data = plot_df.groupby(\"ElapsedRaw\")['node_network_transmit_packets'].quantile(.95)\n",
    "ax.plot(p95_data.index, p95_data, color=\"black\", linestyle=\"dashed\", label=\"$95^{th}$ percentile\")\n",
    "\n",
    "ax.get_yaxis().set_major_formatter(ScalarFormatter(useMathText=True))\n",
    "ax.yaxis.get_offset_text().set_visible(False)\n",
    "fig.tight_layout()\n",
    "\n",
    "ax.set_xlabel(\"Job Duration [Hour]\", fontsize=22)\n",
    "ax.set_ylabel(\"Transmitted Packets\\n({})\".format(ax.get_yaxis().get_major_formatter().get_offset()), fontsize=22)  # Based on https://stackoverflow.com/a/45766598\n",
    "\n",
    "ax.tick_params(axis='both', which='major', labelsize=16)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=16)\n",
    "ax.get_yaxis().get_offset_text().set_size(14)\n",
    "\n",
    "ax.legend(prop={\"size\": 16}, loc=\"upper left\")\n",
    "fig.tight_layout()\n",
    "\n",
    "date_time = datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n",
    "fig.savefig(f\"node_network_transmit_packets_job_scatter_{date_time}.pdf\", bbox_inches = \"tight\")\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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}