description of code

$-$ Simulate CPU Scheduling: Implement priority scheduling algorithm with round robin. The simulation should continue until all the processes in the input file terminate.

$$

$-$ Deadlock Detection and Recovery: Implement an appropriate deadlock detection algorithm to monitor the system status and identify deadlock situations. If a deadlock is detected, implement a deadlock recovery strategy of your choice $($e$.$g$.,$ process termination, resource preemption$).$

$$

At the end of simulation, your program must show the Gantt chart representing the timeline of process execution, average waiting time, and average turnaround time for all processes. Also report the detected deadlock states and how recovery was handled

edit this code to take the data from file input and to be work correctly and test it

input format

$001$ CPU $\{$R$[1],50,$ F$[1]\}$

$151$ CPU $\{20\}$ IO$\{30\}$ CPU $\{20,$ R$[2],30,$ F$[2],10\}$

import heapq from collections import deque, defaultdict class Process: def $\_\_$init$\_\_($self$,$ pid, arrival$\_$time, priority, bursts$)$: self.pid $=$ pid self.arrival$\_$time $=$ arrival$\_$time self.priority $=$ priority self.bursts $=$ deque$($bursts$)$ # Queue of CPU and IO bursts self.waiting$\_$time $=0$ self.turnaround$\_$time $=0$ self.current$\_$burst$\_$time $=0$ self.resource$\_$requests $=[]$ self.is$\_$waiting $=$ False class Scheduler: def $\_\_$init$\_\_($self$)$: self.time $=0$ self.ready$\_$queue $=[]$ # Priority queue for scheduling self.io$\_$queue $=$ deque$()$ self.resource$\_$allocation $=$ defaultdict$($lambda: None$)$ # Resource allocation self.waiting$\_$processes $=$ deque$()$ self.completed$\_$processes $=[]$ self.deadlock$\_$states $=[]$ def add$\_$process$($self$,$ process$)$: heapq.heappush$($self$.$ready$\_$queue, $($process$.$priority, process.arrival$\_$time, process$))$ def simulate$($self$)$: while self.ready$\_$queue or self.io$\_$queue or self.waiting$\_$processes: self.execute$\_$ready$\_$queue$()$ self.execute$\_$io$\_$queue$()$ self.check$\_$deadlock$()$ def execute$\_$ready$\_$queue$($self$)$: if self.ready$\_$queue: $\_,\_,$ process $=$ heapq.heappop$($self$.$ready$\_$queue$)$ current$\_$burst $=$ process.bursts.popleft$()$ if isinstance$($current$\_$burst, tuple$)$: # CPU with resource requests$/$releases self.handle$\_$resource$\_$requests$($process$,$ current$\_$burst$)$ else: self.time $+=$ current$\_$burst # Simulate CPU burst process.turnaround$\_$time $+=$ self.time $-$ process.arrival$\_$time if not process.bursts: self.completed$\_$processes.append$($process$)$ else: self.io$\_$queue.append$($process$)$ def execute$\_$io$\_$queue$($self$)$: # Simulate IO bursts and move back to ready queue if self.io$\_$queue: io$\_$process $=$ self.io$\_$queue.popleft$()$ io$\_$burst $=$ io$\_$process.bursts.popleft$()$ self.time $+=$ io$\_$burst self.add$\_$process$($io$\_$process$)$ def handle$\_$resource$\_$requests$($self$,$ process, resource$\_$burst$)$: request$\_$type, resource, burst$\_$time $=$ resource$\_$burst if request$\_$type $=="$R$"$: if self.resource$\_$allocation$[$resource$]$ is None: self.resource$\_$allocation$[$resource$]=$ process.pid process.current$\_$burst$\_$time $+=$ burst$\_$time else: process.is$\_$waiting $=$ True self.waiting$\_$processes.append$($process$)$ elif request$\_$type $=="$F$"$: if self.resource$\_$allocation$[$resource$]==$ process.pid: self.resource$\_$allocation$[$resource$]=$ None process.current$\_$burst$\_$time $+=$ burst$\_$time else: raise Exception$("$Invalid resource release"$)$ def check$\_$deadlock$($self$)$: # Simple deadlock detection: cyclic dependency check if self.detect$\_$deadlock$()$: self.deadlock$\_$states.append$(($self$.$time, list$($self$.$waiting$\_$processes$)))$ self.recover$\_$from$\_$deadlock$()$ def detect$\_$deadlock$($self$)$: # Use resource allocation graph or similar technique return False # Placeholder for actual deadlock detection logic def recover$\_$from$\_$deadlock$($self$)$: # Recover by terminating or preempting processes if self.waiting$\_$processes: victim $=$ self.waiting$\_$processes.popleft$()$ print$($f$"$Recovering from deadlock by terminating process $\{$victim$.$pid$\}")$ def generate$\_$statistics$($self$)$: total$\_$waiting$\_$time $=$ sum$($p$.$waiting$\_$time for p in self.completed$\_$processes$)$ total$\_$turnaround$\_$time $=$ sum$($p$.$turnaround$\_$time for p in self.completed$\_$processes$)$ avg$\_$waiting$\_$time $=$ total$\_$waiting$\_$time $/$ len$($self$.$completed$\_$processes$)$ avg$\_$turnaround$\_$time $=$ total$\_$turnaround$\_$time $/$ len$($self$.$completed$\_$processes$)$ print$($f$"$Average Waiting Time: $\{$avg$\_$waiting$\_$time$\}")$ print$($f$"$Average Turnaround Time: $\{$avg$\_$turnaround$\_$time$\}")$ # Generate Gantt Chart print$("$Gantt Chart: $($Time $->$ Process$)")$ # Example usage processes $=[$ Process$(0,0,1,[("$R$",1,50),("$F$",1,0)]),$ Process$(1,5,1,[20,("$IO$",$ None, $30),20,("$R$",2,30),("$F$",2,10)]),]$ scheduler $=$ Scheduler$()$ for p in processes: scheduler.add$\_$process$($p$)$ scheduler.simulate$()$ scheduler.generate$\_$statistics$()$