Full_Cluster_bottleneck_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import pytz\n",
    "from scipy import stats\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from datetime import datetime\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from mpl_toolkits.axes_grid1.inset_locator import mark_inset\n",
    "from matplotlib.ticker import MultipleLocator, FixedLocator, LogLocator, NullFormatter\n",
    "\n",
    "import pytz\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_dataset = \"path to machine metric dataset\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4350\n"
     ]
    }
   ],
   "source": [
    "# Count the number of physical cores in LISA so that we can compare it with the summed load1 metric across all nodes.\n",
    "# Based on https://userinfo.surfsara.nl/systems/lisa/description accessed on 2020-10-08\n",
    "number_of_cores_in_lisa = 0\n",
    "number_of_cores_in_lisa += 23  * 6  # Intel® Xeon® Bronze 3104 Processor \n",
    "number_of_cores_in_lisa += 2   * 6  # Intel® Xeon® Bronze 3104 Processor \n",
    "number_of_cores_in_lisa += 29  * 12 # Intel® Xeon® Gold 5118 Processor \n",
    "number_of_cores_in_lisa += 192 * 16 # Intel® Xeon® Gold 6130 Processor \n",
    "number_of_cores_in_lisa += 96  * 8  # Intel® Xeon® Silver 4110 Processor \n",
    "number_of_cores_in_lisa += 1   * 12 # Intel® Xeon® Gold 6126 Processor \n",
    "print(number_of_cores_in_lisa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perform the load1 computation\n",
    "load1_df = pd.read_parquet(os.path.join(root_dataset, \"node_load1\"))\n",
    "# load1_df[\"dt\"] = pd.to_datetime(df_1128.index, utc=True, unit=\"s\")\n",
    "# load1_df[\"dt\"] = load1_df[\"dt\"].dt.tz_convert(pytz.timezone('Europe/Amsterdam')).dt.tz_localize(None)\n",
    "# load1_df = load1_df.set_index(\"dt\")\n",
    "load1_df.replace(-1.0, 0, inplace=True) # Make sure we set \"invalid values\" to 0 to avoid influencing the sum\n",
    "load1_df = load1_df.sum(axis=1, skipna=True) # Sum the values across the columns (axis = 1), so we get per timestamp the total load1 across LISA\n",
    "\n",
    "load1_df = load1_df / number_of_cores_in_lisa\n",
    "load1_df.clip(upper=1.0, inplace=True)  # Clip values above the number of cores to 1 ()\n",
    "load1_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1577685615"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load1_df.index.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.33402266523285634"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_tempature_allowed =  77  # based on https://ark.intel.com/content/www/us/en/ark/products/123547/intel-xeon-silver-4110-processor-11m-cache-2-10-ghz.html which has the lowest T_CASE across all\n",
    "\n",
    "# Perform the ambient temperature computation\n",
    "rack_temp = pd.read_parquet(os.path.join(root_dataset, \"surfsara_ambient_temp\"))\n",
    "rack_temp.replace(-1.0, np.nan, inplace=True)  # Set -1 values which are invalid to NaNs so we can omit them.\n",
    "rack_temp = rack_temp.mean(axis=1, skipna=True)  # Compute the mean, skip NaNs\n",
    "rack_temp.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "rack_temp = rack_temp / max_tempature_allowed\n",
    "rack_temp.clip(upper=1.0, inplace=True)  # Clip values above 1 with respect to max_tempature_allowed\n",
    "rack_temp.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LISA has two types of GPUs:\n",
    "# GeForce 1080Ti and Titan V. Both have the Thermal Threshold of 91 degree Celcius.\n",
    "# https://www.nvidia.com/en-sg/geforce/products/10series/geforce-gtx-1080-ti/\n",
    "# https://www.nvidia.com/en-us/titan/titan-v/\n",
    "max_gpu_tempature_allowed =  91\n",
    "\n",
    "# Perform the ambient temperature computation\n",
    "gpu_temp = pd.read_parquet(os.path.join(root_dataset, \"nvidia_gpu_temperature_celsius\"))\n",
    "gpu_temp.replace(-1.0, np.nan, inplace=True)  # Set -1 values which are invalid to NaNs so we can omit them.\n",
    "gpu_temp = gpu_temp.mean(axis=1, skipna=True)  # Compute the mean, skip NaNs\n",
    "gpu_temp.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "gpu_temp = gpu_temp / max_gpu_tempature_allowed\n",
    "gpu_temp.clip(upper=1.0, inplace=True)  # Clip values above 1 with respect to max_tempature_allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8290666666666666"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The average power consumption throught the datacenter.\n",
    "# The cooling for all the racks is the same, with a capability of max 5500 Watts\n",
    "\n",
    "cluster_power_df = pd.read_parquet(os.path.join(root_dataset, \"surfsara_power_usage\"))\n",
    "\n",
    "cluster_power_df.replace(-1.0, np.nan, inplace=True)  # Set -1 values which are invalid to NaNs so we can omit them.\n",
    "\n",
    "# Drop columns that only have NaN values, we need to drop them because they will add to max_allowed_power_consumption but do not contribute in the sum.\n",
    "cluster_power_df.dropna(how='all', axis=1, inplace=True) \n",
    "cluster_power_df.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "\n",
    "# Lisa's cooling system can handle 5500 Watt per rack, compute this ceiling.\n",
    "max_allowed_power_consumption = 5500 * len({col.split(\"n\")[0] for col in cluster_power_df.columns})\n",
    "\n",
    "cluster_power_df = cluster_power_df.sum(axis=1, skipna=True)  # Compute the mean, skip NaNs\n",
    "cluster_power_df = cluster_power_df / max_allowed_power_consumption\n",
    "cluster_power_df.clip(upper=1.0, inplace=True)  # Clip values above 1 as we know values can exceed the cooling system's capability.\n",
    "cluster_power_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1577685615    0.137794\n",
      "1577685630    0.145134\n",
      "1577685645    0.145976\n",
      "1577685660    0.145503\n",
      "1577685675    0.145419\n",
      "                ...   \n",
      "1589925525    0.138196\n",
      "1589925540    0.138075\n",
      "1589925555    0.137709\n",
      "1589925570    0.137474\n",
      "1589925585    0.137419\n",
      "Length: 804719, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# RAM usage computation.\n",
    "memory_total = pd.read_parquet(os.path.join(root_dataset, \"node_memory_MemTotal\"))\n",
    "memory_free = pd.read_parquet(os.path.join(root_dataset, \"node_memory_MemFree\"))\n",
    "\n",
    "# Align the two dataframes, use inner so that all mismatched between columns and timestmaps are dropped.\n",
    "# Axis = none aligns on both index AND columns, which is what we want.\n",
    "memory_total, memory_free = memory_total.align(memory_free, join=\"inner\", axis=None)\n",
    "\n",
    "# We can now devide safely because all indices and columns are aligned.\n",
    "memory_df = memory_free / memory_total\n",
    "del memory_total, memory_free # Free up RAM during computation\n",
    "\n",
    "# Switch to memory_consumed rather than free\n",
    "memory_df = 1 - memory_df\n",
    "\n",
    "# Compute the average\n",
    "memory_df = memory_df.mean(axis=1, skipna=True)\n",
    "print(memory_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5461344537815126"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# GPU fan speed computation\n",
    "max_fanspeed =  100  # It's percentage based \n",
    "\n",
    "gpu_fanspeed_df = pd.read_parquet(os.path.join(root_dataset, \"nvidia_gpu_fanspeed_percent\"))\n",
    "gpu_fanspeed_df.replace(-1.0, np.nan, inplace=True)  # Set -1 values which are invalid to NaNs so we can omit them.\n",
    "gpu_fanspeed_df = gpu_fanspeed_df.mean(axis=1, skipna=True)  # Compute the mean, skip NaNs\n",
    "gpu_fanspeed_df.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "gpu_fanspeed_df = gpu_fanspeed_df / max_fanspeed\n",
    "gpu_fanspeed_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.519530961007783"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# GPU memory computation\n",
    "gpu_memory_df = pd.read_parquet(os.path.join(root_dataset, \"nvidia_gpu_memory_used_bytes\"))\n",
    "\n",
    "# # Here, we need to do a bit of computation.\n",
    "# # There are three GPU versions in the cluster, the GTX 1080 ti with 11GB or RAM and the Titan V / Titan RTX, which have 12 and 24GB of RAM.\n",
    "# # We first ceil the maximum usage per node and ceil it. Then per rack, we find the maximum value and set that maximum to all nodes.\n",
    "# # If the maximum is >11.0 then it must be a Titan with 24GB. If the value is <= 11.0 then we assume it's the 1080 ti.\n",
    "# # This means that a poorly used Titans across its entire lifespan (which is possibly, but unlikely) will be classified as a 1080ti, but \n",
    "# # as this is highly unlikely, we beleive this is for now the best approach given the data.\n",
    "# ceiled_values = np.ceil((gpu_memory_df.max() / (1024*1024*1024)))\n",
    "\n",
    "# # Based on https://github.com/sara-nl/SURFace/blob/master/node%20information.md\n",
    "\n",
    "# node_max = dict()\n",
    "# for index, value in ceiled_values.items():\n",
    "#     if value > 12.0 or index in confirmed_titan_nodes:\n",
    "#         value = 24.0\n",
    "#     elif value > 11.0:\n",
    "#         value = 12.0\n",
    "#     else:\n",
    "#         value = 11.0\n",
    "    \n",
    "#     if index not in node_max:\n",
    "#         node_max[index] = value\n",
    "    \n",
    "#     node_max[index] = max(node_max[index], value)\n",
    "\n",
    "# print(node_max)\n",
    "\n",
    "# # gpu_memory_df.replace(-1.0, np.nan, inplace=True)  # Set -1 values which are invalid to NaNs so we can omit them.\n",
    "\n",
    "# # Devide all values based on the found maximum.\n",
    "# for node_name, max_gpu_value in node_max.items():\n",
    "#     gpu_memory_df[node_name] = gpu_memory_df[node_name] / (max_gpu_value * 1024 * 1024 * 1024)\n",
    "\n",
    "for column in gpu_memory_df.columns:\n",
    "    gpu_name = column[1]\n",
    "    if \"GeForce GTX 1080 Ti\" in gpu_name:\n",
    "        GPU_GB = 11\n",
    "    elif \"TITAN V\" in gpu_name:\n",
    "        GPU_GB = 12\n",
    "    elif \"TITAN RTX\" in gpu_name:\n",
    "        GPU_GB = 24\n",
    "    else:\n",
    "        print(gpu_name)\n",
    "        GPU_GB = 0  # Make it crash - unknown GPU type\n",
    "    gpu_memory_df[column] = gpu_memory_df[column] / (GPU_GB * 1024 * 1024 * 1024)\n",
    "    \n",
    "gpu_memory_df.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "gpu_memory_df = gpu_memory_df.mean(axis=1, skipna=True)  # Compute the mean across the entire cluster for all nodes,gpu pairs\n",
    "gpu_memory_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1387104665.6\n",
      "867582939511.4667\n",
      "867583387852.8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# DISK IO\n",
    "\n",
    "# For this, we are summing up the node_disk_bytes_read values and the node_disk_bytes_written\n",
    "bytes_read_df = pd.read_parquet(os.path.join(root_dataset, \"node_disk_bytes_read\"))\n",
    "bytes_read_df.replace(-1.0, np.nan, inplace=True)\n",
    "\n",
    "# Compute the time since the last timestamp, in case there are gaps in the index.\n",
    "time_between_indices = bytes_read_df.index.to_series().diff().dropna()\n",
    "\n",
    "# Drop columns with no recorded values\n",
    "bytes_read_df.dropna(how='all', axis=1, inplace=True)\n",
    "\n",
    "# As the values are incremental, we have totake the difference between the row and the previous\n",
    "bytes_read_df = bytes_read_df.diff()\n",
    "\n",
    "# Drop rows with only NA values\n",
    "bytes_read_df.dropna(how='all', inplace=True)  # The first row will be N/A because we do not know how many bytes were writting on that timestamp, there may be others.\n",
    "\n",
    "# Convert the bytes_read to values per second\n",
    "bytes_read_df = bytes_read_df.div(time_between_indices, axis=0)\n",
    "print(bytes_read_df.max().max())\n",
    "\n",
    "# We apply the same to bytes_written\n",
    "bytes_written_df = pd.read_parquet(os.path.join(root_dataset, \"node_disk_bytes_written\"))\n",
    "bytes_written_df.replace(-1.0, np.nan, inplace=True)\n",
    "\n",
    "# Compute the time since the last timestamp, in case there are gaps.\n",
    "time_between_indices = bytes_written_df.index.to_series().diff().dropna()\n",
    "\n",
    "# Drop columns with no recorded values\n",
    "bytes_written_df.dropna(how='all', axis=1, inplace=True) \n",
    "bytes_written_df = bytes_written_df.diff()\n",
    "bytes_written_df.dropna(how='all', inplace=True)\n",
    "bytes_written_df = bytes_written_df.div(time_between_indices, axis=0)\n",
    "print(bytes_written_df.max().max())\n",
    "\n",
    "del time_between_indices\n",
    "\n",
    "# Align the two dataframes on index and columns (for safety) so we can safely sum!\n",
    "bytes_read_df, bytes_written_df = bytes_read_df.align(bytes_written_df, join=\"inner\", axis=None)\n",
    "\n",
    "# Sum them up!\n",
    "disk_io_df = bytes_read_df + bytes_written_df\n",
    "del bytes_read_df, bytes_written_df  # Free up RAM\n",
    "\n",
    "print(disk_io_df.max().max())\n",
    "\n",
    "# Compute how much IO we can expect, assuming that all the nodes have a disk that we investigate\n",
    "max_disk_io = 1.8 * disk_io_df.shape[1] * 1000 * 1000 * 1000\n",
    "disk_io_df = disk_io_df.sum(axis=1, skipna=True) # Sum the values across the columns (axis = 1), so we get per timestamp the total load1 across LISA\n",
    "disk_io_df = disk_io_df / max_disk_io # Get the fractions, and we're done!\n",
    "\n",
    "disk_io_df.clip(upper=1.0, inplace=True)  # Clip values above the number of cores to 1 ()\n",
    "\n",
    "disk_io_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\laurens\\AppData\\Local\\Temp/ipykernel_4388/233596307.py:26: FutureWarning: casting datetime64[ns, UTC] values to int64 with .astype(...) is deprecated and will raise in a future version. Use .view(...) instead.\n",
      "  job_arrival_df.index = job_arrival_df.index.astype(np.int64) // 10 ** 9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Submit\n",
       "1577477610    1.000000\n",
       "1577477625    0.000000\n",
       "1577477640    0.000000\n",
       "1577477655    0.000000\n",
       "1577477670    0.000000\n",
       "                ...   \n",
       "1596758145    0.000000\n",
       "1596758160    0.000000\n",
       "1596758175    0.000000\n",
       "1596758190    0.000000\n",
       "1596758205    0.111111\n",
       "Name: JobID, Length: 1285374, dtype: float64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of incoming jobs\n",
    "# Some of the code in this cell comes from Caspar Greeven at SURFsara \n",
    "\n",
    "# Required preprocessing/parsing of the job data\n",
    "def preprocess_jobdata_to_df(name):\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",
    "location_job_data_csv = \"/path/to/surfsara-jobdata/\"\n",
    "job_arrival_df = preprocess_jobdata_to_df(\"jobdata.csv\")\n",
    "job_arrival_df = job_arrival_df[(job_arrival_df[\"Start\"] >= '2019-12-29 23:00:00') & (job_arrival_df[\"Start\"] <= '2020-08-07 21:59:45')]\n",
    "job_arrival_df = job_arrival_df[(~job_arrival_df[\"NodeList\"].str.contains(\"None\")) & (~job_arrival_df[\"NodeList\"].str.contains(\"software\")) & (~job_arrival_df[\"NodeList\"].str.contains(\"login\"))]\n",
    "job_arrival_df[\"Submit\"] = pd.to_datetime(job_arrival_df[\"Submit\"], utc=True, format=\"%Y-%m-%dT%H:%M:%S\")\n",
    "job_arrival_df = job_arrival_df.set_index(\"Submit\")\n",
    "job_arrival_df = job_arrival_df['JobID'].resample(\"15S\").count()  # Just grab one random column (JobID) to count\n",
    "# Convert the datetime index back to seconds\n",
    "job_arrival_df.index = job_arrival_df.index.astype(np.int64) // 10 ** 9\n",
    "\n",
    "# We observed one gigantic peak in the dataset. Normalizing against that extreme outlier \"dwarfs\" the other periods and \n",
    "# masks the overall behavior. Instead, we normalize against the 99th percentile to avoid these extreme outliers and cap the values to 1\n",
    "job_arrival_per_15s_99th_percentile = job_arrival_df.quantile(0.99)\n",
    "job_arrival_df /= job_arrival_per_15s_99th_percentile\n",
    "job_arrival_df.clip(upper=1.0, inplace=True)  # Clip values to 1 as we do not normalize against the max\n",
    "\n",
    "job_arrival_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5308857578125"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# GPU power computation\n",
    "gpu_power_df = pd.read_parquet(os.path.join(root_dataset, \"nvidia_gpu_power_usage_milliwatts\"))\n",
    "\n",
    "for column in gpu_power_df.columns:\n",
    "    gpu_name = column[1]\n",
    "    if \"GeForce GTX 1080 Ti\" in gpu_name:\n",
    "        GPU_TDP = 250  # TDP see https://www.geforce.com/hardware/desktop-gpus/geforce-gtx-1080-ti/specifications\n",
    "    elif \"TITAN V\" in gpu_name:\n",
    "        GPU_TDP = 250  # TDP see https://www.nvidia.com/en-us/titan/titan-v/ \n",
    "    elif \"TITAN RTX\" in gpu_name:\n",
    "        GPU_TDP = 280  # TDP see https://www.nvidia.com/en-us/deep-learning-ai/products/titan-rtx/\n",
    "    else:\n",
    "        print(gpu_name)\n",
    "        GPU_TDP = 0  # Make it crash - unknown GPU type\n",
    "    gpu_power_df[column] = gpu_power_df[column] / GPU_TDP / 1000  # 1000 because we want Watts\n",
    "    \n",
    "gpu_power_df.dropna(how='all', inplace=True)  # For safety: drop timestamps that had 0 valid values.\n",
    "gpu_power_df = gpu_power_df.mean(axis=1, skipna=True)  # Compute the mean across the entire cluster for all nodes,gpu pairs\n",
    "gpu_power_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\laurens\\AppData\\Local\\Temp/ipykernel_4388/318538639.py:45: FutureWarning: casting datetime64[ns] values to int64 with .astype(...) is deprecated and will raise in a future version. Use .view(...) instead.\n",
      "  df.index = df.index.astype(np.int64) // 10**9  # Convert back to unix timestamp so we can modify the plot axis later\n"
     ]
    }
   ],
   "source": [
    "# Construct the overview figure\n",
    "\n",
    "series_to_use = [\n",
    "    (job_arrival_df, \"Job Arrivals\"),\n",
    "    (load1_df, \"System Load\"),\n",
    "    (cluster_power_df, \"Server Power Usage\"),\n",
    "    (rack_temp, \"Server Temperature\"),\n",
    "    (memory_df, \"Server RAM Usage\"),\n",
    "    (disk_io_df, \"Disk I/O\"),\n",
    "    (gpu_power_df, \"GPU Power Usage\"),\n",
    "    (gpu_temp, \"GPU Temperature\"),\n",
    "    (gpu_fanspeed_df, \"GPU Fan Speed\"),\n",
    "    (gpu_memory_df, \"GPU Memory Usage\"),\n",
    "]\n",
    "\n",
    "# for ser, name in series_to_use:\n",
    "#     ser.name = name\n",
    "    \n",
    "# df = pd.concat([ser for ser, _ in series_to_use], axis=1)\n",
    "\n",
    "df = None\n",
    "\n",
    "for ser, name in series_to_use:\n",
    "    ser.name = name\n",
    "    if df is None:\n",
    "        df = ser.to_frame()\n",
    "    else:\n",
    "        df = df.merge(ser, how='outer', left_index=True, right_index=True)\n",
    "    #del ser  # Free up RAM\n",
    "\n",
    "# Safety, make sure the timestamps are in order\n",
    "df.sort_index(inplace=True)\n",
    "\n",
    "# Important! Get the start now, because we are going to apply a window and that the right side (end)\n",
    "start = df.index[0]\n",
    "\n",
    "# df.dropna(how='all', axis='index', inplace=True)  # Drop rows with only NaNs  - this will remove gaps but ma\n",
    "#df.fillna(0.0, inplace=True) # Fill in others with 0 so they show up as not significant at least - DONT DO THIS WE USE cmap.set_bad(color='grey') NOW\n",
    "\n",
    "# Convert the index to a date so we can resample using a 1 hour window.\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.resample('1H', label='right').max()  # For each hour, get the maximum\n",
    "df.index = df.index.astype(np.int64) // 10**9  # Convert back to unix timestamp so we can modify the plot axis later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1224x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cmap = plt.cm.get_cmap('Reds').copy()\n",
    "cmap.set_bad(color='grey')\n",
    "# cNorm = plt.cm.colors.Normalize(vmin=0, vmax=1)  # Use this one if you want a linear gradient\n",
    "cNorm = mpl.colors.BoundaryNorm(np.linspace(0, 1, 6), cmap.N)  # Use this one if you want a discrete gradient\n",
    "scalarMap = plt.cm.ScalarMappable(norm=cNorm, cmap=cmap)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(17, 4))\n",
    "ax.invert_yaxis()\n",
    "ax.tick_params(axis='both', which='major', labelsize=14)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=14)\n",
    "ax.set_xlabel(\"Time [Hour]\", fontsize=18)\n",
    "\n",
    "#https://stackoverflow.com/questions/14908576/how-to-remove-frame-from-matplotlib-pyplot-figure-vs-matplotlib-figure-frame\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['bottom'].set_visible(False)\n",
    "ax.spines['left'].set_visible(False)\n",
    "\n",
    "left = 0\n",
    "for index, row in df.iterrows():  # Iterate over all the rows\n",
    "    width = index - (start+left)  # Get how wide this piece should be, based on the previous value (timestamp) to account for big gaps\n",
    "    lefts = [left] * len(df.columns)  # For all values, set the offset\n",
    "    # VERY IMPORTANT TO USE MASK_INVALID!! MATPLOTLIB DOES NOT HANDLE NANS - https://stackoverflow.com/questions/52496817/matplotlib-colormaps-set-bad-doesnt-have-an-impact-with-collections\n",
    "    colors = scalarMap.to_rgba(np.ma.masked_invalid(row))  # Compute the colors for this particular slice\n",
    "    ax.barh(df.columns, width=width, left=lefts, height=1.0, linewidth=0, label=df.columns, color=colors, rasterized=True)\n",
    "    left += width  # update left\n",
    "\n",
    "def get_converted_xticks(ax):\n",
    "    \"\"\"\n",
    "    :param ax:\n",
    "    :return list of day and month strings\n",
    "    \"\"\"\n",
    "    # return [pd.to_datetime(start + tick, unit='s').date().strftime(\"%d\\n%b\") for tick in ax.get_xticks()]\n",
    "    return [int((tick) / 3600) for tick in ax.get_xticks()]  # Get the hour number\n",
    "\n",
    "ax.set_xticks(np.linspace(0, ax.get_xlim()[1], num=6, dtype=int))  # Make sure we include 0 and the last value in the plot, so set the xticks ourselves\n",
    "ax.set_xticklabels(get_converted_xticks(ax))\n",
    "\n",
    "# Draw a line at the start of each month + annotate the date\n",
    "first_line = pd.to_datetime(df.index[0], unit='s').date()\n",
    "cur_year = first_line.year\n",
    "cur_month = first_line.month\n",
    "cur_month += 1\n",
    "if cur_month == 13:\n",
    "    cur_month = 1\n",
    "    cur_year += 1\n",
    "start_next_month = time.mktime(datetime(cur_year, cur_month, 1).timetuple())\n",
    "while start_next_month <= df.index[-1]:\n",
    "    ax.axvline(start_next_month - start, ymin=0.05, ymax=0.95, color='black', linestyle='dashed')  # seems we have some margin due to hbars?\n",
    "    ax.text(x=start_next_month - start, y=-0.7, s=datetime(cur_year, cur_month, 1).strftime(\"%B\"), fontsize=16, ha=\"center\")\n",
    "    cur_month += 1\n",
    "    if cur_month == 13:\n",
    "        cur_month = 1\n",
    "        cur_year += 1\n",
    "    start_next_month = time.mktime(datetime(cur_year, cur_month, 1).timetuple())\n",
    "\n",
    "# Based on https://stackoverflow.com/a/39938019 and https://stackoverflow.com/a/39938019\n",
    "pos = ax.get_position()\n",
    "pad = 0.005\n",
    "width = 0.02\n",
    "ax2 = fig.add_axes([pos.xmax + pad, pos.ymin + 0.04, width, 0.9 * (pos.ymax - pos.ymin)])  # x, y, width, height\n",
    "ax2.tick_params(axis='both', which='major', labelsize=14)\n",
    "ax2.tick_params(axis='both', which='minor', labelsize=14)\n",
    "label_pad_pos = [.1, .3, .5, .7, .9]\n",
    "label_pad_text = [\"Very low\", \"Low\", \"Moderate\", \"High\", \"Very High\"]\n",
    "for y, text in zip(label_pad_pos, label_pad_text):\n",
    "    ax2.text(1.25, y, text, ha='left', va='center', fontsize=16)\n",
    "\n",
    "# Add a zoomed-in part\n",
    "ax3 = fig.add_axes([0.15, 1.05, .7, .45], facecolor='lightgrey')\n",
    "start_zoom = time.mktime(datetime(cur_year, 3, 1).timetuple())  # March 1\n",
    "end_zoom = time.mktime(datetime(cur_year, 3, 8).timetuple())  # March 7 (one week)\n",
    "zoom_df = df[(df.index >= start_zoom) & (df.index <= end_zoom)]\n",
    "left = 0\n",
    "for index, row in zoom_df.iterrows():  # Iterate over all the rows\n",
    "    width = index - (start+left)  # Get how wide this piece should be, based on the previous value (timestamp) to account for big gaps\n",
    "    lefts = [left] * len(zoom_df.columns)  # For all values, set the offset\n",
    "    # VERY IMPORTANT TO USE MASK_INVALID!! MATPLOTLIB DOES NOT HANDLE NANS - https://stackoverflow.com/questions/52496817/matplotlib-colormaps-set-bad-doesnt-have-an-impact-with-collections\n",
    "    colors = scalarMap.to_rgba(np.ma.masked_invalid(row))  # Compute the colors for this particular slice\n",
    "    ax3.barh(zoom_df.columns, width=width, left=lefts, height=1.0, linewidth=0, label=zoom_df.columns, color=colors, rasterized=True)\n",
    "    left += width  # update left\n",
    "\n",
    "ax3.set_title('Zoomed-in view (March 1-7)', fontsize=18)\n",
    "zoom_range = np.linspace((start_zoom - start), (start_zoom - start) + (end_zoom - start_zoom), num=7, dtype=int)\n",
    "ax3.set_xlim(zoom_range[0], zoom_range[-1])\n",
    "ax3.xaxis.set_major_locator(FixedLocator(zoom_range))\n",
    "ax3.set_xticklabels(get_converted_xticks(ax3))\n",
    "ax3.invert_yaxis()\n",
    "\n",
    "mark_inset(ax, ax3, loc1=3, loc2=4, fc=\"none\", ec=\"steelblue\")\n",
    "\n",
    "# == end zoomed-in code ==\n",
    "\n",
    "fig.colorbar(scalarMap, cax=ax2)\n",
    "fig.subplots_adjust(bottom=0.15)\n",
    "\n",
    "date_time = datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n",
    "fig.savefig(f\"generic_bottleneck_surf_{date_time}.pdf\", bbox_inches = \"tight\")\n",
    "fig.savefig(f\"generic_bottleneck_surf_{date_time}.png\", bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.isnull().sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bl = df['Server RAM Usage'].copy()\n",
    "bl.index = pd.to_datetime(bl.index, utc=True, unit=\"s\")\n",
    "bl.resample('1H', label='right').max().isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Arrivals\n",
      "[0-0.2]: 96.3%\n",
      "[0.2-0.4]: 1.9%\n",
      "[0.4-0.6]: 0.4%\n",
      "[0.6-0.8]: 0.2%\n",
      "[0.8-1]: 0.1%\n",
      "\n",
      "System Load\n",
      "[0-0.2]: 0.9%\n",
      "[0.2-0.4]: 2.8%\n",
      "[0.4-0.6]: 18.2%\n",
      "[0.6-0.8]: 44.6%\n",
      "[0.8-1]: 20.2%\n",
      "\n",
      "Server Power Usage\n",
      "[0-0.2]: 0.0%\n",
      "[0.2-0.4]: 0.5%\n",
      "[0.4-0.6]: 12.9%\n",
      "[0.6-0.8]: 86.4%\n",
      "[0.8-1]: 0.1%\n",
      "\n",
      "Server Temperature\n",
      "[0-0.2]: 0%\n",
      "[0.2-0.4]: 100.0%\n",
      "[0.4-0.6]: 0%\n",
      "[0.6-0.8]: 0%\n",
      "[0.8-1]: 0%\n",
      "\n",
      "Server RAM Usage\n",
      "[0-0.2]: 66.7%\n",
      "[0.2-0.4]: 33.3%\n",
      "[0.4-0.6]: 0.0%\n",
      "[0.6-0.8]: 0%\n",
      "[0.8-1]: 0%\n",
      "\n",
      "Disk I/O\n",
      "[0-0.2]: 81.5%\n",
      "[0.2-0.4]: 9.9%\n",
      "[0.4-0.6]: 3.1%\n",
      "[0.6-0.8]: 1.3%\n",
      "[0.8-1]: 0.8%\n",
      "\n",
      "GPU Power Usage\n",
      "[0-0.2]: 34.6%\n",
      "[0.2-0.4]: 64.4%\n",
      "[0.4-0.6]: 1.0%\n",
      "[0.6-0.8]: 0%\n",
      "[0.8-1]: 0%\n",
      "\n",
      "GPU Temperature\n",
      "[0-0.2]: 0%\n",
      "[0.2-0.4]: 12.5%\n",
      "[0.4-0.6]: 80.7%\n",
      "[0.6-0.8]: 6.9%\n",
      "[0.8-1]: 0%\n",
      "\n",
      "GPU Fan Speed\n",
      "[0-0.2]: 41.2%\n",
      "[0.2-0.4]: 56.5%\n",
      "[0.4-0.6]: 2.3%\n",
      "[0.6-0.8]: 0%\n",
      "[0.8-1]: 0%\n",
      "\n",
      "GPU Memory Usage\n",
      "[0-0.2]: 40.4%\n",
      "[0.2-0.4]: 58.5%\n",
      "[0.4-0.6]: 1.1%\n",
      "[0.6-0.8]: 0%\n",
      "[0.8-1]: 0%\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tresholds = [0, .2, .4, .6, .8, 1]\n",
    "series_to_use = [\n",
    "    (job_arrival_df, \"Job Arrivals\"),\n",
    "    (load1_df, \"System Load\"),\n",
    "    (cluster_power_df, \"Server Power Usage\"),\n",
    "    (rack_temp, \"Server Temperature\"),\n",
    "    (memory_df, \"Server RAM Usage\"),\n",
    "    (disk_io_df, \"Disk I/O\"),\n",
    "    (gpu_power_df, \"GPU Power Usage\"),\n",
    "    (gpu_temp, \"GPU Temperature\"),\n",
    "    (gpu_fanspeed_df, \"GPU Fan Speed\"),\n",
    "    (gpu_memory_df, \"GPU Memory Usage\"),\n",
    "]\n",
    "\n",
    "for series, name in series_to_use:\n",
    "    print(name)\n",
    "    num_elemnts = len(series)\n",
    "    \n",
    "    for i in range(1, len(tresholds)):\n",
    "        num_elements_in_range = len(series[(series >= tresholds[i-1]) & (series < tresholds[i])])\n",
    "        if num_elements_in_range > 0:\n",
    "            amount = round(100 * (num_elements_in_range / num_elemnts), 1)\n",
    "        else:\n",
    "            amount = 0\n",
    "        print(f\"[{tresholds[i-1]}-{tresholds[i]}]: {amount}%\")\n",
    "    print(\"\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}