notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of processes "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time [0, 0]\n",
      "[2, 1]\n",
      "[4, 2]\n",
      "[6, 3]\n",
      "[8, 4]\n",
      "11100000000000000000\n",
      "00011111100000000000\n",
      "00000000011110000000\n",
      "00000000000001111100\n",
      "00000000000000000011\n",
      "A   0    3   3     3      0\n",
      "B   2    6   9     7      1\n",
      "C   4    4   13     9      5\n",
      "D   6    5   18     12      7\n",
      "E   8    2   20     12      10\n",
      "Avg of TAT  8.6\n",
      "Avg of WT  4.6\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import heapq\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def solve():\n",
    "    print(\"Enter number of processes \", end='')\n",
    "    process = int(input())\n",
    "\n",
    "    arrival = []\n",
    "    burst = []\n",
    "    procompleted = [0] * process\n",
    "    finish = []\n",
    "\n",
    "    p = [] # priority queue arrival number\n",
    "    \n",
    "    for i in range(process):\n",
    "        print(\"Enter arrival time \", end='')\n",
    "        arrival.append(int(input()))\n",
    "        print(\"Enter burst time \", end='')\n",
    "        burst.append(int(input()))\n",
    "        heapq.heappush(p, [arrival[i], i])\n",
    "\n",
    "    completed = 0\n",
    "\n",
    "\n",
    "    v = [] * process # Answer\n",
    "\n",
    "    time = 0\n",
    "    while True:\n",
    "        if p[0][1] <= time:\n",
    "            running_process = heapq.heappop(p)\n",
    "            print(running_process)\n",
    "            total = burst[running_process[1]] + time\n",
    "            # print(running_process[0] , \" \" , running_process[1] , \" \" , running_process[2])\n",
    "            while time < total:\n",
    "                temp = []\n",
    "                for i in range(process):\n",
    "                    if i == running_process[1]:\n",
    "                        temp.append(1)\n",
    "                    else:\n",
    "                        temp.append(0)\n",
    "                v.append(temp)\n",
    "                time += 1\n",
    "            completed += 1\n",
    "            if completed == process:\n",
    "                break\n",
    "            time -= 1\n",
    "        else:\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                # print(i)\n",
    "                temp.append(0)\n",
    "            v.append(temp)\n",
    "        time += 1\n",
    "                 \n",
    "    # print(v)\n",
    "    \n",
    "    for i in range(process):\n",
    "        last_ind = 0\n",
    "        for j in range(len(v)):\n",
    "            print(v[j][i], end='')\n",
    "            if v[j][i] == 1:\n",
    "                last_ind = j\n",
    "        finish.append(last_ind + 1)\n",
    "        print()\n",
    "        \n",
    "    matrix_vec = np.array(v)\n",
    "    \n",
    "    nonzero = np.argwhere(matrix_vec == 1)\n",
    "    \n",
    "    for i, j in nonzero:\n",
    "        plt.fill([i, i + 1, i + 1, i], [len(matrix_vec) - j - 1, len(matrix_vec) - j - 1, len(matrix_vec) - j, len(matrix_vec) - j], 'blue')\n",
    "    \n",
    "        \n",
    "    name = 'A'\n",
    "    avg_wt = 0\n",
    "    avg_tat = 0\n",
    "    max_yticks = 0\n",
    "    for i in range(process):\n",
    "        print(chr(ord(name) + i), \" \", arrival[i], \"  \", burst[i], \" \", finish[i], \"   \", finish[i] - arrival[i], \"    \", finish[i] - arrival[i] - burst[i])\n",
    "        max_yticks = max(max_yticks, finish[i])\n",
    "        avg_wt += finish[i] - arrival[i] - burst[i]\n",
    "        avg_tat += finish[i] - arrival[i]\n",
    "\n",
    "    print(\"Avg of TAT \", avg_tat / process)\n",
    "    print(\"Avg of WT \", avg_wt / process)\n",
    "    \n",
    "    plt.xticks(range(max_yticks + 1))\n",
    "    plt.grid(True)\n",
    "    plt.title('FCFS')\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    n = 1\n",
    "    # n = int(input())\n",
    "    while n > 0:\n",
    "        solve()\n",
    "        n -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of processes Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time 11100000000000000000\n",
      "00010000000000011111\n",
      "00001111000000000000\n",
      "00000000001111100000\n",
      "00000000110000000000\n",
      "A   0    3   3     3      0\n",
      "B   2    6   20     18      12\n",
      "C   4    4   8     4      0\n",
      "D   6    5   15     9      4\n",
      "E   8    2   10     2      0\n",
      "Avg of TAT  7.2\n",
      "Avg of WT  3.2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import heapq\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def solve():\n",
    "    print(\"Enter number of processes \", end='')\n",
    "    process = int(input())\n",
    "\n",
    "    arrival = []\n",
    "    burst = []\n",
    "    procompleted = [0] * process\n",
    "    finish = []\n",
    "\n",
    "    for i in range(process):\n",
    "        print(\"Enter arrival time \", end='')\n",
    "        arrival.append(int(input()))\n",
    "        print(\"Enter burst time \", end='')\n",
    "        burst.append(int(input()))\n",
    "\n",
    "    completed = 0\n",
    "\n",
    "    p = [] # priority queue Burst completed arrival number\n",
    "\n",
    "    v = [] # Answer\n",
    "\n",
    "    time = 0\n",
    "    while True:\n",
    "        for i in range(process):\n",
    "            if arrival[i] <= time and procompleted[i] == 0:\n",
    "                heapq.heappush(p, [burst[i], 0, arrival[i], i])\n",
    "                # print(i)\n",
    "                procompleted[i] = 1\n",
    "        if len(p):\n",
    "            running_process = heapq.heappop(p)\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                if i == running_process[3]:\n",
    "                    temp.append(1)\n",
    "                else:\n",
    "                    temp.append(0)\n",
    "            v.append(temp)\n",
    "            running_process[0] -= 1\n",
    "            running_process[1] = 1\n",
    "            if running_process[0]:\n",
    "                heapq.heappush(p, running_process)\n",
    "            else:\n",
    "                completed += 1\n",
    "            for i in p:\n",
    "                i[2] = 1\n",
    "            if completed == process:\n",
    "                break\n",
    "        else:\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                # print(i)\n",
    "                temp.append(0)\n",
    "            v.append(temp)\n",
    "        time += 1\n",
    "    \n",
    "    for i in range(process):\n",
    "        last_ind = 0\n",
    "        for j in range(len(v)):\n",
    "            print(v[j][i], end='')\n",
    "            if v[j][i] == 1:\n",
    "                last_ind = j\n",
    "        finish.append(last_ind + 1)\n",
    "        print()\n",
    "        \n",
    "    matrix_vec = np.array(v)\n",
    "    \n",
    "    nonzero = np.argwhere(matrix_vec == 1)\n",
    "    plt.subplot(2,2,1)\n",
    "    \n",
    "    for i, j in nonzero:\n",
    "        plt.fill([i, i + 1, i + 1, i], [len(matrix_vec) - j - 1, len(matrix_vec) - j - 1, len(matrix_vec) - j, len(matrix_vec) - j], 'blue')\n",
    "    \n",
    "        \n",
    "    name = 'A'\n",
    "    avg_wt = 0\n",
    "    avg_tat = 0\n",
    "    max_yticks = 0\n",
    "    for i in range(process):\n",
    "        print(chr(ord(name) + i), \" \", arrival[i], \"  \", burst[i], \" \", finish[i], \"   \", finish[i] - arrival[i], \"    \", finish[i] - arrival[i] - burst[i])\n",
    "        max_yticks = max(max_yticks, finish[i])\n",
    "        avg_wt += finish[i] - arrival[i] - burst[i]\n",
    "        avg_tat += finish[i] - arrival[i]\n",
    "\n",
    "    print(\"Avg of TAT \", avg_tat / process)\n",
    "    print(\"Avg of WT \", avg_wt / process)\n",
    "    \n",
    "    plt.xticks(range(max_yticks + 1))\n",
    "    plt.grid(True)\n",
    "    plt.title('SRTF')\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    n = 1\n",
    "    while n > 0:\n",
    "        solve()\n",
    "        n -= 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of processes Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time Enter arrival time Enter burst time 11100000000000000000\n",
      "00011111100000000000\n",
      "00000000000111100000\n",
      "00000000000000011111\n",
      "00000000011000000000\n",
      "A   0    3   3     3      0\n",
      "B   2    6   9     7      1\n",
      "C   4    4   15     11      7\n",
      "D   6    5   20     14      9\n",
      "E   8    2   11     3      1\n",
      "Avg of TAT  7.6\n",
      "Avg of WT  3.6\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import heapq\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def solve():\n",
    "    print(\"Enter number of processes \", end='')\n",
    "    process = int(input())\n",
    "\n",
    "    arrival = []\n",
    "    burst = []\n",
    "    procompleted = [0] * process\n",
    "    finish = []\n",
    "\n",
    "    for i in range(process):\n",
    "        print(\"Enter arrival time \", end='')\n",
    "        arrival.append(int(input()))\n",
    "        print(\"Enter burst time \", end='')\n",
    "        burst.append(int(input()))\n",
    "\n",
    "    completed = 0\n",
    "\n",
    "    p = [] # priority queue Burst completed arrival number\n",
    "\n",
    "    v = [] # Answer\n",
    "\n",
    "    time = 0\n",
    "    while True:\n",
    "        for i in range(process):\n",
    "            if arrival[i] <= time and procompleted[i] == 0:\n",
    "                heapq.heappush(p, [burst[i], arrival[i], i])\n",
    "                # print(i)\n",
    "                procompleted[i] = 1\n",
    "        if len(p):\n",
    "            running_process = heapq.heappop(p)\n",
    "            total = running_process[0] + time\n",
    "            while time < total:\n",
    "                temp = []\n",
    "                for i in range(process):\n",
    "                    if i == running_process[2]:\n",
    "                        temp.append(1)\n",
    "                    else:\n",
    "                        temp.append(0)\n",
    "                v.append(temp)\n",
    "                if arrival[i] <= time and procompleted[i] == 0:\n",
    "                    heapq.heappush(p, [burst[i], arrival[i], i])\n",
    "                    procompleted[i] = 1\n",
    "                time += 1\n",
    "            completed += 1\n",
    "            if completed == process:\n",
    "                break\n",
    "            time -= 1\n",
    "        else:\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                # print(i)\n",
    "                temp.append(0)\n",
    "            v.append(temp)\n",
    "        time += 1\n",
    "    \n",
    "    for i in range(process):\n",
    "        last_ind = 0\n",
    "        for j in range(len(v)):\n",
    "            print(v[j][i], end='')\n",
    "            if v[j][i] == 1:\n",
    "                last_ind = j\n",
    "        finish.append(last_ind + 1)\n",
    "        print()\n",
    "        \n",
    "    matrix_vec = np.array(v)\n",
    "    \n",
    "    nonzero = np.argwhere(matrix_vec == 1)\n",
    "    \n",
    "    for i, j in nonzero:\n",
    "        plt.fill([i, i + 1, i + 1, i], [len(matrix_vec) - j - 1, len(matrix_vec) - j - 1, len(matrix_vec) - j, len(matrix_vec) - j], 'blue')\n",
    "    \n",
    "        \n",
    "    name = 'A'\n",
    "    avg_wt = 0\n",
    "    avg_tat = 0\n",
    "    max_yticks = 0\n",
    "    for i in range(process):\n",
    "        print(chr(ord(name) + i), \" \", arrival[i], \"  \", burst[i], \" \", finish[i], \"   \", finish[i] - arrival[i], \"    \", finish[i] - arrival[i] - burst[i])\n",
    "        max_yticks = max(max_yticks, finish[i])\n",
    "        avg_wt += finish[i] - arrival[i] - burst[i]\n",
    "        avg_tat += finish[i] - arrival[i]\n",
    "\n",
    "    print(\"Avg of TAT \", avg_tat / process)\n",
    "    print(\"Avg of WT \", avg_wt / process)\n",
    "    \n",
    "    plt.xticks(range(max_yticks + 1))\n",
    "    plt.grid(True)\n",
    "    plt.title('SJF')\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    n = 1\n",
    "    while n > 0:\n",
    "        solve()\n",
    "        n -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of processes Enter arrival time Enter burst time Enter priority Enter arrival time Enter burst time Enter priority Enter arrival time Enter burst time Enter priority Enter arrival time Enter burst time Enter priority Enter arrival time Enter burst time Enter priority A   0    3   18     18      15\n",
      "B   2    6   12     10      4\n",
      "C   4    4   8     4      0\n",
      "D   6    5   17     11      6\n",
      "E   8    2   20     12      10\n",
      "Avg of TAT  11.0\n",
      "Avg of WT  7.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import heapq\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def solve():\n",
    "    print(\"Enter number of processes \", end='')\n",
    "    process = int(input())\n",
    "\n",
    "    arrival = []\n",
    "    burst = []\n",
    "    procompleted = [0] * process\n",
    "    finish = []\n",
    "    priority = []\n",
    "\n",
    "    for i in range(process):\n",
    "        print(\"Enter arrival time \", end='')\n",
    "        arrival.append(int(input()))\n",
    "        print(\"Enter burst time \", end='')\n",
    "        burst.append(int(input()))\n",
    "        print(\"Enter priority \", end='')\n",
    "        priority.append(int(input()))\n",
    "\n",
    "    completed = 0\n",
    "\n",
    "    p = [] # priority queue priority Burst number\n",
    "\n",
    "    v = [] * process # Answer\n",
    "\n",
    "    time = 0\n",
    "    while True:\n",
    "        for i in range(process):\n",
    "            if arrival[i] <= time and procompleted[i] == 0:\n",
    "                heapq.heappush(p, [priority[i], burst[i], i])\n",
    "                procompleted[i] = 1\n",
    "        if len(p):\n",
    "            runnn = heapq.heappop(p)\n",
    "            # print(runnn)\n",
    "            # print(runnn[0] , \" \" , runnn[1] , \" \" , runnn[2])\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                if i == runnn[2]:\n",
    "                    temp.append(1)\n",
    "                else:\n",
    "                    temp.append(0)\n",
    "            v.append(temp)\n",
    "            runnn[1] -= 1\n",
    "            if runnn[1] == 0:\n",
    "                completed += 1\n",
    "            else:\n",
    "                heapq.heappush(p, runnn)\n",
    "            if completed == process:\n",
    "                break\n",
    "        else:\n",
    "            temp = []\n",
    "            for i in range(process):\n",
    "                # print(i)\n",
    "                temp.append(0)\n",
    "            v.append(temp)\n",
    "        time += 1\n",
    "                 \n",
    "    # print(v)\n",
    "    \n",
    "    for i in range(process):\n",
    "        last_ind = 0\n",
    "        for j in range(len(v)):\n",
    "            # print(v[j][i], end='')\n",
    "            if v[j][i] == 1:\n",
    "                last_ind = j\n",
    "        finish.append(last_ind + 1)\n",
    "        # print()\n",
    "        \n",
    "    matrix_vec = np.array(v)\n",
    "    \n",
    "    nonzero = np.argwhere(matrix_vec == 1)\n",
    "    \n",
    "    for i, j in nonzero:\n",
    "        plt.fill([i, i + 1, i + 1, i], [len(matrix_vec) - j - 1, len(matrix_vec) - j - 1, len(matrix_vec) - j, len(matrix_vec) - j], 'blue')\n",
    "    \n",
    "        \n",
    "    name = 'A'\n",
    "    avg_wt = 0\n",
    "    avg_tat = 0\n",
    "    max_yticks = 0\n",
    "    for i in range(process):\n",
    "        print(chr(ord(name) + i), \" \", arrival[i], \"  \", burst[i], \" \", finish[i], \"   \", finish[i] - arrival[i], \"    \", finish[i] - arrival[i] - burst[i])\n",
    "        max_yticks = max(max_yticks, finish[i])\n",
    "        avg_wt += finish[i] - arrival[i] - burst[i]\n",
    "        avg_tat += finish[i] - arrival[i]\n",
    "\n",
    "    print(\"Avg of TAT \", avg_tat / process)\n",
    "    print(\"Avg of WT \", avg_wt / process)\n",
    "    \n",
    "    plt.xticks(range(max_yticks + 1))\n",
    "    plt.grid(True)\n",
    "    plt.title('Priority_scheduling')\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    n = 1\n",
    "    # n = int(input())\n",
    "    while n > 0:\n",
    "        solve()\n",
    "        n -= 1\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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}