CPU Scheduling Software.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU Scheduling Software\n",
      "\n",
      "Which algorithm you want to run?\n",
      "\n",
      "For FCFS, Press 1\n",
      "For SJF, Press 2\n",
      "For Round Robin, Press 3\n",
      "For Priority Scheduling, Press 4\n",
      "Enter your Choice = 0\n",
      "\n",
      "Goodbye, have a great day.\n"
     ]
    }
   ],
   "source": [
    "# Driver Code\n",
    "\n",
    "print(\"CPU Scheduling Software\")\n",
    "print()\n",
    "print(\"Which algorithm you want to run?\")\n",
    "print()\n",
    "print(\"For FCFS, Press 1\")\n",
    "print(\"For SJF, Press 2\")\n",
    "print(\"For Round Robin, Press 3\")\n",
    "print(\"For Priority Scheduling, Press 4\")\n",
    "Input = int(input(\"Enter your Choice = \"))\n",
    "print()\n",
    "\n",
    "if Input == 1:\n",
    "    print(\"FCFS:\")\n",
    "    if __name__ == \"__main__\":\n",
    "        no_of_processes = int(input(\"Enter number of processes: \"))\n",
    "        fcfs = FCFS()\n",
    "        fcfs.processData(no_of_processes)\n",
    "\n",
    "\n",
    "elif Input == 2:\n",
    "    print(\"SJF\")\n",
    "    if __name__ == \"__main__\":\n",
    "        no_of_processes = int(input(\"Enter number of processes: \"))\n",
    "        sjf = SJF()\n",
    "        sjf.processData(no_of_processes)\n",
    "    \n",
    "elif Input == 3:\n",
    "    print(\"Round Robin\")\n",
    "    if __name__ == \"__main__\":\n",
    "        no_of_processes = int(input(\"Enter number of processes: \"))\n",
    "        rr = RoundRobin()\n",
    "        rr.processData(no_of_processes)\n",
    "    \n",
    "elif Input == 4:\n",
    "    print(\"Priority Scheduling:\")\n",
    "    if __name__ == \"__main__\":\n",
    "        no_of_processes = int(input(\"Enter number of processes: \"))\n",
    "        priority = Priority()\n",
    "        priority.processData(no_of_processes)\n",
    "\n",
    "elif Input == 0:\n",
    "    print(\"Goodbye, have a great day.\")\n",
    "    \n",
    "else:\n",
    "    print(\"No such option exists, Please try again.\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FCFS\n",
    "\n",
    "class FCFS:\n",
    "    def processData(self, no_of_processes):\n",
    "        process_data = []\n",
    "        for i in range(no_of_processes):\n",
    "            temporary = []\n",
    "            process_id = int(input(\"Enter Process ID: \"))\n",
    "\n",
    "            arrival_time = int(input(\"Enter Arrival Time: \"))\n",
    "\n",
    "            burst_time = int(input(f\"Enter Burst Time for Process {process_id}: \"))\n",
    "\n",
    "            temporary.extend([process_id, arrival_time, burst_time])\n",
    "            process_data.append(temporary)\n",
    "        FCFS.schedulingProcess(self, process_data)\n",
    "\n",
    "    def schedulingProcess(self, process_data):\n",
    "        process_data.sort(key=lambda x: x[1])\n",
    "       \n",
    "        \"\"\"Sort according to Arrival Time\"\"\" \n",
    "       \n",
    "        start_time = []\n",
    "        exit_time = []\n",
    "        s_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            if s_time < process_data[i][1]:\n",
    "                s_time = process_data[i][1]\n",
    "            start_time.append(s_time)\n",
    "            s_time = s_time + process_data[i][2]\n",
    "            e_time = s_time\n",
    "            exit_time.append(e_time)\n",
    "            process_data[i].append(e_time)\n",
    "        t_time = FCFS.calculateTurnaroundTime(self, process_data)\n",
    "        w_time = FCFS.calculateWaitingTime(self, process_data)\n",
    "        FCFS.printData(self, process_data, t_time, w_time)\n",
    "\n",
    "    def calculateTurnaroundTime(self, process_data):\n",
    "        total_turnaround_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            turnaround_time = process_data[i][3] - process_data[i][1]\n",
    "            '''\n",
    "            turnaround_time = completion_time - arrival_time\n",
    "            '''\n",
    "            total_turnaround_time = total_turnaround_time + turnaround_time\n",
    "            process_data[i].append(turnaround_time)\n",
    "        average_turnaround_time = total_turnaround_time / len(process_data)\n",
    "        '''\n",
    "        average_turnaround_time = total_turnaround_time / no_of_processes\n",
    "        '''\n",
    "        return average_turnaround_time\n",
    "\n",
    "    def calculateWaitingTime(self, process_data):\n",
    "        total_waiting_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            waiting_time = process_data[i][4] - process_data[i][2]\n",
    "            '''\n",
    "            waiting_time = turnaround_time - burst_time\n",
    "            '''\n",
    "            total_waiting_time = total_waiting_time + waiting_time\n",
    "            process_data[i].append(waiting_time)\n",
    "        average_waiting_time = total_waiting_time / len(process_data)\n",
    "        '''\n",
    "        average_waiting_time = total_waiting_time / no_of_processes\n",
    "        '''\n",
    "        return average_waiting_time\n",
    "\n",
    "    def printData(self, process_data, average_turnaround_time, average_waiting_time):\n",
    "        print(f'Average Turnaround Time: {average_turnaround_time}')\n",
    "        print(f'Average Waiting Time: {average_waiting_time}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SJF\n",
    "\n",
    "\n",
    "class SJF:\n",
    "\n",
    "    def processData(self, no_of_processes):\n",
    "        process_data = []\n",
    "        for i in range(no_of_processes):\n",
    "            temporary = []\n",
    "            process_id = int(input(\"Enter Process ID: \"))\n",
    "            arrival_time = int(input(f\"Enter Arrival Time for Process {process_id}: \"))\n",
    "            burst_time = int(input(f\"Enter Burst Time for Process {process_id}: \"))\n",
    "            temporary.extend([process_id, arrival_time, burst_time, 0, burst_time])\n",
    "            '''\n",
    "            '0' is the state of the process. 0 means not executed and 1 means execution complete\n",
    "            '''\n",
    "            process_data.append(temporary)\n",
    "        SJF.schedulingProcess(self, process_data)\n",
    "\n",
    "    def schedulingProcess(self, process_data):\n",
    "        start_time = []\n",
    "        exit_time = []\n",
    "        s_time = 0\n",
    "        sequence_of_process = []\n",
    "        process_data.sort(key=lambda x: x[1])\n",
    "        '''\n",
    "        Sort processes according to the Arrival Time\n",
    "        '''\n",
    "        while 1:\n",
    "            ready_queue = []\n",
    "            normal_queue = []\n",
    "            temp = []\n",
    "            for i in range(len(process_data)):\n",
    "                if process_data[i][1] <= s_time and process_data[i][3] == 0:\n",
    "                    temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][4]])\n",
    "                    ready_queue.append(temp)\n",
    "                    temp = []\n",
    "                elif process_data[i][3] == 0:\n",
    "                    temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][4]])\n",
    "                    normal_queue.append(temp)\n",
    "                    temp = []\n",
    "            if len(ready_queue) == 0 and len(normal_queue) == 0:\n",
    "                break\n",
    "            if len(ready_queue) != 0:\n",
    "                ready_queue.sort(key=lambda x: x[2])\n",
    "                '''\n",
    "                Sort processes according to Burst Time\n",
    "                '''\n",
    "                start_time.append(s_time)\n",
    "                s_time = s_time + 1\n",
    "                e_time = s_time\n",
    "                exit_time.append(e_time)\n",
    "                sequence_of_process.append(ready_queue[0][0])\n",
    "                for k in range(len(process_data)):\n",
    "                    if process_data[k][0] == ready_queue[0][0]:\n",
    "                        break\n",
    "                process_data[k][2] = process_data[k][2] - 1\n",
    "                if process_data[k][2] == 0:        #If Burst Time of a process is 0, it means the process is completed\n",
    "                    process_data[k][3] = 1\n",
    "                    process_data[k].append(e_time)\n",
    "            if len(ready_queue) == 0:\n",
    "                if s_time < normal_queue[0][1]:\n",
    "                    s_time = normal_queue[0][1]\n",
    "                start_time.append(s_time)\n",
    "                s_time = s_time + 1\n",
    "                e_time = s_time\n",
    "                exit_time.append(e_time)\n",
    "                sequence_of_process.append(normal_queue[0][0])\n",
    "                for k in range(len(process_data)):\n",
    "                    if process_data[k][0] == normal_queue[0][0]:\n",
    "                        break\n",
    "                process_data[k][2] = process_data[k][2] - 1\n",
    "                if process_data[k][2] == 0:        #If Burst Time of a process is 0, it means the process is completed\n",
    "                    process_data[k][3] = 1\n",
    "                    process_data[k].append(e_time)\n",
    "        t_time = SJF.calculateTurnaroundTime(self, process_data)\n",
    "        w_time = SJF.calculateWaitingTime(self, process_data)\n",
    "        SJF.printData(self, process_data, t_time, w_time, sequence_of_process)\n",
    "\n",
    "    def calculateTurnaroundTime(self, process_data):\n",
    "        total_turnaround_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            turnaround_time = process_data[i][5] - process_data[i][1]\n",
    "            '''\n",
    "            turnaround_time = completion_time - arrival_time\n",
    "            '''\n",
    "            total_turnaround_time = total_turnaround_time + turnaround_time\n",
    "            process_data[i].append(turnaround_time)\n",
    "        average_turnaround_time = total_turnaround_time / len(process_data)\n",
    "        '''\n",
    "        average_turnaround_time = total_turnaround_time / no_of_processes\n",
    "        '''\n",
    "        return average_turnaround_time\n",
    "\n",
    "    def calculateWaitingTime(self, process_data):\n",
    "        total_waiting_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            waiting_time = process_data[i][6] - process_data[i][4]\n",
    "            '''\n",
    "            waiting_time = turnaround_time - burst_time\n",
    "            '''\n",
    "            total_waiting_time = total_waiting_time + waiting_time\n",
    "            process_data[i].append(waiting_time)\n",
    "        average_waiting_time = total_waiting_time / len(process_data)\n",
    "        '''\n",
    "        average_waiting_time = total_waiting_time / no_of_processes\n",
    "        '''\n",
    "        return average_waiting_time\n",
    "\n",
    "    def printData(self, process_data, average_turnaround_time, average_waiting_time, sequence_of_process):\n",
    "        process_data.sort(key=lambda x: x[0])\n",
    "        '''\n",
    "        Sort processes according to the Process ID\n",
    "        '''\n",
    "        \n",
    "        print(f'Average Turnaround Time: {average_turnaround_time}')\n",
    "        print(f'Average Waiting Time: {average_waiting_time}')\n",
    "        print(f'Sequence of Process: {sequence_of_process}')\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Round Robin\n",
    "\n",
    "class RoundRobin:\n",
    "\n",
    "    def processData(self, no_of_processes):\n",
    "        process_data = []\n",
    "        for i in range(no_of_processes):\n",
    "            temporary = []\n",
    "            process_id = int(input(\"Enter Process ID: \"))\n",
    "\n",
    "            arrival_time = int(input(f\"Enter Arrival Time for Process {process_id}: \"))\n",
    "\n",
    "            burst_time = int(input(f\"Enter Burst Time for Process {process_id}: \"))\n",
    "\n",
    "            temporary.extend([process_id, arrival_time, burst_time, 0, burst_time])\n",
    "            '''\n",
    "            '0' is the state of the process. 0 means not executed and 1 means execution complete\n",
    "            \n",
    "            '''\n",
    "            process_data.append(temporary)\n",
    "\n",
    "        quantumTime = int(input(\"Enter Quantum Time: \"))\n",
    "\n",
    "        RoundRobin.schedulingProcess(self, process_data, quantumTime)\n",
    "\n",
    "    def schedulingProcess(self, process_data, quantumTime):\n",
    "        start_time = []\n",
    "        exit_time = []\n",
    "        executed_process = []\n",
    "        ready_queue = []\n",
    "        s_time = 0\n",
    "        process_data.sort(key=lambda x: x[1])\n",
    "        '''\n",
    "        Sort processes according to the Arrival Time\n",
    "        '''\n",
    "        while 1:\n",
    "            normal_queue = []\n",
    "            temp = []\n",
    "            for i in range(len(process_data)):\n",
    "                if process_data[i][1] <= s_time and process_data[i][3] == 0:\n",
    "                    present = 0\n",
    "                    if len(ready_queue) != 0:\n",
    "                        for k in range(len(ready_queue)):\n",
    "                            if process_data[i][0] == ready_queue[k][0]:\n",
    "                                present = 1\n",
    "                    '''\n",
    "                    The above if loop checks that the next process is not a part of ready_queue\n",
    "                    '''\n",
    "                    if present == 0:\n",
    "                        temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][4]])\n",
    "                        ready_queue.append(temp)\n",
    "                        temp = []\n",
    "                    '''\n",
    "                    The above if loop adds a process to the ready_queue only if it is not already present in it\n",
    "                    '''\n",
    "                    if len(ready_queue) != 0 and len(executed_process) != 0:\n",
    "                        for k in range(len(ready_queue)):\n",
    "                            if ready_queue[k][0] == executed_process[len(executed_process) - 1]:\n",
    "                                ready_queue.insert((len(ready_queue) - 1), ready_queue.pop(k))\n",
    "                    '''\n",
    "                    The above if loop makes sure that the recently executed process is appended at the end of ready_queue\n",
    "                    '''\n",
    "                elif process_data[i][3] == 0:\n",
    "                    temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][4]])\n",
    "                    normal_queue.append(temp)\n",
    "                    temp = []\n",
    "            if len(ready_queue) == 0 and len(normal_queue) == 0:\n",
    "                break\n",
    "            if len(ready_queue) != 0:\n",
    "                if ready_queue[0][2] > quantumTime:\n",
    "                    '''\n",
    "                    If process has remaining burst time greater than the Quantum Time, it will execute for a time period equal to Quantum Time and then switch\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + quantumTime\n",
    "                    e_time = s_time\n",
    "                    exit_time.append(e_time)\n",
    "                    executed_process.append(ready_queue[0][0])\n",
    "                    for j in range(len(process_data)):\n",
    "                        if process_data[j][0] == ready_queue[0][0]:\n",
    "                            break\n",
    "                    process_data[j][2] = process_data[j][2] - quantumTime\n",
    "                    ready_queue.pop(0)\n",
    "                elif ready_queue[0][2] <= quantumTime:\n",
    "                    '''\n",
    "                    If a process has a remaining burst time less than or equal to Quantum Time, it will complete its execution\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + ready_queue[0][2]\n",
    "                    e_time = s_time\n",
    "                    exit_time.append(e_time)\n",
    "                    executed_process.append(ready_queue[0][0])\n",
    "                    for j in range(len(process_data)):\n",
    "                        if process_data[j][0] == ready_queue[0][0]:\n",
    "                            break\n",
    "                    process_data[j][2] = 0\n",
    "                    process_data[j][3] = 1\n",
    "                    process_data[j].append(e_time)\n",
    "                    ready_queue.pop(0)\n",
    "            elif len(ready_queue) == 0:\n",
    "                if s_time < normal_queue[0][1]:\n",
    "                    s_time = normal_queue[0][1]\n",
    "                if normal_queue[0][2] > quantumTime:\n",
    "                    '''\n",
    "                    If process has remaining burst time greater than the Quantum Time, it will execute for a time period equal to Quantum Time and then switch\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + quantumTime\n",
    "                    e_time = s_time\n",
    "                    exit_time.append(e_time)\n",
    "                    executed_process.append(normal_queue[0][0])\n",
    "                    for j in range(len(process_data)):\n",
    "                        if process_data[j][0] == normal_queue[0][0]:\n",
    "                            break\n",
    "                    process_data[j][2] = process_data[j][2] - quantumTime\n",
    "                elif normal_queue[0][2] <= quantumTime:\n",
    "                    '''\n",
    "                    If a process has a remaining burst time less than or equal to Quantum Time, it will complete its execution\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + normal_queue[0][2]\n",
    "                    e_time = s_time\n",
    "                    exit_time.append(e_time)\n",
    "                    executed_process.append(normal_queue[0][0])\n",
    "                    for j in range(len(process_data)):\n",
    "                        if process_data[j][0] == normal_queue[0][0]:\n",
    "                            break\n",
    "                    process_data[j][2] = 0\n",
    "                    process_data[j][3] = 1\n",
    "                    process_data[j].append(e_time)\n",
    "        t_time = RoundRobin.calculateTurnaroundTime(self, process_data)\n",
    "        w_time = RoundRobin.calculateWaitingTime(self, process_data)\n",
    "        RoundRobin.printData(self, process_data, t_time, w_time, executed_process)\n",
    "\n",
    "    def calculateTurnaroundTime(self, process_data):\n",
    "        total_turnaround_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            turnaround_time = process_data[i][5] - process_data[i][1]\n",
    "            '''\n",
    "            turnaround_time = completion_time - arrival_time\n",
    "            '''\n",
    "            total_turnaround_time = total_turnaround_time + turnaround_time\n",
    "            process_data[i].append(turnaround_time)\n",
    "        average_turnaround_time = total_turnaround_time / len(process_data)\n",
    "        '''\n",
    "        average_turnaround_time = total_turnaround_time / no_of_processes\n",
    "        '''\n",
    "        return average_turnaround_time\n",
    "\n",
    "    def calculateWaitingTime(self, process_data):\n",
    "        total_waiting_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            waiting_time = process_data[i][6] - process_data[i][4]\n",
    "            '''\n",
    "            waiting_time = turnaround_time - burst_time\n",
    "            '''\n",
    "            total_waiting_time = total_waiting_time + waiting_time\n",
    "            process_data[i].append(waiting_time)\n",
    "        average_waiting_time = total_waiting_time / len(process_data)\n",
    "        '''\n",
    "        average_waiting_time = total_waiting_time / no_of_processes\n",
    "        '''\n",
    "        return average_waiting_time\n",
    "\n",
    "    def printData(self, process_data, average_turnaround_time, average_waiting_time, executed_process):\n",
    "        process_data.sort(key=lambda x: x[0])\n",
    "\n",
    "        print(f'Average Turnaround Time: {average_turnaround_time}')\n",
    "\n",
    "        print(f'Average Waiting Time: {average_waiting_time}')\n",
    "\n",
    "        print(f'Sequence of Processes: {executed_process}')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Priority Scheduling\n",
    "\n",
    "class Priority:\n",
    "\n",
    "    def processData(self, no_of_processes):\n",
    "        process_data = []\n",
    "        for i in range(no_of_processes):\n",
    "            temporary = []\n",
    "            process_id = int(input(\"Enter Process ID: \"))\n",
    "\n",
    "            arrival_time = int(input(f\"Enter Arrival Time for Process {process_id}: \"))\n",
    "\n",
    "            burst_time = int(input(f\"Enter Burst Time for Process {process_id}: \"))\n",
    "\n",
    "            priority = int(input(f\"Enter Priority for Process {process_id}: \"))\n",
    "\n",
    "            temporary.extend([process_id, arrival_time, burst_time, priority, 0, burst_time])\n",
    "            '''\n",
    "            '0' is the state of the process. 0 means not executed and 1 means execution complete\n",
    "            '''\n",
    "            process_data.append(temporary)\n",
    "        Priority.schedulingProcess(self, process_data)\n",
    "\n",
    "    def schedulingProcess(self, process_data):\n",
    "        start_time = []\n",
    "        exit_time = []\n",
    "        s_time = 0\n",
    "        sequence_of_process = []\n",
    "        process_data.sort(key=lambda x: x[1])\n",
    "        '''\n",
    "        Sort processes according to the Arrival Time\n",
    "        '''\n",
    "        while 1:\n",
    "            ready_queue = []\n",
    "            normal_queue = []\n",
    "            temp = []\n",
    "            for i in range(len(process_data)):\n",
    "                if process_data[i][1] <= s_time and process_data[i][4] == 0:\n",
    "                    temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][3],\n",
    "                                 process_data[i][5]])\n",
    "                    ready_queue.append(temp)\n",
    "                    temp = []\n",
    "                elif process_data[i][4] == 0:\n",
    "                    temp.extend([process_data[i][0], process_data[i][1], process_data[i][2], process_data[i][4],\n",
    "                                 process_data[i][5]])\n",
    "                    normal_queue.append(temp)\n",
    "                    temp = []\n",
    "            if len(ready_queue) == 0 and len(normal_queue) == 0:\n",
    "                break\n",
    "            if len(ready_queue) != 0:\n",
    "                ready_queue.sort(key=lambda x: x[3], reverse=True)\n",
    "                start_time.append(s_time)\n",
    "                s_time = s_time + 1\n",
    "                e_time = s_time\n",
    "                exit_time.append(e_time)\n",
    "                sequence_of_process.append(ready_queue[0][0])\n",
    "                for k in range(len(process_data)):\n",
    "                    if process_data[k][0] == ready_queue[0][0]:\n",
    "                        break\n",
    "                process_data[k][2] = process_data[k][2] - 1\n",
    "                if process_data[k][2] == 0:       #if burst time is zero, it means process is completed\n",
    "                    process_data[k][4] = 1\n",
    "                    process_data[k].append(e_time)\n",
    "            if len(ready_queue) == 0:\n",
    "                normal_queue.sort(key=lambda x: x[1])\n",
    "                if s_time < normal_queue[0][1]:\n",
    "                    s_time = normal_queue[0][1]\n",
    "                start_time.append(s_time)\n",
    "                s_time = s_time + 1\n",
    "                e_time = s_time\n",
    "                exit_time.append(e_time)\n",
    "                sequence_of_process.append(normal_queue[0][0])\n",
    "                for k in range(len(process_data)):\n",
    "                    if process_data[k][0] == normal_queue[0][0]:\n",
    "                        break\n",
    "                process_data[k][2] = process_data[k][2] - 1\n",
    "                if process_data[k][2] == 0:        #if burst time is zero, it means process is completed\n",
    "                    process_data[k][4] = 1\n",
    "                    process_data[k].append(e_time)\n",
    "        t_time = Priority.calculateTurnaroundTime(self, process_data)\n",
    "        w_time = Priority.calculateWaitingTime(self, process_data)\n",
    "        Priority.printData(self, process_data, t_time, w_time, sequence_of_process)\n",
    "\n",
    "    def calculateTurnaroundTime(self, process_data):\n",
    "        total_turnaround_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            turnaround_time = process_data[i][6] - process_data[i][5]\n",
    "            '''\n",
    "            turnaround_time = completion_time - arrival_time\n",
    "            '''\n",
    "            total_turnaround_time = total_turnaround_time + turnaround_time\n",
    "            process_data[i].append(turnaround_time)\n",
    "        average_turnaround_time = total_turnaround_time / len(process_data)\n",
    "        '''\n",
    "        average_turnaround_time = total_turnaround_time / no_of_processes\n",
    "        '''\n",
    "        return average_turnaround_time\n",
    "\n",
    "    def calculateWaitingTime(self, process_data):\n",
    "        total_waiting_time = 0\n",
    "        for i in range(len(process_data)):\n",
    "            waiting_time = process_data[i][6] - process_data[i][2]\n",
    "            '''\n",
    "            waiting_time = turnaround_time - burst_time\n",
    "            '''\n",
    "            total_waiting_time = total_waiting_time + waiting_time\n",
    "            process_data[i].append(waiting_time)\n",
    "        average_waiting_time = total_waiting_time / len(process_data)\n",
    "        '''\n",
    "        average_waiting_time = total_waiting_time / no_of_processes\n",
    "        '''\n",
    "        return average_waiting_time\n",
    "\n",
    "    def printData(self, process_data, average_turnaround_time, average_waiting_time, sequence_of_process):\n",
    "        process_data.sort(key=lambda x: x[0])\n",
    "        print(f'Average Turnaround Time: {average_turnaround_time}')\n",
    "        print(f'Average Waiting Time: {average_waiting_time}')\n",
    "        print(f'Sequence of Process: {sequence_of_process}')\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}