5_Experiment/SchedulerExperiment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import itertools\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import for log the data\n",
    "import hashlib\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "subset_sizes = [1, 4, 2, 1]\n",
    "subset_color = [\n",
    "    \"gold\",\n",
    "    \"violet\",\n",
    "    \"limegreen\",\n",
    "    \"darkorange\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges=[\n",
    "    (0, 1), (0, 2), (0, 3), (0, 4),\n",
    "    \n",
    "    (1, 5), (2, 5),\n",
    "    (3, 6), (4, 6),\n",
    "\n",
    "    (5, 7), (6, 7)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_durations = {\n",
    "    0 : {\n",
    "        \"duration\": 5,\n",
    "    },\n",
    "    1 : {   \n",
    "        \"duration\": 2,\n",
    "    },\n",
    "    2 : {\n",
    "        \"duration\": 2,\n",
    "    },\n",
    "    3 : {\n",
    "        \"duration\": 2,\n",
    "    },\n",
    "    4 : {\n",
    "        \"duration\": 2,\n",
    "    },\n",
    "    5 : {\n",
    "        \"duration\": 4,\n",
    "    },\n",
    "    6 : {\n",
    "        \"duration\": 3,\n",
    "    },\n",
    "    7 : {\n",
    "        \"duration\": 7,\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multilayered_graph(*subset_sizes:list[int], edges:list[tuple]=None) -> nx.DiGraph:\n",
    "    \"\"\"\n",
    "    Create a multilayered graph with the given subset sizes and edges. If edges is None, all possible edges connection between layers are created.\n",
    "    \n",
    "    Args:\n",
    "        subset_sizes (list[int]): The number of nodes in each layer.\n",
    "        edges (list[tuple]): A list of edges between layers. If None, all possible edges are created.\n",
    "\n",
    "    Returns:\n",
    "        nx.DiGraph: A multilayered graph.\n",
    "    \"\"\"\n",
    "    extents = nx.utils.pairwise(itertools.accumulate((0,) + subset_sizes))\n",
    "    layers = [range(start, end) for start, end in extents]\n",
    "    G = nx.DiGraph()\n",
    "    for i, layer in enumerate(layers):\n",
    "        G.add_nodes_from(layer, layer=i)\n",
    "\n",
    "    if edges is None:\n",
    "        for layer1, layer2 in nx.utils.pairwise(layers):\n",
    "            G.add_edges_from(itertools.product(layer1, layer2))\n",
    "    else:\n",
    "        G.add_edges_from(edges)\n",
    "\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def allocate_node_durations(G:nx.DiGraph, node_durations:dict) -> nx.DiGraph:\n",
    "    \"\"\"\n",
    "    Allocate the duration of each node in the graph.\n",
    "\n",
    "    Args:\n",
    "        G (nx.DiGraph): The graph to allocate the durations to.\n",
    "        node_durations (dict): A dictionary of node durations.\n",
    "    \n",
    "    Returns:\n",
    "        nx.DiGraph: The graph with the durations allocated\n",
    "    \"\"\"\n",
    "    for node, data in node_durations.items():\n",
    "        G.nodes[node][\"duration\"] = data[\"duration\"]\n",
    "    return G"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OutEdgeView([(0, 1), (0, 2), (0, 3), (0, 4), (1, 5), (2, 5), (3, 6), (4, 6), (5, 7), (6, 7)])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = multilayered_graph(*subset_sizes, edges=edges)\n",
    "G.edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeDataView({0: {'layer': 0, 'duration': 5}, 1: {'layer': 1, 'duration': 2}, 2: {'layer': 1, 'duration': 2}, 3: {'layer': 1, 'duration': 2}, 4: {'layer': 1, 'duration': 2}, 5: {'layer': 2, 'duration': 4}, 6: {'layer': 2, 'duration': 3}, 7: {'layer': 3, 'duration': 7}})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = allocate_node_durations(G, node_durations)\n",
    "G.nodes.data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "color = [subset_color[data[\"layer\"]] for v, data in G.nodes(data=True)]\n",
    "pos = nx.multipartite_layout(G, subset_key=\"layer\", align='horizontal')\n",
    "plt.figure(figsize=(4,4))\n",
    "nx.draw_networkx(G, pos, node_color=color)\n",
    "# nx.draw_networkx_edge_labels(\n",
    "#     G, pos, edge_labels={(u, v): d[\"weight\"] for u, v, d in G.edges(data=True)}\n",
    "# )\n",
    "plt.axis(\"equal\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Task:\n",
    "    \"\"\"\n",
    "    Represents a task with a name, priority, and duration.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): The name of the task.\n",
    "        duration (int): The duration of the task in minutes.\n",
    "        priority (int): The priority of the task. Lower numbers indicate higher priority.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, name:str, duration:int, priority:int=0) -> None:\n",
    "        \"\"\"\n",
    "        Initializes a new Task instance.\n",
    "\n",
    "        Args:\n",
    "            name (str): The name of the task.\n",
    "            duration (int): The duration of the task in minutes.\n",
    "            priority (int): The priority of the task.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.priority = priority\n",
    "        self.duration = duration\n",
    "        self.status = False # False = not started, True = completed\n",
    "        self.dependencies = [Task]\n",
    "        self.enable = False # False = not enabled, True = enabled\n",
    "        self.processed_by:str = None\n",
    "\n",
    "        self.start_time = 0\n",
    "        self.end_time = self.start_time + self.duration\n",
    "\n",
    "    def check_status(self) -> bool:\n",
    "        \"\"\"\n",
    "        Checks the status of the task.\n",
    "        False = not started;\n",
    "        True = completed;\n",
    "\n",
    "        Returns:\n",
    "            bool: The status of the task.\n",
    "        \"\"\"\n",
    "        return self.status\n",
    "\n",
    "    def start_task(self, start_time:int) -> None:\n",
    "        \"\"\"\n",
    "        Starts the task.\n",
    "\n",
    "        Args:\n",
    "            start_time (int): The start time of the task.\n",
    "        \"\"\"\n",
    "        self.start_time = start_time\n",
    "\n",
    "    def end_task(self) -> None:\n",
    "        \"\"\"\n",
    "        Ends the task.\n",
    "\n",
    "        Args:\n",
    "            end_time (int): The end time of the task.\n",
    "        \"\"\"\n",
    "        self.end_time = self.start_time + self.duration\n",
    "\n",
    "    def task_data(self) -> dict:\n",
    "        \"\"\"\n",
    "        Returns the task data.\n",
    "\n",
    "        Returns:\n",
    "            dict: The task data.\n",
    "        \"\"\"\n",
    "        return {\n",
    "            \"name\": str(self.name),\n",
    "            \"duration\": self.duration,\n",
    "            \"priority\": self.priority,\n",
    "            \"status\": self.status,\n",
    "            \"dependencies\": self.dependencies,\n",
    "            \"enable\": self.enable,\n",
    "            \"processed_by\": self.processed_by,\n",
    "            \"start_time\": self.start_time,\n",
    "            \"end_time\": self.end_time\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Returns a string representation of the Task instance.\n",
    "\n",
    "        Returns:\n",
    "            str: A string representation of the Task instance.\n",
    "        \"\"\"\n",
    "        return f\"Task(name={self.name}, duration={self.duration})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Processor:\n",
    "    \"\"\"\n",
    "    Represents a processor that executes tasks.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): The name of the processor.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, name: str):\n",
    "        \"\"\"\n",
    "        Initializes a new Processor instance.\n",
    "\n",
    "        Args:\n",
    "            name (str): The name of the processor.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "\n",
    "        self.task:Task = None\n",
    "        self.active = False\n",
    "        self.status = \"idle\"\n",
    "\n",
    "    def check_status(self):\n",
    "        \"\"\"\n",
    "        Checks the status of the processor.\n",
    "\n",
    "        Returns:\n",
    "            str: The status of the processor.\n",
    "        \"\"\"\n",
    "        return self.status\n",
    "\n",
    "    def activate(self):\n",
    "        \"\"\"\n",
    "        Activates the processor.\n",
    "        \"\"\"\n",
    "        self.active = True\n",
    "        self.status = \"busy\"\n",
    "\n",
    "    def deactivate(self):\n",
    "        \"\"\"\n",
    "        Deactivates the processor.\n",
    "        \"\"\"\n",
    "        self.active = False\n",
    "        self.status = \"idle\"\n",
    "        self.task = None\n",
    "    \n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Returns a string representation of the Processor instance.\n",
    "\n",
    "        Returns:\n",
    "            str: A string representation of the Processor instance.\n",
    "        \"\"\"\n",
    "        return f\"Processor(name={self.name}, Satus={self.status}, Task={self.task})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Scheduler:\n",
    "    \"\"\"\n",
    "    Manages a list of tasks, allowing tasks to be added, removed, and executed based on priority.\n",
    "\n",
    "    Attributes:\n",
    "        tasks (list): A list of Task instances.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, graph:nx.DiGraph):\n",
    "        \"\"\"\n",
    "        Initializes a new Scheduler instance with an empty task list.\n",
    "\n",
    "        Attributes:\n",
    "            tasks (list): A list of Task instances.\n",
    "        \"\"\"\n",
    "        self.graph = graph\n",
    "        self.tasks:list[Task] = []\n",
    "        self.processor:list[Processor] = [] #, p2 := Processor(\"P2\")]\n",
    "\n",
    "        self.time = 0\n",
    "        self.pending_tasks:list[Task] = [] # list of tasks that can be executed\n",
    "        self.completed_tasks:list[Task] = [] # list of tasks that have been completed\n",
    "\n",
    "    def get_task(self, name:str) -> Task:\n",
    "        \"\"\"\n",
    "        Get a task by name.\n",
    "\n",
    "        Args:\n",
    "            name (str): The name of the task to get.\n",
    "\n",
    "        Returns:\n",
    "            Task: The task instance.\n",
    "        \"\"\"\n",
    "        return next((task for task in self.tasks if task.name == name), None)\n",
    "\n",
    "    def check_pending_tasks(self, name:str) -> bool:\n",
    "        \"\"\"\n",
    "        Check if a task is in the pending tasks list.\n",
    "\n",
    "        Args:\n",
    "            name (str): The name of the task to check.\n",
    "\n",
    "        Returns:\n",
    "            bool: True if the task is in the pending tasks list; False otherwise.\n",
    "        \"\"\"\n",
    "        return any(task.name == name for task in self.pending_tasks)\n",
    "\n",
    "    def get_task_dependencies(self, task:Task) -> list[Task]:\n",
    "        \"\"\"\n",
    "        Get the dependencies of a task.\n",
    "\n",
    "        Args:\n",
    "            task (Task): The task to get the dependencies of.\n",
    "\n",
    "        Returns:\n",
    "            list: The list of dependencies.\n",
    "        \"\"\"\n",
    "        return [self.get_task(name) for name in self.graph.predecessors(task.name)]\n",
    "        # return list(self.graph.predecessors(task.name))\n",
    "\n",
    "    def get_free_processor(self) -> Processor:\n",
    "        \"\"\"\n",
    "        Get a free processor.\n",
    "\n",
    "        Returns:\n",
    "            Processor: The free processor.\n",
    "        \"\"\"\n",
    "        for p in self.processor:\n",
    "            if not p.active:\n",
    "                return p\n",
    "        return None\n",
    "\n",
    "    def add_task(self, task:Task):\n",
    "        \"\"\"\n",
    "        Adds a new task to the scheduler and sorts the tasks by priority.\n",
    "\n",
    "        Args:\n",
    "            task (Task): The Task instance to add.\n",
    "        \"\"\"\n",
    "        self.tasks.append(task)\n",
    "        self.tasks.sort(key=lambda x: x.name)\n",
    "\n",
    "    def remove_pending_tasks(self, task:Task):\n",
    "        \"\"\"\n",
    "        Removes a task from the scheduler.\n",
    "\n",
    "        Args:\n",
    "            task (Task): The Task instance to remove.\n",
    "        \"\"\"\n",
    "        self.pending_tasks.remove(task)\n",
    "\n",
    "    def generate_tasks(self):\n",
    "        \"\"\"\n",
    "        Generates tasks from a directed graph.\n",
    "\n",
    "        Args:\n",
    "            graph (nx.DiGraph): A directed graph representing the tasks.\n",
    "        \"\"\"\n",
    "        self.tasks = []\n",
    "        for node in self.graph.nodes:\n",
    "            task = Task(node, self.graph.nodes[node]['duration'])\n",
    "            task.dependencies = self.get_task_dependencies(task)\n",
    "            self.add_task(task)\n",
    "            if len(task.dependencies) == 0:\n",
    "                task.enable = True\n",
    "                self.pending_tasks.append(task)\n",
    "\n",
    "    def generate_processors(self, quantity:int):\n",
    "        \"\"\"\n",
    "        Generates a quantity of processors.\n",
    "\n",
    "        Args:\n",
    "            quantity (int): The quantity of processors to generate.\n",
    "        \"\"\"\n",
    "        self.processor = []\n",
    "        for i in range(quantity):\n",
    "            processor = Processor(f\"P{i}\")\n",
    "            self.processor.append(processor)\n",
    "\n",
    "    def allocate_task_processor(self):\n",
    "        \"\"\"\n",
    "        Allocates a enabled tasks to a processor if there any of both available.\n",
    "        \"\"\"\n",
    "        if len(self.pending_tasks) == 0:\n",
    "            return\n",
    "\n",
    "        task = random.choice(self.pending_tasks)\n",
    "\n",
    "        if not task.status:\n",
    "            processor = self.get_free_processor()\n",
    "            if processor:\n",
    "                processor.task = task\n",
    "                processor.activate()\n",
    "                task.start_task(self.time)\n",
    "                task.end_task()\n",
    "                task.processed_by = processor.name\n",
    "                self.remove_pending_tasks(task)\n",
    "\n",
    "    def pre_allocation(self, allocation:dict):\n",
    "        \"\"\"\n",
    "        Pre-allocate tasks to processors.\n",
    "\n",
    "        Args:\n",
    "            allocation (dict): A dictionary of tasks allocated to processors.\n",
    "        \"\"\"\n",
    "\n",
    "        for task_name, processor_name in allocation.items():\n",
    "            task = self.get_task(task_name)\n",
    "            processor = next((p for p in self.processor if p.name == processor_name), None)\n",
    "            if (not processor.active) and self.check_pending_tasks(task_name):\n",
    "                processor.task = task\n",
    "                processor.activate()\n",
    "                task.start_task(self.time)\n",
    "                task.end_task()\n",
    "                task.processed_by = processor.name\n",
    "                self.remove_pending_tasks(task)\n",
    "\n",
    "    def complete_tasks(self):\n",
    "        \"\"\"\n",
    "        Completes tasks that have reached their end time. Foe each processor, check if the task has been completed.\n",
    "        \"\"\"\n",
    "        for processor in self.processor:\n",
    "            # print(f\"Processor: {processor.name}\")\n",
    "            if processor.task and self.time >= processor.task.end_time:\n",
    "                # print(f\"Task: {processor.task.name} completed\")\n",
    "                self.completed_tasks.append(processor.task)\n",
    "                processor.task.status = True\n",
    "                processor.deactivate()\n",
    "\n",
    "    def enable_task(self):\n",
    "        \"\"\"\n",
    "        Verify tasks that have all dependencies completed and enable them.\n",
    "        \"\"\"\n",
    "        for task in self.tasks:\n",
    "            if not task.status and not task.enable:\n",
    "                dependencies = [dep.status for dep in task.dependencies]\n",
    "                if all(dependencies):\n",
    "                    task.enable = True\n",
    "                    self.pending_tasks.append(task)\n",
    "\n",
    "    def create_allocation(self, grid:np.ndarray=None) -> dict:\n",
    "        \"\"\"\n",
    "        Create a random allocation of tasks to processors. If a grid is provided, the allocation is based on the grid. Otherwise, the allocation is random.\n",
    "\n",
    "        Args:\n",
    "            grid (np.ndarray): A grid of tasks allocated to processors.\n",
    "\n",
    "        Returns:\n",
    "            dict: A dictionary of tasks allocated to processors.\n",
    "\n",
    "        Example:\n",
    "            {\n",
    "                \"0\": \"P0\",\n",
    "                \"1\": \"P0\",\n",
    "                \"2\": \"P1\",\n",
    "                \"3\": \"P0\",\n",
    "                \"4\": \"P2\"\n",
    "            }\n",
    "        \n",
    "            grid = np.array([ 0, 0, 1, 0, 2])\n",
    "        \"\"\"\n",
    "        allocation = {}\n",
    "        if grid is not None:\n",
    "            for i, processor in enumerate(grid):\n",
    "                task = i\n",
    "                processor = f\"P{processor}\"\n",
    "                allocation[task] = processor\n",
    "        else:\n",
    "            for task in self.tasks:\n",
    "                allocation[task.name] = random.choice(self.processor).name\n",
    "        return allocation\n",
    "\n",
    "    def run(self, grid:np.ndarray=None):\n",
    "        \"\"\"\n",
    "        Runs the scheduler.\n",
    "        \"\"\"\n",
    "        self.generate_processors(2)\n",
    "        self.generate_tasks()\n",
    "        while len(self.completed_tasks) < len(self.tasks):\n",
    "            # print(f\"Time: {self.time}\")\n",
    "            # print(f\"Enable tasks: {[task.name for task in self.pending_tasks]}\")\n",
    "            # print(f\"Completed tasks: {[task.name for task in self.completed_tasks]}\")\n",
    "            # print(f\"Tasks: {[task.name for task in self.tasks]}\")\n",
    "            # print(f\"Time: {self.time}\")\n",
    "            # print(f\"Enable tasks: {[task.name for task in self.enable_tasks]}\")\n",
    "            # print(f\"Completed tasks: {[task.name for task in self.completed_tasks]}\")\n",
    "            # print(f\"Tasks: {[task.name for task in self.tasks]}\")\n",
    "            # print(f\"Processors: {[processor for processor in self.processor]}\")\n",
    "            \n",
    "            if grid is not None:\n",
    "                allocation = self.create_allocation(grid)\n",
    "                self.pre_allocation(allocation)\n",
    "            else:\n",
    "                for _ in range(len(self.processor)):\n",
    "                    self.allocate_task_processor()\n",
    "\n",
    "            self.complete_tasks()\n",
    "            self.time += 1\n",
    "\n",
    "            self.enable_task()\n",
    "\n",
    "            if self.time > 100:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CellularAutomata:\n",
    "    \"\"\"\n",
    "    Represents a 1D cellular automata with a given array size and number of timesteps.\n",
    "\n",
    "    Attributes:\n",
    "        array_size (int): The size of the 1D array.\n",
    "        timesteps (int): The number of timesteps to run the automata.\n",
    "        grid (np.array): The 1D array representing the cellular automata.\n",
    "    \"\"\"\n",
    "    def __init__(self, timesteps:int, array_size:int=8, grid:np.ndarray=None) -> None:\n",
    "        \"\"\"\n",
    "        Initializes a new CellularAutomata instance.\n",
    "\n",
    "        Args:\n",
    "            timesteps (int): The number of timesteps to run the automata.\n",
    "            array_size (int): The size of the 1D array.\n",
    "        \"\"\"\n",
    "        self.timesteps = timesteps\n",
    "        self.array_size = array_size\n",
    "\n",
    "        self.grid = grid\n",
    "        self.history:np.ndarray\n",
    "\n",
    "    def initialize_grid(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Initializes the grid with random 0s and 1s.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray: The initialized grid.\n",
    "        \"\"\"\n",
    "        # Initialize the grid with random 0s and 1s\n",
    "        self.grid = np.random.randint(2, size=self.array_size) if self.grid is None else self.grid\n",
    "        self.history = self.grid\n",
    "        return self.grid\n",
    "\n",
    "    def update_grid(self) -> None:\n",
    "        \"\"\"\n",
    "        Updates the grid based on the given rules.\n",
    "\n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "        # Placeholder for the update logic\n",
    "        new_grid = self.grid.copy()\n",
    "        for i in range(1, self.array_size - 1):\n",
    "            # Example rule: new state is the XOR of the two neighbors\n",
    "            new_grid[i] = self.grid[i-1] ^ self.grid[i+1]\n",
    "        self.grid = new_grid\n",
    "        self.history = np.vstack((self.history, self.grid))\n",
    "\n",
    "    def elementary_update_grid(self) -> None:\n",
    "        \"\"\"\n",
    "        Updates the grid based on the given rules.\n",
    "\n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "        # Initialize the new grid\n",
    "        new_grid = self.grid.copy()\n",
    "        \n",
    "        # Iterate through each cell, excluding the boundary cells\n",
    "        for i in range(1, self.array_size - 1):\n",
    "            # Apply Rule 30: new state is determined by the current state and the state of two neighbors\n",
    "            left = self.grid[i-1]\n",
    "            center = self.grid[i]\n",
    "            right = self.grid[i+1]\n",
    "            \n",
    "            # Rule 30 logic\n",
    "            new_grid[i] = left ^ (center | right)\n",
    "        \n",
    "        # Update the grid\n",
    "        self.grid = new_grid\n",
    "        \n",
    "        # Update the history\n",
    "        self.history = np.vstack((self.history, self.grid))\n",
    "\n",
    "    def run(self) -> None:\n",
    "        \"\"\"\n",
    "        Runs the cellular automata for the given number of timesteps.\n",
    "        \n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "        self.grid = self.initialize_grid()\n",
    "        for _ in range(self.timesteps):\n",
    "            # self.update_grid()\n",
    "            self.elementary_update_grid()\n",
    "\n",
    "    def plot(self) -> None:\n",
    "        \"\"\"\n",
    "        Plots the grid.\n",
    "\n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "        plt.imshow(self.history, cmap='Greys', interpolation='nearest')\n",
    "        plt.title(\"1D Cellular Automata\")\n",
    "        plt.xlabel(\"Cell Index\")\n",
    "        plt.ylabel(\"Timestep\")\n",
    "        plt.show()\n",
    "\n",
    "# another referece for the cellular automata: https://github.com/lantunes/cellpylib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Execution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = np.array([0, 0, 0, 1, 1, 1, 0, 0])\n",
    "ca = CellularAutomata(timesteps=10, grid=grid)\n",
    "ca.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'P0', 1: 'P1', 2: 'P0', 3: 'P1', 4: 'P0', 5: 'P0', 6: 'P0', 7: 'P0'}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sched = Scheduler(G)\n",
    "allocation = sched.create_allocation(grid=ca.grid)\n",
    "allocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "sched = Scheduler(G)\n",
    "sched.run(grid=ca.grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Struct Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>duration</th>\n",
       "      <th>priority</th>\n",
       "      <th>status</th>\n",
       "      <th>dependencies</th>\n",
       "      <th>enable</th>\n",
       "      <th>processed_by</th>\n",
       "      <th>start_time</th>\n",
       "      <th>end_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[]</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=0, duration=5)]</td>\n",
       "      <td>True</td>\n",
       "      <td>P1</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=0, duration=5)]</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=0, duration=5)]</td>\n",
       "      <td>True</td>\n",
       "      <td>P1</td>\n",
       "      <td>9</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=0, duration=5)]</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>9</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=1, duration=2), Task(name=2, durati...</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>12</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=3, duration=2), Task(name=4, durati...</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>17</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>True</td>\n",
       "      <td>[Task(name=5, duration=4), Task(name=6, durati...</td>\n",
       "      <td>True</td>\n",
       "      <td>P0</td>\n",
       "      <td>21</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  name  duration  priority  status  \\\n",
       "0    0         5         0    True   \n",
       "1    1         2         0    True   \n",
       "2    2         2         0    True   \n",
       "3    3         2         0    True   \n",
       "4    4         2         0    True   \n",
       "5    5         4         0    True   \n",
       "6    6         3         0    True   \n",
       "7    7         7         0    True   \n",
       "\n",
       "                                        dependencies  enable processed_by  \\\n",
       "0                                                 []    True           P0   \n",
       "1                         [Task(name=0, duration=5)]    True           P1   \n",
       "2                         [Task(name=0, duration=5)]    True           P0   \n",
       "3                         [Task(name=0, duration=5)]    True           P1   \n",
       "4                         [Task(name=0, duration=5)]    True           P0   \n",
       "5  [Task(name=1, duration=2), Task(name=2, durati...    True           P0   \n",
       "6  [Task(name=3, duration=2), Task(name=4, durati...    True           P0   \n",
       "7  [Task(name=5, duration=4), Task(name=6, durati...    True           P0   \n",
       "\n",
       "   start_time  end_time  \n",
       "0           0         5  \n",
       "1           6         8  \n",
       "2           6         8  \n",
       "3           9        11  \n",
       "4           9        11  \n",
       "5          12        16  \n",
       "6          17        20  \n",
       "7          21        28  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame([task.task_data() for task in sched.tasks])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>processor</th>\n",
       "      <th>start</th>\n",
       "      <th>duration</th>\n",
       "      <th>end</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Task 0</td>\n",
       "      <td>P0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Task 1</td>\n",
       "      <td>P1</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Task 2</td>\n",
       "      <td>P0</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Task 3</td>\n",
       "      <td>P1</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Task 4</td>\n",
       "      <td>P0</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Task 5</td>\n",
       "      <td>P0</td>\n",
       "      <td>12</td>\n",
       "      <td>4</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Task 6</td>\n",
       "      <td>P0</td>\n",
       "      <td>17</td>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Task 7</td>\n",
       "      <td>P0</td>\n",
       "      <td>21</td>\n",
       "      <td>7</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     name processor  start  duration  end\n",
       "0  Task 0        P0      0         5    5\n",
       "1  Task 1        P1      6         2    8\n",
       "2  Task 2        P0      6         2    8\n",
       "3  Task 3        P1      9         2   11\n",
       "4  Task 4        P0      9         2   11\n",
       "5  Task 5        P0     12         4   16\n",
       "6  Task 6        P0     17         3   20\n",
       "7  Task 7        P0     21         7   28"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_gantt = df[['name', 'processed_by', 'start_time', 'duration', 'end_time']].copy()\n",
    "df_gantt.rename(columns={'processed_by': 'processor', 'start_time': 'start', 'end_time': 'end'}, inplace=True)\n",
    "def task_name(row):\n",
    "    task_id = str(row[\"name\"]).strip()\n",
    "    return \"Task \" + task_id\n",
    "df_gantt[\"name\"] = df_gantt.apply(task_name, axis=1)\n",
    "df_gantt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Task 0', 'processor': 'P0', 'start': 0, 'duration': 5, 'end': 5},\n",
       " {'name': 'Task 1', 'processor': 'P1', 'start': 6, 'duration': 2, 'end': 8},\n",
       " {'name': 'Task 2', 'processor': 'P0', 'start': 6, 'duration': 2, 'end': 8},\n",
       " {'name': 'Task 3', 'processor': 'P1', 'start': 9, 'duration': 2, 'end': 11},\n",
       " {'name': 'Task 4', 'processor': 'P0', 'start': 9, 'duration': 2, 'end': 11},\n",
       " {'name': 'Task 5', 'processor': 'P0', 'start': 12, 'duration': 4, 'end': 16},\n",
       " {'name': 'Task 6', 'processor': 'P0', 'start': 17, 'duration': 3, 'end': 20},\n",
       " {'name': 'Task 7', 'processor': 'P0', 'start': 21, 'duration': 7, 'end': 28}]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Data for the Gantt chart\n",
    "tasks = df_gantt.to_dict('records')\n",
    "tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make the grid not visible on the area of the barh, you can set the z-order of the bars to be higher than the grid lines. This way, the bars will be drawn on top of the grid lines.\n",
    "In this code, the zorder parameter is used to control the drawing order. The grid lines are set with zorder=1, the bars with zorder=3, and the text labels with zorder=4. This ensures that the bars and text labels are drawn on top of the grid lines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create figure and axis\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "# Create a color map for processors\n",
    "colors = {'P0': 'skyblue', 'P1': 'lightgreen', 'P2': 'salmon'}\n",
    "\n",
    "# Plot the Gantt chart\n",
    "for idx, task in df_gantt.iterrows():\n",
    "    ax.barh(task['processor'], task['duration'], left=task['start'], color=colors[task['processor']], zorder=3)\n",
    "\n",
    "# Add task labels inside the bars\n",
    "for idx, task in df_gantt.iterrows():\n",
    "    ax.text(task['start'] + task['duration']/2, task['processor'], task['name'],\n",
    "            va='center', ha='center', color='black', fontweight='bold', zorder=4)\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel('Time')\n",
    "ax.set_ylabel('Processor')\n",
    "ax.set_title('Gantt Chart')\n",
    "\n",
    "# Set grid\n",
    "ax.grid(True, which='both', linestyle='--', linewidth=0.5, zorder=1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LearingPhase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LearningPhase:\n",
    "    \"\"\"\n",
    "    A class to represent a learning phase. Run a Genetic Algorithm to learn the best allocation of tasks to processors.\n",
    "    \"\"\"\n",
    "    def __init__(self,\n",
    "                graph: nx.DiGraph,\n",
    "                processor_quantity: int = 2,\n",
    "\n",
    "                population_size: int = 10,\n",
    "                mutation_rate: float = 0.1,\n",
    "                crossover_rate: float = 0.8,\n",
    "                elitism_rate: float = 0.1,\n",
    "                max_generations: int = 100):\n",
    "        \"\"\"\n",
    "        Initializes a new LearningPhase instance.\n",
    "\n",
    "        Args:\n",
    "            graph (nx.DiGraph): The directed graph representing the tasks and their dependencies.\n",
    "            population_size (int): The size of the population in the genetic algorithm.\n",
    "            mutation_rate (float): The probability of mutation in the genetic algorithm.\n",
    "            crossover_rate (float): The probability of crossover in the genetic algorithm.\n",
    "            elitism_rate (float): The percentage of the population to be preserved as elite individuals in the genetic algorithm.\n",
    "            max_generations (int): The maximum number of generations in the genetic algorithm.\n",
    "        \"\"\"\n",
    "        self.graph = graph\n",
    "        self.processor_quantity = processor_quantity\n",
    "\n",
    "        self.population_size = population_size\n",
    "        self.mutation_rate = mutation_rate\n",
    "        self.crossover_rate = crossover_rate\n",
    "        self.elitism_rate = elitism_rate\n",
    "        self.max_generations = max_generations\n",
    "\n",
    "        self.best_hystory = []\n",
    "\n",
    "    def initialize_population(self) -> list[np.ndarray]:\n",
    "        \"\"\"\n",
    "        Initializes the population of individuals.\n",
    "\n",
    "        Returns:\n",
    "            list[np.ndarray]: The initial population of individuals.\n",
    "        \"\"\"\n",
    "        population = []\n",
    "        ca = CellularAutomata(timesteps=10, array_size=len(self.graph.nodes))\n",
    "        for _ in range(self.population_size):\n",
    "            ca.grid = None\n",
    "            ca.run()            \n",
    "            population.append(ca.grid)\n",
    "        return population\n",
    "\n",
    "    def evaluate_fitness(self, grid: np.ndarray) -> float:\n",
    "        \"\"\"\n",
    "        Evaluates the fitness of an allocation.\n",
    "\n",
    "        Args:\n",
    "            grid (np.ndarray): A grid of tasks allocated to processors.\n",
    "\n",
    "        Returns:\n",
    "            float: The fitness value of the allocation.\n",
    "        \"\"\"\n",
    "        sched = Scheduler(self.graph)\n",
    "        sched.run(grid)\n",
    "        return max([task.task_data()['end_time'] for task in sched.tasks])\n",
    "        makespan = max([task.task_data()['end_time'] for task in sched.tasks])\n",
    "        return 1 / makespan\n",
    "\n",
    "    def select_parents(self, population: list[np.ndarray]) -> tuple[np.ndarray, np.ndarray]:\n",
    "        \"\"\"\n",
    "        Selects two parents from the population using tournament selection.\n",
    "\n",
    "        Args:\n",
    "            population (list[np.ndarray]): The population of individuals.\n",
    "\n",
    "        Returns:\n",
    "            tuple[np.ndarray, np.ndarray]: The selected parents.\n",
    "        \"\"\"\n",
    "        parent1 = random.choice(population)\n",
    "        parent2 = random.choice(population)\n",
    "        if self.evaluate_fitness(parent1) > self.evaluate_fitness(parent2):\n",
    "            return parent1, parent2\n",
    "        else:\n",
    "            return parent2, parent1\n",
    "\n",
    "    def crossover(self, parent1: np.ndarray, parent2: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Performs crossover between two parents to produce a child.\n",
    "\n",
    "        Args:\n",
    "            parent1 (np.ndarray): The first parent.\n",
    "            parent2 (np.ndarray): The second parent.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray: The child allocation.\n",
    "        \"\"\"\n",
    "        child = []\n",
    "        for task in parent1:\n",
    "            if random.random() < self.crossover_rate:\n",
    "                child.append(parent1[task])\n",
    "            else:\n",
    "                child.append(parent2[task])\n",
    "        return np.array(child, dtype=int)\n",
    "\n",
    "    def mutate(self, grid: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Performs mutation on an allocation.\n",
    "\n",
    "        Args:\n",
    "            grid (np.ndarray): A grid of tasks allocated to processors. The allocation to mutate.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray: The mutated allocation.\n",
    "        \"\"\"\n",
    "        mutaded_grid = []\n",
    "        for task in grid:\n",
    "            if random.random() < self.mutation_rate:\n",
    "                processors = set([p for p in range(self.processor_quantity)])\n",
    "                processors.remove(task)\n",
    "                p = random.choice(list(processors))\n",
    "                mutaded_grid.append(p)\n",
    "            else:\n",
    "                mutaded_grid.append(task)\n",
    "        return mutaded_grid\n",
    "\n",
    "    def elitism_selection(self, population: list[np.ndarray]) -> list[np.ndarray]:\n",
    "        \"\"\"\n",
    "        Performs elitism selection to preserve the best individuals in the population.\n",
    "\n",
    "        Args:\n",
    "            population (list[np.ndarray]): The population of individuals.\n",
    "\n",
    "        Returns:\n",
    "            list[np.ndarray]: The selected individuals.\n",
    "        \"\"\"\n",
    "        population.sort(key=lambda x: self.evaluate_fitness(x), reverse=True)\n",
    "        elite_size = int(self.elitism_rate * self.population_size)\n",
    "        return population[:elite_size]\n",
    "\n",
    "    def run_genetic_algorithm(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Runs the genetic algorithm to find the best allocation of tasks to processors.\n",
    "\n",
    "        Returns:\n",
    "            dict[int, str]: The best allocation found.\n",
    "        \"\"\"\n",
    "        population = self.initialize_population()\n",
    "        for _ in range(self.max_generations):\n",
    "            new_population = self.elitism_selection(population)\n",
    "            while len(new_population) < self.population_size:\n",
    "                parent1, parent2 = self.select_parents(population)\n",
    "                child = self.crossover(parent1, parent2)\n",
    "                child = self.mutate(child)\n",
    "                new_population.append(child)\n",
    "            population = new_population\n",
    "            self.best_hystory.append(min(population, key=lambda x: self.evaluate_fitness(x)))\n",
    "        best_allocation = min(population, key=lambda x: self.evaluate_fitness(x))\n",
    "        return best_allocation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 0, 1, 0, 0, 0, 1]),\n",
       " array([0, 1, 0, 1, 0, 1, 0, 0]),\n",
       " array([0, 1, 0, 1, 0, 1, 0, 0]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 1]),\n",
       " array([0, 1, 0, 1, 0, 0, 1, 0]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0]),\n",
       " array([1, 0, 1, 0, 0, 1, 0, 0]),\n",
       " array([0, 1, 0, 1, 0, 1, 0, 1]),\n",
       " array([0, 1, 0, 1, 0, 0, 0, 0]),\n",
       " array([1, 0, 1, 0, 1, 0, 0, 1])]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.initialize_population()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.initialize_population()\n",
    "lp.evaluate_fitness(lp.initialize_population()[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 0, 1, 0, 1, 0, 0, 0]), array([0, 1, 0, 1, 0, 1, 1, 0]))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.initialize_population()\n",
    "lp.select_parents(lp.initialize_population())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.initialize_population()\n",
    "parent1, parent2 = lp.select_parents(lp.initialize_population())\n",
    "lp.crossover(parent1, parent2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 1, 1, 0, 1, 1]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.mutate(np.array([0, 1, 1, 1, 1, 0, 1, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 0, 1, 0, 1, 0, 0, 0])]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "lp.initialize_population()\n",
    "lp.elitism_selection(lp.initialize_population())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 0, 0, 1, 0, 1, 1]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lp = LearningPhase(G)\n",
    "best = lp.run_genetic_algorithm()\n",
    "print(lp.evaluate_fitness(best))\n",
    "best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 0, 0, 1, 0, 0]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_hystory = min(lp.best_hystory, key=lambda x: lp.evaluate_fitness(x))\n",
    "print(lp.evaluate_fitness(best_hystory))\n",
    "best_hystory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "sched = Scheduler(G)\n",
    "sched.run(grid=best_hystory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>processor</th>\n",
       "      <th>start</th>\n",
       "      <th>duration</th>\n",
       "      <th>end</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Task 0</td>\n",
       "      <td>P0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Task 1</td>\n",
       "      <td>P1</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Task 2</td>\n",
       "      <td>P1</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Task 3</td>\n",
       "      <td>P0</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Task 4</td>\n",
       "      <td>P0</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Task 5</td>\n",
       "      <td>P1</td>\n",
       "      <td>12</td>\n",
       "      <td>4</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Task 6</td>\n",
       "      <td>P0</td>\n",
       "      <td>12</td>\n",
       "      <td>3</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Task 7</td>\n",
       "      <td>P0</td>\n",
       "      <td>17</td>\n",
       "      <td>7</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     name processor  start  duration  end\n",
       "0  Task 0        P0      0         5    5\n",
       "1  Task 1        P1      6         2    8\n",
       "2  Task 2        P1      9         2   11\n",
       "3  Task 3        P0      6         2    8\n",
       "4  Task 4        P0      9         2   11\n",
       "5  Task 5        P1     12         4   16\n",
       "6  Task 6        P0     12         3   15\n",
       "7  Task 7        P0     17         7   24"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame([task.task_data() for task in sched.tasks])\n",
    "df_gantt = df[['name', 'processed_by', 'start_time', 'duration', 'end_time']].copy()\n",
    "df_gantt.rename(columns={'processed_by': 'processor', 'start_time': 'start', 'end_time': 'end'}, inplace=True)\n",
    "def task_name(row):\n",
    "    task_id = str(row[\"name\"]).strip()\n",
    "    return \"Task \" + task_id\n",
    "df_gantt[\"name\"] = df_gantt.apply(task_name, axis=1)\n",
    "df_gantt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create figure and axis\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "# Create a color map for processors\n",
    "colors = {'P0': 'skyblue', 'P1': 'lightgreen', 'P2': 'salmon'}\n",
    "\n",
    "# Plot the Gantt chart\n",
    "for idx, task in df_gantt.iterrows():\n",
    "    ax.barh(task['processor'], task['duration'], left=task['start'], color=colors[task['processor']], zorder=3)\n",
    "\n",
    "# Add task labels inside the bars\n",
    "for idx, task in df_gantt.iterrows():\n",
    "    ax.text(task['start'] + task['duration']/2, task['processor'], task['name'],\n",
    "            va='center', ha='center', color='black', fontweight='bold', zorder=4)\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel('Time')\n",
    "ax.set_ylabel('Processor')\n",
    "ax.set_title('Gantt Chart')\n",
    "\n",
    "# Set grid\n",
    "ax.grid(True, which='both', linestyle='--', linewidth=0.5, zorder=1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cells = 100  # Number of cells and generations\n",
    "# Generating corresponding 'time taken' data\n",
    "times = [lp.evaluate_fitness(x) for x in lp.best_hystory]\n",
    "\n",
    "# Creating the plot\n",
    "fig, axs = plt.subplots(1, 2, figsize=(10, 5), gridspec_kw={'width_ratios': [1, 3]})\n",
    "\n",
    "# Plot for the automaton\n",
    "axs[0].imshow(lp.best_hystory, cmap='Greys', aspect='auto')\n",
    "axs[0].set_title(\"Cellular Automaton\")\n",
    "axs[0].axis('off')\n",
    "\n",
    "# Plot for the horizontal bar plot\n",
    "axs[1].barh(range(cells), times, color='gray')\n",
    "axs[1].set_title(\"Time Taken\")\n",
    "axs[1].set_xlabel(\"Time\")\n",
    "axs[1].set_yticks([])  # Hide y-ticks for cleaner look\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Log the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3341a2173eda3e09ca624d589a48c46e'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to generate a hash identifier for the execution based on the date and time\n",
    "def generate_hash() -> str:\n",
    "    \"\"\"\n",
    "    Generate a hash identifier for the execution based on the date and time.\n",
    "\n",
    "    Returns:\n",
    "        str: The hash identifier.\n",
    "    \"\"\"\n",
    "    return hashlib.md5(str(datetime.now()).encode()).hexdigest()\n",
    "\n",
    "generate_hash()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>processor</th>\n",
       "      <th>start</th>\n",
       "      <th>duration</th>\n",
       "      <th>end</th>\n",
       "      <th>hash</th>\n",
       "      <th>total_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Task 0</td>\n",
       "      <td>P0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Task 1</td>\n",
       "      <td>P1</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Task 2</td>\n",
       "      <td>P1</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Task 3</td>\n",
       "      <td>P0</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Task 4</td>\n",
       "      <td>P0</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>11</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Task 5</td>\n",
       "      <td>P1</td>\n",
       "      <td>12</td>\n",
       "      <td>4</td>\n",
       "      <td>16</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Task 6</td>\n",
       "      <td>P0</td>\n",
       "      <td>12</td>\n",
       "      <td>3</td>\n",
       "      <td>15</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Task 7</td>\n",
       "      <td>P0</td>\n",
       "      <td>17</td>\n",
       "      <td>7</td>\n",
       "      <td>24</td>\n",
       "      <td>16f94b521975ce8132a693ae3e1c67ef</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     name processor  start  duration  end                              hash  \\\n",
       "0  Task 0        P0      0         5    5  16f94b521975ce8132a693ae3e1c67ef   \n",
       "1  Task 1        P1      6         2    8  16f94b521975ce8132a693ae3e1c67ef   \n",
       "2  Task 2        P1      9         2   11  16f94b521975ce8132a693ae3e1c67ef   \n",
       "3  Task 3        P0      6         2    8  16f94b521975ce8132a693ae3e1c67ef   \n",
       "4  Task 4        P0      9         2   11  16f94b521975ce8132a693ae3e1c67ef   \n",
       "5  Task 5        P1     12         4   16  16f94b521975ce8132a693ae3e1c67ef   \n",
       "6  Task 6        P0     12         3   15  16f94b521975ce8132a693ae3e1c67ef   \n",
       "7  Task 7        P0     17         7   24  16f94b521975ce8132a693ae3e1c67ef   \n",
       "\n",
       "   total_time  \n",
       "0          24  \n",
       "1          24  \n",
       "2          24  \n",
       "3          24  \n",
       "4          24  \n",
       "5          24  \n",
       "6          24  \n",
       "7          24  "
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apply the generated hash to create a new column 'hash' in df_gantt\n",
    "df_gantt['hash'] = generate_hash()\n",
    "df_gantt['total_time'] = df_gantt['end'].max()\n",
    "df_gantt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create a logic to log the df_gantt data to a csv file. must check if the file exists, if not, create it, if it exists, append the data to the file.\n",
    "\n",
    "directory = './data/'\n",
    "\n",
    "# Function to log the Gantt chart data to a CSV file\n",
    "def log_gantt_data(df:pd.DataFrame) -> None:\n",
    "    \"\"\"\n",
    "    Log the Gantt chart data to a CSV file.\n",
    "\n",
    "    Args:\n",
    "        df (pd.DataFrame): The Gantt chart data.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Open the file in append mode\n",
    "        with open(directory+'executions.csv', 'a') as f:\n",
    "            # Write the data to the file\n",
    "            df.to_csv(f, header=f.tell()==0, index=False)\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred: {e}\")\n",
    "\n",
    "# log_gantt_data(df_gantt)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}