Article

Types for Safe Locking

Authors:

Cormac Flanagan,

Martín AbadiAuthors Info & Claims

ESOP '99: Proceedings of the 8th European Symposium on Programming Languages and Systems

Pages 91 - 108

Published: 22 March 1999 Publication History

Abstract

A race condition is a situation where two threads manipulate a data structure simultaneously, without synchronization. Race conditions are common errors in multithreaded programming. They often lead to unintended nondeterminism and wrong results. Moreover, they are notoriously hard to diagnose, and attempts to eliminate them can introduce deadlocks. In practice, race conditions and deadlocks are often avoided through prudent programming discipline: protecting each shared data structure with a lock and imposing a partial order on lock acquisitions. In this paper we show that this discipline can be captured (if not completely, to a significant extent) through a set of static rules. We present these rules as a type system for a concurrent, imperative language. Although weaker than a full-blown program-verification calculus, the type system is effective and easy to apply. We emphasize a core, first-order type system focused on race conditions; we also consider extensions with polymorphism, existential types, and a partial order on lock types.

References

[1]

S. Abramsky, S. Gay, and R. Nagarajan. A type-theoretic approach to deadlock-freedom of asynchronous systems. In Theoretical Aspects of Computer Software, volume 1281 of Lecture Notes in Computer Science, pages 295-320. Springer-Verlag, 1997.

[2]

A. Aiken and D. Gay. Barrier inference. In Proceedings of the 25th Symposium on Principles of Programming Languages, pages 243-354, 1998.

[3]

T. Amtoft, F. Nielson, and H. R. Nielson. Type and behaviour reconstruction for higher-order concurrent programs. Journal of Functional Programming, 7(3):321- 347, 1997.

[4]

G. S. Avrunin, U. A. Buy, J. C. Corbett, L. K. Dillon, and J. C. Wileden. Automated analysis of concurrent systems with the constrained expression toolset. IEEE Transactions on Software Engineering, 17(11):1204-1222, 1991.

[5]

A. D. Birrell. An introduction to programming with threads. Research Report 35, Digital Equipment Corporation Systems Research Center, 1989.

[6]

L. Cardelli. Type systems. Handbook of Computer Science and Engineering, pages 2208-2236, 1997.

[7]

A. T. Chamillard, L. A. Clarke, and G. S. Avrunin. An empirical comparison of static concurrency analysis techniques. Technical Report 96-084, Department of Computer Science, University of Massachusetts at Amherst, 1996.

[8]

G.-I. Cheng, M. Feng, C. E. Leiserson, K. H. Randall, and A. F. Stark. Detecting data races in Cilk programs that use locks. In Proceedings of the 10th Symposium on Parallel Algorithms and Architectures, pages 298-309, 1998.

[9]

C. Colby. Analyzing the communication topology of concurrent programs. In ACM Symposium on Partial Evaluation and Semantics-Based Program Manipulation, pages 202-213, 1995.

[10]

J. C. Corbett. Evaluating deadlock detection methods for concurrent software. IEEE Transactions on Software Engineering, 22(3):161-180, 1996.

[11]

M. B. Dwyer and L. A. Clarke. Data flow analysis for verifying properties of concurrent programs. Technical Report 94-045, Department of Computer Science, University of Massachusetts at Amherst, 1994.

[12]

L. Fajstrup, E. Goubault, and M. Raussen. Detecting deadlocks in concurrent systems. In CONCUR'98: Concurrency Theory, volume 1466 of Lecture Notes in Computer Science. Springer-Verlag, 1998.

[13]

P. Godefroid. Model checking for programming languages using VeriSoft. In Proceedings of the 24th Symposium on Principles of Programming Languages, pages 174-186, 1997.

[14]

J. Gosling, B. Joy, and G. Steele. The Java Language Specification. Addison-Wesley, 1996.

[15]

P. Jouvelot and D. Gifford. Algebraic reconstruction of types and effects. In Proceedings of the 18th Symposium on Principles of Programming Languages, pages 303-310, 1991.

[16]

N. Kobayashi. A partially deadlock-free typed process calculus. In Proceedings of the 12th Annual IEEE Symposium on Logic in Computer Science, pages 128-139, 1997.

[17]

J. M. Lucassen and D. K. Gifford. Polymorphic effect systems. In Proceedings of the ACM Conference on Lisp and Functional Programming, pages 47-57, 1988.

[18]

F. Nielson. Annotated type and effect systems. ACM Computing Surveys, 28(2):344-345, 1996. Invited position statement for the Symposium on Models of Programming Languages and Computation.

[19]

H. R. Nielson and F. Nielson. Higher-order concurrent programs with finite communication topology. In Proceedings of the 21st Symposium on Principles of Programming Languages, pages 84-97, 1994.

[20]

J. H. Reppy. CML: a higher-order concurrent language. In ACM '91 Conference on Programming Language Design and Implementation., pages 293-305, 1991.

[21]

S. Savage, M. Burrows, G. Nelson, P. Sobalvarro, and T. E. Anderson. Eraser: A dynamic data race detector for multi-threaded programs. ACM Transactions on Computer Systems, 15(4):391-411, 1997.

[22]

N. Sterling. Warlock: A static data race analysis tool. In USENIX Winter Technical Conference, pages 97-106, 1993.

[23]

J.-P. Talpin and P. Jouvelot. Polymorphic type, region and effect inference. Journal of Functional Programming, 2(3):245-271, 1992.

[24]

M. Tofte and J.-P. Talpin. Implementation of the typed call-by-value lambda-calculus using a stack of regions. In Proceedings of the 21st Symposium on Principles of Programming Languages, pages 188-201, 1994.

[25]

M. Tofte and J.-P. Talpin. Region-based memory management. Information and Computation, 132(2):109-176, 1997.

Cited By

Bianchi FMargara APezze M(2018)A Survey of Recent Trends in Testing Concurrent Software SystemsIEEE Transactions on Software Engineering10.1109/TSE.2017.270708944:8(747-783)Online publication date: 1-Aug-2018
https://dl.acm.org/doi/10.1109/TSE.2017.2707089
Gordon CErnst MGrossman DParkinson M(2017)Verifying Invariants of Lock-Free Data Structures with Rely-Guarantee and Refinement TypesACM Transactions on Programming Languages and Systems10.1145/306485039:3(1-54)Online publication date: 10-May-2017
https://dl.acm.org/doi/10.1145/3064850
Balabonski TPottier FProtzenko J(2016)The Design and Formalization of Mezzo, a Permission-Based Programming LanguageACM Transactions on Programming Languages and Systems10.1145/283702238:4(1-94)Online publication date: 2-Aug-2016
https://dl.acm.org/doi/10.1145/2837022
Show More Cited By

Recommendations

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

Most multiprocessors are multiprogrammed to achieve acceptable response time and to increase their utilization. Unfortunately, inopportune preemption may significantly degrade the performance of synchronized parallel applications. To address this ...
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

This paper presents a new static type system for multithreaded programs; well-typed programs in our system are guaranteed to be free of data races and deadlocks. Our type system allows programmers to partition the locks into a fixed number of ...
Pre-analysis locking: a safe and deadlock free locking policy
VLDB '85: Proceedings of the 11th international conference on Very Large Data Bases - Volume 11

A safe and deadlock free lock policy is introduced, called pre-analysis locking. Pre-analysis locking is based on an efficient geometric algorithm which inserts lock and unlock operations into the transactions. Pre-analysis locking is the first safe and ...

Comments

Information & Contributors

Information

Published In

cover image Guide Proceedings

ESOP '99: Proceedings of the 8th European Symposium on Programming Languages and Systems

March 1999

304 pages

ISBN:3540656995

Editor:
S. Doaitse Swierstra

Publisher

Springer-Verlag

Berlin, Heidelberg

Publication History

Published: 22 March 1999

Qualifiers

Article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

89
Total Citations
View Citations
0
Total Downloads

Downloads (Last 12 months)0
Downloads (Last 6 weeks)0

Reflects downloads up to 26 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Bianchi FMargara APezze M(2018)A Survey of Recent Trends in Testing Concurrent Software SystemsIEEE Transactions on Software Engineering10.1109/TSE.2017.270708944:8(747-783)Online publication date: 1-Aug-2018
https://dl.acm.org/doi/10.1109/TSE.2017.2707089
Gordon CErnst MGrossman DParkinson M(2017)Verifying Invariants of Lock-Free Data Structures with Rely-Guarantee and Refinement TypesACM Transactions on Programming Languages and Systems10.1145/306485039:3(1-54)Online publication date: 10-May-2017
https://dl.acm.org/doi/10.1145/3064850
Balabonski TPottier FProtzenko J(2016)The Design and Formalization of Mezzo, a Permission-Based Programming LanguageACM Transactions on Programming Languages and Systems10.1145/283702238:4(1-94)Online publication date: 2-Aug-2016
https://dl.acm.org/doi/10.1145/2837022
Clebsch SDrossopoulou SBlessing SMcNeil ABoix EHaller PRicci AVarela C(2015)Deny capabilities for safe, fast actorsProceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control10.1145/2824815.2824816(1-12)Online publication date: 26-Oct-2015
https://dl.acm.org/doi/10.1145/2824815.2824816
Stievenart QNicolay JDe Meuter WDe Roover CFalaschi MAlbert E(2015)Detecting concurrency bugs in higher-order programs through abstract interpretationProceedings of the 17th International Symposium on Principles and Practice of Declarative Programming10.1145/2790449.2790530(232-243)Online publication date: 14-Jul-2015
https://dl.acm.org/doi/10.1145/2790449.2790530
Grande JBoudol GSerrano MFalaschi MAlbert E(2015)Jthread, a deadlock-free mutex libraryProceedings of the 17th International Symposium on Principles and Practice of Declarative Programming10.1145/2790449.2790523(149-160)Online publication date: 14-Jul-2015
https://dl.acm.org/doi/10.1145/2790449.2790523
Clarke DÖstlund JSergey IWrigstad T(2013)Ownership typesAliasing in Object-Oriented Programming10.5555/2554511.2554516(15-58)Online publication date: 1-Jan-2013
https://dl.acm.org/doi/10.5555/2554511.2554516
Gordon CErnst MGrossman D(2013)Rely-guarantee references for refinement types over aliased mutable dataACM SIGPLAN Notices10.1145/2499370.246216048:6(73-84)Online publication date: 16-Jun-2013
https://dl.acm.org/doi/10.1145/2499370.2462160
Gordon CErnst MGrossman DBoehm HFlanagan C(2013)Rely-guarantee references for refinement types over aliased mutable dataProceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation10.1145/2491956.2462160(73-84)Online publication date: 16-Jun-2013
https://dl.acm.org/doi/10.1145/2491956.2462160
Lu YPotter JXue J(2013)Structural lock correlation with ownership typesProceedings of the 22nd European conference on Programming Languages and Systems10.1007/978-3-642-37036-6_22(391-410)Online publication date: 16-Mar-2013
https://dl.acm.org/doi/10.1007/978-3-642-37036-6_22
Show More Cited By

View Options

View options

Figures

Tables

Media

View Table of Conten