infra.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Infrastructure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Partie 1 : Downloading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import requests\n",
    "from urllib import request\n",
    "import gzip, shutil\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "os.environ[\"SPARK_HOME\"] = \"/opt/spark\"\n",
    "os.environ[\"PYSPARK_PYTHON\"]=\"/home/mocmoc/anaconda3/bin/python3\"\n",
    "\n",
    "def extract_file(url: str) -> list[str]:\n",
    "    file_list = []\n",
    "    trace_xml = requests.get(url)\n",
    "    trace_filenames = re.findall(r'<Key>(.*?)</Key>', trace_xml.text)\n",
    "    for trace_filename in trace_filenames:\n",
    "        file_list.append(f\"{url}/{trace_filename}\")\n",
    "    return file_list\n",
    "\n",
    "\n",
    "def download_url(trace_url: str) -> str:\n",
    "    trace_filename = f\"{trace_url.split('/')[-2]}_{trace_url.split('/')[-1]}\"\n",
    "    if os.path.exists(trace_filename) or os.path.exists(trace_filename.replace(\".gz\", \"\")):\n",
    "        try:\n",
    "            os.remove(trace_filename)\n",
    "        except:\n",
    "            pass\n",
    "        return\n",
    "    \n",
    "    print(f\"Downloading of {trace_filename}\")\n",
    "    request.urlretrieve(\n",
    "                url=trace_url,\n",
    "                filename=trace_filename\n",
    "        )\n",
    "    return trace_filename\n",
    "\n",
    "def unzip_file(file: str):\n",
    "    path = file.replace(\".gz\", \"\")\n",
    "    \n",
    "    if os.path.exists(path):\n",
    "        \n",
    "        return\n",
    "    with gzip.open(file, 'r') as f_in, open(file.replace(\".gz\", \"\"), 'wb') as f_out:\n",
    "            shutil.copyfileobj(f_in, f_out)\n",
    "    os.remove(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "GCS_URI = \"https://storage.googleapis.com\"\n",
    "DATASET_NAME = \"clusterdata_2019_schema\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://storage.googleapis.com/clusterdata_2019_schema/collection_events.schema.json\n",
      "Downloading of clusterdata_2019_schema_collection_events.schema.json\n",
      "https://storage.googleapis.com/clusterdata_2019_schema/instance_events.schema.json\n",
      "Downloading of clusterdata_2019_schema_instance_events.schema.json\n",
      "https://storage.googleapis.com/clusterdata_2019_schema/instance_usage.schema.json\n",
      "Downloading of clusterdata_2019_schema_instance_usage.schema.json\n",
      "https://storage.googleapis.com/clusterdata_2019_schema/machine_attributes.schema.json\n",
      "Downloading of clusterdata_2019_schema_machine_attributes.schema.json\n",
      "https://storage.googleapis.com/clusterdata_2019_schema/machine_events.schema.json\n",
      "Downloading of clusterdata_2019_schema_machine_events.schema.json\n"
     ]
    }
   ],
   "source": [
    "for file in extract_file(f\"{GCS_URI}/{DATASET_NAME}\"):\n",
    "    print(file)\n",
    "    download_url(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://storage.googleapis.com/clusterdata_2019_a/collection_events-000000000001.json.gz\n",
    "# ...GCS_URI.../...DATASET_NAME..._...dataset_letter.../...COLLECTION_NAME...event_number...FILE_EXTENSION\n",
    "GCS_URI = \"https://storage.googleapis.com\"\n",
    "DATASET_NAME = \"clusterdata_2019\"\n",
    "DATASET_LETTERS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace_list = []\n",
    "for letter in DATASET_LETTERS:\n",
    "    trace_url = f\"{GCS_URI}/{DATASET_NAME}_{letter}\"\n",
    "    letter_trace_url = extract_file(trace_url)\n",
    "    trace_list.extend(letter_trace_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "collection_a = [trace_url for trace_url in trace_list if (\"collection\" in trace_url) and (\"clusterdata_2019_a\" in trace_url)]\n",
    "instance_a = [trace_url for trace_url in trace_list if (\"instance\" in trace_url) and (\"clusterdata_2019_a\" in trace_url)]\n",
    "usage_a = [trace_url for trace_url in trace_list if (\"usage\" in trace_url) and (\"clusterdata_2019_a\" in trace_url)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# downloading files\n",
    "for trace_url in collection_a[:7]:\n",
    "        download_url(trace_url)\n",
    "\n",
    "for trace_url in instance_a[:7]:\n",
    "        download_url(trace_url)\n",
    "\n",
    "for trace_url in usage_a[:7]:\n",
    "        download_url(trace_url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize Spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: An illegal reflective access operation has occurred\n",
      "WARNING: Illegal reflective access by org.apache.spark.unsafe.Platform (file:/opt/spark/jars/spark-unsafe_2.12-3.2.1.jar) to constructor java.nio.DirectByteBuffer(long,int)\n",
      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.unsafe.Platform\n",
      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
      "WARNING: All illegal access operations will be denied in a future release\n",
      "Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties\n",
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
      "22/06/25 21:55:54 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "\n",
    "spark = SparkSession\\\n",
    "    .builder\\\n",
    "    .master(\"spark://192.168.1.93:7077\")\\\n",
    "    .appName(\"PROJET_INFRA\")\\\n",
    "    .getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - in-memory</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://master:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.2.1</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>spark://192.168.1.93:7077</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>PROJET_INFRA</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7fe1377314f0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Partie 2 : Loading data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Instance Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On créé le schéma :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType, FloatType, ArrayType, DoubleType\n",
    "from pyspark.ml.linalg import VectorUDT\n",
    "\n",
    "data_schemaUsage = StructType([ \\\n",
    "    StructField(\"start_time\",             StringType(), True), \\\n",
    "      #TimestampType()\n",
    "    StructField(\"end_time\",               StringType(), True), \\\n",
    "      #TimestampType()\n",
    "    StructField(\"collection_id\",          StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"instance_index\",         StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"machine_id\",             StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"alloc_collection_id\",    StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"alloc_instance_index\",   StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"collection_type\",        StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"average_usage\",          StructType([\\\n",
    "                                                StructField(\"cpus\", FloatType(), True), \\\n",
    "                                                StructField(\"memory\", FloatType(), True), \\\n",
    "                                              ]), True), \\\n",
    "    StructField(\"maximum_usage\",          StructType([\\\n",
    "                                                StructField(\"cpus\", FloatType(), True), \\\n",
    "                                                StructField(\"memory\", FloatType(), True), \\\n",
    "                                              ]), True), \\\n",
    "    StructField(\"random_sample_usage\",    StructType([\\\n",
    "                                                StructField(\"cpus\", FloatType(), True), \\\n",
    "                                                StructField(\"memory\", FloatType(), True), \\\n",
    "                                              ]), True), \\\n",
    "    StructField(\"assigned_memory\",        FloatType(), True), \\\n",
    "    StructField(\"page_cache_memory\",      FloatType(), True), \\\n",
    "    StructField(\"cycles_per_instruction\", FloatType(), True), \\\n",
    "    StructField(\"memory_accesses_per_instruction\", FloatType(), True), \\\n",
    "    StructField(\"sample_rate\",            FloatType(), True), \\\n",
    "    StructField(\"cpu_usage_distribution\", ArrayType(DoubleType()), True), \\\n",
    "    StructField(\"tail_cpu_usage_distribution\", ArrayType(DoubleType()), True), \\\n",
    "  ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On charge le fichier .json correspondant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"clusterdata_2019_a_\" + \"instance_usage-000000000000.json\"\n",
    "\n",
    "dfUsage = spark.read\\\n",
    "    .format(\"json\")\\\n",
    "    .schema(data_schemaUsage)\\\n",
    "    .load(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certaines variables contiennent des dictionnaires ayant comme clefs : `cpus` et `memory`. Ainsi, on créé de nouvelles variables contenant la valeur de ces clefs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfUsage = dfUsage\\\n",
    "                .withColumn(\"random_sample_memory_usage\", dfUsage.random_sample_usage.getItem(\"memory\"))\\\n",
    "                .withColumn(\"random_sample_cpu_usage\", dfUsage.random_sample_usage.getItem(\"cpus\"))\\\n",
    "                .withColumn(\"average_memory_usage\", dfUsage.average_usage.getItem(\"memory\"))\\\n",
    "                .withColumn(\"average_cpu_usage\", dfUsage.average_usage.getItem(\"cpus\"))\\\n",
    "                .withColumn(\"maximum_memory_usage\", dfUsage.maximum_usage.getItem(\"memory\"))\\\n",
    "                .withColumn(\"maximum_cpu_usage\", dfUsage.maximum_usage.getItem(\"cpus\"))\\\n",
    "                .drop(\"maximum_usage\")\\\n",
    "                .drop(\"average_usage\")\\\n",
    "                .drop(\"random_sample_usage\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On transforme le type des variables vers les bons (Google donne par défaut des `strings`) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import Column\n",
    "import pyspark.sql.functions as F\n",
    "from pyspark.sql.functions import udf\n",
    "from pyspark.ml.linalg import Vectors, VectorUDT\n",
    "\n",
    "dfUsage = dfUsage\\\n",
    "    .na.drop(how=\"any\", subset=[\"memory_accesses_per_instruction\"])\\\n",
    "    .na.drop(how=\"any\", subset=[\"cpu_usage_distribution\"])\\\n",
    "    .na.drop(how=\"any\", subset=[\"tail_cpu_usage_distribution\"])\\\n",
    "    .filter(F.size(F.col(\"cpu_usage_distribution\")) >= 1)\\\n",
    "    .filter(F.size(F.col(\"tail_cpu_usage_distribution\")) >= 1)\\\n",
    "\n",
    "list_to_vector_udf = udf(lambda l: Vectors.dense(l), VectorUDT())\n",
    "\n",
    "dfUsage = dfUsage\\\n",
    "    .withColumn(\"start_time\", dfUsage.start_time.cast('double'))\\\n",
    "    .withColumn(\"end_time\", dfUsage.end_time.cast('double'))\\\n",
    "    .withColumn(\"collection_id\", dfUsage.collection_id.cast('double'))\\\n",
    "    .withColumn(\"instance_index\", dfUsage.instance_index.cast('double'))\\\n",
    "    .withColumn(\"machine_id\", dfUsage.machine_id.cast(IntegerType()))\\\n",
    "    .withColumn(\"alloc_collection_id\", dfUsage.alloc_collection_id.cast('double'))\\\n",
    "    .withColumn(\"alloc_instance_index\", dfUsage.alloc_instance_index.cast('double'))\\\n",
    "    .withColumn(\"collection_type\", dfUsage.collection_type.cast('int'))\\\n",
    "    .withColumn(\"cpu_usage_distribution\", list_to_vector_udf(dfUsage[\"cpu_usage_distribution\"]))\\\n",
    "    .withColumn(\"tail_cpu_usage_distribution\", list_to_vector_udf(dfUsage[\"tail_cpu_usage_distribution\"]))\\\n",
    "        \n",
    "dfUsage = dfUsage\\\n",
    "    .withColumn(\"duration\", dfUsage.end_time-dfUsage.start_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérification :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'string' in np.array(dfUsage.dtypes)[:,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Instance Events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On répète la même procédure que la partie précédente :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType, FloatType, ArrayType, DoubleType\n",
    "from pyspark.ml.linalg import VectorUDT\n",
    "\n",
    "data_schemaEvents = StructType([ \\\n",
    "    StructField(\"time\",             StringType(), True), \\\n",
    "      #TimestampType()\n",
    "    StructField(\"type\",               StringType(), True), \\\n",
    "      #TimestampType()\n",
    "    StructField(\"collection_id\",          StringType(), True), \\\n",
    "      #IntegerType()    \n",
    "    StructField(\"machine_id\",        StringType(), True), \\\n",
    "    StructField(\"scheduling_class\",         StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"missing_type\",             StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"collection_type\",    StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"priority\",   StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    StructField(\"alloc_collection_id\",        StringType(), True), \\\n",
    "      #IntegerType()\n",
    "    \n",
    "    StructField(\"instance_index\",        StringType(), True), \\\n",
    "    StructField(\"alloc_instance_index\",        StringType(), True), \\\n",
    "    StructField(\"resource_request\",        StructType([\\\n",
    "                                                StructField(\"cpus\", FloatType(), True), \\\n",
    "                                                StructField(\"memory\", FloatType(), True), \\\n",
    "                                              ]), True), \\\n",
    "    StructField(\"constraint\",        StringType(), True)\n",
    "  ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"clusterdata_2019_a_\" + \"instance_events-000000000000.json\"\n",
    "\n",
    "dfEvents = spark.read\\\n",
    "    .format(\"json\")\\\n",
    "    .schema(data_schemaEvents)\\\n",
    "    .load(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfEvents = dfEvents\\\n",
    "                .withColumn(\"memory_request\", dfEvents.resource_request.getItem(\"memory\"))\\\n",
    "                .withColumn(\"cpu_request\", dfEvents.resource_request.getItem(\"cpus\"))\\\n",
    "                .drop(\"resource_request\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('time', 'string'),\n",
       " ('type', 'string'),\n",
       " ('collection_id', 'string'),\n",
       " ('machine_id', 'string'),\n",
       " ('scheduling_class', 'string'),\n",
       " ('missing_type', 'string'),\n",
       " ('collection_type', 'string'),\n",
       " ('priority', 'string'),\n",
       " ('alloc_collection_id', 'string'),\n",
       " ('instance_index', 'string'),\n",
       " ('alloc_instance_index', 'string'),\n",
       " ('constraint', 'string'),\n",
       " ('memory_request', 'float'),\n",
       " ('cpu_request', 'float')]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfEvents.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfEvents = dfEvents\\\n",
    "    .withColumn(\"time\", dfEvents.time.cast('double'))\\\n",
    "    .withColumn(\"type\", dfEvents.type.cast('double'))\\\n",
    "    .withColumn(\"collection_id\", dfEvents.collection_id.cast('double'))\\\n",
    "    .withColumn(\"machine_id\", dfEvents.machine_id.cast(IntegerType()))\\\n",
    "    .withColumn(\"scheduling_class\", dfEvents.scheduling_class.cast('double'))\\\n",
    "    .withColumn(\"missing_type\", dfEvents.missing_type.cast('double'))\\\n",
    "    .withColumn(\"collection_type\", dfEvents.collection_type.cast('double'))\\\n",
    "    .withColumn(\"priority\", dfEvents.priority.cast('double'))\\\n",
    "    .withColumn(\"alloc_collection_id\", dfEvents.alloc_collection_id.cast('int'))\\\n",
    "    .withColumn(\"instance_index\", dfEvents.instance_index.cast('int'))\\\n",
    "    .withColumn(\"alloc_instance_index\", dfEvents.alloc_instance_index.cast('int'))\\\n",
    "    .withColumn(\"constraint\", dfEvents.constraint.cast('int'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'string' in np.array(dfEvents.dtypes)[:,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Machine Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType, FloatType, ArrayType, DoubleType\n",
    "from pyspark.ml.linalg import VectorUDT\n",
    "\n",
    "data_schemaMachines_attributes = StructType([ \\\n",
    "    StructField(\"time\",             StringType(), True), \\\n",
    "    StructField(\"machine_id\",        StringType(), True), \\\n",
    "    StructField(\"name\",         StringType(), True), \\\n",
    "    StructField(\"value\",             StringType(), True), \\\n",
    "    StructField(\"deleted\",    StringType(), True), \\\n",
    "  ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"machine_attributes-000000000000.json\"\n",
    "\n",
    "dfMachine_attributes = spark.read\\\n",
    "    .format(\"json\")\\\n",
    "    .schema(data_schemaMachines_attributes)\\\n",
    "    .load(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMachine_attributes = dfMachine_attributes\\\n",
    "    .withColumn(\"time\", dfMachine_attributes.time.cast('double'))\\\n",
    "    .withColumn(\"machine_id\", dfMachine_attributes.machine_id.cast(IntegerType()))\\\n",
    "    .withColumn(\"value\", dfMachine_attributes.value.cast('double'))\\\n",
    "    .withColumn(\"deleted\", dfMachine_attributes.deleted.cast('boolean'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Machine Events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType, FloatType, ArrayType, DoubleType\n",
    "from pyspark.ml.linalg import VectorUDT\n",
    "\n",
    "data_schemaMachines_events = StructType([ \\\n",
    "    StructField(\"time\",             StringType(), True), \\\n",
    "    StructField(\"machine_id\",        StringType(), True), \\\n",
    "    StructField(\"type\",         StringType(), True), \\\n",
    "    StructField(\"switch_id\",             StringType(), True), \\\n",
    "    StructField(\"capacity\",        StructType([\\\n",
    "                                                StructField(\"cpus\", FloatType(), True), \\\n",
    "                                                StructField(\"memory\", FloatType(), True), \\\n",
    "                                              ]), True), \\\n",
    "    StructField(\"platform_id\",             StringType(), True), \\\n",
    "    StructField(\"missing_data_reason\",             StringType(), True), \\\n",
    "  ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"machine_events-000000000000.json\"\n",
    "\n",
    "dfMachine_events = spark.read\\\n",
    "    .format(\"json\")\\\n",
    "    .schema(data_schemaMachines_events)\\\n",
    "    .load(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMachine_events = dfMachine_events\\\n",
    "                .withColumn(\"memory_capacity\", dfMachine_events.capacity.getItem(\"memory\"))\\\n",
    "                .withColumn(\"cpu_capacity\", dfMachine_events.capacity.getItem(\"cpus\"))\\\n",
    "                .drop(\"capacity\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMachine_events = dfMachine_events\\\n",
    "    .withColumn(\"time\", dfMachine_events.time.cast('double'))\\\n",
    "    .withColumn(\"type\", dfMachine_events.type.cast('double'))\\\n",
    "    .withColumn(\"switch_id\", dfMachine_events.switch_id.cast('double'))\\\n",
    "    .withColumn(\"machine_id\", dfMachine_events.machine_id.cast('double'))\\\n",
    "    .withColumn(\"platform_id\", dfMachine_events.platform_id.cast('double'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Partie 3 : Data Transformation and Exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Creating new variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que les données sont chargées dans leur dataframes respectifs. On peut fusionner `dfUsage` et `dfEvents` selon les clefs communes suivantes : `collection_id`, `instance_index`, `machine_id`, `alloc_collection_id`, `alloc_instance_index`, `collection_type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# merging dataframes by id\n",
    "dfMerged = dfUsage.join(dfEvents, on=[\"collection_id\", \"instance_index\", \"machine_id\", \"alloc_collection_id\", \"alloc_instance_index\", \"collection_type\"]).distinct()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va créer également une nouvelle variable qui correspond au ratio entre `maximum_cpu_usage` et `cpu_request` (pareil mais avec `memory` au lieu de `cpu`). On appellera ces nouvelles variables : `ratio_cpu_waste` et `ratio_memory_waste`. \n",
    "\n",
    "Par exemple : \n",
    "$$\n",
    "\\text{ratio cpu waste} = 1 - \\frac{\\text{maximum cpu usage}}{\\text{requested cpu}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMerged = dfMerged\\\n",
    "                .withColumn(\"ratio_memory_waste\", \n",
    "                                1-dfMerged.maximum_memory_usage/dfMerged.memory_request)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMerged = dfMerged\\\n",
    "                .withColumn(\"ratio_cpu_waste\", \n",
    "                                1-dfMerged.maximum_cpu_usage/dfMerged.cpu_request)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Transformation des données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans le dataframe `dfMerged`, on a deux variables correspondantes à des distributions : `cpu_usage_distribution`, `tail_cpu_usage_distribution`. Ces variables ne sont pas vraiment utilisables telles quelles. Ainsi, on va créer deux autres nouvelles variables catégoriques pour les remplacer : \n",
    "- `cpu_workload`\n",
    "\n",
    "Ces deux variables sont catégoriques et prennent les valeurs suivantes : `high`, `medium` et `low`, représentant l'intensité de la tâche sur le processeur et la mémoire.\n",
    "\n",
    "Pour faire cette transformation, on utilise une classification `K-means`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importation des librairies\n",
    "from pyspark.ml.clustering import KMeans\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.ml.linalg import Vectors\n",
    "from pyspark.ml.feature import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "22/06/25 21:56:24 WARN package: Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Vectorisation des données\n",
    "data_usage_distri = VectorAssembler(\n",
    "    inputCols = [\n",
    "        \"cpu_usage_distribution\"\n",
    "    ],\n",
    "    outputCol = \"features\"\n",
    ")\n",
    "\n",
    "data_usage_distri = data_usage_distri.transform(dfMerged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Y A PAS BESOIN DE CA\n",
    "# Standardisation des données\n",
    "scale = StandardScaler(inputCol='features', outputCol='standardized')\n",
    "data_scale = scale.fit(data_usage_distri)\n",
    "\n",
    "data_usage_distri_scaled = data_scale.transform(data_usage_distri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Application du K-means. On prend k = 3\n",
    "from pyspark.ml.evaluation import ClusteringEvaluator\n",
    "\n",
    "KMeans_algo = KMeans(featuresCol = 'standardized', k = 3)\n",
    "\n",
    "KMeans_fit = KMeans_algo.fit(data_usage_distri_scaled)\n",
    "output = KMeans_fit.transform(data_usage_distri_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMerged = output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluator = ClusteringEvaluator(predictionCol = 'prediction',\n",
    "#                                 featuresCol = 'standardized',\n",
    "#                                 metricName = 'silhouette',\n",
    "#                                 distanceMeasure = 'squaredEuclidean')\n",
    "\n",
    "# dfMerged = output.drop(\"features\", \"standardized\", \"cpu_usage_distribution\")\n",
    "            \n",
    "# score=evaluator.evaluate(output)\n",
    "\n",
    "# print(\"Silhouette Score:\",score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le score est plutôt très bon. On va visualiser les clusters à l'aide d'une Analyse par Composante Principales (pour réduire la dimension) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "22/06/25 22:52:55 WARN LAPACK: Failed to load implementation from: com.github.fommil.netlib.NativeSystemLAPACK\n",
      "22/06/25 22:52:55 WARN LAPACK: Failed to load implementation from: com.github.fommil.netlib.NativeRefLAPACK\n"
     ]
    }
   ],
   "source": [
    "from pyspark.ml.feature import PCA as PCAml\n",
    "\n",
    "pca = PCAml(k=2, inputCol=\"standardized\", outputCol=\"pca\")\n",
    "pca_model = pca.fit(dfMerged)\n",
    "pca_transformed = pca_model.transform(dfMerged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x_pca = np.array(pca_transformed.rdd.map(lambda row: row.pca).collect())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "cluster_assignment = np.array(output.rdd.map(lambda row: row.prediction).collect()).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 537.375x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "pca_data = np.hstack((x_pca, cluster_assignment))\n",
    "\n",
    "pca_df = pd.DataFrame(data=pca_data, columns=(\"1st_principal\", \"2nd_principal\", \"cluster_assignment\"))\n",
    "sns.FacetGrid(pca_df,hue=\"cluster_assignment\", height=6).map(plt.scatter, '1st_principal', '2nd_principal' ).add_legend()\n",
    "plt.title(\"PCA of cluster data workload\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import figure\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfKmeans = dfMerged.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.histplot(data=dfKmeans, x='average_cpu_usage', hue='prediction', cumulative=True)\n",
    "\n",
    "plt.title('Average CPU usage for each cluster')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.histplot(data=dfKmeans, x='maximum_cpu_usage', hue='prediction', cumulative=True)\n",
    "plt.title('Maximum CPU usage for each cluster')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 CPU and Memory capacities of machines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorting Events by time\n",
    "dfMachine_events = dfMachine_events.sort('time', ascending=True)# \n",
    "dfEvents = dfEvents.sort('time', ascending=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import figure\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1 Machine's type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMachineType = dfMachine_events.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.histplot(data=dfMachineType, x='type')\n",
    "plt.title('Distribution of Add (1); Remove (2) and Update (3)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.histplot(data=dfMachineType, x='time', hue='type')\n",
    "plt.title('Distribution of Add (1); Remove (2) and Update (3)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.2 CPU and Memory in machines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfMachineCapacity = dfMachine_events\\\n",
    "    .where(dfMachine_events.type == 1)\\\n",
    "    .groupBy('cpu_capacity', 'memory_capacity')\\\n",
    "    .count()\n",
    "# dfMachineCapacity = dfMachineCapacity.withColumnRenamed('avg(memory_capacity)', 'memory_capacity_sum')\n",
    "dfMachineCapacity = dfMachineCapacity.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.lineplot(data=dfMachineCapacity, x='cpu_capacity', y='count', ci=None)\n",
    "plt.title('Count of CPU capacity of machines')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(8, 5), dpi=100)\n",
    "sns.lineplot(data=dfMachineCapacity, x='memory_capacity', y='count', ci=None)\n",
    "plt.title('Count of Memory capacity of machines')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Partie 4: Our study"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part X: Scheduling optimization (skip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each task is represented by the following variables:\n",
    "- Time: when the task is created\n",
    "- Duration: how long the tasks takes from when a machine is allocated to perform the task until it finishes executing it\n",
    "- Workload: Low, Medium, High - how much CPU the task uses\n",
    "- CPU_request: how much CPU the task is requesting\n",
    "- Memory_request: how much memory the task is requesting\n",
    "- Priority: importance of the task\n",
    "\n",
    "From now on, we make the following suppositions:\n",
    "- The CPU_request and memory_request cannot be changed even if the task does not use all the capacity requested\n",
    "\n",
    "Therefore, we are looking at optimizing the scheduling of tasks throughout the machines.\n",
    "\n",
    "To do this, we are going to create a waiting list and one executing list for the machines (they are esentially dictionaries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorting Events by time\n",
    "dfMachine_events = dfMachine_events.sort('time', ascending=True)\n",
    "dfEvents = dfEvents.sort('time', ascending=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_lists(machineEvents):\n",
    "    \"\"\"\n",
    "    Function that initializes the model. \n",
    "    Input:\n",
    "        - machineEvents: dataframe of all machines' events \n",
    "    Output:\n",
    "        - wait_list: array representing the waiting list for each task\n",
    "        - machines: dictionnary : {'machine_id': {'memory': memory_capacity, 'cpu': cpu_capacity}, \n",
    "                                                {'task': taskid, 'time': start_time, 'duration': duration},\n",
    "                                                cpu_request_total, \n",
    "                                                memory_request_total }\n",
    "        - time0: model's starting time\n",
    "    \"\"\"\n",
    "\n",
    "    machineEvents = machineEvents.sort('time', ascending=True)\n",
    "    \n",
    "    time0 = machineEvents.select('time').first()[0]\n",
    "    \n",
    "\n",
    "    dfMachines = machineEvents.filter((dfMachine_events.time == time0) & (dfMachine_events.type == 1.0)).select('time', 'machine_id', 'memory_capacity', 'cpu_capacity') \n",
    "\n",
    "    currentMachinesInfo = [{machine: [{'memory':mem, 'cpu':cpu}, dict.fromkeys(['collection_ids', 'instance_indexes', 'times', 'durations', 'priorities']), 0, 0] for machine, mem, cpu in dfMachines.select('machine_id', 'memory_capacity', 'cpu_capacity').collect()}]\n",
    "\n",
    "    return currentMachinesInfo[0], time0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addTasks(dfTasks, time):\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 685:=====================================================> (66 + 2) / 68]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-RECORD 0--------------------------------\n",
      " time                 | 0.0              \n",
      " type                 | 0.0              \n",
      " collection_id        | 3.74890160342E11 \n",
      " machine_id           | null             \n",
      " scheduling_class     | 0.0              \n",
      " missing_type         | null             \n",
      " collection_type      | 0.0              \n",
      " priority             | 0.0              \n",
      " alloc_collection_id  | 0                \n",
      " instance_index       | 144              \n",
      " alloc_instance_index | -1               \n",
      " constraint           | null             \n",
      " memory_request       | 0.0022888184     \n",
      " cpu_request          | 0.0020256042     \n",
      "only showing top 1 row\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "dfEvents.sort('time', ascending=True).show(n=1, vertical=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Running simulation\n",
    "tasks0, machinesRunningInfo0, time0 = init_lists(dfMachine_events, dfMerged)\n",
    "# currentMachines = list(machinesRunningInfo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 679:==================================================>    (12 + 1) / 13]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------------+--------------+-----------+--------------+---------------+\n",
      "|   collection_id|instance_index|cpu_request|memory_request|           time|\n",
      "+----------------+--------------+-----------+--------------+---------------+\n",
      "|3.75086626207E11|         134.0|0.011352539|  0.0023117065|2.9785076152E10|\n",
      "+----------------+--------------+-----------+--------------+---------------+\n",
      "only showing top 1 row\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "dfMerged.select('collection_id', 'instance_index', 'cpu_request', 'memory_request', 'time').sort('time', ascending=True).show(n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updateStateMachines(state, MachineEvents, time):\n",
    "    \"\"\"\n",
    "    Function that updates  the state: dictionnary of machines, current_tasks\n",
    "    \"\"\"\n",
    "    dfMachines = MachineEvents.filter(MachineEvents.time == time).select('machine_id', 'time', 'type', 'cpu_capacity', 'memory_capacity')\n",
    "    \n",
    "    expiredMachines = dfMachines.filter(dfMachines.type == 2.0).select('machine_id').rdd.flatMap(lambda x: x).collect()\n",
    "\n",
    "    addedMachines = dfMachines.filter(dfMachines.type == 1.0).drop('type')# .rdd.flatMap(lambda x: x).collect()\n",
    "\n",
    "    oldTasks, machinesInfo, oldTime = state\n",
    "\n",
    "    oldMachinesInfo = machinesInfo.copy()\n",
    "    \n",
    "    # list of all old machines\n",
    "    oldMachines = list(oldMachinesInfo)\n",
    "\n",
    "    # updating MachinesInfo dictionnary\n",
    "    for expiredMachine in expiredMachines:\n",
    "        # old machine expired\n",
    "        # have to gather all the tasks that did not finish\n",
    "        # remember to update duration\n",
    "        # as a first approach, kill tasks\n",
    "        if expiredMachine in oldMachines:\n",
    "            oldMachinesInfo.pop(expiredMachine)\n",
    "\n",
    "    newMachinesInfo = [{machine: [{'memory':mem, 'cpu':cpu}, dict.fromkeys(['collection_ids', 'instance_indexes', 'times', 'durations', 'priorities']), 0, 0] for machine, mem, cpu in addedMachines.select('machine_id', 'memory_capacity', 'cpu_capacity').collect()}]\n",
    "\n",
    "    try:\n",
    "        currentMachinesInfo = dict(oldMachinesInfo).update(newMachinesInfo)\n",
    "        currentMachines = list(currentMachinesInfo)\n",
    "    except:\n",
    "        currentMachines = list(oldMachinesInfo)\n",
    "        currentMachinesInfo = oldMachinesInfo\n",
    "\n",
    "        pass\n",
    "    print(\"Old length: \", len(oldMachines), \" new length: \", len(currentMachines))\n",
    "\n",
    "    return oldTasks, currentMachinesInfo, time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printState(MachinesInfo):\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "22/06/19 10:35:53 WARN package: Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Running simulation\n",
    "tasks0, machinesRunningInfo0, time0 = init_lists(dfMachine_events, dfMerged)\n",
    "# currentMachines = list(machinesRunningInfo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dfMachine_events.filter((dfMachine_events.machine_id == 102892982852.0) & (dfMachine_events.time == 0.0)).select('machine_id', 'type').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "all_times = dfMachine_events.select('time').distinct().sort('time', ascending=True).rdd.flatMap(lambda x: x).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Old length:  9526  new length:  9526\n",
      "[102892982852.0]\n",
      "Old length:  9526  new length:  9525\n",
      "[]\n",
      "Old length:  9525  new length:  9525\n",
      "[]\n",
      "Old length:  9525  new length:  9525\n",
      "[]\n",
      "Old length:  9525  new length:  9525\n",
      "[1579832655.0]\n",
      "Old length:  9525  new length:  9524\n",
      "[1574329911.0]\n",
      "Old length:  9524  new length:  9523\n",
      "[44327628355.0]\n",
      "Old length:  9523  new length:  9522\n",
      "[44493424971.0]\n",
      "Old length:  9522  new length:  9521\n",
      "[44338119771.0]\n",
      "Old length:  9521  new length:  9520\n",
      "[]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:KeyboardInterrupt while sending command.\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/mocmoc/anaconda3/lib/python3.9/site-packages/py4j/java_gateway.py\", line 1038, in send_command\n",
      "    response = connection.send_command(command)\n",
      "  File \"/home/mocmoc/anaconda3/lib/python3.9/site-packages/py4j/clientserver.py\", line 475, in send_command\n",
      "    answer = smart_decode(self.stream.readline()[:-1])\n",
      "  File \"/home/mocmoc/anaconda3/lib/python3.9/socket.py\", line 704, in readinto\n",
      "    return self._sock.recv_into(b)\n",
      "KeyboardInterrupt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old length:  9520  new length:  9520\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_198414/241622843.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mtime\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mall_times\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mtasks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmachinesRunningInfo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mupdateState\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtasks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmachinesRunningInfo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdfMachine_events\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_198414/4024704166.py\u001b[0m in \u001b[0;36mupdateState\u001b[0;34m(state, MachineEvents, time)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mdfMachines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMachineEvents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMachineEvents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'machine_id'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'time'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'type'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'cpu_capacity'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'memory_capacity'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0mexpiredMachines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdfMachines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdfMachines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'machine_id'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrdd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcollect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpiredMachines\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0maddedMachines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdfMachines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdfMachines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'type'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m# .rdd.flatMap(lambda x: x).collect()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pyspark/sql/dataframe.py\u001b[0m in \u001b[0;36mrdd\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     84\u001b[0m         \"\"\"\n\u001b[1;32m     85\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lazy_rdd\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m             \u001b[0mjrdd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjavaToPython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     87\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lazy_rdd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mRDD\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjrdd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msql_ctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBatchedSerializer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPickleSerializer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     88\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lazy_rdd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/py4j/java_gateway.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m   1318\u001b[0m             \u001b[0mproto\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEND_COMMAND_PART\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1319\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1320\u001b[0;31m         \u001b[0manswer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgateway_client\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend_command\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcommand\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1321\u001b[0m         return_value = get_return_value(\n\u001b[1;32m   1322\u001b[0m             answer, self.gateway_client, self.target_id, self.name)\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/py4j/java_gateway.py\u001b[0m in \u001b[0;36msend_command\u001b[0;34m(self, command, retry, binary)\u001b[0m\n\u001b[1;32m   1036\u001b[0m         \u001b[0mconnection\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_connection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1037\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1038\u001b[0;31m             \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconnection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend_command\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcommand\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1039\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mbinary\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1040\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_connection_guard\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/py4j/clientserver.py\u001b[0m in \u001b[0;36msend_command\u001b[0;34m(self, command)\u001b[0m\n\u001b[1;32m    473\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    474\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 475\u001b[0;31m                 \u001b[0manswer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msmart_decode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    476\u001b[0m                 \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Answer received: {0}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manswer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    477\u001b[0m                 \u001b[0;31m# Happens when a the other end is dead. There might be an empty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/socket.py\u001b[0m in \u001b[0;36mreadinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m    702\u001b[0m         \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    703\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sock\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_into\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    705\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    706\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_timeout_occurred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# running simulation\n",
    "tasks, times = tasks0, time0\n",
    "machinesRunningInfo = machinesRunningInfo0.copy()\n",
    "\n",
    "for time in all_times:\n",
    "    tasks, machinesRunningInfo, times = updateStateMachines([tasks, machinesRunningInfo, times], dfMachine_events, time=time)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+----------------+----+---------+-----------+-------------------+---------------+------------+\n",
      "|time|      machine_id|type|switch_id|platform_id|missing_data_reason|memory_capacity|cpu_capacity|\n",
      "+----+----------------+----+---------+-----------+-------------------+---------------+------------+\n",
      "| 0.0|1.02892982852E11| 1.0|     null|       null|               null|            1.0|         1.0|\n",
      "+----+----------------+----+---------+-----------+-------------------+---------------+------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dfMachine_events.filter((dfMachine_events.time == 0.0) & (dfMachine_events.machine_id == \"102892982852.0\")).show(n=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 607408236.0,\n",
       " 719309720.0,\n",
       " 763535042.0,\n",
       " 827849468.0,\n",
       " 871196551.0,\n",
       " 872596350.0,\n",
       " 877858805.0,\n",
       " 879537932.0,\n",
       " 883281321.0,\n",
       " 886975475.0,\n",
       " 1094232377.0,\n",
       " 1112236497.0,\n",
       " 1136640442.0,\n",
       " 1904320438.0,\n",
       " 2320412540.0,\n",
       " 2372736623.0,\n",
       " 2583850589.0,\n",
       " 2600870803.0,\n",
       " 2711036674.0,\n",
       " 2868632674.0,\n",
       " 2868632707.0,\n",
       " 2868632739.0,\n",
       " 2868632785.0,\n",
       " 2879843078.0,\n",
       " 2956848928.0,\n",
       " 3004599015.0,\n",
       " 3007824060.0,\n",
       " 3266821951.0,\n",
       " 3586641000.0,\n",
       " 3998333529.0,\n",
       " 4033551729.0,\n",
       " 4072580584.0,\n",
       " 4383136803.0,\n",
       " 4589741579.0,\n",
       " 4811313593.0,\n",
       " 4813417904.0,\n",
       " 4818735766.0,\n",
       " 4821499574.0,\n",
       " 5210766872.0,\n",
       " 5447328337.0,\n",
       " 5682072583.0,\n",
       " 5993873271.0,\n",
       " 6506436836.0,\n",
       " 6805886529.0,\n",
       " 6805886594.0,\n",
       " 6805886663.0,\n",
       " 6805886713.0,\n",
       " 6805886779.0,\n",
       " 6918786205.0,\n",
       " 7063144091.0,\n",
       " 7314960072.0,\n",
       " 7982929304.0,\n",
       " 8010220664.0,\n",
       " 8820292424.0,\n",
       " 8854258804.0,\n",
       " 8950495144.0,\n",
       " 9047841288.0,\n",
       " 9363998666.0,\n",
       " 9440894676.0,\n",
       " 9608294449.0,\n",
       " 10631787258.0,\n",
       " 10843464454.0,\n",
       " 11309464450.0,\n",
       " 11567851918.0,\n",
       " 12410488538.0,\n",
       " 12437702454.0,\n",
       " 12821839356.0,\n",
       " 13144685261.0,\n",
       " 13425819412.0,\n",
       " 13720886265.0,\n",
       " 14279673511.0,\n",
       " 14337162590.0,\n",
       " 14796389166.0,\n",
       " 14808527930.0,\n",
       " 15420353418.0,\n",
       " 15738057315.0,\n",
       " 16011217298.0,\n",
       " 16496229817.0,\n",
       " 16662272008.0,\n",
       " 17022385692.0,\n",
       " 17855893168.0,\n",
       " 18058272276.0,\n",
       " 18075313655.0,\n",
       " 18996064207.0,\n",
       " 19120588752.0,\n",
       " 19291363851.0,\n",
       " 19293428176.0,\n",
       " 19336176308.0,\n",
       " 19785437143.0,\n",
       " 20055419037.0,\n",
       " 21158825093.0,\n",
       " 22042898814.0,\n",
       " 22045049745.0,\n",
       " 22137353727.0,\n",
       " 23166753637.0,\n",
       " 23404373392.0,\n",
       " 24639252608.0,\n",
       " 24654278039.0,\n",
       " 25146364170.0,\n",
       " 26772329652.0,\n",
       " 27703101705.0,\n",
       " 27773827035.0,\n",
       " 27976778608.0,\n",
       " 28092464877.0,\n",
       " 29133425029.0,\n",
       " 30230528315.0,\n",
       " 30409048972.0,\n",
       " 31208416268.0,\n",
       " 31383277462.0,\n",
       " 32485382199.0,\n",
       " 32706652415.0,\n",
       " 33330147953.0,\n",
       " 33611400224.0,\n",
       " 34578724704.0,\n",
       " 35221511752.0,\n",
       " 36066929359.0,\n",
       " 36937546698.0,\n",
       " 37156487391.0,\n",
       " 37553590956.0,\n",
       " 37921707694.0,\n",
       " 38322929176.0,\n",
       " 38510111021.0,\n",
       " 39123934185.0,\n",
       " 40477365999.0,\n",
       " 40991625311.0,\n",
       " 41313331686.0,\n",
       " 42381584965.0,\n",
       " 42592106151.0,\n",
       " 42617119425.0,\n",
       " 42617119754.0,\n",
       " 42617119776.0,\n",
       " 42617119826.0,\n",
       " 42617119846.0,\n",
       " 42617119894.0,\n",
       " 42617119933.0,\n",
       " 42620585693.0,\n",
       " 42625473254.0,\n",
       " 42625473264.0,\n",
       " 42625473598.0,\n",
       " 42625473960.0,\n",
       " 42625474357.0,\n",
       " 42625474382.0,\n",
       " 42626889436.0,\n",
       " 42628406710.0,\n",
       " 42628406762.0,\n",
       " 42629410421.0,\n",
       " 42629410473.0,\n",
       " 42631250648.0,\n",
       " 42631250702.0,\n",
       " 42631250806.0,\n",
       " 42631250838.0,\n",
       " 42637459002.0,\n",
       " 42637459239.0,\n",
       " 42658363117.0,\n",
       " 42658363156.0,\n",
       " 42658363200.0,\n",
       " 42658363250.0,\n",
       " 42661501543.0,\n",
       " 42680696232.0,\n",
       " 42680696261.0,\n",
       " 42680696301.0,\n",
       " 42680696324.0,\n",
       " 42680696358.0,\n",
       " 42680696370.0,\n",
       " 42680696422.0,\n",
       " 42680696436.0,\n",
       " 42680696455.0,\n",
       " 42682331449.0,\n",
       " 42691277677.0,\n",
       " 42691277687.0,\n",
       " 42691277697.0,\n",
       " 42692326521.0,\n",
       " 42743157788.0,\n",
       " 42743157809.0,\n",
       " 42743157836.0,\n",
       " 42838755352.0,\n",
       " 42838755376.0,\n",
       " 42838755386.0,\n",
       " 42838755396.0,\n",
       " 42838755406.0,\n",
       " 42861077509.0,\n",
       " 42861077539.0,\n",
       " 42861077950.0,\n",
       " 42861078351.0,\n",
       " 42861078374.0,\n",
       " 42879947636.0,\n",
       " 42892438882.0,\n",
       " 42892438909.0,\n",
       " 42895076847.0,\n",
       " 42901166892.0,\n",
       " 42902644101.0,\n",
       " 42923573892.0,\n",
       " 43157813752.0,\n",
       " 43362905933.0,\n",
       " 43362905943.0,\n",
       " 43490294043.0,\n",
       " 43498942968.0,\n",
       " 43512991871.0,\n",
       " 43521394128.0,\n",
       " 43521394152.0,\n",
       " 43521394177.0,\n",
       " 43521394187.0,\n",
       " 43521394226.0,\n",
       " 43521394275.0,\n",
       " 43521394314.0,\n",
       " 43521728797.0,\n",
       " 43521728819.0,\n",
       " 43522632802.0,\n",
       " 43523332362.0,\n",
       " 43524480701.0,\n",
       " 43532958949.0,\n",
       " 43532958959.0,\n",
       " 43532958974.0,\n",
       " 43532959014.0,\n",
       " 43536792205.0,\n",
       " 43541139775.0,\n",
       " 43551754368.0,\n",
       " 43552999051.0,\n",
       " 43552999097.0,\n",
       " 43553195027.0,\n",
       " 43562548011.0,\n",
       " 43562548045.0,\n",
       " 43572153884.0,\n",
       " 43582720381.0,\n",
       " 43582720556.0,\n",
       " 43582993506.0,\n",
       " 43616149565.0,\n",
       " 43616149730.0,\n",
       " 43616658198.0,\n",
       " 43618718096.0,\n",
       " 43622546046.0,\n",
       " 43624883972.0,\n",
       " 43631330300.0,\n",
       " 43744049063.0,\n",
       " 43754164908.0,\n",
       " 43754569086.0,\n",
       " 43754569129.0,\n",
       " 43765854075.0,\n",
       " 43786085615.0,\n",
       " 43806072696.0,\n",
       " 43807037894.0,\n",
       " 43810827542.0,\n",
       " 43812917973.0,\n",
       " 43812918699.0,\n",
       " 43827874596.0,\n",
       " 43828118057.0,\n",
       " 43850788509.0,\n",
       " 43865639540.0,\n",
       " 43878813894.0,\n",
       " 43887607541.0,\n",
       " 43888720847.0,\n",
       " 43890428737.0,\n",
       " 43892725138.0,\n",
       " 43902205500.0,\n",
       " 43909782279.0,\n",
       " 43910134747.0,\n",
       " 43918173067.0,\n",
       " 43920355725.0,\n",
       " 43950892744.0,\n",
       " 43950953702.0,\n",
       " 43954190186.0,\n",
       " 43956715609.0,\n",
       " 43983549235.0,\n",
       " 43986334381.0,\n",
       " 43986744943.0,\n",
       " 43986745279.0,\n",
       " 43986862561.0,\n",
       " 43988760174.0,\n",
       " 43995685862.0,\n",
       " 43995775266.0,\n",
       " 43998873960.0,\n",
       " 44009972335.0,\n",
       " 44016215413.0,\n",
       " 44022378233.0,\n",
       " 44022752134.0,\n",
       " 44038251233.0,\n",
       " 44046722657.0,\n",
       " 44048121995.0,\n",
       " 44064314997.0,\n",
       " 44073983695.0,\n",
       " 44074383823.0,\n",
       " 44075051097.0,\n",
       " 44110574269.0,\n",
       " 44113223193.0,\n",
       " 44135716567.0,\n",
       " 44159891251.0,\n",
       " 44169458518.0,\n",
       " 44170224873.0,\n",
       " 44177329538.0,\n",
       " 44180171122.0,\n",
       " 44217336766.0,\n",
       " 44229682023.0,\n",
       " 44262200603.0,\n",
       " 44264882316.0,\n",
       " 44271496179.0,\n",
       " 44271496189.0,\n",
       " 44275612229.0,\n",
       " 44276839535.0,\n",
       " 44278015307.0,\n",
       " 44280758589.0,\n",
       " 44291609375.0,\n",
       " 44299376134.0,\n",
       " 44310251904.0,\n",
       " 44311406196.0,\n",
       " 44315513268.0,\n",
       " 44323271131.0,\n",
       " 44328598550.0,\n",
       " 44335724094.0,\n",
       " 44350348084.0,\n",
       " 44350348095.0,\n",
       " 44364837716.0,\n",
       " 44402632277.0,\n",
       " 44405470600.0,\n",
       " 44409330979.0,\n",
       " 44418526199.0,\n",
       " 44423815382.0,\n",
       " 44430846938.0,\n",
       " 44435818214.0,\n",
       " 44439285764.0,\n",
       " 44443161951.0,\n",
       " 44446706132.0,\n",
       " 44462921519.0,\n",
       " 44464033170.0,\n",
       " 44465796684.0,\n",
       " 44469617103.0,\n",
       " 44480150620.0,\n",
       " 44494162722.0,\n",
       " 44505267970.0,\n",
       " 44505978211.0,\n",
       " 44515302223.0,\n",
       " 44533645916.0,\n",
       " 44542384625.0,\n",
       " 44555719673.0,\n",
       " 44586307147.0,\n",
       " 44589502706.0,\n",
       " 44606807636.0,\n",
       " 44619406053.0,\n",
       " 44642242862.0,\n",
       " 44652787617.0,\n",
       " 44707596098.0,\n",
       " 44710184267.0,\n",
       " 44728520658.0,\n",
       " 44736445357.0,\n",
       " 44737593102.0,\n",
       " 44754509408.0,\n",
       " 44756912472.0,\n",
       " 44766245877.0,\n",
       " 44766427990.0,\n",
       " 44772916403.0,\n",
       " 44789949225.0,\n",
       " 44802704060.0,\n",
       " 44811978581.0,\n",
       " 44817680396.0,\n",
       " 44821338743.0,\n",
       " 44821338784.0,\n",
       " 44824121498.0,\n",
       " 44827090179.0,\n",
       " 44828669277.0,\n",
       " 44851400826.0,\n",
       " 44865451898.0,\n",
       " 44875269760.0,\n",
       " 44890353368.0,\n",
       " 44891553622.0,\n",
       " 44901900014.0,\n",
       " 44914875476.0,\n",
       " 44920843575.0,\n",
       " 44926986124.0,\n",
       " 44961588200.0,\n",
       " 44961665870.0,\n",
       " 44982514701.0,\n",
       " 45002847197.0,\n",
       " 45006921085.0,\n",
       " 45015850294.0,\n",
       " 45021236300.0,\n",
       " 45036302673.0,\n",
       " 45040450724.0,\n",
       " 45070593768.0,\n",
       " 45074149038.0,\n",
       " 45084176387.0,\n",
       " 45088907984.0,\n",
       " 45099843275.0,\n",
       " 45099843286.0,\n",
       " 45099843300.0,\n",
       " 45124368445.0,\n",
       " 45132037845.0,\n",
       " 45132395839.0,\n",
       " 45141701536.0,\n",
       " 45144223683.0,\n",
       " 45144223702.0,\n",
       " 45165271564.0,\n",
       " 45179564806.0,\n",
       " 45181088591.0,\n",
       " 45187520808.0,\n",
       " 45187520855.0,\n",
       " 45188431731.0,\n",
       " 45190114386.0,\n",
       " 45190114411.0,\n",
       " 45195778359.0,\n",
       " 45195778374.0,\n",
       " 45197911584.0,\n",
       " 45205850622.0,\n",
       " 45206906217.0,\n",
       " 45236296301.0,\n",
       " 45239062671.0,\n",
       " 45239062692.0,\n",
       " 45248863002.0,\n",
       " 45251711086.0,\n",
       " 45251711108.0,\n",
       " 45251716128.0,\n",
       " 45251716138.0,\n",
       " 45251725479.0,\n",
       " 45253750794.0,\n",
       " 45259522687.0,\n",
       " 45271531666.0,\n",
       " 45279462169.0,\n",
       " 45279782566.0,\n",
       " 45289669067.0,\n",
       " 45295267574.0,\n",
       " 45303977262.0,\n",
       " 45306305404.0,\n",
       " 45312207497.0,\n",
       " 45314038227.0,\n",
       " 45315133102.0,\n",
       " 45315364098.0,\n",
       " 45315364116.0,\n",
       " 45315364478.0,\n",
       " 45325217004.0,\n",
       " 45325217044.0,\n",
       " 45325217067.0,\n",
       " 45327051946.0,\n",
       " 45328709250.0,\n",
       " 45328709289.0,\n",
       " 45332065646.0,\n",
       " 45335242524.0,\n",
       " 45340972798.0,\n",
       " 45345729208.0,\n",
       " 45346646588.0,\n",
       " 45356741381.0,\n",
       " 45360407702.0,\n",
       " 45360703402.0,\n",
       " 45364458954.0,\n",
       " 45365683657.0,\n",
       " 45365683699.0,\n",
       " 45374366424.0,\n",
       " 45375677506.0,\n",
       " 45375677516.0,\n",
       " 45376688044.0,\n",
       " 45376688059.0,\n",
       " 45383078225.0,\n",
       " 45403205583.0,\n",
       " 45414545937.0,\n",
       " 45420258236.0,\n",
       " 45420542965.0,\n",
       " 45420542999.0,\n",
       " 45428457977.0,\n",
       " 45429975993.0,\n",
       " 45431698559.0,\n",
       " 45431698875.0,\n",
       " 45431698891.0,\n",
       " 45431699253.0,\n",
       " 45431699305.0,\n",
       " 45431699326.0,\n",
       " 45431699336.0,\n",
       " 45431699366.0,\n",
       " 45431699381.0,\n",
       " 45434969988.0,\n",
       " 45438821642.0,\n",
       " 45438821657.0,\n",
       " 45439452833.0,\n",
       " 45441664381.0,\n",
       " 45441664416.0,\n",
       " 45468840885.0,\n",
       " 45491033843.0,\n",
       " 45491033882.0,\n",
       " 45494490329.0,\n",
       " 45504825474.0,\n",
       " 45510639010.0,\n",
       " 45535040775.0,\n",
       " 45539024937.0,\n",
       " 45539024976.0,\n",
       " 45551824559.0,\n",
       " 45565763982.0,\n",
       " 45594351781.0,\n",
       " 45608604325.0,\n",
       " 45610519013.0,\n",
       " 45632275067.0,\n",
       " 45632275088.0,\n",
       " 45637743191.0,\n",
       " 45657033405.0,\n",
       " 45657164328.0,\n",
       " 45738018943.0,\n",
       " 45738018981.0,\n",
       " 45778899263.0,\n",
       " 45793176161.0,\n",
       " 45793176182.0,\n",
       " 45795254409.0,\n",
       " 45816538659.0,\n",
       " 45842613669.0,\n",
       " 45842733569.0,\n",
       " 45842831010.0,\n",
       " 45856067968.0,\n",
       " 45856067988.0,\n",
       " 45871282297.0,\n",
       " 45924345545.0,\n",
       " 45926598042.0,\n",
       " 45926598068.0,\n",
       " 45927426953.0,\n",
       " 45935357096.0,\n",
       " 45935357126.0,\n",
       " 45935357136.0,\n",
       " 45936366890.0,\n",
       " 45937935419.0,\n",
       " 45949176206.0,\n",
       " 45959095055.0,\n",
       " 45966765487.0,\n",
       " 45966765923.0,\n",
       " 45967489394.0,\n",
       " 45972091544.0,\n",
       " 45973739412.0,\n",
       " 45976089869.0,\n",
       " 45999553115.0,\n",
       " 45999732189.0,\n",
       " 46006616008.0,\n",
       " 46014070303.0,\n",
       " 46018202474.0,\n",
       " 46030341413.0,\n",
       " 46030341448.0,\n",
       " 46031274062.0,\n",
       " 46031274272.0,\n",
       " 46031274687.0,\n",
       " 46039425529.0,\n",
       " 46045440638.0,\n",
       " 46049814444.0,\n",
       " 46051093548.0,\n",
       " 46052206586.0,\n",
       " 46059912971.0,\n",
       " 46060320057.0,\n",
       " 46076705493.0,\n",
       " 46083606942.0,\n",
       " 46086791379.0,\n",
       " 46088878466.0,\n",
       " 46088878786.0,\n",
       " 46089498756.0,\n",
       " 46090340773.0,\n",
       " 46101564470.0,\n",
       " 46108093289.0,\n",
       " 46133034484.0,\n",
       " 46143082813.0,\n",
       " 46144897653.0,\n",
       " 46152147605.0,\n",
       " 46152680823.0,\n",
       " 46152680834.0,\n",
       " 46152909686.0,\n",
       " 46152909708.0,\n",
       " 46154558130.0,\n",
       " 46154985800.0,\n",
       " 46154986148.0,\n",
       " 46156245252.0,\n",
       " 46156245645.0,\n",
       " 46162873629.0,\n",
       " 46174948328.0,\n",
       " 46177813764.0,\n",
       " 46188831619.0,\n",
       " 46206056226.0,\n",
       " 46210229446.0,\n",
       " 46210280651.0,\n",
       " 46214587937.0,\n",
       " 46214976800.0,\n",
       " 46224612556.0,\n",
       " 46251146566.0,\n",
       " 46268317366.0,\n",
       " 46268317660.0,\n",
       " 46277940752.0,\n",
       " 46279457521.0,\n",
       " 46303843731.0,\n",
       " 46304551225.0,\n",
       " 46318406129.0,\n",
       " 46332152055.0,\n",
       " 46334182952.0,\n",
       " 46334182962.0,\n",
       " 46372105184.0,\n",
       " 46384276442.0,\n",
       " 46395199610.0,\n",
       " 46395199892.0,\n",
       " 46403886563.0,\n",
       " 46446639023.0,\n",
       " 46446816438.0,\n",
       " 46447196491.0,\n",
       " 46448735850.0,\n",
       " 46454894213.0,\n",
       " 46456639496.0,\n",
       " 46456854910.0,\n",
       " 46461639736.0,\n",
       " 46466577475.0,\n",
       " 46479307466.0,\n",
       " 46491584660.0,\n",
       " 46494815241.0,\n",
       " 46495626725.0,\n",
       " 46500436601.0,\n",
       " 46506042075.0,\n",
       " 46507311503.0,\n",
       " 46542728194.0,\n",
       " 46543518000.0,\n",
       " 46549114779.0,\n",
       " 46557504534.0,\n",
       " 46573067864.0,\n",
       " 46574309176.0,\n",
       " 46574854088.0,\n",
       " 46576303076.0,\n",
       " 46580752266.0,\n",
       " 46584742393.0,\n",
       " 46587612633.0,\n",
       " 46589090160.0,\n",
       " 46593461051.0,\n",
       " 46593600846.0,\n",
       " 46596517073.0,\n",
       " 46596518213.0,\n",
       " 46596893724.0,\n",
       " 46599657995.0,\n",
       " 46603466233.0,\n",
       " 46606045061.0,\n",
       " 46608966547.0,\n",
       " 46609136580.0,\n",
       " 46610236339.0,\n",
       " 46614695255.0,\n",
       " 46617384258.0,\n",
       " 46620112415.0,\n",
       " 46621066158.0,\n",
       " 46625007467.0,\n",
       " 46625418187.0,\n",
       " 46630602636.0,\n",
       " 46630603047.0,\n",
       " 46631831475.0,\n",
       " 46634677904.0,\n",
       " 46641891202.0,\n",
       " 46645629992.0,\n",
       " 46659503645.0,\n",
       " 46662282355.0,\n",
       " 46665935182.0,\n",
       " 46675025320.0,\n",
       " 46682819817.0,\n",
       " 46686715756.0,\n",
       " 46695488241.0,\n",
       " 46698213383.0,\n",
       " 46699026663.0,\n",
       " 46700552149.0,\n",
       " 46709985099.0,\n",
       " 46711119570.0,\n",
       " 46714384369.0,\n",
       " 46720042500.0,\n",
       " 46725613916.0,\n",
       " 46729236692.0,\n",
       " 46732090105.0,\n",
       " 46737449674.0,\n",
       " 46741214438.0,\n",
       " 46741619060.0,\n",
       " 46751225753.0,\n",
       " 46752619565.0,\n",
       " 46753268566.0,\n",
       " 46757691784.0,\n",
       " 46765857443.0,\n",
       " 46771487730.0,\n",
       " 46779534591.0,\n",
       " 46814314980.0,\n",
       " 46844438796.0,\n",
       " 46866782952.0,\n",
       " 46872496060.0,\n",
       " 46886114781.0,\n",
       " 46891297920.0,\n",
       " 46897176560.0,\n",
       " 46907166548.0,\n",
       " 46909185723.0,\n",
       " 46933154109.0,\n",
       " 46934192280.0,\n",
       " 46936327179.0,\n",
       " 46942037751.0,\n",
       " 46950662726.0,\n",
       " 46951184708.0,\n",
       " 46951246004.0,\n",
       " 46963493732.0,\n",
       " 46967832435.0,\n",
       " 46988021287.0,\n",
       " 46992887879.0,\n",
       " 46996638200.0,\n",
       " 47004487895.0,\n",
       " 47009339023.0,\n",
       " 47014455658.0,\n",
       " 47023189811.0,\n",
       " 47031588517.0,\n",
       " 47037428288.0,\n",
       " 47038416853.0,\n",
       " 47054172939.0,\n",
       " 47054173005.0,\n",
       " 47057981800.0,\n",
       " 47057981815.0,\n",
       " 47059054829.0,\n",
       " 47073250580.0,\n",
       " 47092137311.0,\n",
       " 47097534326.0,\n",
       " 47097740212.0,\n",
       " 47105634087.0,\n",
       " 47117667339.0,\n",
       " 47119720871.0,\n",
       " 47121497070.0,\n",
       " 47123838040.0,\n",
       " 47123838346.0,\n",
       " 47123975632.0,\n",
       " 47124396467.0,\n",
       " 47126258701.0,\n",
       " 47137694046.0,\n",
       " 47151016057.0,\n",
       " 47151792928.0,\n",
       " 47155620210.0,\n",
       " 47160830908.0,\n",
       " 47169845983.0,\n",
       " 47187350048.0,\n",
       " 47189687516.0,\n",
       " 47191300248.0,\n",
       " 47192423695.0,\n",
       " 47193099128.0,\n",
       " 47200074595.0,\n",
       " 47203956501.0,\n",
       " 47206067530.0,\n",
       " 47213083526.0,\n",
       " 47213083540.0,\n",
       " 47213083748.0,\n",
       " 47214950386.0,\n",
       " 47218974735.0,\n",
       " 47220156953.0,\n",
       " 47224699385.0,\n",
       " 47241844635.0,\n",
       " 47251578142.0,\n",
       " 47258426430.0,\n",
       " 47262496173.0,\n",
       " 47266249612.0,\n",
       " 47270586315.0,\n",
       " 47280653214.0,\n",
       " 47281978352.0,\n",
       " 47290688087.0,\n",
       " 47292897871.0,\n",
       " 47295199228.0,\n",
       " 47295278151.0,\n",
       " 47296077429.0,\n",
       " 47296513126.0,\n",
       " 47323316147.0,\n",
       " 47327188801.0,\n",
       " 47332417712.0,\n",
       " 47386415052.0,\n",
       " 47388513064.0,\n",
       " 47393205518.0,\n",
       " 47409524906.0,\n",
       " 47421765273.0,\n",
       " 47423564565.0,\n",
       " 47424247064.0,\n",
       " 47430969747.0,\n",
       " 47433292743.0,\n",
       " 47438067516.0,\n",
       " 47449152443.0,\n",
       " 47455636572.0,\n",
       " 47457985726.0,\n",
       " 47460605240.0,\n",
       " 47470516849.0,\n",
       " 47479222085.0,\n",
       " 47482473399.0,\n",
       " 47493716399.0,\n",
       " 47506392559.0,\n",
       " 47517915001.0,\n",
       " 47526185673.0,\n",
       " 47539584016.0,\n",
       " 47548893314.0,\n",
       " 47548893640.0,\n",
       " 47548894023.0,\n",
       " 47557285014.0,\n",
       " 47562216114.0,\n",
       " 47574253508.0,\n",
       " 47579080142.0,\n",
       " 47584900272.0,\n",
       " 47592639117.0,\n",
       " 47592639142.0,\n",
       " 47592639170.0,\n",
       " 47596112329.0,\n",
       " 47601184962.0,\n",
       " 47601185027.0,\n",
       " 47605867600.0,\n",
       " 47605867689.0,\n",
       " 47605867723.0,\n",
       " 47605867761.0,\n",
       " 47608609534.0,\n",
       " 47611420616.0,\n",
       " 47612152212.0,\n",
       " 47616541545.0,\n",
       " 47622271760.0,\n",
       " 47624421443.0,\n",
       " 47634028108.0,\n",
       " 47634849205.0,\n",
       " 47647116072.0,\n",
       " 47647116410.0,\n",
       " 47647116427.0,\n",
       " 47647116437.0,\n",
       " 47647116448.0,\n",
       " 47647116474.0,\n",
       " 47647506198.0,\n",
       " 47647506508.0,\n",
       " 47648027883.0,\n",
       " 47648027893.0,\n",
       " 47655419400.0,\n",
       " 47666076162.0,\n",
       " 47672661789.0,\n",
       " 47672661812.0,\n",
       " 47672661831.0,\n",
       " 47672661850.0,\n",
       " 47672661870.0,\n",
       " 47674536244.0,\n",
       " 47676086058.0,\n",
       " 47680436282.0,\n",
       " 47680586404.0,\n",
       " 47682375460.0,\n",
       " 47682628825.0,\n",
       " 47686004416.0,\n",
       " 47699265942.0,\n",
       " 47699265956.0,\n",
       " 47699266003.0,\n",
       " 47708798278.0,\n",
       " 47708798304.0,\n",
       " 47708798347.0,\n",
       " 47708798386.0,\n",
       " 47710401987.0,\n",
       " 47710402010.0,\n",
       " 47710402040.0,\n",
       " 47710402080.0,\n",
       " 47710402131.0,\n",
       " 47710402151.0,\n",
       " 47710402184.0,\n",
       " 47710770929.0,\n",
       " 47719668720.0,\n",
       " 47719669126.0,\n",
       " 47732437460.0,\n",
       " 47740811983.0,\n",
       " 47740812015.0,\n",
       " 47741264679.0,\n",
       " 47744356910.0,\n",
       " 47747999266.0,\n",
       " 47762674177.0,\n",
       " 47770943218.0,\n",
       " 47772263412.0,\n",
       " 47781823879.0,\n",
       " 47801813259.0,\n",
       " 47802743655.0,\n",
       " 47804243829.0,\n",
       " 47813005250.0,\n",
       " 47813005590.0,\n",
       " 47813005643.0,\n",
       " 47814597038.0,\n",
       " 47818339831.0,\n",
       " 47820331132.0,\n",
       " 47827895222.0,\n",
       " 47829424281.0,\n",
       " 47848123466.0,\n",
       " 47850370024.0,\n",
       " 47850370369.0,\n",
       " 47867955266.0,\n",
       " 47871594551.0,\n",
       " 47873848461.0,\n",
       " 47891082629.0,\n",
       " 47913407654.0,\n",
       " 47927449093.0,\n",
       " 47991263140.0,\n",
       " 48039253794.0,\n",
       " 48040229534.0,\n",
       " 48040229959.0,\n",
       " 48061630506.0,\n",
       " 48071286648.0,\n",
       " 48072278044.0,\n",
       " 48072278069.0,\n",
       " 48072693089.0,\n",
       " 48072890795.0,\n",
       " 48073617636.0,\n",
       " 48073617700.0,\n",
       " 48082842491.0,\n",
       " 48085305781.0,\n",
       " 48085465671.0,\n",
       " 48102957633.0,\n",
       " 48113787124.0,\n",
       " 48133592090.0,\n",
       " 48133592100.0,\n",
       " 48133751164.0,\n",
       " 48173284550.0,\n",
       " 48185087054.0,\n",
       " 48195784311.0,\n",
       " 48195784325.0,\n",
       " 48195963823.0,\n",
       " 48206165358.0,\n",
       " 48246861554.0,\n",
       " 48247127954.0,\n",
       " 48247127975.0,\n",
       " 48247374287.0,\n",
       " 48247374323.0,\n",
       " 48250245301.0,\n",
       " 48250479035.0,\n",
       " 48252013666.0,\n",
       " 48257803010.0,\n",
       " 48258320820.0,\n",
       " 48272320419.0,\n",
       " 48280186901.0,\n",
       " 48291819957.0,\n",
       " 48301553579.0,\n",
       " 48312153977.0,\n",
       " 48312154008.0,\n",
       " 48312154028.0,\n",
       " 48312154038.0,\n",
       " 48312154048.0,\n",
       " 48333528943.0,\n",
       " 48342746463.0,\n",
       " 48343470696.0,\n",
       " 48346575752.0,\n",
       " 48364928139.0,\n",
       " 48365115942.0,\n",
       " 48365311574.0,\n",
       " 48365311598.0,\n",
       " 48367198772.0,\n",
       " 48376228935.0,\n",
       " 48387350840.0,\n",
       " 48387891310.0,\n",
       " 48432988722.0,\n",
       " 48433099271.0,\n",
       " 48433099285.0,\n",
       " 48445066357.0,\n",
       " 48445066374.0,\n",
       " 48451820285.0,\n",
       " 48478311548.0,\n",
       " 48490614603.0,\n",
       " 48506051297.0,\n",
       " 48542126232.0,\n",
       " 48565696952.0,\n",
       " 48575515711.0,\n",
       " 48584917388.0,\n",
       " 48586797060.0,\n",
       " 48597520274.0,\n",
       " 48605447455.0,\n",
       " 48626109328.0,\n",
       " 48631102637.0,\n",
       " 48648324990.0,\n",
       " 48670317849.0,\n",
       " 48689791287.0,\n",
       " 48689791323.0,\n",
       " 48702970249.0,\n",
       " 48709720652.0,\n",
       " 48718354389.0,\n",
       " 48737857501.0,\n",
       " 48744275747.0,\n",
       " 48744553079.0,\n",
       " 48746084217.0,\n",
       " 48746753872.0,\n",
       " 48747495516.0,\n",
       " 48750946902.0,\n",
       " 48750946933.0,\n",
       " 48750947197.0,\n",
       " 48750947242.0,\n",
       " 48750947293.0,\n",
       " 48751577557.0,\n",
       " 48751577585.0,\n",
       " 48751577684.0,\n",
       " 48751577703.0,\n",
       " 48752027115.0,\n",
       " 48752027140.0,\n",
       " 48752027530.0,\n",
       " 48752755594.0,\n",
       " 48752755614.0,\n",
       " 48753184772.0,\n",
       " 48753552811.0,\n",
       " 48754178190.0,\n",
       " 48755889043.0,\n",
       " 48760413108.0,\n",
       " 48762277641.0,\n",
       " 48784372289.0,\n",
       " 48785215022.0,\n",
       " 48787417169.0,\n",
       " 48787495997.0,\n",
       " 48787527048.0,\n",
       " 48790165454.0,\n",
       " 48791247527.0,\n",
       " 48791247567.0,\n",
       " 48792198802.0,\n",
       " 48792678452.0,\n",
       " 48792992472.0,\n",
       " 48794160789.0,\n",
       " 48803799149.0,\n",
       " 48806838466.0,\n",
       " 48807365360.0,\n",
       " 48808327285.0,\n",
       " 48809897462.0,\n",
       " 48811292376.0,\n",
       " 48814408064.0,\n",
       " 48820282118.0,\n",
       " 48824252291.0,\n",
       " 48825222573.0,\n",
       " 48836099137.0,\n",
       " 48836422477.0,\n",
       " 48839847294.0,\n",
       " ...]"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.select('time').distinct().sort('time', ascending=True).rdd.flatMap(lambda x: x).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'memory': 0.5, 'cpu': 1.0},\n",
       " {'collection_ids': None,\n",
       "  'instance_indexes': None,\n",
       "  'times': None,\n",
       "  'durations': None,\n",
       "  'priorities': None},\n",
       " 0,\n",
       " 0]"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machinesRunningInfo[92126449465.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['time',\n",
       " 'machine_id',\n",
       " 'type',\n",
       " 'switch_id',\n",
       " 'platform_id',\n",
       " 'missing_data_reason',\n",
       " 'memory_capacity',\n",
       " 'cpu_capacity']"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92126449465.0 0.0 1.0 1.0 0.5\n"
     ]
    }
   ],
   "source": [
    "tstdf = dfMachine_events.select('machine_id', 'time', 'type', 'cpu_capacity', 'memory_capacity').collect()\n",
    "\n",
    "for machine, time, type, cpu, memory in tstdf:\n",
    "    print(machine, time, type, cpu, memory)\n",
    "    break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[102892982852.0,\n",
       " 1579832655.0,\n",
       " 1574329911.0,\n",
       " 44327628355.0,\n",
       " 44493424971.0,\n",
       " 44338119771.0,\n",
       " 23744677134.0,\n",
       " 102892982852.0,\n",
       " 280915661294.0,\n",
       " 1579760836.0,\n",
       " 1579815410.0,\n",
       " 1579722454.0,\n",
       " 1579462312.0,\n",
       " 1579760979.0,\n",
       " 102894724234.0,\n",
       " 574675431.0,\n",
       " 572902041.0,\n",
       " 44994105741.0,\n",
       " 573125313.0,\n",
       " 35891849385.0,\n",
       " 70338052101.0,\n",
       " 573130630.0,\n",
       " 574490256.0,\n",
       " 44432949466.0,\n",
       " 574432123.0,\n",
       " 93516757997.0,\n",
       " 40159863710.0,\n",
       " 86188560608.0,\n",
       " 96914881883.0,\n",
       " 44499257564.0,\n",
       " 104792798696.0,\n",
       " 45163617204.0,\n",
       " 348039609205.0,\n",
       " 373870252151.0,\n",
       " 574715302.0,\n",
       " 574465775.0,\n",
       " 25535109069.0,\n",
       " 104791526323.0,\n",
       " 55049743664.0,\n",
       " 44434192503.0,\n",
       " 102894420327.0,\n",
       " 1579460561.0,\n",
       " 1579460561.0,\n",
       " 573128890.0,\n",
       " 573115987.0,\n",
       " 574480415.0,\n",
       " 1377377717.0,\n",
       " 35893131594.0,\n",
       " 23744627221.0,\n",
       " 23770707138.0,\n",
       " 73747258778.0,\n",
       " 25013784437.0,\n",
       " 104792603923.0,\n",
       " 25013784437.0,\n",
       " 20741529.0,\n",
       " 21430418.0,\n",
       " 44591936371.0,\n",
       " 25535045122.0,\n",
       " 86188560608.0,\n",
       " 25013784437.0,\n",
       " 35882188436.0,\n",
       " 92031092474.0,\n",
       " 373578848227.0,\n",
       " 352962709124.0,\n",
       " 21387320.0,\n",
       " 104792041704.0,\n",
       " 143876847279.0,\n",
       " 373578576838.0,\n",
       " 105126709465.0,\n",
       " 104792130851.0,\n",
       " 20736708.0,\n",
       " 20736692.0,\n",
       " 21284380.0,\n",
       " 21375454.0,\n",
       " 34560063.0,\n",
       " 21558858.0,\n",
       " 20737037.0,\n",
       " 20736844.0,\n",
       " 36050084903.0,\n",
       " 25676982.0,\n",
       " 21400964.0,\n",
       " 20737005.0,\n",
       " 26006751.0,\n",
       " 105213962589.0,\n",
       " 102983239691.0,\n",
       " 93522167453.0,\n",
       " 104791450693.0,\n",
       " 104791450680.0,\n",
       " 104792326079.0,\n",
       " 143876604227.0,\n",
       " 102894346371.0,\n",
       " 96917056612.0,\n",
       " 180919610408.0,\n",
       " 20741481.0,\n",
       " 22620986.0,\n",
       " 21366202.0,\n",
       " 1715349839.0,\n",
       " 360096475768.0,\n",
       " 105214688657.0,\n",
       " 21382996.0,\n",
       " 20736932.0,\n",
       " 21412015.0,\n",
       " 3092537147.0,\n",
       " 20738144.0,\n",
       " 20736924.0,\n",
       " 21284384.0,\n",
       " 21112873.0,\n",
       " 20734337.0,\n",
       " 20736993.0,\n",
       " 21372308.0,\n",
       " 1712866415.0,\n",
       " 20736919.0,\n",
       " 21389239.0,\n",
       " 360096584282.0,\n",
       " 21378223.0,\n",
       " 88409069898.0,\n",
       " 21375646.0,\n",
       " 21284872.0,\n",
       " 21284767.0,\n",
       " 21284321.0,\n",
       " 20737119.0,\n",
       " 21382997.0,\n",
       " 96916043191.0,\n",
       " 104792376637.0,\n",
       " 21373047.0,\n",
       " 21382999.0,\n",
       " 21530654.0,\n",
       " 359825842415.0,\n",
       " 20737138.0,\n",
       " 360234052793.0,\n",
       " 104792102077.0,\n",
       " 1375374317.0,\n",
       " 102983317675.0,\n",
       " 21072261.0,\n",
       " 21128900.0,\n",
       " 21880033.0,\n",
       " 20736925.0,\n",
       " 104791450681.0,\n",
       " 143876944375.0,\n",
       " 20736930.0,\n",
       " 21284875.0,\n",
       " 373579085649.0,\n",
       " 1638743919.0,\n",
       " 1638822238.0,\n",
       " 127001112763.0,\n",
       " 20737070.0,\n",
       " 104792326080.0,\n",
       " 249388539987.0,\n",
       " 1377377762.0,\n",
       " 104791627997.0,\n",
       " 21437725.0,\n",
       " 96916336080.0,\n",
       " 21297603.0,\n",
       " 4459193359.0,\n",
       " 22505140.0,\n",
       " 21308826.0,\n",
       " 4451633799.0,\n",
       " 128562408713.0,\n",
       " 20737549.0,\n",
       " 3093463669.0,\n",
       " 1578781504.0,\n",
       " 1375616181.0,\n",
       " 19917846519.0,\n",
       " 2059698354.0,\n",
       " 23749063647.0,\n",
       " 2449640455.0,\n",
       " 23748990288.0,\n",
       " 360232097829.0,\n",
       " 20733596.0,\n",
       " 4458944111.0,\n",
       " 1461283652.0,\n",
       " 1375593567.0,\n",
       " 573249720.0,\n",
       " 20744584.0,\n",
       " 23754213804.0,\n",
       " 4646883554.0,\n",
       " 1376368800.0,\n",
       " 1376335590.0,\n",
       " 70338052101.0,\n",
       " 20737055.0,\n",
       " 20736940.0,\n",
       " 75504587644.0,\n",
       " 35872543662.0,\n",
       " 4450932869.0,\n",
       " 4451070325.0,\n",
       " 2957842774.0,\n",
       " 293283971023.0,\n",
       " 53767373293.0,\n",
       " 35973968030.0,\n",
       " 4450933045.0,\n",
       " 334694608511.0,\n",
       " 198552471370.0,\n",
       " 25537020398.0,\n",
       " 373229493970.0,\n",
       " 21242379.0,\n",
       " 108569645120.0,\n",
       " 20744357.0,\n",
       " 34773740672.0,\n",
       " 21109329.0,\n",
       " 21378226.0,\n",
       " 4451161211.0,\n",
       " 494897527.0,\n",
       " 45163617204.0,\n",
       " 4468807961.0,\n",
       " 574480415.0,\n",
       " 70525860597.0,\n",
       " 2449425154.0,\n",
       " 1713162907.0,\n",
       " 20733597.0,\n",
       " 24289989731.0,\n",
       " 297653628576.0,\n",
       " 4459219574.0,\n",
       " 4459198729.0,\n",
       " 21375457.0,\n",
       " 4459282050.0,\n",
       " 2059424866.0,\n",
       " 4450834282.0,\n",
       " 77435278858.0,\n",
       " 1376330409.0,\n",
       " 21384470.0,\n",
       " 20981430.0,\n",
       " 20733613.0,\n",
       " 1604990879.0,\n",
       " 20748053.0,\n",
       " 1461292423.0,\n",
       " 2243916040.0,\n",
       " 107689502.0,\n",
       " 296342736359.0,\n",
       " 77439046230.0,\n",
       " 4451164029.0,\n",
       " 104792275448.0,\n",
       " 1376481610.0,\n",
       " 1161528242.0,\n",
       " 1377327251.0,\n",
       " 68443908728.0,\n",
       " 1375641748.0,\n",
       " 1375616123.0,\n",
       " 96915615613.0,\n",
       " 1377994084.0,\n",
       " 19882051227.0,\n",
       " 23744673029.0,\n",
       " 360232054153.0,\n",
       " 22669389.0,\n",
       " 23744627221.0,\n",
       " 2449580330.0,\n",
       " 1375616182.0,\n",
       " 2958235318.0,\n",
       " 2961068391.0,\n",
       " 363903213105.0,\n",
       " 4468841060.0,\n",
       " 23744712975.0,\n",
       " 36221387676.0,\n",
       " 36050512310.0,\n",
       " 23749026789.0,\n",
       " 80669614631.0,\n",
       " 938828872.0,\n",
       " 2448094865.0,\n",
       " 1375479411.0,\n",
       " 24270649338.0,\n",
       " 3098304099.0,\n",
       " 104791421192.0,\n",
       " 21430417.0,\n",
       " 1376035963.0,\n",
       " 21389237.0,\n",
       " 21307905.0,\n",
       " 21284765.0,\n",
       " 1376335591.0,\n",
       " 46220802480.0,\n",
       " 90725545671.0,\n",
       " 20736678.0,\n",
       " 21814902.0,\n",
       " 19882913433.0,\n",
       " 45449695473.0,\n",
       " 45422102990.0,\n",
       " 1128625127.0,\n",
       " 2958239100.0,\n",
       " 10879508095.0,\n",
       " 35882146929.0,\n",
       " 4646853973.0,\n",
       " 24273051133.0,\n",
       " 4450781991.0,\n",
       " 20736711.0,\n",
       " 1377377718.0,\n",
       " 21399554.0,\n",
       " 4451020877.0,\n",
       " 22368119.0,\n",
       " 2059086188.0,\n",
       " 1375606823.0,\n",
       " 2448094864.0,\n",
       " 495556297.0,\n",
       " 27208683.0,\n",
       " 20946831.0,\n",
       " 36050798942.0,\n",
       " 2960611688.0,\n",
       " 10881612897.0,\n",
       " 20146503587.0,\n",
       " 2448129807.0,\n",
       " 71843022953.0,\n",
       " 4646657653.0,\n",
       " 23859856991.0,\n",
       " 24273107602.0,\n",
       " 939045172.0,\n",
       " 21408526.0,\n",
       " 20737011.0,\n",
       " 21284373.0,\n",
       " 21284213.0,\n",
       " 2448088341.0,\n",
       " 4458933234.0,\n",
       " 2449630191.0,\n",
       " 20744381.0,\n",
       " 20747579.0,\n",
       " 938905129.0,\n",
       " 20736668.0,\n",
       " 20737091.0,\n",
       " 1376620150.0,\n",
       " 77440415150.0,\n",
       " 2960942023.0,\n",
       " 1375389192.0,\n",
       " 35892271310.0,\n",
       " 23744632836.0,\n",
       " 938852336.0,\n",
       " 4649665950.0,\n",
       " 4451219516.0,\n",
       " 938957904.0,\n",
       " 938885672.0,\n",
       " 21178088.0,\n",
       " 21225084.0,\n",
       " 2449464111.0,\n",
       " 21243991.0,\n",
       " 36050364005.0,\n",
       " 19917839119.0,\n",
       " 72285478132.0,\n",
       " 2961169764.0,\n",
       " 20736956.0,\n",
       " 4451070322.0,\n",
       " 128558844450.0,\n",
       " 2059479298.0,\n",
       " 1377412697.0,\n",
       " 35872531885.0,\n",
       " 1377352748.0,\n",
       " 185699229086.0,\n",
       " 73007618119.0,\n",
       " 35875637443.0,\n",
       " 396816960.0,\n",
       " 20736951.0,\n",
       " 20736679.0,\n",
       " 96961511373.0,\n",
       " 1375616183.0,\n",
       " 1375475631.0,\n",
       " 1375623190.0,\n",
       " 2960942104.0,\n",
       " 23744712982.0,\n",
       " 21310332.0,\n",
       " 3092508310.0,\n",
       " 939000732.0,\n",
       " 1638817914.0,\n",
       " 70336392459.0,\n",
       " 374219354303.0,\n",
       " 4458984458.0,\n",
       " 20736881.0,\n",
       " 2957845087.0,\n",
       " 1130924862.0,\n",
       " 35881581569.0,\n",
       " 2448302565.0,\n",
       " 20737114.0,\n",
       " 374217185376.0,\n",
       " 80824342329.0,\n",
       " 10933493426.0,\n",
       " 4459472625.0,\n",
       " 33152153029.0,\n",
       " 2059021788.0,\n",
       " 36050197355.0,\n",
       " 127486390778.0,\n",
       " 1376297681.0,\n",
       " 52767141451.0,\n",
       " 20733598.0,\n",
       " 20737867.0,\n",
       " 35872445118.0,\n",
       " 68341413342.0,\n",
       " 4646080821.0,\n",
       " 574609784.0,\n",
       " 2960080993.0,\n",
       " 361046238087.0,\n",
       " 572902041.0,\n",
       " 260487321887.0,\n",
       " 20744587.0,\n",
       " 21464554.0,\n",
       " 36050478595.0,\n",
       " 45427990926.0,\n",
       " 21284209.0,\n",
       " 23859188838.0,\n",
       " 2960861699.0,\n",
       " 53768440403.0,\n",
       " 20734333.0,\n",
       " 2060303307.0,\n",
       " 23744555249.0,\n",
       " 938851617.0,\n",
       " 4451079771.0,\n",
       " 128557580048.0,\n",
       " 20737071.0,\n",
       " 572767334.0,\n",
       " 20736948.0,\n",
       " 22784754.0,\n",
       " 1187326085.0,\n",
       " 45425334477.0,\n",
       " 1376504123.0,\n",
       " 20136328047.0,\n",
       " 1375607069.0,\n",
       " 1376330391.0,\n",
       " 2957846673.0,\n",
       " 23859856991.0,\n",
       " 20737104.0,\n",
       " 359819475669.0,\n",
       " 1377126412.0,\n",
       " 1377904269.0,\n",
       " 4450957821.0,\n",
       " 4646177054.0,\n",
       " 1377075966.0,\n",
       " 4512111771.0,\n",
       " 4450856485.0,\n",
       " 1375488625.0,\n",
       " 2958224473.0,\n",
       " 3094478163.0,\n",
       " 96911569358.0,\n",
       " 1377921155.0,\n",
       " 571902122.0,\n",
       " 1376080052.0,\n",
       " 572514442.0,\n",
       " 21284368.0,\n",
       " 20736705.0,\n",
       " 20736974.0,\n",
       " 20736987.0,\n",
       " 22265819.0,\n",
       " 573576861.0,\n",
       " 69271243759.0,\n",
       " 4451111421.0,\n",
       " 24273649623.0,\n",
       " 4451020892.0,\n",
       " 24273024679.0,\n",
       " 4451012313.0,\n",
       " 1639282618.0,\n",
       " 297073097757.0,\n",
       " 23749194069.0,\n",
       " 23744711289.0,\n",
       " 2960875735.0,\n",
       " 24273991390.0,\n",
       " 24272897915.0,\n",
       " 20737536.0,\n",
       " 20737139.0,\n",
       " 3092923812.0,\n",
       " 20736913.0,\n",
       " 2058603886.0,\n",
       " 571643868.0,\n",
       " 1377899666.0,\n",
       " 939992334.0,\n",
       " 938989228.0,\n",
       " 21247079.0,\n",
       " 2960942057.0,\n",
       " 1377328836.0,\n",
       " 114640324325.0,\n",
       " 107698268573.0,\n",
       " 23859856991.0,\n",
       " 4667400959.0,\n",
       " 2449889587.0,\n",
       " 4451203481.0,\n",
       " 32977677596.0,\n",
       " 1377904335.0,\n",
       " 1376335586.0,\n",
       " 2449579098.0,\n",
       " 32972586955.0,\n",
       " 311936409579.0,\n",
       " 127697519822.0,\n",
       " 2958377152.0,\n",
       " 4647239008.0,\n",
       " 102894346373.0,\n",
       " 21455536.0,\n",
       " 20738128.0,\n",
       " 23657605.0,\n",
       " 20142892865.0,\n",
       " 4646190048.0,\n",
       " 24270689586.0,\n",
       " 4451168713.0,\n",
       " 20736933.0,\n",
       " 4450856714.0,\n",
       " 938779252.0,\n",
       " 4458912558.0,\n",
       " 35891849385.0,\n",
       " 20734322.0,\n",
       " 33687391507.0,\n",
       " 23744544997.0,\n",
       " 75644645115.0,\n",
       " 1377139849.0,\n",
       " 25013784437.0,\n",
       " 1185821955.0,\n",
       " 1375623572.0,\n",
       " 21421071.0,\n",
       " 1639302828.0,\n",
       " 1375613545.0,\n",
       " 35970848854.0,\n",
       " 113865479473.0,\n",
       " 32290735409.0,\n",
       " 62156456.0,\n",
       " 4459433738.0,\n",
       " 2724677155.0,\n",
       " 24273454568.0,\n",
       " 24270695545.0,\n",
       " 77439467926.0,\n",
       " 139998956730.0,\n",
       " 23028899.0,\n",
       " 4451168735.0,\n",
       " 938916803.0,\n",
       " 2448159274.0,\n",
       " 297123864547.0,\n",
       " 4450776993.0,\n",
       " 21575987.0,\n",
       " 1579711805.0,\n",
       " 125950523290.0,\n",
       " 938905380.0,\n",
       " 25956360.0,\n",
       " 4459200576.0,\n",
       " 2449628859.0,\n",
       " 4451432962.0,\n",
       " 23744543820.0,\n",
       " 23749096602.0,\n",
       " 249681967837.0,\n",
       " 32290701982.0,\n",
       " 35892321977.0,\n",
       " 55053145426.0,\n",
       " 20736591.0,\n",
       " 1639393793.0,\n",
       " 1375591284.0,\n",
       " 104792344442.0,\n",
       " 19882121483.0,\n",
       " 75472709324.0,\n",
       " 4450833295.0,\n",
       " 23744686627.0,\n",
       " 23749075893.0,\n",
       " 244909481692.0,\n",
       " 2448160091.0,\n",
       " 20738258.0,\n",
       " 2958146081.0,\n",
       " 112751262929.0,\n",
       " 1712972811.0,\n",
       " 30889482.0,\n",
       " 20737866.0,\n",
       " 2450595184.0,\n",
       " 21243995.0,\n",
       " 100217273.0,\n",
       " 4646445801.0,\n",
       " 2335861241.0,\n",
       " 45409764636.0,\n",
       " 20736731.0,\n",
       " 21372217.0,\n",
       " 939040528.0,\n",
       " 35971219282.0,\n",
       " 24273737478.0,\n",
       " 262851520619.0,\n",
       " 939090472.0,\n",
       " 10879664420.0,\n",
       " 2449580331.0,\n",
       " 334632915891.0,\n",
       " 23860253894.0,\n",
       " 2095153055.0,\n",
       " 4646454757.0,\n",
       " 1375375859.0,\n",
       " 50428396.0,\n",
       " 1185564279.0,\n",
       " 360232143642.0,\n",
       " 2961404821.0,\n",
       " 2960942021.0,\n",
       " 360096231194.0,\n",
       " 23744670419.0,\n",
       " 2449670537.0,\n",
       " 1187339114.0,\n",
       " 20973863.0,\n",
       " 33687376291.0,\n",
       " 938980718.0,\n",
       " 1376076741.0,\n",
       " 1377327253.0,\n",
       " 23859548954.0,\n",
       " 10879541101.0,\n",
       " 82974476169.0,\n",
       " 20737058.0,\n",
       " 1185859567.0,\n",
       " 35971172205.0,\n",
       " 22339897.0,\n",
       " 21238174.0,\n",
       " 35971223892.0,\n",
       " 35881981946.0,\n",
       " 2957767441.0,\n",
       " 23744555248.0,\n",
       " 44591936371.0,\n",
       " 23749113149.0,\n",
       " 1639113844.0,\n",
       " 23744545654.0,\n",
       " 35970971191.0,\n",
       " 2961393155.0,\n",
       " 77442344939.0,\n",
       " 21560059.0,\n",
       " 1376305244.0,\n",
       " 20737060.0,\n",
       " 35872866766.0,\n",
       " 35872539986.0,\n",
       " 22490634.0,\n",
       " 21412019.0,\n",
       " 21108567.0,\n",
       " 21393406.0,\n",
       " 20736686.0,\n",
       " 34985996.0,\n",
       " 21400968.0,\n",
       " 1639329069.0,\n",
       " 1377323906.0,\n",
       " 21400962.0,\n",
       " 573370823.0,\n",
       " 1375616178.0,\n",
       " 169543922388.0,\n",
       " 1376076740.0,\n",
       " 2450260493.0,\n",
       " 1376277003.0,\n",
       " 495596883.0,\n",
       " 4450951585.0,\n",
       " 55052448740.0,\n",
       " 573518757.0,\n",
       " 4459282047.0,\n",
       " 20733593.0,\n",
       " 20733607.0,\n",
       " 334582773765.0,\n",
       " 373311994480.0,\n",
       " 68671286457.0,\n",
       " 70529578045.0,\n",
       " 49850405.0,\n",
       " 77441368785.0,\n",
       " 1129148856.0,\n",
       " 4649866723.0,\n",
       " 521216012.0,\n",
       " 4451433073.0,\n",
       " 10880091288.0,\n",
       " 494811204.0,\n",
       " 75629300492.0,\n",
       " 24270631297.0,\n",
       " 10879548962.0,\n",
       " 24273119864.0,\n",
       " 4646469958.0,\n",
       " 53765620729.0,\n",
       " 19918009426.0,\n",
       " 35892268115.0,\n",
       " 32977724490.0,\n",
       " 24272952225.0,\n",
       " 1638804336.0,\n",
       " 80824306440.0,\n",
       " 4451012314.0,\n",
       " 21284372.0,\n",
       " 3109169097.0,\n",
       " 296401864789.0,\n",
       " 19882732948.0,\n",
       " 20736637.0,\n",
       " 1375475633.0,\n",
       " 939067339.0,\n",
       " 1377618118.0,\n",
       " 373215854037.0,\n",
       " 2058825532.0,\n",
       " 32977234272.0,\n",
       " 571890735.0,\n",
       " 494784279.0,\n",
       " 45413543434.0,\n",
       " 32981858613.0,\n",
       " 1185219177.0,\n",
       " 77442990681.0,\n",
       " 3219877813.0,\n",
       " 20744380.0,\n",
       " 4646595560.0,\n",
       " 940094804.0,\n",
       " 21284375.0,\n",
       " 24272636013.0,\n",
       " 1377352765.0,\n",
       " 3097531645.0,\n",
       " 21205162.0,\n",
       " 938779284.0,\n",
       " 70338093986.0,\n",
       " 1375897895.0,\n",
       " 20736698.0,\n",
       " 105213728905.0,\n",
       " 21366401.0,\n",
       " 2958186781.0,\n",
       " 4459587993.0,\n",
       " 80825455616.0,\n",
       " 23859645177.0,\n",
       " 25013784437.0,\n",
       " 494897526.0,\n",
       " 20142079056.0,\n",
       " 24273024667.0,\n",
       " 494834135.0,\n",
       " 20736897.0,\n",
       " 128352036654.0,\n",
       " 20967739.0,\n",
       " 20737025.0,\n",
       " 20737120.0,\n",
       " 330384008461.0,\n",
       " 1375477848.0,\n",
       " 3174410985.0,\n",
       " 21412982.0,\n",
       " 77437468868.0,\n",
       " 21392417.0,\n",
       " 1377961507.0,\n",
       " 24273400034.0,\n",
       " 2448204175.0,\n",
       " 2447757895.0,\n",
       " 35872405318.0,\n",
       " 36297059449.0,\n",
       " 668023731.0,\n",
       " 23859547980.0,\n",
       " 1713949398.0,\n",
       " 20741519.0,\n",
       " 35872405191.0,\n",
       " 2448138677.0,\n",
       " 2448129806.0,\n",
       " 36050051648.0,\n",
       " 2450258100.0,\n",
       " 20736902.0,\n",
       " 2058771713.0,\n",
       " 3092664378.0,\n",
       " 1503443861.0,\n",
       " 21373056.0,\n",
       " 22519898.0,\n",
       " 20737086.0,\n",
       " 73750100488.0,\n",
       " 21285495.0,\n",
       " 331895612913.0,\n",
       " 23749170578.0,\n",
       " 2960528268.0,\n",
       " 25534638781.0,\n",
       " 70521532667.0,\n",
       " 1375473511.0,\n",
       " 2449580335.0,\n",
       " 20736981.0,\n",
       " 1377888763.0,\n",
       " 20736638.0,\n",
       " 20738058.0,\n",
       " 4468924981.0,\n",
       " 4650060015.0,\n",
       " 250623081695.0,\n",
       " 1377542099.0,\n",
       " 104387609464.0,\n",
       " 62156447.0,\n",
       " 2449638514.0,\n",
       " 20737865.0,\n",
       " 23773698428.0,\n",
       " 23748856159.0,\n",
       " 4451038310.0,\n",
       " 20737057.0,\n",
       " 21378238.0,\n",
       " 4649685235.0,\n",
       " 24273424205.0,\n",
       " 1377075979.0,\n",
       " 35881579049.0,\n",
       " 4646401464.0,\n",
       " 938717907.0,\n",
       " 104791526308.0,\n",
       " 62185123.0,\n",
       " 940046040.0,\n",
       " 35970981830.0,\n",
       " 2058869591.0,\n",
       " 320014305089.0,\n",
       " 138179916426.0,\n",
       " 360234112938.0,\n",
       " 23744688102.0,\n",
       " 21296942.0,\n",
       " 1375375858.0,\n",
       " 4450985239.0,\n",
       " 20736964.0,\n",
       " 23749111795.0,\n",
       " 297129235819.0,\n",
       " 198551369562.0,\n",
       " 4450846752.0,\n",
       " 4451128776.0,\n",
       " 35974353682.0,\n",
       " 1376548917.0,\n",
       " 1375480817.0,\n",
       " 1187491994.0,\n",
       " 938767765.0,\n",
       " 1375493313.0,\n",
       " 35970032861.0,\n",
       " 35882005350.0,\n",
       " 21408525.0,\n",
       " 23744429896.0,\n",
       " 20736886.0,\n",
       " 84774793960.0,\n",
       " 4458881207.0,\n",
       " 248826888822.0,\n",
       " 3094241974.0,\n",
       " 373579216279.0,\n",
       " 1375999038.0,\n",
       " 938582137.0,\n",
       " 2960767117.0,\n",
       " 2449416026.0,\n",
       " 45444599169.0,\n",
       " 33686724936.0,\n",
       " 23741797368.0,\n",
       " 24272149335.0,\n",
       " 10879075898.0,\n",
       " 23749264666.0,\n",
       " 24272650398.0,\n",
       " 105123311154.0,\n",
       " 21550977.0,\n",
       " 112751292604.0,\n",
       " 50650407.0,\n",
       " 22320982.0,\n",
       " 21307764.0,\n",
       " 1713141410.0,\n",
       " 25609200.0,\n",
       " 259731772237.0,\n",
       " 20736641.0,\n",
       " 62185161.0,\n",
       " 21296941.0,\n",
       " 96936815458.0,\n",
       " 104800886835.0,\n",
       " 102893244766.0,\n",
       " 19454967241.0,\n",
       " 23297977.0,\n",
       " 22477068.0,\n",
       " 2960948652.0,\n",
       " 2058902282.0,\n",
       " 938847647.0,\n",
       " 3096048232.0,\n",
       " 2960707192.0,\n",
       " 2447805563.0,\n",
       " 2058806854.0,\n",
       " 1377352804.0,\n",
       " 938854173.0,\n",
       " 2449037531.0,\n",
       " 2449416027.0,\n",
       " 940119882.0,\n",
       " 1377129933.0,\n",
       " 1185557718.0,\n",
       " 20736944.0,\n",
       " 4673904615.0,\n",
       " 289856136580.0,\n",
       " 23859643108.0,\n",
       " 24272870492.0,\n",
       " 344437928172.0,\n",
       " 360096629265.0,\n",
       " 35872379449.0,\n",
       " 2449630192.0,\n",
       " 33686927546.0,\n",
       " 23859751536.0,\n",
       " 4450793427.0,\n",
       " 4451071445.0,\n",
       " 4450958396.0,\n",
       " 21556000.0,\n",
       " 21387316.0,\n",
       " 32296205383.0,\n",
       " 4450787334.0,\n",
       " 19882840092.0,\n",
       " 19878963391.0,\n",
       " 1377790208.0,\n",
       " 23005003.0,\n",
       " 20738253.0,\n",
       " 21296398.0,\n",
       " 105505962816.0,\n",
       " 1491381526.0,\n",
       " 1185564414.0,\n",
       " 33690423191.0,\n",
       " 23860522120.0,\n",
       " 259857648737.0,\n",
       " 21399556.0,\n",
       " 96914452955.0,\n",
       " 312160155837.0,\n",
       " 1377117658.0,\n",
       " 4459508019.0,\n",
       " 20737044.0,\n",
       " 104597614857.0,\n",
       " 2449596197.0,\n",
       " 1377848359.0,\n",
       " 2449847516.0,\n",
       " 21576191.0,\n",
       " 1378099580.0,\n",
       " 1375476794.0,\n",
       " 5609426927.0,\n",
       " 4458933236.0,\n",
       " 1187491994.0,\n",
       " 360232973083.0,\n",
       " 348054508389.0,\n",
       " 2960942022.0,\n",
       " 2448138705.0,\n",
       " 23744680298.0,\n",
       " 35872801579.0,\n",
       " 170568685735.0,\n",
       " 20737108.0,\n",
       " 4450985243.0,\n",
       " 74607501474.0,\n",
       " 1162261743.0,\n",
       " 21564654.0,\n",
       " 7235052964.0,\n",
       " 32975479998.0,\n",
       " 21561852.0,\n",
       " 23859723060.0,\n",
       " 19876105366.0,\n",
       " 372910141539.0,\n",
       " 20737064.0,\n",
       " 32978295428.0,\n",
       " 20146756197.0,\n",
       " 55049743664.0,\n",
       " 70532274179.0,\n",
       " 35872391357.0,\n",
       " 1642011244.0,\n",
       " 1375391573.0,\n",
       " 23894642229.0,\n",
       " 21297602.0,\n",
       " 20747544.0,\n",
       " 112360341156.0,\n",
       " 20736916.0,\n",
       " 20737050.0,\n",
       " 21247439.0,\n",
       " 1377075998.0,\n",
       " 1377323905.0,\n",
       " 938885809.0,\n",
       " 4459131168.0,\n",
       " 4647326162.0,\n",
       " 21296094.0,\n",
       " 21214360.0,\n",
       " 23859500511.0,\n",
       " 32975521812.0,\n",
       " 4646001869.0,\n",
       " 23749096590.0,\n",
       " 35872445118.0,\n",
       " 45411998949.0,\n",
       " 20736965.0,\n",
       " 938767765.0,\n",
       " 21246716.0,\n",
       " 21242378.0,\n",
       " 2448132787.0,\n",
       " 21571381.0,\n",
       " 1375641575.0,\n",
       " 102983126799.0,\n",
       " 4458935410.0,\n",
       " 23744451423.0,\n",
       " 23744529618.0,\n",
       " 127516266643.0,\n",
       " 1377940832.0,\n",
       " 2449477711.0,\n",
       " 938957905.0,\n",
       " 20736683.0,\n",
       " 1376555938.0,\n",
       " 4649777267.0,\n",
       " 1375388647.0,\n",
       " 571885274.0,\n",
       " 77441611178.0,\n",
       " 1376476535.0,\n",
       " 20736690.0,\n",
       " 20736967.0,\n",
       " 35872303748.0,\n",
       " 21387315.0,\n",
       " 4451240253.0,\n",
       " 302499497017.0,\n",
       " 10881000111.0,\n",
       " 33687010791.0,\n",
       " 32976603040.0,\n",
       " 21408529.0,\n",
       " 1377327179.0,\n",
       " 20737162.0,\n",
       " 45422586579.0,\n",
       " 20737017.0,\n",
       " 20736714.0,\n",
       " 1185507476.0,\n",
       " 198551369561.0,\n",
       " 33151752931.0,\n",
       " 360202170868.0,\n",
       " 1375592481.0,\n",
       " 4451430231.0,\n",
       " 2450000756.0,\n",
       " 23859555568.0,\n",
       " 21381317.0,\n",
       " 20736647.0,\n",
       " 938730529.0,\n",
       " 1375824433.0,\n",
       " 938859237.0,\n",
       " 1377129858.0,\n",
       " 24273536295.0,\n",
       " 20737541.0,\n",
       " 2058552058.0,\n",
       " 4451436984.0,\n",
       " 21153047.0,\n",
       " 23856331406.0,\n",
       " 62185579.0,\n",
       " 102893299823.0,\n",
       " 2448203686.0,\n",
       " 23748865555.0,\n",
       " 4649860646.0,\n",
       " 23744514637.0,\n",
       " 35892262367.0,\n",
       " 104792289025.0,\n",
       " 20737531.0,\n",
       " 4450985241.0,\n",
       " 23859461314.0,\n",
       " 20733604.0,\n",
       " 23749080414.0,\n",
       " 21375642.0,\n",
       " 104791627994.0,\n",
       " 35892204313.0,\n",
       " 2958103698.0,\n",
       " ...]"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.filter(dfMachine_events.type == 2.0).select('machine_id').rdd.flatMap(lambda x: x).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0},\n",
       " {'collection_id': 374909906957.0,\n",
       "  'instance_index': 3.0,\n",
       "  'time': 0.0,\n",
       "  'cpu_request': 0.00026416778564453125,\n",
       "  'memory_request': 0.002410888671875,\n",
       "  'priority': 200.0}]"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tasks0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'memory': 0.5, 'cpu': 1.0},\n",
       " {'collection_ids': None,\n",
       "  'instance_indexes': None,\n",
       "  'times': None,\n",
       "  'durations': None,\n",
       "  'priorities': None},\n",
       " 0,\n",
       " 0]"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machinesRunningInfo[92126449465.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updateMachines(state, MachineEvents, time):\n",
    "    \"\"\"\n",
    "    Function that updates  the state: dictionnary of machines, current_tasks\n",
    "    \"\"\"\n",
    "    currentMachines = MachineEvents.filter(MachineEvents.time == time).collect()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['time',\n",
       " 'machine_id',\n",
       " 'type',\n",
       " 'switch_id',\n",
       " 'platform_id',\n",
       " 'missing_data_reason',\n",
       " 'memory_capacity',\n",
       " 'cpu_capacity']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(type=1.0), Row(type=2.0), Row(type=3.0)]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.select('type').distinct().collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------+----------+----+---------+-----------+-------------------+---------------+------------+\n",
      "|             time|machine_id|type|switch_id|platform_id|missing_data_reason|memory_capacity|cpu_capacity|\n",
      "+-----------------+----------+----+---------+-----------+-------------------+---------------+------------+\n",
      "|              0.0|1945139169| 1.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "| 3.20489993854E11|1945139169| 2.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "| 3.23131149422E11|1945139169| 1.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "| 9.43928053819E11|1945139169| 2.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "| 9.46334189084E11|1945139169| 1.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "|2.488311357199E12|1945139169| 2.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "| 2.49087332954E12|1945139169| 1.0|     null|       null|               null|      0.3334961|   0.5917969|\n",
      "+-----------------+----------+----+---------+-----------+-------------------+---------------+------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dfMachine_events.where((dfMachine_events.machine_id == 1945139169.0) ).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169),\n",
       " Row(machine_id=1945139169)]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfMachine_events.filter(dfMachine_events.machine_id == 1945139169.0).select('machine_id').collect()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3b094327bad1904107d29c0074ac3c4773dbfacc30fbd5b6f4f304f318479fa0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}