Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Overview of Approach
Discussion
Related Work
Conclusions
References
All Topics
Computer Science
Operating Systems

Gadara: Dynamic deadlock avoidance for multithreaded programs

Profile image of Stéphane LafortuneStéphane Lafortune

2008, Proceedings of the Eighth Symposium on Operating Systems Design and Implementation (OSDI���08)

https://doi.org/10.5555/1855741.1855761
visibility

…

description

14 pages

link

1 file

Abstract

Abstract: 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 ...

Related papers

Detecting Potential Deadlocks with Static Analysis and Run-Time Monitoring
Rahul Agarwal

2005

Concurrent programs are notorious for containing errors that are difficult to reproduce and diagnose. A common kind of concurrency error is deadlock, which occurs when a set of threads is blocked each trying to acquire a lock held by another thread in that set. Static and dynamic (run-time) analysis techniques exist to detect deadlocks. Havelund's GoodLock algorithm detects potential deadlocks at run-time. However, it detects only potential deadlocks involving exactly two threads. This paper presents a generalized version of the GoodLock algorithm that detects potential deadlocks involving any number of threads. Run-time checking may miss errors in unexecuted code. On the positive side, runtime checking generally produces fewer false alarms than static analysis. This paper explores the use of static analysis to automatically reduce the overhead of run-time checking. We extend our type system, Extended Parameterized Atomic Java (EPAJ), which ensures absence of races and atomicity violations, with Boyapati et al.'s deadlock types. We give an algorithm that infers deadlock types for a given program and an algorithm that determines, based on the result of type inference, which run-time checks can safely be omitted. The new type system, called Deadlock-Free EPAJ (DEPAJ), has the added benefit of giving stronger atomicity guarantees than previous atomicity type systems.

View PDFchevron_right
An Automatic Technique for Static Deadlock Prevention
Bertrand Meyer

Lecture Notes in Computer Science, 2015

Deadlocks remain one of the biggest threats to concurrent programming. Usually, the best programmers can expect is dynamic deadlock detection, which is only a palliative. Object-oriented programs, with their rich reference structure and the resulting presence of aliasing, raise additional problems. The technique developed in this paper relies on the "alias calculus" to offer a completely static and completely automatic analysis of concurrent object-oriented programs. The discussion illustrates the technique by applying it to two versions of the "dining philosophers" program, of which it proves that the first is deadlockfree and the second deadlock-prone.

View PDFchevron_right
A transformation to provide deadlock-free programs
Pablo Pérez

2003

A commonly employed technique to control access to shared resources in concurrent programs consists of using critical sections. Unfortunately, it is well known that programs using several critical sections may suffer from deadlocks. In this paper we introduce a new approach for ensuring deadlock-freedom in a transparent manner from the programmer's point of view. Such an approach consists of obtaining a deadlock-free "version" of the original program by using some program transformations. We formally prove the correctness of those transformations and we analyze their applicability.

View PDFchevron_right
Scalable Dynamic Deadlock Analysis of Multi-Threaded Programs
Klaus Havelund

This paper presents a dynamic program analysis algorithm that can detect deadlock potentials in a multi-threaded program by ex- amining a single execution trace, obtained by running an instrumented version of the program. The algorithm is interesting because it can iden- tify deadlock potentials even though no deadlocks occur in the examined execution, and therefore it scales very well in contrast to more formal approaches to deadlock detection. It is an improvement of an existing algorithm in that it reduces the number of false positives (false warn- ings). The paper describes an implementation, Java PathExplorer, for analyzing Java programs. An application of the implementation to two case studies is described.

View PDFchevron_right
The theory of deadlock avoidance via discrete control
Scott Mahlke

2009

Abstract Deadlock in multithreaded programs is an increasingly important problem as ubiquitous multicore architectures force parallelization upon an ever wider range of software. This paper presents a theoretical foundation for dynamic deadlock avoidance in concurrent programs that employ conventional mutual exclusion and synchronization primitives (eg, multithreaded C/Pthreads programs).

View PDFchevron_right
Dynamic Deadlock Analysis of Multi-threaded Programs
Klaus Havelund

Lecture Notes in Computer Science, 2006

This paper presents a dynamic program analysis algorithm that can detect deadlock potentials in a multi-threaded program by examining a single execution trace, obtained by running an instrumented version of the program. The algorithm is interesting because it can identify deadlock potentials even though no deadlocks occur in the examined execution, and therefore it scales very well in contrast to more formal approaches to deadlock detection. It is an improvement of an existing algorithm in that it reduces the number of false positives (false warnings). The paper describes an implementation and an application to three case studies.

View PDFchevron_right
A Compile-Time Deadlock Detection Pattern
Michał Korzycki

Computer Science, 2013

The paper presents the application of the trait technique in generic programming for compiletime deadlock detection and prevention in multithreaded applications.

View PDFchevron_right
Detecting deadlock in programs with data-centric synchronization
Jan Vitek, Julian Dolby

2013 35th International Conference on Software Engineering (ICSE), 2013

Previously, we developed a data-centric approach to concurrency control in which programmers specify synchronization constraints declaratively, by grouping shared locations into atomic sets. We implemented our ideas in a Java extension called AJ, using Java locks to implement synchronization. We proved that atomicity violations are prevented by construction, and demonstrated that realistic Java programs can be refactored into AJ without significant loss of performance.

View PDFchevron_right
Detection of deadlock potentials in multithreaded programs
Rahul Agarwal

Ibm Journal of Research and Development, 2010

Concurrent programs are well known for containing errors that are difficult to detect, reproduce, and diagnose. Deadlock is a common concurrency error, which occurs when a set of threads are blocked, due to each attempting to acquire a lock held by another. This paper presents a collection of highly scalable static and dynamic techniques for exposing potential deadlocks. The basis is a known algorithm, which, when locks are acquired in a nested fashion, captures the nesting order in a lock graph. A cycle in the graph indicates a deadlock potential. We propose three extensions to this basic algorithm to eliminate, or label as low severity, false warnings of possible deadlocks (false positives). These false positives may be due to cycles within one thread, cycles guarded by a gate lock (an enclosing lock that prevents deadlocks), and cycles involving several code fragments that cannot possibly execute in parallel. We also present a technique that combines information from multiple runs of the program into a single lock graph, to find deadlock potentials that would not be revealed by analyzing one run at a time. Finally, this paper describes the use of static analysis to automatically reduce the overhead of dynamic checking for deadlock potentials.

View PDFchevron_right
The application of supervisory control to deadlock avoidance in concurrent software
Scott Mahlke

2008

Abstract Ensuring deadlock-free execution of concurrent programs is a notoriously difficult problem, but an increasingly important one as multicore processors compel performance-conscious 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.

View PDFchevron_right

References (50)

  1. AGARWAL, R., AND STOLLER, S. D. Run-time detection of po- tential deadlocks for programs with locks, semaphores, and con- dition variables. In Proc. Workshop on Parallel and Distributed Systems: Testing and Debugging (2006).
  2. AGARWAL, R., WANG, L., AND STOLLER, S. D. Detecting potential deadlocks with static analysis and runtime monitoring. In Proc. Parallel and Distributed Systems (2006), vol. 3875 of LNCS, Springer-Verlag.
  3. BAUGH, L., AND ZILLES, C. An analysis of i/o and syscalls in critical sections and their implications for transactional memory. In TRANSACT (2007).
  4. BOER, E. R., AND MURATA, T. Generating basis siphons and traps of Petri nets using the sign incidence matrix. IEEE Trans. on Circuits and Systems-I 41, 4 (1994).
  5. CASSANDRAS, C. G., AND LAFORTUNE, S. Introduction to Dsicrete Event Systems, second ed. Springer, 2007.
  6. CLARKE, E., GRUMBERG, O., AND PELED, D. Model Check- ing. MIT Press, 2002.
  7. DIJKSTRA, E. W. Solution of a problem in concurrent program- ming control. CACM 8, 9 (1965).
  8. DIJKSTRA, E. W. Selected Writings on Computing. Springer- Verlag, 1982, ch. The Mathematics Behind the Banker's Algo- rithm.
  9. ENGLER, D., AND ASHCRAFT, K. RacerX : effective, static detection of race conditions and deadlocks. In SOSP (2003).
  10. FINKEL, R., AND MADDURI, H. H. An efficient deadlock avoid- ance algorithm. Inf. Process. Lett. 24, 1 (1987).
  11. FLANAGAN, C., LEINO, K. R. M., LILLIBRIDGE, M., NEL- SON, G., SAXE, J. B., AND STATA:, R. Extended static check- ing for Java. In PLDI (2002).
  12. GOLD, E. M. Deadlock prediction: Easy and difficult cases. SIAM J. Comput. 7, 3 (1978).
  13. HABERMANN, A. N. Prevention of system deadlocks. CACM 12, 7 (1969).
  14. HELLERSTEIN, J. L., DIAO, Y., PAREKH, S., AND TILBURY, D. M. Feedback Control of Computing Systems. Wiley, 2004.
  15. HOLLOWAY, L., KROGH, B., AND GIUA, A. A survey of Petri net methods for controlled discrete event systems. Discrete Event Dynamic Systems: Theory and Applications 7, 2 (1997).
  16. HOLT, R. C. Comments on prevention of system deadlocks. CACM 14, 1 (1971).
  17. HOLT, R. C. Some deadlock properties of computer systems. ACM Comput. Surv. 4, 3 (1972).
  18. Intel C++ STM Compiler, Prototype Edition, Jan. 2008.
  19. IORDACHE, M. V., AND ANTSAKLIS, P. J. Supervisory Con- trol of Concurrent Systems: A Petri Net Structural Approach. Birkhäuser, 2006.
  20. JULA, H., AND CANDEA, G. A scalable, sound, eventually- complete algorithm for deadlock immunity. In Workshop on Run- time Verification (2008).
  21. KAVI, K. M., MOSHTAGHI, A., AND YI CHEN, D. Modeling multithreaded applications using Petri nets. International Journal of Parallel Programming 30, 5 (2002).
  22. KNUTH, D. E. Additional comments on a problem in concurrent programming control. CACM 9, 5 (1966).
  23. LANDI, W. Undecidability of static analysis. ACM Lett. Pro- gram. Lang. Syst. 1, 4 (1992).
  24. LANG, S.-D. An extended banker's algorithm for deadlock avoidance. IEEE Trans. Software Eng 25, 3 (1999).
  25. LARUS, J., AND RAJWAR, R. Transactional Memory. Morgan & Claypool Publishers, 2007.
  26. LEE, E. A. The problem with threads. Tech. rep., UC Berkeley EE & CS Department, Jan. 2006.
  27. LI, Z., ZHOU, M., AND WU, N. A survey and comparison of Petri net-based deadlock prevention policies for flexible manufac- turing systems. IEEE Trans. on Systems, Man, and Cybernetics- Part C 38, 2 (2008).
  28. LU, S., PARK, S., SEO, E., AND ZHOU, Y. Learning from mistakes: a comprehensive study on real world concurrency bug characteristics. In ASPLOS (2008).
  29. MILLER, M. S. Robust Composition: Towards a Unified Ap- proach to Access Control and Concurrency Control. PhD thesis, Johns Hopkins University, 2006.
  30. MINOURA, T. Deadlock avoidance revisited. J. ACM 29, 4 (1982).
  31. MOODY, J. O., AND ANTSAKLIS, P. J. Supervisory Control of Discrete Event Systems Using Petri Nets. Kluwer Academic Publishers, 1998.
  32. MURATA, T. Petri nets: Properties, analysis and applications. Proceedings of the IEEE 77, 4 (1989).
  33. NEWTON, G. Deadlock prevention, detection, and resolution: an annotated bibliography. SIGOPS Oper. Syst. Rev. 13, 2 (1979).
  34. NI, Y., WELC, A., ADL-TABATABAI, A.-R., BACH, M., BERKOWITS, S., COWNIE, J., GEVA, R., KOZHUKOW, S., NARAYANASWAMY, R., PREIS, J. O. S., SAHA, B., TAL, A., AND TIAN, X. Design and implementation of transactional con- structs for C/C++. In OOPSLA (2008).
  35. NIR-BUCHBINDER, Y., TZOREF, R., AND UR, S. Deadlocks: from exhibiting to healing. In Workshop on Runtime Verification (2008).
  36. OpenIMPACT. http://www.gelato.uiuc.edu/.
  37. OpenLDAP Issue Tracking System. http://www. openldap.org/its/.
  38. QIN, F., TUCEK, J., ZHOU, Y., AND SUNDARESAN, J. Rx: Treating bugs as allergies-safe method to survive software fail- ures. ACM TOCS 25, 3 (2007).
  39. REVELIOTIS, S. A. Real-Time Management of Resource Allo- cation Systems: A Discrete-Event Systems Approach. Springer, 2005.
  40. SAVAGE, S., BURROWS, M., NELSON, G., SOBALVARRO, P., AND ANDERSON, T. Eraser: A dynamic data race detector for multithreaded programs. ACM TOCS 15, 4 (1997).
  41. SCHROEDER, B., WIERMAN, A., AND HARCHOL-BALTER, M. Open versus closed: A cautionary tale. In NSDI (2006).
  42. SPEAR, M. F., SILVERMAN, M., DALESSANDRO, L., MICHAEL, M. M., AND SCOTT, M. L. Implementing and ex- ploiting inevitability in software transactional memory. In Int'l. Conf. on Parallel Processing (2008).
  43. SUN. WorkShop: Command-Line Utilities. Sun Press, 2006, ch. 24: Using Lock Lint.
  44. SUTTER, H., AND LARUS, J. Software and the concurrency rev- olution. ACM Queue 3, 7 (2005).
  45. TRICAS, F., COLOM, J. M., AND EZPELETA, J. Some improve- ments to the banker's algorithm based on the process structure. In IEEE Int'l. Conf. on Robotics and Automation (2000).
  46. WALLACE, C., JENSEN, P., AND SOPARKAR, N. Supervisory control of workflow scheduling. In Proc. Int'l. Workshop on Ad- vanced Transaction Models and Architectures (1996).
  47. WANG, Y., KELLY, T., KUDLUR, M., MAHLKE, S., AND LAFORTUNE, S. The application of supervisory control to dead- lock avoidance in concurrent software. In Workshop on Discrete Event Systems (2008).
  48. WANG, Y., KELLY, T., AND LAFORTUNE, S. Discrete con- trol for safe execution of IT automation workflows. In EuroSys (2007).
  49. WELC, A., SAHA, B., AND ADL-TABATABAI, A.-R. Irrevoca- ble transactions and their applications. In SPAA (2008).
  50. Z ÖBEL, D., AND KOCH, C. Resolution techniques and complex- ity results with deadlocks: a classifying and annotated bibliogra- phy. SIGOPS Oper. Syst. Rev. 22, 1 (1988).

Related papers

Dynamic deadlock avoidance in systems code using statically inferred effects
Konstantinos Sagonas

Proceedings of the 6th Workshop on Programming Languages and Operating Systems - PLOS '11, 2011

Deadlocks can have devastating effects in systems code. We have developed a type and effect system that provably avoids them and in this paper we present a tool that uses a sound static analysis to instrument multithreaded C programs and then links these programs with a run-time system that avoids possible deadlocks. In contrast to most other purely static tools for deadlock freedom, our tool does not insist that programs adhere to a strict lock acquisition order or use lock primitives in a block-structured way, thus it is appropriate for systems code and OS applications. We also report some very promising benchmark results which show that all possible deadlocks can automatically be avoided with only a small run-time overhead. More importantly, this is done without having to modify the original source program by altering the order of resource acquisition operations or by adding annotations.

View PDFchevron_right
Gadara nets: Modeling and analyzing lock allocation for deadlock avoidance in multithreaded software
Scott Mahlke

2009

Abstract Deadlock avoidance in shared-memory multithreaded programs is receiving increased attention as multicore architectures and parallel programming are becoming more prevalent. In our on-going project, called Gadara, the objective is to control the execution of multithreaded programs in order to avoid deadlocks by using techniques from discrete-event control theory. In this project, Petri nets are employed to model parallel programs.

View PDFchevron_right
Maximally permissive deadlock avoidance for multithreaded computer programs (Extended abstract)
Stéphane Lafortune

2009 IEEE International Conference on Automation Science and Engineering, 2009

Multicore architectures in computer hardware bring an unprecedented need for parallel programming. In the work considered in this presentation, we are especially interested in multithreaded programs with shared data. In this widely- used programming paradigm, "lock" primitives are employed to control access to the shared data within the program threads.In this write-up, we report the progress of an ongoing project,

View PDFchevron_right
A Deadlock Prevention Policy for a Class of Multithreaded Software
Oussama Karoui

IEEE Access, 2020

Deadlock is an undesired situation in multithreaded software since it can lead to the stoppage of software. This paper studies the problem of deadlock control of multithreaded software based on Gadara nets, which are well studied for modelling concurrent programs. In particular, an iterative deadlock prevention policy based on siphons is proposed for a class of ordinary Gadara nets where the initial marking of each idle place is one. At each iteration, we compute emptiable siphons containing the smallest number of resource places. Then, bad markings are computed based on these siphons. On the basis of the bad markings, a constraint is constructed that forbids not only bad markings that empty one of the siphons but also some other bad markings. The algorithm is carried out until no emptiable siphon exists in the net. Compared with the existing methods, the resultant net derived from the proposed method is live and maximally permissive with a simpler supervisor. Finally, two examples ...

View PDFchevron_right
Maximally permissive deadlock avoidance for multithreaded computer programs
Scott Mahlke

2009

Abstract Multicore architectures in computer hardware bring an unprecedented need for parallel programming. In the work considered in this presentation, we are especially interested in multithreaded programs with shared data. In this widely-used programming paradigm," lock" primitives are employed to control access to the shared data within the program threads.

View PDFchevron_right

Related topics

  • Deadlock Avoidance
  • Software Transactional Memory
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved