Safe locking policies for dynamic databases
PODS '95 Proceedings of the fourteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems
Type-based race detection for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Typed memory management via static capabilities
ACM Transactions on Programming Languages and Systems (TOPLAS)
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
ESOP '00 Proceedings of the 9th European Symposium on Programming Languages and Systems
Alias Types for Recursive Data Structures
TIC '00 Selected papers from the Third International Workshop on Types in Compilation
Permission accounting in separation logic
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular typestate checking of aliased objects
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
The theory of deadlock avoidance via discrete control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Basis for Verifying Multi-threaded Programs
ESOP '09 Proceedings of the 18th European Symposium on Programming Languages and Systems: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
A Deadlock-Free Semantics for Shared Memory Concurrency
ICTAC '09 Proceedings of the 6th International Colloquium on Theoretical Aspects of Computing
Strictly declarative specification of sophisticated points-to analyses
Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
Sequential verification of serializability
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Checking interference with fractional permissions
SAS'03 Proceedings of the 10th international conference on Static analysis
Gadara: dynamic deadlock avoidance for multithreaded programs
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
Capabilities for uniqueness and borrowing
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
A type and effect system for deadlock avoidance in low-level languages
Proceedings of the 7th ACM SIGPLAN workshop on Types in language design and implementation
A new type system for deadlock-free processes
CONCUR'06 Proceedings of the 17th international conference on Concurrency Theory
Deadlock-Free channels and locks
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Detecting deadlock in programs with data-centric synchronization
Proceedings of the 2013 International Conference on Software Engineering
Hi-index | 0.00 |
We present a technique --- lock capabilities --- for statically verifying that multithreaded programs with locks will not deadlock. Most previous work on deadlock prevention requires a strict total order on all locks held simultaneously by a thread, but such an invariant often does not hold with fine-grained locking, especially when data-structure mutations change the order locks are acquired. Lock capabilities support idioms that use fine-grained locking, such as mutable binary trees, circular lists, and arrays where each element has a different lock. Lock capabilities do not enforce a total order and do not prevent external references to data-structure nodes. Instead, the technique reasons about static capabilities, where a thread already holding locks can attempt to acquire another lock only if its capabilities allow it. Acquiring one lock may grant a capability to acquire further locks; in data-structures where heap shape affects safe locking orders, the heap structure can induce the capability-granting relation. Deadlock-freedom follows from ensuring that the capability-granting relation is acyclic. Where necessary, we restrict aliasing with a variant of unique references to allow strong updates to the capability-granting relation, while still allowing other aliases that are used only to acquire locks while holding no locks. We formalize our technique as a type-and-effect system, demonstrate it handles realistic challenging idioms, and use syntactic techniques (type preservation) to show it soundly prevents deadlock.