ACM Computing Surveys (CSUR)
A New Approach to Proving the Correctness of Multiprocess Programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Extended static checking for Java
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Region-based memory management in cyclone
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Ownership types for safe programming: preventing data races and deadlocks
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
ESOP '99 Proceedings of the 8th European Symposium on Programming Languages and Systems
CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs
CC '02 Proceedings of the 11th International Conference on Compiler Construction
RacerX: effective, static detection of race conditions and deadlocks
SOSP '03 Proceedings of the nineteenth ACM symposium on Operating systems principles
Rx: Treating bugs as allergies—a safe method to survive software failures
ACM Transactions on Computer Systems (TOCS)
RELAY: static race detection on millions of lines of code
Proceedings of the the 6th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering
The theory of deadlock avoidance via discrete control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
APLAS '08 Proceedings of the 6th Asian Symposium on Programming Languages and Systems
A Deadlock-Free Semantics for Shared Memory Concurrency
ICTAC '09 Proceedings of the 6th International Colloquium on Theoretical Aspects of Computing
Race-free and memory-safe multithreading: design and implementation in cyclone
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
Gadara: dynamic deadlock avoidance for multithreaded programs
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
Deadlock immunity: enabling systems to defend against deadlocks
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
A new type system for deadlock-free processes
CONCUR'06 Proceedings of the 17th international conference on Concurrency Theory
Dynamic deadlock avoidance in systems code using statically inferred effects
PLOS '11 Proceedings of the 6th Workshop on Programming Languages and Operating Systems
Static lock capabilities for deadlock freedom
TLDI '12 Proceedings of the 8th ACM SIGPLAN workshop on Types in language design and implementation
Detecting deadlock in programs with data-centric synchronization
Proceedings of the 2013 International Conference on Software Engineering
REDACT: preventing database deadlocks from application-based transactions
Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering
Static safety guarantees for a low-level multithreaded language with regions
Science of Computer Programming
Hi-index | 0.00 |
The possibility to run into a deadlock is an annoying and commonly occurring hazard associated with the concurrent execution of programs. In this paper we present a polymorphic type and effect system that can be used to dynamically avoid deadlocks, guided by information about the order of lock and unlock operations which is computed statically. In contrast to most other type-based approaches to deadlock freedom, our system does not insist that programs adhere to a strict lock acquisition order or use locking primitives in a block-structured way. Lifting these restrictions is primarily motivated by our desire to target low-level languages, such as C with pthreads, but it also allows our system to be directly applicable in optimizing compilers for high-level languages, such as Java. To show the effectiveness of our approach, we have also developed a tool that uses static analysis to instrument concurrent programs written in C/pthreads and then links these programs with a run-time system that avoids possible deadlocks. Although our tool is still in an early development stage, in the sense that currently its analysis only handles a limited class of programs, our benchmark results are very promising: they show that it is not only possible to avoid all deadlocks with a small run-time overhead, but also often achieve better throughput in highly concurrent programs by naturally reducing lock contention.