diff --git a/session_stats.ipynb b/session_stats.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..474da7ade9d9ca2787ce9c7c19acb56e9f39fc95 --- /dev/null +++ b/session_stats.ipynb @@ -0,0 +1,1053 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of user sessions in Parallel Workload Logs\n", + "\n", + "Reproducing Zakay and Feitelson 2013 (doi:10.1007/978-3-642-35867-8_12).\n", + "\n", + "### Initializing libs and vars" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd, numpy as np, json\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "# plt.rcParams[\"figure.figsize\"] = [15, 5]\n", + "\n", + "def print_general_stats(data):\n", + " log_makespan = data['max_finish_time'].max() - data['first_submit_time'].min()\n", + " log_length = data['last_submit_time'].max() - data['first_submit_time'].min()\n", + " sess = data['nb_sessions']\n", + " print(f\"\\\n", + " Makespan: {log_makespan / (24*3600):.2f} days\\n\\\n", + " Length: {log_length / (24*3600):.2f} days\\n\\\n", + " #users: {data['max_finish_time'].count()}\\n\\\n", + " #sessions: {data['nb_sessions'].sum()}\\n\\\n", + " Sessions/user: avg:{sess.mean():.0f} (min:{sess.min():.0f}, med:{sess.median():.0f}, max:{sess.max():.0f})\\n\\\n", + " \")\n", + " data.boxplot(column='nb_sessions', showmeans=True, widths=0.5, vert=False, figsize=(15,1))\n", + " plt.xscale('log')\n", + " plt.show()\n", + "\n", + "def plot_length_stay(length_of_stay):\n", + " agg = {}\n", + " agg['0'] = ((length_of_stay == 0).sum())\n", + " agg['<1d'] = (((length_of_stay > 0) & (length_of_stay < 24*3600)).sum())\n", + " agg['<7d'] = (((length_of_stay >= 24*3600) & (length_of_stay < 7*24*3600)).sum())\n", + " agg['<1m'] = (((length_of_stay >= 7*24*3600) & (length_of_stay < 30*24*3600)).sum())\n", + " agg['<6m'] = (((length_of_stay >= 30*24*3600) & (length_of_stay < 6*30*24*3600)).sum())\n", + " agg['6m+'] = (((length_of_stay >= 6*30*24*3600)).sum())\n", + "\n", + " fig, ax = plt.subplots()\n", + " fig.set_size_inches(6,3)\n", + " ax.bar(agg.keys(), agg.values(), width=.5)\n", + " ax.set_xlabel(\"Length of stay\")\n", + " ax.set_ylabel(\"#users\")\n", + " plt.show()\n", + "\n", + "def user_stats_to_session_data(user_stats):\n", + " session_list = []\n", + " for ses in user_stats['sessions']:\n", + " session_list += ses\n", + " sessions = pd.DataFrame(session_list)\n", + " sessions['makespan'] = sessions['finish_time'] - sessions['first_submit_time']\n", + " sessions['makespan_mn'] = sessions['makespan'] / 60\n", + " sessions['length'] = sessions['last_submit_time'] - sessions['first_submit_time']\n", + " sessions['length_mn'] = sessions['length'] / 60\n", + " return sessions\n", + "\n", + "def line_plot_distri_length(sessions, ax, label):\n", + " distri_plot(sessions[sessions.length_mn > 2].length_mn, ax, label)\n", + "\n", + "def distri_plot(serie, ax, label):\n", + " # https://stackoverflow.com/a/8822554/13235501\n", + " y,binEdges=np.histogram(serie,bins=np.linspace(0,100,num=100))\n", + " bincenters = 0.5*(binEdges[1:]+binEdges[:-1])\n", + " ax.plot(bincenters,y,'-',label=label)\n", + "\n", + "def multi_plot_distri_length(data_array, label_array, ax):\n", + " # Build session data for each dataset\n", + " N = len(data_array)\n", + " session_array = []\n", + " for i in range(N):\n", + " session_array.append(user_stats_to_session_data(data_array[i]))\n", + "\n", + " # Line graph, excluding sessions <= 2mn (like in Zackay&Feitelson2013)\n", + " for i in range(N):\n", + " line_plot_distri_length(session_array[i], ax[0], label_array[i])\n", + " ax[0].set_xlim(1,100)\n", + " ax[0].set_xscale('log')\n", + " ax[0].set_xlabel(\"Session length (mn)\")\n", + " ax[0].set_ylabel(\"#sessions\")\n", + " ax[0].legend()\n", + "\n", + " # Boxplots\n", + " session_length = pd.DataFrame()\n", + " for i in range(N):\n", + " sessions = session_array[i]\n", + " session_length[label_array[i]] = sessions['length_mn']\n", + " session_length.boxplot(showmeans=True, widths=0.5, vert=False, ax=ax[1])\n", + " # Zoom in boxplot\n", + " session_length.boxplot(showmeans=True, showfliers=False, widths=0.5, vert=False, ax=ax[2])\n", + "\n", + " # Distribution of #jobs/session\n", + " session_nbjobs = pd.DataFrame()\n", + " for i in range(N):\n", + " bla = session_array[i]['nb_jobs'].value_counts(\n", + " normalize=True).sort_index()\n", + " bla.cumsum().plot.line(ax=ax[3], logx=True)\n", + " ax[3].set_title(\"#jobs/session (cumulative)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analyse the SWF log to get information about user sessions\n", + "\n", + "For workload KTH:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SWF parsing done.\n", + "Number of users: 214\n", + "Number of sessions: 15247\n", + "The output files have been stored in the folder out/KTH_arrival_t10\n", + "\n", + "SWF parsing done.\n", + "Number of users: 214\n", + "Number of sessions: 13050\n", + "The output files have been stored in the folder out/KTH_arrival_t20\n", + "\n", + "SWF parsing done.\n", + "Number of users: 214\n", + "Number of sessions: 10293\n", + "The output files have been stored in the folder out/KTH_arrival_t60\n" + ] + } + ], + "source": [ + "input_swf = 'workloads/KTH-SP2-1996-2.1-cln.swf'\n", + "\n", + "for threshold in [10, 20, 60]:\n", + " out_dir = f'out/KTH_arrival_t{threshold}'\n", + " ! ./swf2userSessions.py {input_swf} {out_dir} \\\n", + " --arrival {threshold} --session_stat --no_SABjson_output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For workload metacentrum:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing swf line 100000\n", + "Processing swf line 200000\n", + "Processing swf line 300000\n", + "Processing swf line 400000\n", + "Processing swf line 500000\n", + "Processing swf line 600000\n", + "Processing swf line 700000\n", + "Processing swf line 800000\n", + "Processing swf line 900000\n", + "Processing swf line 1000000\n", + "Processing swf line 1100000\n", + "Processing swf line 1200000\n", + "Processing swf line 1300000\n", + "Processing swf line 1400000\n", + "Processing swf line 1500000\n", + "Processing swf line 1600000\n", + "Processing swf line 1700000\n", + "Processing swf line 1800000\n", + "Processing swf line 1900000\n", + "Processing swf line 2000000\n", + "Processing swf line 2100000\n", + "Processing swf line 2200000\n", + "Processing swf line 2300000\n", + "Processing swf line 2400000\n", + "Processing swf line 2500000\n", + "Processing swf line 2600000\n", + "Processing swf line 2700000\n", + "Processing swf line 2800000\n", + "Processing swf line 2900000\n", + "Processing swf line 3000000\n", + "Processing swf line 3100000\n", + "Processing swf line 3200000\n", + "Processing swf line 3300000\n", + "Processing swf line 3400000\n", + "Processing swf line 3500000\n", + "Processing swf line 3600000\n", + "Processing swf line 3700000\n", + "Processing swf line 3800000\n", + "Processing swf line 3900000\n", + "Processing swf line 4000000\n", + "Processing swf line 4100000\n", + "Processing swf line 4200000\n", + "Processing swf line 4300000\n", + "Processing swf line 4400000\n", + "Processing swf line 4500000\n", + "Processing swf line 4600000\n", + "Processing swf line 4700000\n", + "Processing swf line 4800000\n", + "Processing swf line 4900000\n", + "Processing swf line 5000000\n", + "Processing swf line 5100000\n", + "Processing swf line 5200000\n", + "Processing swf line 5300000\n", + "Processing swf line 5400000\n", + "Processing swf line 5500000\n", + "Processing swf line 5600000\n", + "Processing swf line 5700000\n", + "\n", + "SWF parsing done.\n", + "Number of users: 878\n", + "Number of sessions: 206655\n", + "The output files have been stored in the folder out/mc_arrival_t10\n", + "Processing swf line 100000\n", + "Processing swf line 200000\n", + "Processing swf line 300000\n", + "Processing swf line 400000\n", + "Processing swf line 500000\n", + "Processing swf line 600000\n", + "Processing swf line 700000\n", + "Processing swf line 800000\n", + "Processing swf line 900000\n", + "Processing swf line 1000000\n", + "Processing swf line 1100000\n", + "Processing swf line 1200000\n", + "Processing swf line 1300000\n", + "Processing swf line 1400000\n", + "Processing swf line 1500000\n", + "Processing swf line 1600000\n", + "Processing swf line 1700000\n", + "Processing swf line 1800000\n", + "Processing swf line 1900000\n", + "Processing swf line 2000000\n", + "Processing swf line 2100000\n", + "Processing swf line 2200000\n", + "Processing swf line 2300000\n", + "Processing swf line 2400000\n", + "Processing swf line 2500000\n", + "Processing swf line 2600000\n", + "Processing swf line 2700000\n", + "Processing swf line 2800000\n", + "Processing swf line 2900000\n", + "Processing swf line 3000000\n", + "Processing swf line 3100000\n", + "Processing swf line 3200000\n", + "Processing swf line 3300000\n", + "Processing swf line 3400000\n", + "Processing swf line 3500000\n", + "Processing swf line 3600000\n", + "Processing swf line 3700000\n", + "Processing swf line 3800000\n", + "Processing swf line 3900000\n", + "Processing swf line 4000000\n", + "Processing swf line 4100000\n", + "Processing swf line 4200000\n", + "Processing swf line 4300000\n", + "Processing swf line 4400000\n", + "Processing swf line 4500000\n", + "Processing swf line 4600000\n", + "Processing swf line 4700000\n", + "Processing swf line 4800000\n", + "Processing swf line 4900000\n", + "Processing swf line 5000000\n", + "Processing swf line 5100000\n", + "Processing swf line 5200000\n", + "Processing swf line 5300000\n", + "Processing swf line 5400000\n", + "Processing swf line 5500000\n", + "Processing swf line 5600000\n", + "Processing swf line 5700000\n", + "\n", + "SWF parsing done.\n", + "Number of users: 878\n", + "Number of sessions: 152612\n", + "The output files have been stored in the folder out/mc_arrival_t20\n", + "\u001b[KProcessing swf line 5700000\n", + "SWF parsing done.\n", + "Number of users: 878\n", + "Number of sessions: 100655\n", + "The output files have been stored in the folder out/mc_arrival_t60\n" + ] + } + ], + "source": [ + "input_swf = 'workloads/metacentrum.swf'\n", + "\n", + "for threshold in [10, 20, 60]:\n", + " out_dir = f'out/mc_arrival_t{threshold}'\n", + " ! ./swf2userSessions.py {input_swf} {out_dir} \\\n", + " --arrival {threshold} --session_stat --no_SABjson_output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Raw visualization of output json:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>first_submit_time</th>\n", + " <th>max_finish_time</th>\n", + " <th>last_submit_time</th>\n", + " <th>last_finish_time</th>\n", + " <th>nb_sessions</th>\n", + " <th>sessions</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>12</th>\n", + " <td>599850</td>\n", + " <td>29017402</td>\n", + " <td>29016615</td>\n", + " <td>29017402</td>\n", + " <td>176</td>\n", + " <td>[{'first_submit_time': 599850.0, 'last_submit_...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>13</th>\n", + " <td>600022</td>\n", + " <td>19801346</td>\n", + " <td>19706570</td>\n", + " <td>19801346</td>\n", + " <td>225</td>\n", + " <td>[{'first_submit_time': 600022.0, 'last_submit_...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>14</th>\n", + " <td>600476</td>\n", + " <td>27859303</td>\n", + " <td>27669361</td>\n", + " <td>27859303</td>\n", + " <td>204</td>\n", + " <td>[{'first_submit_time': 600476.0, 'last_submit_...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>15</th>\n", + " <td>600836</td>\n", + " <td>20332528</td>\n", + " <td>20325683</td>\n", + " <td>20326477</td>\n", + " <td>138</td>\n", + " <td>[{'first_submit_time': 600836.0, 'last_submit_...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>16</th>\n", + " <td>603930</td>\n", + " <td>4421620</td>\n", + " <td>4420473</td>\n", + " <td>4421620</td>\n", + " <td>39</td>\n", + " <td>[{'first_submit_time': 603930.0, 'last_submit_...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>210</th>\n", + " <td>29117445</td>\n", + " <td>29303265</td>\n", + " <td>29302518</td>\n", + " <td>29303224</td>\n", + " <td>2</td>\n", + " <td>[{'first_submit_time': 29117445.0, 'last_submi...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>211</th>\n", + " <td>29122750</td>\n", + " <td>29123244</td>\n", + " <td>29122750</td>\n", + " <td>29123244</td>\n", + " <td>1</td>\n", + " <td>[{'first_submit_time': 29122750.0, 'last_submi...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>212</th>\n", + " <td>29206099</td>\n", + " <td>29299029</td>\n", + " <td>29297134</td>\n", + " <td>29299029</td>\n", + " <td>3</td>\n", + " <td>[{'first_submit_time': 29206099.0, 'last_submi...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>213</th>\n", + " <td>29294165</td>\n", + " <td>29302118</td>\n", + " <td>29294165</td>\n", + " <td>29302118</td>\n", + " <td>1</td>\n", + " <td>[{'first_submit_time': 29294165.0, 'last_submi...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>214</th>\n", + " <td>29299986</td>\n", + " <td>29301206</td>\n", + " <td>29299986</td>\n", + " <td>29301206</td>\n", + " <td>1</td>\n", + " <td>[{'first_submit_time': 29299986.0, 'last_submi...</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>214 rows × 6 columns</p>\n", + "</div>" + ], + "text/plain": [ + " first_submit_time max_finish_time last_submit_time last_finish_time \\\n", + "12 599850 29017402 29016615 29017402 \n", + "13 600022 19801346 19706570 19801346 \n", + "14 600476 27859303 27669361 27859303 \n", + "15 600836 20332528 20325683 20326477 \n", + "16 603930 4421620 4420473 4421620 \n", + ".. ... ... ... ... \n", + "210 29117445 29303265 29302518 29303224 \n", + "211 29122750 29123244 29122750 29123244 \n", + "212 29206099 29299029 29297134 29299029 \n", + "213 29294165 29302118 29294165 29302118 \n", + "214 29299986 29301206 29299986 29301206 \n", + "\n", + " nb_sessions sessions \n", + "12 176 [{'first_submit_time': 599850.0, 'last_submit_... \n", + "13 225 [{'first_submit_time': 600022.0, 'last_submit_... \n", + "14 204 [{'first_submit_time': 600476.0, 'last_submit_... \n", + "15 138 [{'first_submit_time': 600836.0, 'last_submit_... \n", + "16 39 [{'first_submit_time': 603930.0, 'last_submit_... \n", + ".. ... ... \n", + "210 2 [{'first_submit_time': 29117445.0, 'last_submi... \n", + "211 1 [{'first_submit_time': 29122750.0, 'last_submi... \n", + "212 3 [{'first_submit_time': 29206099.0, 'last_submi... \n", + "213 1 [{'first_submit_time': 29294165.0, 'last_submi... \n", + "214 1 [{'first_submit_time': 29299986.0, 'last_submi... \n", + "\n", + "[214 rows x 6 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_file = 'out/KTH_arrival_t60_session_stat.json'\n", + "data = pd.read_json(data_file, orient='index')\n", + "data\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Workload KTH\n", + "\n", + "Charge dataframe in memory and print global stats." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KTH_arrival_t10:\n", + " Makespan: 332.93 days\n", + " Length: 332.91 days\n", + " #users: 214\n", + " #sessions: 15247\n", + " Sessions/user: avg:71 (min:1, med:21, max:745)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KTH_arrival_t20:\n", + " Makespan: 332.93 days\n", + " Length: 332.91 days\n", + " #users: 214\n", + " #sessions: 13050\n", + " Sessions/user: avg:61 (min:1, med:16, max:647)\n", + " \n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABPoAAAB9CAYAAAA7gA3fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdiElEQVR4nO3de3BU9d3H8c8mmwRyVUhIIASSUoRGgSiXBEUTENRA8IaIY6cKo60FpmLjE2rtKN4KjggKKDaNbXXMUC+gTB+MNl6gionAE4YOigakIDHcIlACiYZk83v+sLvNldx2czYn79fMDrPn8vt9ziW/3f1y9qzDGGMEAAAAAAAAoEcLsDoAAAAAAAAAgK6j0AcAAAAAAADYAIU+AAAAAAAAwAYo9AEAAAAAAAA2QKEPAAAAAAAAsAEKfQAAAAAAAIANUOgDAAAAAAAAbIBCHwAAAAAAAGADTqsDoLn6+nodPnxYERERcjgcVscBAAAAAACAhYwxOnPmjAYNGqSAgNav26PQ54cOHz6shIQEq2MAAAAAAADAj5SVlWnw4MGtzqfQ54ciIiIk/XDwIiMjLU7jHbW1tSosLNQ111yjoKAgq+MAALyE8R0A7InxHQD8S2VlpRISEjw1o9ZQ6PND7q/rRkZG2qrQFxoaqsjISN4oAICNML4DgD0xvgOAf2rrFm/8GAcAAAAAAABgAxT6AAAAAAAAABug0AcAAAAAAADYAIU+AAAAAAAAwAYo9AEAAAAAAAA2QKEPAAAAAAAAsAEKfQAAAAAAAIANUOgDAAAAAAAAbIBCHwAAAAAAAGADFPoAAAAAAAAAG6DQBwAAAAAAANgAhT4AAAAAAADABij0AQAAAAAAADZAoQ8AAAAAAACwAQp9AAAAAAAAgA04rQ4AAOheB76tUlVNndUxYBN1dXUqOyt9frhSTidvK9qjxvW9Dld9rUFhQxUS2MfqOADaEBbiVFJ0mNUxAABoF96RA0AvcuDbKk1+eovVMWA7Tj29+1OrQ/QYAX3KFZa0RlUHfqX67+OtjgOgHTb/TwbFPgBAj0ChDwB6EfeVfM/OSdGPB4RbnAZ2UFdXp61bt2rSpElc0ddOBypL9eB2adWcFCVFjrA6DoDz+Or4Wd332i6uhAcA9Bi8IweAXujHA8J1SXyU1TFgA7W1tfo6XLp4UKSCgoKsjtMjBPT5ocg+bEC4kvvzdwgAAADv4cc4AAAAAAAAABug0AcAAAAAAADYAIU+AAAAAAAAwAYo9AEAAAAAAAA2QKEPAAAAAAAAsAEKfQAAAAAAAIANUOhDt6iurtb+/ftVXV1tdRQAAAAAaFN1dbV27tzJZxgAPQqFPnSL0tJS3X///SotLbU6CgAAAAC06csvv9TYsWP15ZdfWh0FANqNQh8AAAAAAABgAxT6AAAAAAAAABug0AcAAAAAAADYgNObjTkcDr311lu68cYbvdmsT23ZskWTJ0/WqVOndMEFF1gdBwAAAADQw7lcLn388cc6cuSIBg4cqCuvvFKBgYHNpl9++eUqKiryPE9NTVVubq7279+vYcOGacGCBQoODta5c+e0du1az/R77rlH27Zta9Z+Z/Js2bJFH374ocrKypSQkKApU6YoIyOjxfbc7ZSXl6uiokIxMTGKj48/b/9tbXPTdTvThy81zHP06FGdPHlSAQEBysjIaHU/ebvvhvtKUovH0lf9dbbtpues+1zuDt7cjh7JeJEk89Zbb3mzSZ+rqakxR44cMfX19VZH8Th9+rSRZE6fPm11FK/Ztm2bkWS2bdtmdRSgV9v9zb/N0N9sMru/+bfVUWAT586dMxs3bjTnzp2zOkqP8fm3n5tLXrrEfP7t51ZHAWyrqLzIXP/W9aaovKhL7fTm103Gd2NKSkqMJFNSUtKh9TZs2GASExONJM8jMTHR5OTkNJvudDobPW/6cDqdZvz48W0ul5iYaDZs2NDhPDExMS22FxMT06y9ltppq/+W1mm6LQ3X7UwfvnS+PJLMgAEDfJappb5jYmLMgAEDfLJfWjtPOtN2Tk5Os+PsdDpNTk5Ol3O2xZvb4W/aWyvq9V/dDQ4OVlxcnBwOh9VRAAAAAHSRMUardq7Sv07/S6t2rpIxxupI6EXefPNN3XLLLRo1apSKi4t15swZFRcXKzo6WsuXL1d0dLSKi4uVn58vSerfv78cDodmzJghSZ4rnl588UXl5eUpODhYO3bsUHBwsPLy8vTiiy82Wm7RokUqLi7WqFGjdMstt+jNN9/sUJ6KigpJUlpamtasWaO0tDRJUkVFhWbNmuVpz91OdHS0HA6HMjMzlZeXp8zMTElSdHR0s/6b9p2fny+Hw6H+/ftLkvLz8xtlX7x4sacPSY36cDgcLfbhSw232W306NGaOHGiHA6HRo4cqePHj/skU0vHbdmyZaqoqNDx48e1bNkyz7Fs7dh3tb/Otr148WItX75c/fv3V15eno4cOaK8vDz1799fy5cv1+LFizudszu3o0frSPUwPT3d/OpXvzI5OTnmwgsvNLGxsWbJkiWe+ZLM2rVrzXXXXWf69OljkpKSzBtvvNGutmtqaszChQtNXFycCQkJMUOGDDFLly71zD916pS56667THR0tImIiDCTJ082u3bt8szftWuXycjIMOHh4SYiIsJcdtllZseOHcYYYw4ePGiysrLMBRdcYEJDQ01ycrJ5++23jTHGbN682Ugyp06d8rS1fv16k5ycbIKDg83QoUPN008/3Sjr0KFDze9//3szb948Ex4ebhISEkxubm67t6UtXNEHwFd685UJ8A2u+Og4rugDfGvrN1vNJS9d4nls/WZrp9vqza+bjO8dv6Kvrq7OJCYmmpkzZxqXy9VsemxsrElMTDQ1NTWe5Wpra82MGTOMJBMbG2tqamrMzJkzTVJSkqmurjaBgYHG4XAYp9NpqqurPevV1NSY2NhY43Q6TU1NjXG5XJ716urq2swzZMgQExAQYBwOh5kxY4ZnvsvlMllZWSY0NNSEhoY2ypuVldWsPXe/7vnu/pv23fB5bW1to6zuPp1Op5kxY4YZOnRoi30kJSU16sOX3HmzsrLMkCFDTN++fU1WVpZxuVyN8syYMcOEhoZ6NVNLx61hnqb7oKVj39X+3Dradk1NjXE6nSY2NtbU1tY2mldbW9vonPU2b26Hv2pvrajD9+h7+eWXlZ2drW3btqm4uFhz587VFVdcoWnTpkmSHnroIT355JNatWqVXnnlFd12223avXu3fvKTn5y33dWrV+tvf/ubXn/9dQ0ZMkRlZWUqKyvzzJ89e7b69u2rd955R1FRUcrNzdXVV1+tvXv3ql+/fvrpT3+qSy+9VC+88IICAwO1a9cuBQUFSZIWLlyoc+fO6aOPPlJYWJj27Nmj8PDwFnOUlJTo1ltv1SOPPKI5c+aoqKhICxYsUP/+/TV37lzPcitWrNDjjz+uBx98UOvXr9f8+fOVnp6uESNGtLktTdXU1KimpsbzvLKyUpJUW1ur2tra8x+QHuLsdz9s394jpxX89QmL0wC91/6KKklS1Xc1thlfYC33ecT51H51dXWef9lvgHcZY7R652oFOAJUb+oV4AjQ6p2rNT5mfKe+wVP1n/ewpUdOe/52e4u6ujqVnZX+eeiknE6v3tq9xyg98m9JP3yWac94/Y9//EMHDx7UK6+8IpfLJZfL1Wj6Cy+8oPnz52vNmjWe5YwxSkpKkiTdfvvtcjgcysnJ0VVXXaXs7Gy5XC7dfvvtWrdunbKzsz3rORwOLVmyRAsWLNCaNWt07733etbbvHmz0tPTz5vn0KFDntzXXntto/mLFy/Wpk2bJEkHDx705M3OztamTZuatefu99e//rU2bdqkzZs3e9Z1L9swizGmWdZp06Zp06ZNSkpK0ttvv638/PwW+7jvvvs8faSnp3f1ELd5LN3bJEm/+c1vWszz9ttv68CBA17L1NJxa7r/Gu67hnk6k6G188StI22vWbNGdXV1evTRR2WMafZ30/Sc9SZvboe/au/7xg6P2KNHj9aSJUskScOHD9dzzz2nDz74wFPomz17tu6++25J0uOPP6733ntPa9as0dq1a8/b7qFDhzR8+HBNmjRJDodDQ4cO9czbunWrtm/fruPHjyskJESS9PTTT2vjxo1av369fvGLX+jQoUPKycnRyJEjPdkatj1r1iyNGjVKkvSjH/2o1RwrV67U1VdfrYceekiSdNFFF2nPnj1avnx5o0Lf9OnTtWDBAkk//ME/88wz2rx5s0aMGHHebWnJsmXL9OijjzabXlhYqNDQ0POu21MU7d4vScp5a49Cis9ZnAbApi3FOhpjdQrYyXvvvWd1hB7jcN1hSdInWz/RAecBi9MA9rKvdp/2VO3xPK839dpzco9W/221hgcNP8+aLfu/Ckly6v71u70XskdxSrv/z+oQlqk5+pUk6e3NxTr17fE2l//oo48kSd98841OnDjRbHqfPn0kSR9++GGj5fbu3StJqqqqUkFBgb777jtJ0qeffipJGj9+vNatW+d57l6vYXs//vGPPeu98847qqqqajOP2969e1VQUOB57m7HzZ3XnbNpe+7l9+3b5+nfzb1s0yxNs7rX7UgfVVVV8hV3Xnd/TTM1zePNTC0dt4bTWuqv6f7san8NdaRt97kSEhLS6Jxya3rOepM3t8NfVVdXt2u5ThX6Gho4cKCOH//voDdx4sRG8ydOnKhdu3a12e7cuXM1bdo0jRgxQtddd52ysrJ0zTXXSJL++c9/6uzZs57v8rt999132r//hwJSdna27r77br3yyiuaOnWqZs+erWHDhkmS7r33Xs2fP1+FhYWaOnWqZs2a1Ww73L744gvdcMMNjaZdccUVevbZZ+VyuTy/1NJwfYfDobi4OM9+ON+2tOS3v/2tsrOzPc8rKyuVkJCga665RpGRkW3uu54g4oJP9ZSk5Tcl65KUy6yOA/Ra+yuqdP/63crKmKjLhl5odRzYQG1trd577z1NmzbNcyU9zu+Lk19o7btrdcWkK/STfuf/xgOA9jPGaN3f1ymg+oer+dwCHAHaEbJD9157b4ev6ov7+pRe+WqHVtwySsNiwrwd2a/V1dXp008/VVpaWq+9ou+Lz/rq9pelGZMnauKEcW0uHxYWppUrV2rw4MFKTU1tNv3777+XJE2ZMkUFBQWe5d5//30VFhYqLCxM06dP9xT00tLStGvXLu3YsaPRc/d67vv1TZkypdF6mZmZSk9PbzOP20UXXaTp06d7nrvbcXPnveiiiySpWXvu5d0X27jv29ew76ZZmmb9+uuvPVkKCwvb1Ycvr8py5214AVHDTE3zeDNTS8et4TTzn/uONuyv6f7san8NdaTtr776SgUFBaqpqWl0Trk1PWe9yZvb4a/c3/5sU0e+D5yenm4WLVrUaNoNN9xg7rzzTmN+ONvMyy+/3Gj+fffdZzIyMtrV/unTp82rr75q7r77bhMVFWVmzZpljDHmySefNPHx8Wbfvn3NHhUVFZ71S0tLzcqVK820adNMcHCwefPNNz3zDh06ZF544QVz0003maCgILN69WpjTPN79F166aXmkUceaZRr48aNJigoyPNd7qFDh5pnnnmm0TJjxoxpdL/C1ralvftB3KMPgA/05nsNwTe4h1PHcY8+wDea3puv6aMz9+rrza+bjO/co4979HGPPu7R51/aWyvyeqFv/vz5jeanpaU1m9Ye7777rpFkTpw4YQoLC01gYKA5cOBAu9e/7bbbzMyZM1uc98ADD5hRo0YZY5oX+m6//XYzbdq0Rsvn5OSYiy++2PO8PYW+1ralPSj0AfCV3vyBBb7BB8GOo9AHeF99fb2Z879zzKiXRrVY5Bv10igz53/nmPr6+g6125tfNxnfO17oM8aYDRs2GIfDYWbOnGmKiopMZWWlKSoqMuPGjTOSzLhx40xRUZHJz8/3FPfcxTZJJjg42EgyeXl5Jjc314SGhhpJJjQ01OTm5pq8vLxGyy1atMgUFRWZmTNnGofDYTZs2NChPO5HWlqaWbVqlUlLS2s03d2eu51x48YZh8NhMjMzTW5ursnMzPRsV9P+m/adn59vHA6HiY2NNZJMfn5+o+w5OTmePiQ16qNh30230VcabrN7f4wePdqkpaUZh8NhRo4caST5JFNLx23p0qWeHEuXLvUcy9aOfVf762zbOTk5nnM7NzfXlJeXm9zcXM9xz8nJ6XTO7twOf2RZoS86Otr86U9/MqWlpebhhx82AQEB5vPP234ju2LFCrNu3TrzxRdfmNLSUnPXXXeZuLg443K5TH19vZk0aZIZM2aM+fvf/24OHDhgPvnkE/Pggw+aHTt2mOrqarNw4UKzefNmc/DgQbN161YzbNgws3jxYmOMMYsWLTLvvvuu+de//mVKSkpMamqqufXWW40xzQt9JSUlJiAgwDz22GOmtLTUvPTSS6Zv377mL3/5iydrW4W+821Le1DoA+ArvfkDC3yDD4IdR6EP8L6auhqT/mr6ea/oS3813dTUdewqkt78usn43rlCnzE/FBsSExMbFcySkpJMTk5Os+lOp7PR86YPp9Npxo8f3+ZySUlJrRYxzpcnJiamxfYGDBjQYtGwaTtt9d/SOk23peG6nenDl86Xp7X95Mu+BwwYYAYMGOCT/dLaedKZtnNycpodZ6fT6dMin5s3t8Pf+OxXd9vy6KOP6tVXX9WCBQs0cOBA/fWvf1VycnKb60VEROipp57Svn37FBgYqPHjx6ugoEABAQGSpIKCAv3ud7/TvHnzVFFRobi4OF111VWKjY1VYGCgTpw4oTvuuEPHjh1TdHS0br75Zs8PXLhcLi1cuFDffPONIiMjdd111+mZZ55pMcdll12m119/XQ8//LAef/xxDRw4UI899lijH+Lo6rYAAAAA8J7gwGC9mvWqTn5/stVl+vXpp+DA4G5Mhd7q5ptv1g033KCPP/5YR44c0cCBA3XllVcqMDBQy5YtazT98ssvV1FRked5amqqcnNztX//fg0bNkwLFixQcHCwzp07p7Vr13qm33PPPdq2bVuz9juTZ8uWLfrwww9VVlamhIQETZkyRRkZGc3aa9hOeXm5KioqFBMTo/j4+Fb7b6nvptvccN3O9OFLTfMcPXpUJ0+eVEBAgDIyMlrcT77ou+G+ktTisfRVf51p+6mnntITTzzR6Jx1n8u+5s3t6KkcxvznTo7wG5WVlYqKitLp06dt82Mc27dvV2pqqrZt26YJEyZYHQfotT4rP62sNVu16VeTdEl8lNVxYAO1tbUqKCjQ9OnT+TGOdtpzYo/mbJqj17JeU3L/tv8zFIB1evPrJuO7tHPnTo0dO1YlJSW67DJ+UBCAtdpbK+ISMwAAAAAAAMAGuq3Qt3TpUoWHh7f4cP/8NgAAAAAAAIDO8fo9+lrzy1/+UrfeemuL8/r27dtdMQAAAAAAAABb6rZCX79+/dSvX7/u6g4AAAAAAADoVbhHH7rFiBEjtGLFCo0YMcLqKAAAAADQppEjR6qkpEQjR460OgoAtFu3XdGH3i00NFTDhg1TaGio1VEAAAAAoE2hoaH82i6AHocr+gAAAAAAAAAboNAHAAAAAAAA2ACFPgAAAAAAAMAGKPQBAAAAAAAANkChDwAAAAAAALABfnUXAHqR72pdkqTPyk9bnAR2UVdXp7Kz0ueHK+V08raiPQ5UnpUk7T9+VvXf87cI+LOvjp+1OgIAAB3CO3IA6EX2/+cDywNv7rY4CezFqad3f2p1iB4joE+5wpKkRa/tUv33FVbHAdAOYSF8bAIA9Ay8YgFAL3LNxXGSpGEDwtU3KNDiNLCDuro6bd26VZMmTeKKvnaqcX2vw1UpGjR5qEIC+1gdB0AbwkKcSooOszoGAADtwjtyAOhF+oUF67YJQ6yOARupra3V1+HSxYMiFRQUZHWcHiJKYxVrdQgAAADYED/GAQAAAAAAANgAhT4AAAAAAADABij0AQAAAAAAADZAoQ8AAAAAAACwAQp9AAAAAAAAgA1Q6AMAAAAAAABsgEIfAAAAAAAAYAMU+gAAAAAAAAAboNAHAAAAAAAA2ACFPgAAAAAAAMAGKPQBAAAAAAAANkChDwAAAAAAALABCn0AAAAAAACADVDoAwAAAAAAAGyAQh8AAAAAAABgAxT6AAAAAAAAABtwWh0AzRljJEmVlZUWJ/Ge2tpaVVdXq7KyUkFBQVbHAQB4CeM7ANgT4zsA+Bd3jchdM2oNhT4/dObMGUlSQkKCxUkAAAAAAADgL86cOaOoqKhW5ztMW6VAdLv6+nodPnxYERERcjgcnW5n/Pjx2rFjh1cydbWtyspKJSQkqKysTJGRkV7JhO7nzXOqp+vJ+8LfsluVpzv69VUfjO/wNn8bF6zUk/eFv2VnfLe2XcZ3SP43LlipJ+8Lf8vO+G5Nu8YYnTlzRoMGDVJAQOt34uOKPj8UEBCgwYMHd7mdwMBAr70oe6utyMhI3ij0YN48p3q6nrwv/C27VXm6o19f9cH4Dm/zt3HBSj15X/hbdsZ3a9tlfIfkf+OClXryvvC37Izv1rV7viv53PgxDhtbuHChX7aFnovz4L968r7wt+xW5emOfn3VB+M7vI3z4L968r7wt+yM79a262/nA6zBefBfPXlf+Ft2xnf/abclfHUX3aKyslJRUVE6ffq0X/1PBACgaxjfAcCeGN8BoGfiij50i5CQEC1ZskQhISFWRwEAeBHjOwDYE+M7APRMXNEHAAAAAAAA2ABX9AEAAAAAAAA2QKEPAAAAAAAAsAEKfQAAAAAAAIANUOgDAAAAAAAAbIBCH/zCpk2bNGLECA0fPlwvvvii1XEAAF5y00036cILL9Qtt9xidRQAgJeUlZUpIyNDycnJGj16tN544w2rIwEA/oNf3YXl6urqlJycrM2bNysqKkpjx45VUVGR+vfvb3U0AEAXbdmyRWfOnNHLL7+s9evXWx0HAOAFR44c0bFjx5SSkqKjR49q7Nix2rt3r8LCwqyOBgC9Hlf0wXLbt2/XxRdfrPj4eIWHhyszM1OFhYVWxwIAeEFGRoYiIiKsjgEA8KKBAwcqJSVFkhQXF6fo6GidPHnS2lAAAEkU+uAFH330kWbOnKlBgwbJ4XBo48aNzZZ5/vnnlZiYqD59+ig1NVXbt2/3zDt8+LDi4+M9z+Pj41VeXt4d0QEA59HV8R0A4J+8Ob6XlJTI5XIpISHBx6kBAO1BoQ9dVlVVpTFjxuj5559vcf5rr72m7OxsLVmyRDt37tSYMWN07bXX6vjx492cFADQEYzvAGBP3hrfT548qTvuuEN//OMfuyM2AKAdKPShyzIzM/XEE0/opptuanH+ypUr9fOf/1zz5s1TcnKy/vCHPyg0NFR//vOfJUmDBg1qdAVfeXm5Bg0a1C3ZAQCt6+r4DgDwT94Y32tqanTjjTfqgQce0OWXX95d0QEAbaDQB586d+6cSkpKNHXqVM+0gIAATZ06VcXFxZKkCRMm6LPPPlN5ebnOnj2rd955R9dee61VkQEA7dCe8R0A0PO0Z3w3xmju3LmaMmWKfvazn1kVFQDQAgp98Klvv/1WLpdLsbGxjabHxsbq6NGjkiSn06kVK1Zo8uTJSklJ0f33388v7gKAn2vP+C5JU6dO1ezZs1VQUKDBgwdTBAQAP9ee8f2TTz7Ra6+9po0bNyolJUUpKSnavXu3FXEBAE04rQ4ASNL111+v66+/3uoYAAAve//9962OAADwskmTJqm+vt7qGACAFnBFH3wqOjpagYGBOnbsWKPpx44dU1xcnEWpAABdxfgOAPbE+A4APRuFPvhUcHCwxo4dqw8++MAzrb6+Xh988IEmTpxoYTIAQFcwvgOAPTG+A0DPxld30WVnz57VV1995Xl+4MAB7dq1S/369dOQIUOUnZ2tO++8U+PGjdOECRP07LPPqqqqSvPmzbMwNQCgLYzvAGBPjO8AYF8OY4yxOgR6ti1btmjy5MnNpt9555166aWXJEnPPfecli9frqNHjyolJUWrV69WampqNycFAHQE4zsA2BPjOwDYF4U+AAAAAAAAwAa4Rx8AAAAAAABgAxT6AAAAAAAAABug0AcAAAAAAADYAIU+AAAAAAAAwAYo9AEAAAAAAAA2QKEPAAAAAAAAsAEKfQAAAAAAAIANUOgDAAAAAAAAbIBCHwAAAAAAAGADFPoAAAAAAAAAG6DQBwAAAAAAANgAhT4AAAAAAADABij0AQAAAAAAADbw//b5AWxPiC8FAAAAAElFTkSuQmCC", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KTH_arrival_t60:\n", + " Makespan: 332.93 days\n", + " Length: 332.91 days\n", + " #users: 214\n", + " #sessions: 10293\n", + " Sessions/user: avg:48 (min:1, med:12, max:514)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "KTH_a_t10 = pd.read_json('out/KTH_arrival_t10_session_stat.json', orient='index')\n", + "KTH_a_t20 = pd.read_json('out/KTH_arrival_t20_session_stat.json', orient='index')\n", + "KTH_a_t60 = pd.read_json('out/KTH_arrival_t60_session_stat.json', orient='index')\n", + "\n", + "print(\"KTH_arrival_t10:\")\n", + "print_general_stats(KTH_a_t10)\n", + "print(\"KTH_arrival_t20:\")\n", + "print_general_stats(KTH_a_t20)\n", + "print(\"KTH_arrival_t60:\")\n", + "print_general_stats(KTH_a_t60)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "length_of_stay = KTH_a_t10['last_submit_time'] - KTH_a_t10['first_submit_time']\n", + "plot_length_stay(length_of_stay)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Distribution of session lengths (log: KTH, delimitation: Arrival)')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x1000 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(4, gridspec_kw={'height_ratios': [3,1,1,3]}, figsize=[15,10])\n", + "multi_plot_distri_length(\n", + " [KTH_a_t10, KTH_a_t20, KTH_a_t60],\n", + " [\"10mn\", \"20mn\", \"60mn\"],\n", + " ax\n", + ")\n", + "ax[0].set_title(\"Distribution of session lengths (log: KTH, delimitation: Arrival)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Workload Metacentrum\n", + "\n", + "Charge dataframe in memory and print global stats." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mc_arrival_t10:\n", + " Makespan: 836.52 days\n", + " Length: 729.00 days\n", + " #users: 878\n", + " #sessions: 206655\n", + " Sessions/user: avg:235 (min:1, med:39, max:18015)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mc_arrival_t20:\n", + " Makespan: 836.52 days\n", + " Length: 729.00 days\n", + " #users: 878\n", + " #sessions: 152612\n", + " Sessions/user: avg:174 (min:1, med:33, max:10918)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mc_arrival_t60:\n", + " Makespan: 836.52 days\n", + " Length: 729.00 days\n", + " #users: 878\n", + " #sessions: 100655\n", + " Sessions/user: avg:115 (min:1, med:25, max:2896)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mc_a_t10 = pd.read_json('out/mc_arrival_t10_session_stat.json', orient='index')\n", + "mc_a_t20 = pd.read_json('out/mc_arrival_t20_session_stat.json', orient='index')\n", + "mc_a_t60 = pd.read_json('out/mc_arrival_t60_session_stat.json', orient='index')\n", + "\n", + "print(\"mc_arrival_t10:\")\n", + "print_general_stats(mc_a_t10)\n", + "print(\"mc_arrival_t20:\")\n", + "print_general_stats(mc_a_t20)\n", + "print(\"mc_arrival_t60:\")\n", + "print_general_stats(mc_a_t60)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAAEmCAYAAAAp90kqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoAUlEQVR4nO3de1RVdf7/8ddBBOQepBCJl7JSFC+DqYillYJKpolpjhn5tSyjJqWvGY3lZFOaY5mWpTUj2pTVmGlLnSg1rRlFQw1TM9KWBsnNKQVxkot8fn/09fw6CQansz2Az8daey3OZ3/2Pu/Pp7M8r/blbJsxxggAAMBCHu4uAAAANH0EDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5TzdXUBDUF1drfz8fAUEBMhms7m7HAAAGg1jjE6ePKmIiAh5eNR+HIPAISk/P1+RkZHuLgMAgEYrLy9PrVu3rnU9gUNSQECApJ8mKzAw0M3VAADQeJSWlioyMtL+XVobAodkP40SGBhI4AAAwAm/dkkCF40CAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJbjh78AAHCxdo+ud3cJtToyJ9Et78sRDgAAYDkCBwAAsByBAwAAWI7AAQAALNdgAsecOXNks9k0ZcoUe9vp06eVkpKi0NBQ+fv7KykpSUVFRQ7b5ebmKjExUb6+vmrVqpWmTZumqqqqC1w9AAA4nwYROLKysrRkyRJ17drVoX3q1Klau3atVq5cqU8++UT5+fkaOXKkff2ZM2eUmJioiooKbdu2TcuXL9eyZcv0xBNPXOghAACA83B74CgrK9O4ceP02muv6ZJLLrG3l5SU6G9/+5uef/553XjjjYqJiVF6erq2bdum7du3S5I++ugjffnll3rjjTfUvXt3DRkyRE899ZQWLVqkiooKdw0JAAD8gtsDR0pKihITEzVw4ECH9l27dqmystKhvWPHjmrTpo0yMzMlSZmZmYqOjlZYWJi9T0JCgkpLS7V///4LMwAAAPCr3PrDX2+//bZ2796trKysc9YVFhbKy8tLwcHBDu1hYWEqLCy09/l52Di7/uy62pSXl6u8vNz+urS01NkhAACAOnDbEY68vDw99NBDevPNN+Xj43NB33v27NkKCgqyL5GRkRf0/QEAuNi4LXDs2rVLxcXF+t3vfidPT095enrqk08+0cKFC+Xp6amwsDBVVFToxIkTDtsVFRUpPDxckhQeHn7OXStnX5/tU5O0tDSVlJTYl7y8PNcODgAAOHBb4Ljpppu0d+9eZWdn25eePXtq3Lhx9r+bN2+uTZs22bfJyclRbm6uYmNjJUmxsbHau3eviouL7X02bNigwMBARUVF1fre3t7eCgwMdFgAAIB13HYNR0BAgLp06eLQ5ufnp9DQUHv7xIkTlZqaqpCQEAUGBurBBx9UbGys+vTpI0mKj49XVFSUxo8fr7lz56qwsFAzZsxQSkqKvL29L/iYAABAzRr002Lnz58vDw8PJSUlqby8XAkJCXr55Zft65s1a6Z169Zp8uTJio2NlZ+fn5KTkzVr1iw3Vg0AAH7JZowx7i7C3UpLSxUUFKSSkhJOrwAAfrOL6fH0df0OdfvvcAAAgKaPwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAs59bA8corr6hr164KDAxUYGCgYmNj9cEHH9jXnz59WikpKQoNDZW/v7+SkpJUVFTksI/c3FwlJibK19dXrVq10rRp01RVVXWhhwIAAM7DrYGjdevWmjNnjnbt2qWdO3fqxhtv1PDhw7V//35J0tSpU7V27VqtXLlSn3zyifLz8zVy5Ej79mfOnFFiYqIqKiq0bds2LV++XMuWLdMTTzzhriEBAIAa2Iwxxt1F/FxISIj+8pe/aNSoUWrZsqVWrFihUaNGSZK++uorderUSZmZmerTp48++OAD3XzzzcrPz1dYWJgkafHixZo+fbqOHTsmLy+vOr1naWmpgoKCVFJSosDAQMvGBgC4OLR7dL27S6jVkTmJLt1fXb9DG8w1HGfOnNHbb7+tU6dOKTY2Vrt27VJlZaUGDhxo79OxY0e1adNGmZmZkqTMzExFR0fbw4YkJSQkqLS01H6UpCbl5eUqLS11WAAAgHXcHjj27t0rf39/eXt767777tPq1asVFRWlwsJCeXl5KTg42KF/WFiYCgsLJUmFhYUOYePs+rPrajN79mwFBQXZl8jISNcOCgAAOHB74LjmmmuUnZ2tHTt2aPLkyUpOTtaXX35p6XumpaWppKTEvuTl5Vn6fgAAXOw83V2Al5eXOnToIEmKiYlRVlaWFixYoDFjxqiiokInTpxwOMpRVFSk8PBwSVJ4eLg+++wzh/2dvYvlbJ+aeHt7y9vb28UjAQAAtXH7EY5fqq6uVnl5uWJiYtS8eXNt2rTJvi4nJ0e5ubmKjY2VJMXGxmrv3r0qLi6299mwYYMCAwMVFRV1wWsHAAA1c+sRjrS0NA0ZMkRt2rTRyZMntWLFCm3ZskUffvihgoKCNHHiRKWmpiokJESBgYF68MEHFRsbqz59+kiS4uPjFRUVpfHjx2vu3LkqLCzUjBkzlJKSwhEMAAAaELcGjuLiYt15550qKChQUFCQunbtqg8//FCDBg2SJM2fP18eHh5KSkpSeXm5EhIS9PLLL9u3b9asmdatW6fJkycrNjZWfn5+Sk5O1qxZs9w1JAAAUIMG9zsc7sDvcAAAXInf4ThXg7uGAwAAND0EDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWc0ngKC0t1Zo1a3TgwAFX7A4AADQxTgWO0aNH66WXXpIk/fjjj+rZs6dGjx6trl27atWqVS4tEAAANH5OBY5PP/1U1113nSRp9erVMsboxIkTWrhwof785z+7tEAAAND4ORU4SkpKFBISIknKyMhQUlKSfH19lZiYqIMHD7q0QAAA0Pg5FTgiIyOVmZmpU6dOKSMjQ/Hx8ZKk48ePy8fHx6UFAgCAxs/TmY2mTJmicePGyd/fX23bttWAAQMk/XSqJTo62pX1AQCAJsCpwHH//ferd+/eys3N1aBBg+Th8dOBkiuuuIJrOAAAwDnqfUqlsrJSV155pXx9fXXrrbfK39/fvi4xMVFxcXEuLRAAADR+9Q4czZs31+nTp62oBQAANFFOXTSakpKiZ599VlVVVa6uBwAANEFOXcORlZWlTZs26aOPPlJ0dLT8/Pwc1r/33nsuKQ4A4H7tHl3v7hJqdWROortLQB05FTiCg4OVlJTk6loAAEAT5VTgSE9Pd3UdAACgCXP64W1VVVXauHGjlixZopMnT0qS8vPzVVZW5rLiAABA0+DUEY5vv/1WgwcPVm5ursrLyzVo0CAFBATo2WefVXl5uRYvXuzqOgEAQCPm1BGOhx56SD179tTx48fVokULe/utt96qTZs2uaw4AADQNDh1hONf//qXtm3bJi8vL4f2du3a6ejRoy4pDAAANB1OHeGorq7WmTNnzmn/7rvvFBAQ8JuLAgAATYtTgSM+Pl4vvPCC/bXNZlNZWZlmzpypoUOHuqo2AADQRDh1SuW5555TQkKCoqKidPr0af3+97/XwYMHdemll+qtt95ydY0AAKCRcypwtG7dWnv27NE777yjPXv2qKysTBMnTtS4ceMcLiIFAACQnAwckuTp6alx48Zp3LhxrqwHAAA0QU5dw7F8+XKtX///f1v/kUceUXBwsPr27atvv/3WZcUBAICmwanA8cwzz9hPnWRmZuqll17S3Llzdemll2rq1KkuLRAAADR+Tp1SycvLU4cOHSRJa9as0ahRozRp0iTFxcVpwIABrqwPAAA0AU4d4fD399f3338vSfroo480aNAgSZKPj49+/PFH11UHAACaBKeOcAwaNEh33323evTooa+//tr+2xv79+9Xu3btXFkfAABoApw6wrFo0SLFxsbq2LFjWrVqlUJDQyVJu3bt0tixY+u8n9mzZ+vaa69VQECAWrVqpREjRignJ8ehz+nTp5WSkqLQ0FD5+/srKSlJRUVFDn1yc3OVmJgoX19ftWrVStOmTVNVVZUzQwMAABZw6ghHcHCwXnrppXPan3zyyXrt55NPPlFKSoquvfZaVVVV6bHHHlN8fLy+/PJL+fn5SZKmTp2q9evXa+XKlQoKCtIDDzygkSNHauvWrZKkM2fOKDExUeHh4dq2bZsKCgp05513qnnz5nrmmWecGR4AAHAxmzHG1HejTz/99Lzrr7/+eqeKOXbsmFq1aqVPPvlE119/vUpKStSyZUutWLFCo0aNkiR99dVX6tSpkzIzM9WnTx998MEHuvnmm5Wfn6+wsDBJ0uLFizV9+nQdO3bsnAfM1aS0tFRBQUEqKSlRYGCgU7UDQFPV7tH1v97JTY7MSXR3CTW6mOasrt+hTh3hqOlOFJvNZv+7pge71UVJSYkkKSQkRNJPp2gqKys1cOBAe5+OHTuqTZs29sCRmZmp6Ohoe9iQpISEBE2ePFn79+9Xjx49nKoFAAC4jlOB4/jx4w6vKysr9fnnn+vxxx/X008/7VQh1dXVmjJliuLi4tSlSxdJUmFhoby8vBQcHOzQNywsTIWFhfY+Pw8bZ9efXVeT8vJylZeX21+XlpY6VTMAAKgbpwJHUFDQOW2DBg2Sl5eXUlNTtWvXrnrvMyUlRfv27dO///1vZ0qql9mzZ9f7ehMAAOA8p+5SqU1YWNg5d5nUxQMPPKB169Zp8+bNat26tb09PDxcFRUVOnHihEP/oqIihYeH2/v88q6Vs6/P9vmltLQ0lZSU2Je8vLx61wwAAOrOqSMcX3zxhcNrY4wKCgo0Z84cde/evc77McbowQcf1OrVq7Vlyxa1b9/eYX1MTIyaN2+uTZs2KSkpSZKUk5Oj3NxcxcbGSpJiY2P19NNPq7i4WK1atZIkbdiwQYGBgYqKiqrxfb29veXt7V3nOgEAwG/jVODo3r27bDabfnmDS58+fbR06dI67yclJUUrVqzQ+++/r4CAAPs1F0FBQWrRooWCgoI0ceJEpaamKiQkRIGBgXrwwQcVGxurPn36SJLi4+MVFRWl8ePHa+7cuSosLNSMGTOUkpJCqAAAoIFwKnAcPnzY4bWHh4datmwpHx+feu3nlVdekXTuXS/p6em66667JEnz58+Xh4eHkpKSVF5eroSEBL388sv2vs2aNdO6des0efJkxcbGys/PT8nJyZo1a1b9BwYAACzhVOBo27atHnjgAc2aNct+C6sz6vITID4+Plq0aJEWLVp03nr++c9/Ol0HAACwVr0uGv3uu+/sf69YsUJlZWWSpOjoaC68BAAAtarXEY6OHTsqNDRUcXFxOn36tPLy8tSmTRsdOXJElZWVVtUIAAAauXod4Thx4oRWrlypmJgYVVdXa+jQobr66qtVXl6uDz/88JzbUwEAAKR6Bo7Kykr16tVLDz/8sFq0aKHPP/9c6enpatasmZYuXar27dvrmmuusapWAADQSNXrlEpwcLC6d++uuLg4VVRU6Mcff1RcXJw8PT31zjvv6PLLL1dWVpZVtQIAgEaqXkc4jh49qhkzZsjb21tVVVWKiYnRddddp4qKCu3evVs2m039+vWzqlYAANBI1StwXHrppRo2bJhmz54tX19fZWVl6cEHH5TNZtP//u//KigoSP3797eqVgAA0Ej9pmepBAUFafTo0WrevLk+/vhjHT58WPfff7+ragMAAE2EUz/8Jf30PJXLL79c0k8/vNW8eXOFh4drzJgxLisOAAA0DU4HjsjISPvf+/btc0kxAACgaXLp4+kBAABqQuAAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFjOrYHj008/1bBhwxQRESGbzaY1a9Y4rDfG6IknntBll12mFi1aaODAgTp48KBDnx9++EHjxo1TYGCggoODNXHiRJWVlV3AUQAAgF/j1sBx6tQpdevWTYsWLapx/dy5c7Vw4UItXrxYO3bskJ+fnxISEnT69Gl7n3Hjxmn//v3asGGD1q1bp08//VSTJk26UEMAAAB14OnONx8yZIiGDBlS4zpjjF544QXNmDFDw4cPlyS9/vrrCgsL05o1a3T77bfrwIEDysjIUFZWlnr27ClJevHFFzV06FDNmzdPERERF2wsAACgdg32Go7Dhw+rsLBQAwcOtLcFBQWpd+/eyszMlCRlZmYqODjYHjYkaeDAgfLw8NCOHTtq3Xd5eblKS0sdFgAAYJ0GGzgKCwslSWFhYQ7tYWFh9nWFhYVq1aqVw3pPT0+FhITY+9Rk9uzZCgoKsi+RkZEurh4AAPxcgw0cVkpLS1NJSYl9ycvLc3dJAAA0aQ02cISHh0uSioqKHNqLiors68LDw1VcXOywvqqqSj/88IO9T028vb0VGBjosAAAAOs02MDRvn17hYeHa9OmTfa20tJS7dixQ7GxsZKk2NhYnThxQrt27bL3+fjjj1VdXa3evXtf8JoBAEDN3HqXSllZmQ4dOmR/ffjwYWVnZyskJERt2rTRlClT9Oc//1lXXXWV2rdvr8cff1wREREaMWKEJKlTp04aPHiw7rnnHi1evFiVlZV64IEHdPvtt3OHCgAADYhbA8fOnTt1ww032F+npqZKkpKTk7Vs2TI98sgjOnXqlCZNmqQTJ06oX79+ysjIkI+Pj32bN998Uw888IBuuukmeXh4KCkpSQsXLrzgYwEAALWzGWOMu4twt9LSUgUFBamkpITrOQDgF9o9ut7dJdTqyJxEd5dQo4tpzur6Hdpgr+EAAABNB4EDAABYzq3XcAC/1FAPQzbUw7YA0FhwhAMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOU93FwAAF1K7R9e7u4RaHZmT6O4SAMtwhAMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOW4SwVo5BrqXRfccQHg5wgcFuKLAACAn3BKBQAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALBckwkcixYtUrt27eTj46PevXvrs88+c3dJAADg/zSJwPHOO+8oNTVVM2fO1O7du9WtWzclJCSouLjY3aUBAAA1kcDx/PPP65577tGECRMUFRWlxYsXy9fXV0uXLnV3aQAAQJKnuwv4rSoqKrRr1y6lpaXZ2zw8PDRw4EBlZmbWuE15ebnKy8vtr0tKSiRJpaWlLq2tuvy/Lt2fq7h6nK7EnNUfc1Y/DXW+JObMGcxZ/bl6zs7uzxhz/o6mkTt69KiRZLZt2+bQPm3aNNOrV68at5k5c6aRxMLCwsLCwuKiJS8v77zf143+CIcz0tLSlJqaan9dXV2tH374QaGhobLZbG6srGalpaWKjIxUXl6eAgMD3V1Oo8Cc1R9zVn/MWf0wX/XXGObMGKOTJ08qIiLivP0afeC49NJL1axZMxUVFTm0FxUVKTw8vMZtvL295e3t7dAWHBxsVYkuExgY2GA/cA0Vc1Z/zFn9MWf1w3zVX0Ofs6CgoF/t0+gvGvXy8lJMTIw2bdpkb6uurtamTZsUGxvrxsoAAMBZjf4IhySlpqYqOTlZPXv2VK9evfTCCy/o1KlTmjBhgrtLAwAAaiKBY8yYMTp27JieeOIJFRYWqnv37srIyFBYWJi7S3MJb29vzZw585zTQKgdc1Z/zFn9MWf1w3zVX1OaM5sxv3YfCwAAwG/T6K/hAAAADR+BAwAAWI7AAQAALEfgACRt2bJFNptNJ06ccHcpjcayZcsaxe/XAGgYCByNwKJFi9SuXTv5+Piod+/e+uyzz9xdUoP29NNPq2/fvvL19eULsQ7Ohq2alqysLHeX16Dw2XLO+vXr1bt3b7Vo0UKXXHKJRowY4e6SLrijR4/qjjvuUGhoqFq0aKHo6Gjt3LnT3WVdUASOBu6dd95RamqqZs6cqd27d6tbt25KSEhQcXGxu0trUI4fP66ysjJJPz3Q77bbbtPkyZPdXFXDdnbO+vbtq4KCAofl7rvvVvv27dWzZ093l+l2fLbq7+dztmrVKo0fP14TJkzQnj17tHXrVv3+9793c4UX1vHjxxUXF6fmzZvrgw8+0JdffqnnnntOl1xyiUvfZ9myZRowYIBL9+lSrnmEGqzSq1cvk5KSYn995swZExERYWbPnu3GqhqGyspKs27dOjNq1Cjj7e1tsrOzHdanp6eboKCgGrddv369ueqqq4yPj48ZMGCASU9PN5LM8ePHrS/cjX5tzowxpqKiwrRs2dLMmjXLoT09Pd1ERkaaFi1amBEjRph58+bVOr+NnbOfrc2bNxtJJiMjw3Tv3t34+PiYG264wRQVFZl//vOfpmPHjiYgIMCMHTvWnDp16gKN5sKoac4qKyvN5Zdfbv7617/Wut3FMGfTp083/fr1O2+ftm3bmqeeesqMHz/e+Pn5mTZt2pj333/fFBcXm1tuucX4+fmZ6Ohok5WVVes+0tPTTf/+/V1cvesQOBqw8vJy06xZM7N69WqH9jvvvNPccsst7imqAfjiiy9MamqqCQsLMyEhIWby5MnnPC3YmNq/FHJzc423t7dJTU01X331lXnjjTdMWFhYkw4cdZ0zY4x59913jYeHh8OTH7dv3248PDzMs88+a3JycsyCBQtMcHBwkwscv/WzdfbLs0+fPubf//632b17t+nQoYPp37+/iY+PN7t37zaffvqpCQ0NNXPmzLkAI7Le+eZsx44dRpJZunSp6d69uwkPDzeDBw82e/futW9/McxZp06dzJQpU8yoUaNMy5YtTffu3c2rr77q0Kdt27YmJCTELF682Hz99ddm8uTJJjAw0AwePNj84x//MDk5OWbEiBGmU6dOprq6usb3IXDAaUePHjWSzvkHb9q0aaZXr15uqso9/vOf/5gXXnjB9OjRw3h5eZkRI0aYVatWmfLy8lq3qe1LIS0tzURFRTm0TZ8+vckFDmfmzBhjhgwZYoYMGeLQNnbsWDN06FCHtjFjxjSJwOHKz9bZL8+NGzfa22bPnm0kmW+++cbedu+995qEhASXjuNCquucvfXWW0aSadOmjXn33XfNzp07zdixY01oaKj5/vvvjTEXx5x5e3sbb29vk5aWZnbv3m2WLFlifHx8zLJly+x92rZta+644w7764KCAiPJPP744/a2zMxMI8kUFBTU+D4NPXA0iZ82R9P34osv6sknn9R1112nQ4cOKTIy0ul9HThwQL1793Zoa4oP+nNmzr777jt9+OGH+sc//uHQfuDAAd16660ObbGxscrIyHBpze7gys/WWV27drX/HRYWJl9fX11xxRUObY354u+6zll1dbUk6Y9//KOSkpIkSenp6WrdurVWrlype++91963Kc9ZdXW1evbsqWeeeUaS1KNHD+3bt0+LFy9WcnKyvd8v50CSoqOjz2krLi5WeHi4cnNzFRUVZV9fVVWlyspK+fv729see+wxPfbYY9YMrJ4IHA3YpZdeqmbNmqmoqMihvaioSOHh4W6qyj0mTZokT09Pvf766+rcubOSkpI0fvx4DRgwQB4eXPtcE2fmLD09XaGhobrlllsucLXuY8Vnq3nz5va/bTabw+uzbWe/jBujus7ZZZddJkkOX4re3t664oorlJub67DPpjxnl112mcMcSFKnTp20atUqh7ZfzkFtbWfnISIiQtnZ2fb17733nlatWqU333zT3hYSEuKaQbgA/1I3YF5eXoqJidGmTZvsbdXV1dq0aVOT/D/y84mIiNCMGTP09ddfKyMjQ15eXho5cqTatm2rRx99VPv376/zvjp16nTO/ylt377d1SW7XX3nzBij9PR03Xnnnef8Y9+pUyft2LHDoa2pzJkrP1sXi7rOWUxMjLy9vZWTk2PftrKyUkeOHFHbtm3dVf4FFxcX5zAHkvT111//5jnw9PRUhw4d7EurVq3UokULhzYCB+osNTVVr732mpYvX64DBw5o8uTJOnXqlCZMmODu0tymb9++WrJkiQoLC/WXv/xF2dnZ6tatm/bu3StJys3NVXZ2tnJzc3XmzBllZ2crOzvbfpvefffdp4MHD2ratGnKycnRihUrtGzZMjeOyHq/NmeS9PHHH+vw4cO6++67z9n+D3/4gzIyMjRv3jwdPHhQL730UpM4nfJLv/WzdTE635wFBgbqvvvu08yZM/XRRx8pJyfHfkvxbbfd5ubKL5ypU6dq+/bteuaZZ3To0CGtWLFCr776qlJSUtxd2oXl7otI8OtefPFF06ZNG+Pl5WV69epltm/f7u6SGpyjR4+akpISY4wxycnJRtI5y+bNm+39165dazp06GC8vb3NddddZ5YuXdrkLhr9NT+fM2N+ujC0b9++tfb/29/+Zlq3bm1atGhhhg0b1qRvi/25+ny2zl4A+fPPUU0XmM6cOdN069btwgzADX4+ZxUVFebhhx82rVq1MgEBAWbgwIFm37599r4Xy5ytXbvWdOnSxXh7e5uOHTvWeJfK/PnzHdokOdylePjwYSPJfP755zW+R0O/aJTH0wMAAMtxSgUAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwC3ueuuuzRixAiX77ewsFCDBg2Sn5+fgoODXb5/APVH4ACaOKu+1OvjyJEjstlsDg+astL8+fNVUFCg7Oxsff311/Xe/k9/+pO6d+/u+sKAixhPiwXQ5HzzzTeKiYnRVVdd5e5SAPwfjnAAF7l9+/ZpyJAh8vf3V1hYmMaPH6///Oc/9vUDBgzQH/7wBz3yyCMKCQlReHi4/vSnPzns46uvvlK/fv3k4+OjqKgobdy4UTabTWvWrJEktW/fXpLUo0cP2Ww2DRgwwGH7efPm6bLLLlNoaKhSUlJUWVl53ppfeeUVXXnllfLy8tI111yjv//97/Z17dq106pVq/T666/LZrPprrvuqnEfW7ZsUa9eveynXeLi4vTtt99q2bJlevLJJ7Vnzx7ZbDbZbDb7w/2ef/55RUdHy8/PT5GRkbr//vvtD247deqUAgMD9e677zq8z5o1a+Tn56eTJ0+ed0xAU0fgAC5iJ06c0I033qgePXpo586dysjIUFFRkUaPHu3Qb/ny5fLz89OOHTs0d+5czZo1Sxs2bJAknTlzRiNGjJCvr6927NihV199VX/84x8dtv/ss88kSRs3blRBQYHee+89+7rNmzfrm2++0ebNm7V8+XItW7bsvE/vXb16tR566CE9/PDD2rdvn+69915NmDBBmzdvliRlZWVp8ODBGj16tAoKCrRgwYJz9lFVVaURI0aof//++uKLL5SZmalJkybJZrNpzJgxevjhh9W5c2cVFBSooKBAY8aMkSR5eHho4cKF2r9/v5YvX66PP/5YjzzyiCTJz89Pt99+u9LT0x3eKz09XaNGjVJAQEBd/pMATZe7nx4HwFrJyclm+PDhNa576qmnTHx8vENbXl6ekWRycnKMMcb079/f9OvXz6HPtddea6ZPn26MMeaDDz4wnp6epqCgwL5+w4YNDk+6rO0pl8nJyaZt27amqqrK3nbbbbeZMWPG1Dqevn37mnvuuceh7bbbbjNDhw61vx4+fLhJTk6udR/ff/+9kWS2bNlS4/q6Ppl05cqVJjQ01P56x44dplmzZiY/P98YY0xRUZHx9PSs9X2AiwlHOICL2J49e7R582b5+/vbl44dO0r66TqIs7p27eqw3WWXXabi4mJJUk5OjiIjIxUeHm5f36tXrzrX0LlzZzVr1qzGfdfkwIEDiouLc2iLi4vTgQMH6vyeISEhuuuuu5SQkKBhw4ZpwYIFKigo+NXtNm7cqJtuukmXX365AgICNH78eH3//ff673//K+mncXfu3FnLly+XJL3xxhtq27atrr/++jrXBjRVBA7gIlZWVqZhw4YpOzvbYTl48KDDl2Tz5s0dtrPZbKqurnZJDVbu+3zS09OVmZmpvn376p133tHVV1+t7du319r/yJEjuvnmm9W1a1etWrVKu3bt0qJFiyRJFRUV9n533323/ZRQenq6JkyYIJvNZulYgMaAwAFcxH73u99p//79ateunTp06OCw+Pn51Wkf11xzjfLy8lRUVGRvy8rKcujj5eUl6afrPX6rTp06aevWrQ5tW7duVVRUVL331aNHD6WlpWnbtm3q0qWLVqxYYa/3l7Xu2rVL1dXVeu6559SnTx9dffXVys/PP2efd9xxh7799lstXLhQX375pZKTk+tdF9AUcVsscBEoKSk55zcwzt4R8tprr2ns2LH2u1AOHTqkt99+W3/9618dTnXUZtCgQbryyiuVnJysuXPn6uTJk5oxY4Yk2f/PvlWrVmrRooUyMjLUunVr+fj4KCgoyKmxTJs2TaNHj1aPHj00cOBArV27Vu+99542btxY530cPnxYr776qm655RZFREQoJydHBw8e1J133inppztdDh8+rOzsbLVu3VoBAQHq0KGDKisr9eKLL2rYsGHaunWrFi9efM6+L7nkEo0cOVLTpk1TfHy8Wrdu7dQ4gaaGIxzARWDLli3q0aOHw/Lkk08qIiJCW7du1ZkzZxQfH6/o6GhNmTJFwcHB8vCo2z8PzZo105o1a1RWVqZrr71Wd999t/0uFR8fH0mSp6enFi5cqCVLligiIkLDhw93eiwjRozQggULNG/ePHXu3FlLlixRenr6Obfano+vr6+++uorJSUl6eqrr9akSZOUkpKie++9V5KUlJSkwYMH64YbblDLli311ltvqVu3bnr++ef17LPPqkuXLnrzzTc1e/bsGvc/ceJEVVRU6H/+53+cHifQ1NiMMcbdRQBoWrZu3ap+/frp0KFDuvLKK91dzgX397//XVOnTlV+fr79dBJwseOUCoDfbPXq1fL399dVV12lQ4cO6aGHHlJcXNxFFzb++9//qqCgQHPmzNG9995L2AB+hlMqAH6zkydPKiUlRR07dtRdd92la6+9Vu+//767y7rg5s6dq44dOyo8PFxpaWnuLgdoUDilAgAALMcRDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABguf8HaRsdSVahY1cAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 600x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "length_of_stay = mc_a_t10['last_submit_time'] - mc_a_t10['first_submit_time']\n", + "agg = {}\n", + "agg['0'] = ((length_of_stay == 0).sum())\n", + "agg['<1d'] = (((length_of_stay > 0) & (length_of_stay < 24*3600)).sum())\n", + "agg['<7d'] = (((length_of_stay >= 24*3600) & (length_of_stay < 7*24*3600)).sum())\n", + "agg['<1m'] = (((length_of_stay >= 7*24*3600) & (length_of_stay < 30*24*3600)).sum())\n", + "agg['<6m'] = (((length_of_stay >= 30*24*3600) & (length_of_stay < 6*30*24*3600)).sum())\n", + "agg['6m+'] = (((length_of_stay >= 6*30*24*3600)).sum())\n", + "\n", + "fig, ax = plt.subplots()\n", + "fig.set_size_inches(6,3)\n", + "ax.bar(agg.keys(), agg.values(), width=.5)\n", + "ax.set_xlabel(\"Length of stay\")\n", + "ax.set_ylabel(\"#users\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Distribution of session lengths (log: Metacentrum, delimitation: Arrival)')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x1000 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(4, gridspec_kw={'height_ratios': [3,1,1,3]}, figsize=[15,10])\n", + "multi_plot_distri_length(\n", + " [mc_a_t10, mc_a_t20, mc_a_t60],\n", + " [\"10mn\", \"20mn\", \"60mn\"],\n", + " ax\n", + ")\n", + "ax[0].set_title(\"Distribution of session lengths (log: Metacentrum, delimitation: Arrival)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Workload Metacentrum_EuroPar\n", + "\n", + "The workload used in the article Madon et al. 2022.\n", + "\n", + "Do the session analysis:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[KProcessing swf line 1600000\n", + "SWF parsing done.\n", + "Number of users: 546\n", + "Number of sessions: 44799\n", + "The output files have been stored in the folder out/mc_europar_a10\n", + "\u001b[KProcessing swf line 1600000\n", + "SWF parsing done.\n", + "Number of users: 546\n", + "Number of sessions: 34701\n", + "The output files have been stored in the folder out/mc_europar_a20\n", + "\u001b[KProcessing swf line 1600000\n", + "SWF parsing done.\n", + "Number of users: 546\n", + "Number of sessions: 23638\n", + "The output files have been stored in the folder out/mc_europar_a60\n" + ] + } + ], + "source": [ + "input_swf = 'workloads/MC_EuroPar.swf'\n", + "\n", + "for threshold in [10, 20, 60]:\n", + " out_dir = f'out/mc_europar_a{threshold}'\n", + " ! ./swf2userSessions.py {input_swf} {out_dir} \\\n", + " --arrival {threshold} --session_stat --no_SABjson_output" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC_EuroPar_arrival_t10:\n", + " Makespan: 237.00 days\n", + " Length: 183.04 days\n", + " #users: 546\n", + " #sessions: 44799\n", + " Sessions/user: avg:82 (min:1, med:18, max:2837)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC_EuroPar_arrival_t20:\n", + " Makespan: 237.00 days\n", + " Length: 183.04 days\n", + " #users: 546\n", + " #sessions: 34701\n", + " Sessions/user: avg:64 (min:1, med:15, max:1922)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC_EuroPar_arrival_t60:\n", + " Makespan: 237.00 days\n", + " Length: 183.04 days\n", + " #users: 546\n", + " #sessions: 23638\n", + " Sessions/user: avg:43 (min:1, med:12, max:763)\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x100 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mc_a_t10 = pd.read_json('out/mc_europar_a10_session_stat.json', orient='index', convert_dates=False)\n", + "mc_a_t20 = pd.read_json('out/mc_europar_a20_session_stat.json', orient='index', convert_dates=False)\n", + "mc_a_t60 = pd.read_json('out/mc_europar_a60_session_stat.json', orient='index', convert_dates=False)\n", + "\n", + "print(\"MC_EuroPar_arrival_t10:\")\n", + "print_general_stats(mc_a_t10)\n", + "print(\"MC_EuroPar_arrival_t20:\")\n", + "print_general_stats(mc_a_t20)\n", + "print(\"MC_EuroPar_arrival_t60:\")\n", + "print_general_stats(mc_a_t60)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAAEmCAYAAAAp90kqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsNElEQVR4nO3de1hVZf7//9cG5CgbAgUkES0zQPHw9YhYWSl4yDIxzUzRsSwHm1Eac2iczOoTZnayLGtmQpuJMjPt0ibKs5OiKX7IQ0bqZWFyaixBLQHl/v3Rx/1rJxgQy434fFzXui7Wve611nvd7cv9ah32shljjAAAACzk5uoCAABA00fgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYzsPVBTQGVVVVKigokL+/v2w2m6vLAQDgkmGM0YkTJxQeHi43t5rPYxA4JBUUFCgiIsLVZQAAcMk6cuSIWrduXeNyAockf39/ST8Nlt1ud3E1AABcOsrKyhQREeH4Lq0JgUNyXEax2+0EDgAA6uHXbkngplEAAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHL88BcA4ILa/vkDV5dQo6/mDnV1CaglznAAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIuDRyvvPKKOnfuLLvdLrvdrri4OH344YeO5adPn1ZKSoqCg4PVvHlzJSUlqbi42Gkb+fn5Gjp0qHx9fRUSEqIZM2bozJkzF/tQAADABbg0cLRu3Vpz585VTk6Odu7cqZtuukm33Xab9u3bJ0maPn26Vq1apWXLlmnTpk0qKCjQiBEjHOufPXtWQ4cOVUVFhbZu3aolS5Zo8eLFeuSRR1x1SAAAoBo2Y4xxdRE/FxQUpKefflojR45Uy5YtlZmZqZEjR0qSvvjiC0VHRys7O1t9+vTRhx9+qFtuuUUFBQUKDQ2VJC1atEgzZ87Ut99+K09Pz1rts6ysTAEBASotLZXdbrfs2ADgUsTbYnEhtf0ObTT3cJw9e1Zvv/22Tp06pbi4OOXk5KiyslIDBgxw9ImKilKbNm2UnZ0tScrOzlZsbKwjbEhSYmKiysrKHGdJAACA63m4uoA9e/YoLi5Op0+fVvPmzbVixQrFxMQoNzdXnp6eCgwMdOofGhqqoqIiSVJRUZFT2Di3/NyympSXl6u8vNwxX1ZW1kBHAwAAquPyMxzXXnutcnNztX37dk2ZMkXJycn6/PPPLd1nenq6AgICHFNERISl+wMA4HLn8sDh6emp9u3bq3v37kpPT1eXLl30wgsvKCwsTBUVFTp+/LhT/+LiYoWFhUmSwsLCzntq5dz8uT7VSUtLU2lpqWM6cuRIwx4UAABw4vLA8UtVVVUqLy9X9+7d1axZM61bt86xLC8vT/n5+YqLi5MkxcXFac+ePSopKXH0WbNmjex2u2JiYmrch5eXl+NR3HMTAACwjkvv4UhLS9PgwYPVpk0bnThxQpmZmdq4caM++ugjBQQEaNKkSUpNTVVQUJDsdrseeOABxcXFqU+fPpKkhIQExcTEaNy4cZo3b56Kioo0a9YspaSkyMvLy5WHBgAAfsalgaOkpETjx49XYWGhAgIC1LlzZ3300UcaOHCgJOm5556Tm5ubkpKSVF5ersTERL388suO9d3d3bV69WpNmTJFcXFx8vPzU3Jysh577DFXHRIAAKhGo/sdDlfgdzgAoGb8Dgcu5JL7HQ4AANB0ETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAs59LAkZ6erp49e8rf318hISEaPny48vLynPr0799fNpvNabr//vud+uTn52vo0KHy9fVVSEiIZsyYoTNnzlzMQwEAABfg4cqdb9q0SSkpKerZs6fOnDmjhx9+WAkJCfr888/l5+fn6Hfvvffqsccec8z7+vo6/j579qyGDh2qsLAwbd26VYWFhRo/fryaNWumJ5988qIeDwAAqJ5LA0dWVpbT/OLFixUSEqKcnBxdf/31jnZfX1+FhYVVu42PP/5Yn3/+udauXavQ0FB17dpVjz/+uGbOnKlHH31Unp6elh4DAAD4dY3qHo7S0lJJUlBQkFP7m2++qRYtWqhTp05KS0vTDz/84FiWnZ2t2NhYhYaGOtoSExNVVlamffv2Vbuf8vJylZWVOU0AAMA6Lj3D8XNVVVWaNm2a4uPj1alTJ0f7XXfdpcjISIWHh2v37t2aOXOm8vLy9N5770mSioqKnMKGJMd8UVFRtftKT0/XnDlzLDoSAADwS40mcKSkpGjv3r365JNPnNonT57s+Ds2NlatWrXSzTffrEOHDunqq6+u177S0tKUmprqmC8rK1NERET9CgcAAL+qUVxSmTp1qlavXq0NGzaodevWF+zbu3dvSdLBgwclSWFhYSouLnbqc26+pvs+vLy8ZLfbnSYAAGAdlwYOY4ymTp2qFStWaP369WrXrt2vrpObmytJatWqlSQpLi5Oe/bsUUlJiaPPmjVrZLfbFRMTY0ndAACgblx6SSUlJUWZmZl6//335e/v77jnIiAgQD4+Pjp06JAyMzM1ZMgQBQcHa/fu3Zo+fbquv/56de7cWZKUkJCgmJgYjRs3TvPmzVNRUZFmzZqllJQUeXl5ufLwAADA/3HpGY5XXnlFpaWl6t+/v1q1auWYli5dKkny9PTU2rVrlZCQoKioKD344INKSkrSqlWrHNtwd3fX6tWr5e7urri4ON19990aP3680+92AAAA13LpGQ5jzAWXR0REaNOmTb+6ncjISP373/9uqLIAAEADaxQ3jQIAgKaNwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5lwaO9PR09ezZU/7+/goJCdHw4cOVl5fn1Of06dNKSUlRcHCwmjdvrqSkJBUXFzv1yc/P19ChQ+Xr66uQkBDNmDFDZ86cuZiHAgAALsClgWPTpk1KSUnRtm3btGbNGlVWViohIUGnTp1y9Jk+fbpWrVqlZcuWadOmTSooKNCIESMcy8+ePauhQ4eqoqJCW7du1ZIlS7R48WI98sgjrjgkAABQDZsxxri6iHO+/fZbhYSEaNOmTbr++utVWlqqli1bKjMzUyNHjpQkffHFF4qOjlZ2drb69OmjDz/8ULfccosKCgoUGhoqSVq0aJFmzpypb7/9Vp6enr+637KyMgUEBKi0tFR2u93SYwSAS03bP3/g6hJq9NXcoa4u4bJX2+/QBjnDUVZWppUrV2r//v2/aTulpaWSpKCgIElSTk6OKisrNWDAAEefqKgotWnTRtnZ2ZKk7OxsxcbGOsKGJCUmJqqsrEz79u2rdj/l5eUqKytzmgAAgHXqFThGjRqll156SZL0448/qkePHho1apQ6d+6s5cuX16uQqqoqTZs2TfHx8erUqZMkqaioSJ6engoMDHTqGxoaqqKiIkefn4eNc8vPLatOenq6AgICHFNERES9agYAALVTr8CxefNmXXfddZKkFStWyBij48ePa8GCBXriiSfqVUhKSor27t2rt99+u17r10VaWppKS0sd05EjRyzfJwAAl7N6BY7S0lLHZY+srCwlJSXJ19dXQ4cO1YEDB+q8valTp2r16tXasGGDWrdu7WgPCwtTRUWFjh8/7tS/uLhYYWFhjj6/fGrl3Py5Pr/k5eUlu93uNAEAAOvUK3BEREQoOztbp06dUlZWlhISEiRJ33//vby9vWu9HWOMpk6dqhUrVmj9+vVq166d0/Lu3burWbNmWrdunaMtLy9P+fn5iouLkyTFxcVpz549KikpcfRZs2aN7Ha7YmJi6nN4AACggXnUZ6Vp06Zp7Nixat68uSIjI9W/f39JP11qiY2NrfV2UlJSlJmZqffff1/+/v6Oey4CAgLk4+OjgIAATZo0SampqQoKCpLdbtcDDzyguLg49enTR5KUkJCgmJgYjRs3TvPmzVNRUZFmzZqllJQUeXl51efwAABAA6v3Y7E5OTnKz8/XwIED1bx5c0nSBx98oMDAQMXHx9du5zZbte0ZGRmaMGGCpJ9++OvBBx/UW2+9pfLyciUmJurll192ulzy9ddfa8qUKdq4caP8/PyUnJysuXPnysOjdnmKx2IBoGY8FosLqe13aJ0DR2VlpaKiorR69WpFR0f/5kIbAwIHANSMwIELsex3OJo1a6bTp0//puIAAMDlpV43jaakpOipp57ifSUAAKBW6nXT6I4dO7Ru3Tp9/PHHio2NlZ+fn9Py9957r0GKAwAATUO9AkdgYKCSkpIauhYAANBE1StwZGRkNHQdAACgCav3y9vOnDmjtWvX6tVXX9WJEyckSQUFBTp58mSDFQcAAJqGep3h+PrrrzVo0CDl5+ervLxcAwcOlL+/v5566imVl5dr0aJFDV0nAAC4hNXrDMcf//hH9ejRQ99//718fHwc7bfffrvTz5ADAABI9TzD8Z///Edbt26Vp6enU3vbtm119OjRBikMAAA0HfU6w1FVVaWzZ8+e1/7NN9/I39//NxcFAACalnoFjoSEBD3//POOeZvNppMnT2r27NkaMmRIQ9UGAACaiHpdUnnmmWeUmJiomJgYnT59WnfddZcOHDigFi1a6K233mroGgEAwCWuXoGjdevW+uyzz7R06VJ99tlnOnnypCZNmqSxY8c63UQKAAAg1TNwSJKHh4fGjh2rsWPHNmQ9AACgCarXPRxLlizRBx/8/68rfuihhxQYGKi+ffvq66+/brDiAABA01CvwPHkk086Lp1kZ2frpZde0rx589SiRQtNnz69QQsEAACXvnpdUjly5Ijat28vSVq5cqVGjhypyZMnKz4+Xv3792/I+gAAQBNQrzMczZs317FjxyRJH3/8sQYOHChJ8vb21o8//thw1QEAgCahXmc4Bg4cqHvuuUfdunXTl19+6fjtjX379qlt27YNWR8AAGgC6nWGY+HChYqLi9O3336r5cuXKzg4WJKUk5OjMWPGNGiBAADg0levMxyBgYF66aWXzmufM2fOby4IAAA0PfUKHJs3b77g8uuvv75exQAAgKapXoGjuidRbDab4+/qXuwGAAAuX/W6h+P77793mkpKSpSVlaWePXvq448/rvV2Nm/erGHDhik8PFw2m00rV650Wj5hwgTZbDanadCgQU59vvvuO40dO1Z2u12BgYGaNGmSTp48WZ/DAgAAFqnXGY6AgIDz2gYOHChPT0+lpqYqJyenVts5deqUunTpot/97ncaMWJEtX0GDRqkjIwMx7yXl5fT8rFjx6qwsFBr1qxRZWWlJk6cqMmTJyszM7MORwQAAKxU73epVCc0NFR5eXm17j948GANHjz4gn28vLwUFhZW7bL9+/crKytLO3bsUI8ePSRJL774ooYMGaL58+crPDy89sUDAADL1Ctw7N6922neGKPCwkLNnTtXXbt2bYi6HDZu3KiQkBBdccUVuummm/TEE084HsPNzs5WYGCgI2xI0oABA+Tm5qbt27fr9ttvr3ab5eXlKi8vd8yXlZU1aM0AAMBZvQJH165dZbPZZIxxau/Tp49ef/31BilM+ulyyogRI9SuXTsdOnRIDz/8sAYPHqzs7Gy5u7urqKhIISEhTut4eHgoKChIRUVFNW43PT2dR3gBALiI6hU4Dh8+7DTv5uamli1bytvbu0GKOufOO+90/B0bG6vOnTvr6quv1saNG3XzzTfXe7tpaWlKTU11zJeVlSkiIuI31QoAAGpWr6dUIiMj9fTTT8vf31+RkZGKiIho8LBRnauuukotWrTQwYMHJUlhYWEqKSlx6nPmzBl99913Nd73If10X4jdbneaAACAdeoUOL755hvH35mZmY7HT2NjY3XkyJGGrayG/R87dkytWrWSJMXFxen48eNOT8WsX79eVVVV6t27t+X1AACA2qnTJZWoqCgFBwcrPj5ep0+f1pEjR9SmTRt99dVXqqysrPPOT5486ThbIf10qSY3N1dBQUEKCgrSnDlzlJSUpLCwMB06dEgPPfSQ2rdvr8TERElSdHS0Bg0apHvvvVeLFi1SZWWlpk6dqjvvvJMnVAAAaETqdIbj+PHjWrZsmbp3766qqioNGTJEHTp0UHl5uT766CMVFxfXaec7d+5Ut27d1K1bN0lSamqqunXrpkceeUTu7u7avXu3br31VnXo0EGTJk1S9+7d9Z///MfptzjefPNNRUVF6eabb9aQIUPUr18/vfbaa3WqAwAAWMtmfvmoyQX8+OOP8vHxkSRdccUVysnJUWFhoQYMGKBOnTpp3759ioiIqNNvcTQGZWVlCggIUGlpKfdzAMAvtP3zB64uoUZfzR3q6hIue7X9Dq3TJZXAwEB17dpV8fHxqqio0I8//qj4+Hh5eHho6dKluvLKK7Vjx47fXDwAAGha6nRJ5ejRo5o1a5a8vLx05swZde/eXdddd50qKiq0a9cu2Ww29evXz6paAQDAJapOgaNFixYaNmyY0tPT5evrqx07duiBBx6QzWbTn/70JwUEBOiGG26wqlYAAHCJqtfvcJwTEBCgUaNGqVmzZlq/fr0OHz6s3//+9w1VGwAAaCLq/fK23bt368orr5T00w+BNWvWTGFhYRo9enSDFQcAAJqGegeOn/8U+N69exukGAAA0DT9pksqAAAAtUHgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACzn0sCxefNmDRs2TOHh4bLZbFq5cqXTcmOMHnnkEbVq1Uo+Pj4aMGCADhw44NTnu+++09ixY2W32xUYGKhJkybp5MmTF/EoAADAr3Fp4Dh16pS6dOmihQsXVrt83rx5WrBggRYtWqTt27fLz89PiYmJOn36tKPP2LFjtW/fPq1Zs0arV6/W5s2bNXny5It1CAAAoBY8XLnzwYMHa/DgwdUuM8bo+eef16xZs3TbbbdJkt544w2FhoZq5cqVuvPOO7V//35lZWVpx44d6tGjhyTpxRdf1JAhQzR//nyFh4dftGMBAAA1a7T3cBw+fFhFRUUaMGCAoy0gIEC9e/dWdna2JCk7O1uBgYGOsCFJAwYMkJubm7Zv317jtsvLy1VWVuY0AQAA6zTawFFUVCRJCg0NdWoPDQ11LCsqKlJISIjTcg8PDwUFBTn6VCc9PV0BAQGOKSIiooGrBwAAP9doA4eV0tLSVFpa6piOHDni6pIAAGjSGm3gCAsLkyQVFxc7tRcXFzuWhYWFqaSkxGn5mTNn9N133zn6VMfLy0t2u91pAgAA1mm0gaNdu3YKCwvTunXrHG1lZWXavn274uLiJElxcXE6fvy4cnJyHH3Wr1+vqqoq9e7d+6LXDAAAqufSp1ROnjypgwcPOuYPHz6s3NxcBQUFqU2bNpo2bZqeeOIJXXPNNWrXrp3++te/Kjw8XMOHD5ckRUdHa9CgQbr33nu1aNEiVVZWaurUqbrzzjt5QgUAgEbEpYFj586duvHGGx3zqampkqTk5GQtXrxYDz30kE6dOqXJkyfr+PHj6tevn7KysuTt7e1Y580339TUqVN18803y83NTUlJSVqwYMFFPxYAAFAzmzHGuLoIVysrK1NAQIBKS0u5nwMAfqHtnz9wdQk1+mruUFeXcNmr7Xdoo72HAwAANB0EDgAAYDkCBwAAsByBAwAAWI7AAQAALEfgAAAAliNwAAAAyxE4AACA5QgcAADAcgQOAABgOQIHAACwHIEDAABYjsABAAAsR+AAAACWI3AAAADLETgAAIDlPFxdAABcTG3//IGrS6jRV3OHuroEwDKc4QAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsFyjDhyPPvqobDab0xQVFeVYfvr0aaWkpCg4OFjNmzdXUlKSiouLXVgxAACoTqMOHJLUsWNHFRYWOqZPPvnEsWz69OlatWqVli1bpk2bNqmgoEAjRoxwYbUAAKA6jf6Hvzw8PBQWFnZee2lpqf7xj38oMzNTN910kyQpIyND0dHR2rZtm/r06XOxS0UDaKw/ysQPMgHAb9Poz3AcOHBA4eHhuuqqqzR27Fjl5+dLknJyclRZWakBAwY4+kZFRalNmzbKzs6+4DbLy8tVVlbmNAEAAOs06sDRu3dvLV68WFlZWXrllVd0+PBhXXfddTpx4oSKiork6empwMBAp3VCQ0NVVFR0we2mp6crICDAMUVERFh4FAAAoFFfUhk8eLDj786dO6t3796KjIzUO++8Ix8fn3pvNy0tTampqY75srIyQgcAABZq1Gc4fikwMFAdOnTQwYMHFRYWpoqKCh0/ftypT3FxcbX3fPycl5eX7Ha70wQAAKxzSQWOkydP6tChQ2rVqpW6d++uZs2aad26dY7leXl5ys/PV1xcnAurBAAAv9SoL6n86U9/0rBhwxQZGamCggLNnj1b7u7uGjNmjAICAjRp0iSlpqYqKChIdrtdDzzwgOLi4nhCBZcVnuwBcClo1IHjm2++0ZgxY3Ts2DG1bNlS/fr107Zt29SyZUtJ0nPPPSc3NzclJSWpvLxciYmJevnll11cNQAA+KVGHTjefvvtCy739vbWwoULtXDhwotUEQAAqI9GHTgudZzqBgDgJ5fUTaMAAODSROAAAACWI3AAAADLETgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHK8LRYAgAbWWN8WLrnujeGc4QAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBAwAAWI7AAQAALNdkAsfChQvVtm1beXt7q3fv3vr0009dXRIAAPg/TSJwLF26VKmpqZo9e7Z27dqlLl26KDExUSUlJa4uDQAAqIkEjmeffVb33nuvJk6cqJiYGC1atEi+vr56/fXXXV0aAABQE3iXSkVFhXJycpSWluZoc3Nz04ABA5SdnV3tOuXl5SovL3fMl5aWSpLKysoatLaq8h8adHsNpaGPsyExZnXHmNVNYx0viTGrD8as7hp6zM5tzxhz4Y7mEnf06FEjyWzdutWpfcaMGaZXr17VrjN79mwjiYmJiYmJiamBpiNHjlzw+/qSP8NRH2lpaUpNTXXMV1VV6bvvvlNwcLBsNpsLK6teWVmZIiIidOTIEdntdleXc0lgzOqOMas7xqxuGK+6uxTGzBijEydOKDw8/IL9LvnA0aJFC7m7u6u4uNipvbi4WGFhYdWu4+XlJS8vL6e2wMBAq0psMHa7vdF+4BorxqzuGLO6Y8zqhvGqu8Y+ZgEBAb/a55K/adTT01Pdu3fXunXrHG1VVVVat26d4uLiXFgZAAA455I/wyFJqampSk5OVo8ePdSrVy89//zzOnXqlCZOnOjq0gAAgJpI4Bg9erS+/fZbPfLIIyoqKlLXrl2VlZWl0NBQV5fWILy8vDR79uzzLgOhZoxZ3TFmdceY1Q3jVXdNacxsxvzacywAAAC/zSV/DwcAAGj8CBwAAMByBA4AAGA5AgcgaePGjbLZbDp+/LirS7lkLF68+JL4/RoAjQOB4xKwcOFCtW3bVt7e3urdu7c+/fRTV5fUqP3P//yP+vbtK19fX74Qa+Fc2Kpu2rFjh6vLa1T4bNXPBx98oN69e8vHx0dXXHGFhg8f7uqSLrqjR4/q7rvvVnBwsHx8fBQbG6udO3e6uqyLisDRyC1dulSpqamaPXu2du3apS5duigxMVElJSWuLq1R+f7773Xy5ElJP73Q74477tCUKVNcXFXjdm7M+vbtq8LCQqfpnnvuUbt27dSjRw9Xl+lyfLbq7udjtnz5co0bN04TJ07UZ599pi1btuiuu+5ycYUX1/fff6/4+Hg1a9ZMH374oT7//HM988wzuuKKKxp0P4sXL1b//v0bdJsNqmFeoQar9OrVy6SkpDjmz549a8LDw016eroLq2ocKisrzerVq83IkSONl5eXyc3NdVqekZFhAgICql33gw8+MNdcc43x9vY2/fv3NxkZGUaS+f77760v3IV+bcyMMaaiosK0bNnSPPbYY07tGRkZJiIiwvj4+Jjhw4eb+fPn1zi+l7r6frY2bNhgJJmsrCzTtWtX4+3tbW688UZTXFxs/v3vf5uoqCjj7+9vxowZY06dOnWRjubiqG7MKisrzZVXXmn+/ve/17je5TBmM2fONP369btgn8jISPP444+bcePGGT8/P9OmTRvz/vvvm5KSEnPrrbcaPz8/Exsba3bs2FHjNjIyMswNN9zQwNU3HAJHI1ZeXm7c3d3NihUrnNrHjx9vbr31VtcU1Qjs3r3bpKammtDQUBMUFGSmTJly3tuCjan5SyE/P994eXmZ1NRU88UXX5h//etfJjQ0tEkHjtqOmTHGvPvuu8bNzc3pzY/btm0zbm5u5qmnnjJ5eXnmhRdeMIGBgU0ucPzWz9a5L88+ffqYTz75xOzatcu0b9/e3HDDDSYhIcHs2rXLbN682QQHB5u5c+dehCOy3oXGbPv27UaSef31103Xrl1NWFiYGTRokNmzZ49j/cthzKKjo820adPMyJEjTcuWLU3Xrl3Na6+95tQnMjLSBAUFmUWLFpkvv/zSTJkyxdjtdjNo0CDzzjvvmLy8PDN8+HATHR1tqqqqqt0PgQP1dvToUSPpvH/wZsyYYXr16uWiqlzjv//9r3n++edNt27djKenpxk+fLhZvny5KS8vr3Gdmr4U0tLSTExMjFPbzJkzm1zgqM+YGWPM4MGDzeDBg53axowZY4YMGeLUNnr06CYROBrys3Xuy3Pt2rWOtvT0dCPJHDp0yNF23333mcTExAY9jouptmP21ltvGUmmTZs25t133zU7d+40Y8aMMcHBwebYsWPGmMtjzLy8vIyXl5dJS0szu3btMq+++qrx9vY2ixcvdvSJjIw0d999t2O+sLDQSDJ//etfHW3Z2dlGkiksLKx2P409cDSJnzZH0/fiiy9qzpw5uu6663Tw4EFFRETUe1v79+9X7969ndqa4ov+6jNm33zzjT766CO98847Tu379+/X7bff7tQWFxenrKysBq3ZFRrys3VO586dHX+HhobK19dXV111lVPbpXzzd23HrKqqSpL0l7/8RUlJSZKkjIwMtW7dWsuWLdN9993n6NuUx6yqqko9evTQk08+KUnq1q2b9u7dq0WLFik5OdnR75djIEmxsbHntZWUlCgsLEz5+fmKiYlxLD9z5owqKyvVvHlzR9vDDz+shx9+2JoDqyMCRyPWokULubu7q7i42Km9uLhYYWFhLqrKNSZPniwPDw+98cYb6tixo5KSkjRu3Dj1799fbm7c+1yd+oxZRkaGgoODdeutt17kal3His9Ws2bNHH/bbDan+XNt576ML0W1HbNWrVpJktOXopeXl6666irl5+c7bbMpj1mrVq2cxkCSoqOjtXz5cqe2X45BTW3nxiE8PFy5ubmO5e+9956WL1+uN99809EWFBTUMAfRAPiXuhHz9PRU9+7dtW7dOkdbVVWV1q1b1yT/j/xCwsPDNWvWLH355ZfKysqSp6enRowYocjISP35z3/Wvn37ar2t6Ojo8/5Padu2bQ1dssvVdcyMMcrIyND48ePP+8c+Ojpa27dvd2prKmPWkJ+ty0Vtx6x79+7y8vJSXl6eY93Kykp99dVXioyMdFX5F118fLzTGEjSl19++ZvHwMPDQ+3bt3dMISEh8vHxcWojcKDWUlNT9be//U1LlizR/v37NWXKFJ06dUoTJ050dWku07dvX7366qsqKirS008/rdzcXHXp0kV79uyRJOXn5ys3N1f5+fk6e/ascnNzlZub63hM7/7779eBAwc0Y8YM5eXlKTMzU4sXL3bhEVnv18ZMktavX6/Dhw/rnnvuOW/9P/zhD8rKytL8+fN14MABvfTSS03icsov/dbP1uXoQmNmt9t1//33a/bs2fr444+Vl5fneKT4jjvucHHlF8/06dO1bds2Pfnkkzp48KAyMzP12muvKSUlxdWlXVyuvokEv+7FF180bdq0MZ6enqZXr15m27Ztri6p0Tl69KgpLS01xhiTnJxsJJ03bdiwwdF/1apVpn379sbLy8tcd9115vXXX29yN43+mp+PmTE/3Rjat2/fGvv/4x//MK1btzY+Pj5m2LBhTfqx2J+ry2fr3A2QP/8cVXeD6ezZs02XLl0uzgG4wM/HrKKiwjz44IMmJCTE+Pv7mwEDBpi9e/c6+l4uY7Zq1SrTqVMn4+XlZaKioqp9SuW5555zapPk9JTi4cOHjSTzv//7v9Xuo7HfNMrr6QEAgOW4pAIAACxH4AAAAJYjcAAAAMsROAAAgOUIHAAAwHIEDgAAYDkCBwAAsByBA4DLTJgwQcOHD2/w7RYVFWngwIHy8/NTYGBgg28fQN0ROIAmzqov9br46quvZLPZnF40ZaXnnntOhYWFys3N1Zdfflnn9R999FF17dq14QsDLmO8LRZAk3Po0CF1795d11xzjatLAfB/OMMBXOb27t2rwYMHq3nz5goNDdW4ceP03//+17G8f//++sMf/qCHHnpIQUFBCgsL06OPPuq0jS+++EL9+vWTt7e3YmJitHbtWtlsNq1cuVKS1K5dO0lSt27dZLPZ1L9/f6f158+fr1atWik4OFgpKSmqrKy8YM2vvPKKrr76anl6euraa6/VP//5T8eytm3bavny5XrjjTdks9k0YcKEarexceNG9erVy3HZJT4+Xl9//bUWL16sOXPm6LPPPpPNZpPNZnO83O/ZZ59VbGys/Pz8FBERod///veOF7edOnVKdrtd7777rtN+Vq5cKT8/P504ceKCxwQ0dQQO4DJ2/Phx3XTTTerWrZt27typrKwsFRcXa9SoUU79lixZIj8/P23fvl3z5s3TY489pjVr1kiSzp49q+HDh8vX11fbt2/Xa6+9pr/85S9O63/66aeSpLVr16qwsFDvvfeeY9mGDRt06NAhbdiwQUuWLNHixYsv+PbeFStW6I9//KMefPBB7d27V/fdd58mTpyoDRs2SJJ27NihQYMGadSoUSosLNQLL7xw3jbOnDmj4cOH64YbbtDu3buVnZ2tyZMny2azafTo0XrwwQfVsWNHFRYWqrCwUKNHj5Ykubm5acGCBdq3b5+WLFmi9evX66GHHpIk+fn56c4771RGRobTvjIyMjRy5Ej5+/vX5j8J0HS5+u1xAKyVnJxsbrvttmqXPf744yYhIcGp7ciRI0aSycvLM8YYc8MNN5h+/fo59enZs6eZOXOmMcaYDz/80Hh4eJjCwkLH8jVr1ji96bKmt1wmJyebyMhIc+bMGUfbHXfcYUaPHl3j8fTt29fce++9Tm133HGHGTJkiGP+tttuM8nJyTVu49ixY0aS2bhxY7XLa/tm0mXLlpng4GDH/Pbt2427u7spKCgwxhhTXFxsPDw8atwPcDnhDAdwGfvss8+0YcMGNW/e3DFFRUVJ+uk+iHM6d+7stF6rVq1UUlIiScrLy1NERITCwsIcy3v16lXrGjp27Ch3d/dqt12d/fv3Kz4+3qktPj5e+/fvr/U+g4KCNGHCBCUmJmrYsGF64YUXVFhY+KvrrV27VjfffLOuvPJK+fv7a9y4cTp27Jh++OEHST8dd8eOHbVkyRJJ0r/+9S9FRkbq+uuvr3VtQFNF4AAuYydPntSwYcOUm5vrNB04cMDpS7JZs2ZO69lsNlVVVTVIDVZu+0IyMjKUnZ2tvn37aunSperQoYO2bdtWY/+vvvpKt9xyizp37qzly5crJydHCxculCRVVFQ4+t1zzz2OS0IZGRmaOHGibDabpccCXAoIHMBl7P/9v/+nffv2qW3btmrfvr3T5OfnV6ttXHvttTpy5IiKi4sdbTt27HDq4+npKemn+z1+q+joaG3ZssWpbcuWLYqJianztrp166a0tDRt3bpVnTp1UmZmpqPeX9aak5OjqqoqPfPMM+rTp486dOiggoKC87Z599136+uvv9aCBQv0+eefKzk5uc51AU0Rj8UCl4HS0tLzfgPj3BMhf/vb3zRmzBjHUygHDx7U22+/rb///e9OlzpqMnDgQF199dVKTk7WvHnzdOLECc2aNUuSHP9nHxISIh8fH2VlZal169by9vZWQEBAvY5lxowZGjVqlLp166YBAwZo1apVeu+997R27dpab+Pw4cN67bXXdOuttyo8PFx5eXk6cOCAxo8fL+mnJ10OHz6s3NxctW7dWv7+/mrfvr0qKyv14osvatiwYdqyZYsWLVp03ravuOIKjRgxQjNmzFBCQoJat25dr+MEmhrOcACXgY0bN6pbt25O05w5cxQeHq4tW7bo7NmzSkhIUGxsrKZNm6bAwEC5udXunwd3d3etXLlSJ0+eVM+ePXXPPfc4nlLx9vaWJHl4eGjBggV69dVXFR4erttuu63exzJ8+HC98MILmj9/vjp27KhXX31VGRkZ5z1qeyG+vr764osvlJSUpA4dOmjy5MlKSUnRfffdJ0lKSkrSoEGDdOONN6ply5Z666231KVLFz377LN66qmn1KlTJ7355ptKT0+vdvuTJk1SRUWFfve739X7OIGmxmaMMa4uAkDTsmXLFvXr108HDx7U1Vdf7epyLrp//vOfmj59ugoKChyXk4DLHZdUAPxmK1asUPPmzXXNNdfo4MGD+uMf/6j4+PjLLmz88MMPKiws1Ny5c3XfffcRNoCf4ZIKgN/sxIkTSklJUVRUlCZMmKCePXvq/fffd3VZF928efMUFRWlsLAwpaWlubocoFHhkgoAALAcZzgAAIDlCBwAAMByBA4AAGA5AgcAALAcgQMAAFiOwAEAACxH4AAAAJYjcAAAAMsROAAAgOX+P33ZponhGiJrAAAAAElFTkSuQmCC", + "text/plain": [ + "<Figure size 600x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "length_of_stay = mc_a_t10['last_submit_time'] - mc_a_t10['first_submit_time']\n", + "agg = {}\n", + "agg['0'] = ((length_of_stay == 0).sum())\n", + "agg['<1d'] = (((length_of_stay > 0) & (length_of_stay < 24*3600)).sum())\n", + "agg['<7d'] = (((length_of_stay >= 24*3600) & (length_of_stay < 7*24*3600)).sum())\n", + "agg['<1m'] = (((length_of_stay >= 7*24*3600) & (length_of_stay < 30*24*3600)).sum())\n", + "agg['<6m'] = (((length_of_stay >= 30*24*3600) & (length_of_stay < 6*30*24*3600)).sum())\n", + "agg['6m+'] = (((length_of_stay >= 6*30*24*3600)).sum())\n", + "\n", + "fig, ax = plt.subplots()\n", + "fig.set_size_inches(6,3)\n", + "ax.bar(agg.keys(), agg.values(), width=.5)\n", + "ax.set_xlabel(\"Length of stay\")\n", + "ax.set_ylabel(\"#users\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Distribution of session lengths (log: Metacentrum, delimitation: Arrival)')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1500x1000 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(4, gridspec_kw={'height_ratios': [3,1,1,3]}, figsize=[15,10])\n", + "multi_plot_distri_length(\n", + " [mc_a_t10, mc_a_t20, mc_a_t60],\n", + " [\"10mn\", \"20mn\", \"60mn\"],\n", + " ax\n", + ")\n", + "ax[0].set_title(\"Distribution of session lengths (log: Metacentrum, delimitation: Arrival)\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}