Revert "기능 추가: RR 스케줄링 구현, Main 테스트 코드 구현"

This reverts commit 851ac3a57da6a1bbfbdae7da8eedf5bf79f15818.

.gitignore

@@ -0,0 +1 @@
+__pycache__/

CPU.py

@@ -2,8 +2,20 @@ class CPU:
     def __init__(self, cpu_id):
         self.cpu_id = cpu_id
         self.process = None
+        self.end_time = -1
 
     def is_idle(self):
         return self.process is None
 
+    def set_idle(self):
+        self.process = None
+
+    def set_process(self, process, cur_time, end_time):
+        self.process = process
+        self.end_time = end_time
+        self.process.remain_BT -= end_time - cur_time
 
+    def is_finished(self, cur_time):
+        if cur_time == self.end_time:
+            return True
+        return False

Main.py

@@ -1,19 +1,43 @@
 from RR import *
 
+def print_process_time_table(processes):
+    print("----------------------------------------------------")
+    print("{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format('PID', 'AT', 'BT', 'WT', 'TT', 'NTT'))
+    average_response_time = 0
+    for process in processes:
+        print("{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format(process.process_id,
+                    process.AT,
+                    process.BT,
+                    process.WT,
+                    process.TT,
+                    round(process.NTT,1)))
+        average_response_time += process.TT
+    average_response_time /= len(processes)
+    print("\nAverage response time(TT) : ", round(average_response_time, 2))
+    print("----------------------------------------------------\n")
+
+
 def test(process_input_list, cpu_count):
     scheduler_list = []
     # fcfs = FCFS(process_input_list, cpu_count)
-    scheduler_list.append(RR(process_input_list, cpu_count, 2))
+    scheduler_list.append(RR(process_input_list, cpu_count, 2)) # quantum = 2
+    scheduler_list.append(RR(process_input_list, cpu_count, 3)) # quantum = 3
     # scheduler_list.append(HRRN(process_input_list, cpu_count))
     # ...
-    for scheduler in scheduler_list:
+    for test_idx, scheduler in enumerate(scheduler_list):
+        print("[ TEST {0} - {1}]=======================================".format(test_idx + 1, type(scheduler).__name__))
         scheduler.run()
+        print_process_time_table(scheduler.processes)
 
 
 def main():
-    test([["p1", 0, 3], ["p2", 2, 7], ["p3", 3, 2], ["p4", 5, 5], ["p5", 6, 3]], 1)
-    test([["p1", 1, 3], ["p2", 2, 7], ["p3", 3, 2], ["p4", 5, 5], ["p5", 6, 3]], 1)
-    test([["p1", 0, 3], ["p2", 5, 5], ["p3", 6, 3]], 1)
+    test([["P1", 0, 3], ["P2", 1, 7], ["P3", 3, 2], ["P4", 5, 5], ["P5", 6, 3]], 1)
+    # print("[TEST 02]")
+    # test([["P1", 0, 3], ["P2", 2, 7], ["P3", 3, 2], ["P4", 5, 5], ["P5", 6, 3]], 1)
+    # print("[TEST 03]")
+    # test([["P1", 1, 3], ["P2", 2, 7], ["P3", 3, 2], ["P4", 5, 5], ["P5", 6, 3]], 1)
+    # print("[TEST 04]")
+    # test([["P1", 0, 3], ["P2", 5, 5], ["P3", 6, 3]], 1)
 
 
 if __name__ == "__main__":

Process.py

@@ -3,16 +3,11 @@ def __init__(self, process_id, AT, BT):
         self.process_id = process_id
         self.AT = AT  # arrival time
         self.BT = BT  # burst time
+        self.remain_BT = BT  # remain burst time
         self.WT = 0  # waiting time(TT - BT)
         self.TT = 0  # turnaround time
         self.NTT = 0  # normalized turnaround time(TT/BT)
 
-    def get_AT(self):
-        return self.AT
-
-    def get_BT(self):
-        return self.BT
-
     def calculate_finished_process(self, cur_time) -> int:
         self.TT = cur_time - self.AT
         self.WT = self.TT - self.BT

RR.py

@@ -9,4 +9,47 @@ def __init__(self, process_input_list, cpu_count, quantum):
 
 
     def run(self):
-        pass
+        cur_time = 0
+        finish_processes_count = 0
+        AT_idx = 0
+        sorted_processes = sorted(self.processes, key= lambda x : x.AT)
+        # 끝난 프로세스가 총 프로세스의 수와 같아질때까지 작동
+        while(finish_processes_count < self.process_count):
+            # 현재 시간에 도착할 프로세스 대기열 큐에 넣어주기
+            for process_idx in range(AT_idx, self.process_count):
+                process = sorted_processes[process_idx]
+                if process.AT == cur_time:
+                    print("processe arrived - cur_time:", cur_time, " p_id :", process.process_id)
+                    self.ready_queue.append(process)
+                elif process.AT > cur_time:
+                    AT_idx = process_idx
+                    break
+
+            # cpu들을 돌면서
+            for cpu in self.cpus:
+                # cpu의 일이 끝났으면
+                if cpu.is_finished(cur_time):
+                    # 만약 프로세스가 실행시간이 남아있으면 다시 대기열 큐에 넣어준다.
+                    if cpu.process.remain_BT > 0:
+                        self.ready_queue.append(cpu.process)
+                    else:
+                        # 프로세스가 완전히 끝나면 현재시간을 기준으로 각 time을 계산
+                        # 끝난 프로세스의 개수 1 증가
+                        print("processe finished - cur_time:", cur_time, " p_id :", cpu.process.process_id)
+                        cpu.process.calculate_finished_process(cur_time)
+                        finish_processes_count += 1
+                    # 일이 끝난 CPU는 쉬게 해준다.
+                    cpu.set_idle()
+
+                # cpu가 쉬고 있고
+                if cpu.is_idle():
+                    # 대기열에 프로세스가 하나 이상 존재한다면
+                    if len(self.ready_queue) >= 1 :
+                        input_process = self.ready_queue.pop(0)
+                        # 현재 넣을 프로세스의 남은 실행 시간이 RR의 quantum보다 작으면
+                        # 남은 실행 시간이 일할시간, 아니면 quantum이 일할 시간이 된다.
+                        remain_BT = input_process.remain_BT
+                        work_time = self.quantum if remain_BT >= self.quantum else remain_BT
+                        cpu.set_process(input_process, cur_time, cur_time + work_time)
+            # 현재시간 증가
+            cur_time += 1