deadlock avoidance in operating system tsi

#DEADLOCK AVOIDANCE IN OPERATING SYSTEM TSI CODE#

The banker's algorithm is a slight variation on deadlock detection: instead of detecting whether there is currently a deadlock, we keep track of the maximum potential requests that each process might make, and block before granting a request that could lead to deadlock in the future if some processes request their maximum allocation. If you can't, then there must be a cycle, so the system is deadlocked.

If you can remove all processes, there is no deadlock: you can run all processes to completion.and all incoming edges to it (since it relinquishes all its resources when it finishes).erase it (this is like running it to completion).While there is a process or resource with no outgoing edge:.Make a copy of the resource allocation graph.In order to detect deadlock, we can use the following algorithm: This check can be done periodically or when a new resource is requested.

#DEADLOCK AVOIDANCE IN OPERATING SYSTEM TSI CODE#

You may end up killing too many threads, but if you are writing code that is expected to be run with deadlock detection, it needs to be able to handle thread death anyway, so killing a few extra threads isn't so bad (this is an example of an end-to-end argument, which we'll discuss in more detail when studying networking).Ī more precise method is to keep track of the resource allocation graph and check it for deadlock. One can respond by either killing a thread (and releasing all of its resources), or by forcing it to roll back.Ī simple practical solution to detecting deadlock is to simply put a time limit on the acquisition of resources. Breaking circular wait: lock orderingĪn alternative approach is Deadlock detectionĪnother general strategy for dealing with deadlock is to simply detect it and respond if it occurs. However, it is still possible to create a form of deadlock with a monitor where one thread needs to wait for some predicate before updating state in a way that satisfies another predicate, while a second thread waits for the second predicate before making the first predicate true.

Monitors partially use this strategy to avoid hold-and-wait: calling wait on a condition variable automatically releases the lock, so that acquiring the monitor lock cannot cause deadlock. Releasing locks may require rollback, which leads to the same issues described above. Breaking hold-and-waitĬan break hold-and-wait by having threads release all locks and re-acquire them all at once. Once you tell the user you've started processing their order, you can't take it back. I/O is a well-known impediment to rollback: once some output has been performed, it may be impossible to return to a consistent state. It is not possible to make all resource preemptible. This state is called livelock: when competing threads are continuously being rolled back before they can finish. Although the system is not deadlocked (both threads seem to be making forward progress), the system may never actually finish its tasks. Once we allow computations to be rolled back, we introduce the possibility that two threads can continue to preempt each other forever. In order to do this, we need some mechanism for rollback: we need to be able to restore whatever program invariants that the resource was held in order to satisfy.įor example, if the resource is a lock protecting a shared variable, we could roll back the thread that holds the lock by restoring the state of the shared variable to the state it held before the lock was acquired, and restarting the process that was performing the update. If a process tries to acquire a resource that is held by another process, we can make it possible for the new process to steal the resource. In some situations we can make resources preemptable. Mutual exclusion is a good condition to break if you can, but often you can't. printers: can't print two documents simultaneously!). However, many resources are inherently non-shareable (e.g.

Using a lock-free data structure is another way to allow multiple threads to access a data structure simultaneously (without blocking). For example, using a reader/writer lock instead of a mutex can make deadlock less likely (since many readers can share the read lock). In some cases, deadlock can be mitigated by making resources more shareable. We can design a system to avoid deadlock by making any of the 4 conditions impossible.

key terms: optimistic concurrency, rollback, livelock.

Deadlock avoidance in operating system tsi