Deadlock is an increasingly pressing concern as the multicore revolution forces parallel programming upon the average programmer. Existing approaches to deadlock impose onerous burdens on developers, entail high runtime performance overheads, or offer no help for unmodified legacy code. Gadara automates dynamic deadlock avoidance for conventional multithreaded programs. It employs whole-program static analysis to model programs, and Discrete Control Theory to synthesize lightweight, decentralized, highly concurrent logic that controls them at runtime. Gadara is safe, and can be applied to legacy code with modest programmer effort. Gadara is efficient because it performs expensive deadlock-avoidance computations offline rather than online. We have implemented Gadara for C/Pthreads programs. In benchmark tests, Gadara successfully avoids injected deadlock faults, imposes negligible to modest performance overheads (at most 18%), and outperforms a software transactional memory system. Tests on a real application show that Gadara identifies and avoids both previously known and unknown deadlocks while adding performance overheads ranging from negligible to 10%. 1

Abstract — Ensuring deadlock-free execution of concurrent programs is a notoriously difficult problem, but an increasingly important one as multicore processors compel performanceconscious software developers to parallelize applications. We propose and validate a novel methodology for dynamically controlling the execution of concurrent software in order to provably avoid deadlocks. The methodology is based on supervisory control of discrete event systems modeled by Petri nets. Specifically, we synthesize feedback controllers for concurrent programs based on the theory of supervision based on place invariants and implement the controllers online to guarantee deadlock avoidance. We describe a full implementation of this methodology and report initial experimental results demonstrating its effectiveness and scalability. I.

this paper, we consider deadlock resolution with reusable resources. In resolving a deadlock state, it is desirable to minimize the number of processes to abort to make the system deadlock-free. Even in the case of single resource units, however, such minimization problem is NP-complete[4]. We present two ecient polynomial time resolution algorithms for the case of multiple resource units. The complexity of deadlock detection and resolution with our two resolution algorithms are O(N p N r ) and O(N r +N p N r N min ), where N p is the number of processes, N r is the number of resources, and N min = min(N p ; N r ). We prove that one algorithm is optimal in the special case when every process is blocked on no more than one resource unit. We also present comparison studies of the two algorithms with randomly generated deadlock scenarios. The results illustrate that, on average, the number of aborts in both techniques exceeds the optimum by less than 10%