shortest_job_first_preemptive_SRT.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 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",
    "\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",
    "            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",
    "        print(\"Process_ID  Arrival_Time  Rem_Burst_Time      Completed  Orig_Burst_Time Completion_Time  Turnaround_Time  Waiting_Time\")\n",
    "        \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 Process: {sequence_of_process}')\n",
    "\n",
    "\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",
    "\n",
    "'''\n",
    "3\n",
    "1\n",
    "0\n",
    "8\n",
    "2\n",
    ".4\n",
    "4\n",
    "3\n",
    "1\n",
    "1\n",
    "\n",
    "\n",
    "'''"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}