round_robin.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Works only if arrival time and burst time is in integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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 = float(input(f\"Enter Arrival Time for Process {process_id}: \"))\n",
    "\n",
    "            burst_time = float(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",
    "        time_slice = int(input(\"Enter Time Slice: \"))\n",
    "\n",
    "        RoundRobin.schedulingProcess(self, process_data, time_slice)\n",
    "\n",
    "    def schedulingProcess(self, process_data, time_slice):\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] > time_slice:\n",
    "                    '''\n",
    "                    If process has remaining burst time greater than the time slice, it will execute for a time period equal to time slice and then switch\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + time_slice\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] - time_slice\n",
    "                    ready_queue.pop(0)\n",
    "                elif ready_queue[0][2] <= time_slice:\n",
    "                    '''\n",
    "                    If a process has a remaining burst time less than or equal to time slice, 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] > time_slice:\n",
    "                    '''\n",
    "                    If process has remaining burst time greater than the time slice, it will execute for a time period equal to time slice and then switch\n",
    "                    '''\n",
    "                    start_time.append(s_time)\n",
    "                    s_time = s_time + time_slice\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] - time_slice\n",
    "                elif normal_queue[0][2] <= time_slice:\n",
    "                    '''\n",
    "                    If a process has a remaining burst time less than or equal to time slice, 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",
    "        Sort processes according to the Process ID\n",
    "        '''\n",
    "        print(\"Process_ID  Arrival_Time  Rem_Burst_Time   Completed  Original_Burst_Time  Completion_Time  Turnaround_Time  Waiting_Time\")\n",
    "        for i in range(len(process_data)):\n",
    "            for j in range(len(process_data[i])):\n",
    "\n",
    "                print(process_data[i][j], end=\"\t\t\")\n",
    "            print()\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",
    "if __name__ == \"__main__\":\n",
    "    no_of_processes = int(input(\"Enter number of processes: \"))\n",
    "    rr = RoundRobin()\n",
    "    rr.processData(no_of_processes)\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}