scheduling.multi_level_feedback_queue
=====================================

.. py:module:: scheduling.multi_level_feedback_queue


Attributes
----------

.. autoapisummary::

   scheduling.multi_level_feedback_queue.P1


Classes
-------

.. autoapisummary::

   scheduling.multi_level_feedback_queue.MLFQ
   scheduling.multi_level_feedback_queue.Process


Module Contents
---------------

.. py:class:: MLFQ(number_of_queues: int, time_slices: list[int], queue: collections.deque[Process], current_time: int)

   MLFQ(Multi Level Feedback Queue)
   https://en.wikipedia.org/wiki/Multilevel_feedback_queue
   MLFQ has a lot of queues that have different priority
   In this MLFQ,
   The first Queue(0) to last second Queue(N-2) of MLFQ have Round Robin Algorithm
   The last Queue(N-1) has First Come, First Served Algorithm


   .. py:method:: calculate_completion_time(queue: list[Process]) -> list[int]

      This method calculates completion time of processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> _ = mlfq.multi_level_feedback_queue()
      >>> mlfq.calculate_turnaround_time([P1, P2, P3, P4])
      [136, 34, 162, 125]



   .. py:method:: calculate_remaining_burst_time_of_processes(queue: collections.deque[Process]) -> list[int]

      This method calculate remaining burst time of processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> finish_queue, ready_queue = mlfq.round_robin(deque([P1, P2, P3, P4]), 17)
      >>> mlfq.calculate_remaining_burst_time_of_processes(mlfq.finish_queue)
      [0]
      >>> mlfq.calculate_remaining_burst_time_of_processes(ready_queue)
      [36, 51, 7]
      >>> finish_queue, ready_queue = mlfq.round_robin(ready_queue, 25)
      >>> mlfq.calculate_remaining_burst_time_of_processes(mlfq.finish_queue)
      [0, 0]
      >>> mlfq.calculate_remaining_burst_time_of_processes(ready_queue)
      [11, 26]



   .. py:method:: calculate_sequence_of_finish_queue() -> list[str]

      This method returns the sequence of finished processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> _ = mlfq.multi_level_feedback_queue()
      >>> mlfq.calculate_sequence_of_finish_queue()
      ['P2', 'P4', 'P1', 'P3']



   .. py:method:: calculate_turnaround_time(queue: list[Process]) -> list[int]

      This method calculates turnaround time of processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> _ = mlfq.multi_level_feedback_queue()
      >>> mlfq.calculate_turnaround_time([P1, P2, P3, P4])
      [136, 34, 162, 125]



   .. py:method:: calculate_waiting_time(queue: list[Process]) -> list[int]

      This method calculates waiting time of processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> _ = mlfq.multi_level_feedback_queue()
      >>> mlfq.calculate_waiting_time([P1, P2, P3, P4])
      [83, 17, 94, 101]



   .. py:method:: first_come_first_served(ready_queue: collections.deque[Process]) -> collections.deque[Process]

      FCFS(First Come, First Served)
      FCFS will be applied to MLFQ's last queue
      A first came process will be finished at first
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> _ = mlfq.first_come_first_served(mlfq.ready_queue)
      >>> mlfq.calculate_sequence_of_finish_queue()
      ['P1', 'P2', 'P3', 'P4']



   .. py:method:: multi_level_feedback_queue() -> collections.deque[Process]

      MLFQ(Multi Level Feedback Queue)
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> finish_queue = mlfq.multi_level_feedback_queue()
      >>> mlfq.calculate_sequence_of_finish_queue()
      ['P2', 'P4', 'P1', 'P3']



   .. py:method:: round_robin(ready_queue: collections.deque[Process], time_slice: int) -> tuple[collections.deque[Process], collections.deque[Process]]

      RR(Round Robin)
      RR will be applied to MLFQ's all queues except last queue
      All processes can't use CPU for time more than time_slice
      If the process consume CPU up to time_slice, it will go back to ready queue
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> finish_queue, ready_queue = mlfq.round_robin(mlfq.ready_queue, 17)
      >>> mlfq.calculate_sequence_of_finish_queue()
      ['P2']



   .. py:method:: update_waiting_time(process: Process) -> int

      This method updates waiting times of unfinished processes
      >>> P1 = Process("P1", 0, 53)
      >>> P2 = Process("P2", 0, 17)
      >>> P3 = Process("P3", 0, 68)
      >>> P4 = Process("P4", 0, 24)
      >>> mlfq = MLFQ(3, [17, 25], deque([P1, P2, P3, P4]), 0)
      >>> mlfq.current_time = 10
      >>> P1.stop_time = 5
      >>> mlfq.update_waiting_time(P1)
      5



   .. py:attribute:: current_time


   .. py:attribute:: finish_queue
      :type:  collections.deque[Process]


   .. py:attribute:: number_of_queues


   .. py:attribute:: ready_queue


   .. py:attribute:: time_slices


.. py:class:: Process(process_name: str, arrival_time: int, burst_time: int)

   .. py:attribute:: arrival_time


   .. py:attribute:: burst_time


   .. py:attribute:: process_name


   .. py:attribute:: stop_time


   .. py:attribute:: turnaround_time
      :value: 0



   .. py:attribute:: waiting_time
      :value: 0



.. py:data:: P1