Abstract
Distributed message-passing based asynchronous systems are becoming increasingly important. Such systems are notoriously hard to design and test. A promising approach to help programmers design such programs is to provide a behavioral type system that checks for behavioral properties such as deadlock freedom using a combination of type inference and model checking. The fundamental challenge in making a behavioral type system work for realistic concurrent programs is state explosion. This paper develops the theory to design a behavioral module system that permits decomposing the type checking problem, saving exponential cost in the analysis. Unlike module systems for sequential programming languages, a behavioral specification for a module typically assumes that the module operates in an appropriate concurrent context. We identify assume-guarantee reasoning as a fundamental principle in designing such a module system.
Concretely, we propose a behavioral module system for π-calculus programs. Types are CCS processes that correctly approximate the behavior of programs, and by applying model checking techniques to process types one can check many interesting program properties, including deadlock-freedom and communication progress. We show that modularity can be achieved in our type system by applying circular assume-guarantee reasoning principles whose soundness requires an induction over time. We state and prove an assume-guarantee rule for CCS. Our module system integrates this assume-guarantee rule into our behavioral type system.
This is a preview of subscription content, log in via an institution.
Buying options
Tax calculation will be finalised at checkout
Purchases are for personal use only
Learn about institutional subscriptionsPreview
Unable to display preview. Download preview PDF.
References
M. Abadi and L. Lamport. Composing specifications. ACM Transactions on Programming Languages and Systems, 15(1):73–132, 1993.
M. Abadi and L. Lamport. Conjoining specifications. ACM Transactions on Programming Languages and Systems, 17(3):507–534, 1995.
R. Alur and T. A. Henzinger. Reactive modules. In LICS’96: Logic in Computer Science, pages 207–218. IEEE Computer Society Press, 1996.
S. Christensen, Y. Hirshfeld, and F. Moller. Decidable subsets of CCS. The Computer Journal, 37(4):233–242, 1994.
R. J. Cleaveland, J. Parrow, and B. Steffen. The Concurrency Workbench: a semantics-based tool for the verification of finite-state systems. ACM Transactions on Programming Languages and Systems, 15(1):36–72, 1993.
A. Eiriksson. The formal design of 1M-gate ASICs. In FMCAD’98: Formal Methods in Computer-Aided Design, LNCS 1522, pages 49–63. Springer-Verlag, 1998.
J. Feret. Confidentiality analysis of mobile systems. In SAS’00: Static Analysis Symposium, LNCS 1824, pages 135–154. Springer-Verlag, 2000.
C. Flanagan and M. Abadi. Types for safe locking. In ESOP’99: European Symposium on Programming, LNCS 1576, pages 91–108. Springer-Verlag, 1999.
C. Flanagan and S. N. Freund. Type-based race detection for Java. In PLDI 00: Programming Language Design and Implementation, pages 219–232. ACM, 2000.
T. A. Henzinger, X. Liu, S. Qadeer, and S. K. Rajamani. Formal specification and verification of a dataflow processor array. In ICCAD’99:Computer-Aided Design, pages 494–499. IEEE Computer Society Press, 1999.
A. Igarashi and N. Kobayashi. A generic type system for the Pi-calculus. In POPL’01: Principles of Programming Languages, pages 128–141. ACM, 2001.
R. M. Karp and R. E. Miller. Parallel program schemata. Journal of Computer and System Sciences, 3:147–195, 1969.
J. R. Larus and M. Parkes. Using cohort scheduling to enhance server performance. Technical Report MSR-TR-2001-39, Microsoft Research, 2001.
L. McDowell. Tappan: The asynchronous programming language specification and analysis system. Summer-Intern Project Report, Microsoft Research, 2000.
K. L. McMillan. A compositional rule for hardware design refinement. In CAV’97: Computer-Aided Verification, LNCS 1254, pages 24–35. Springer-Verlag, 1997.
R. Milner. Communicating and Mobile Systems: the π-Calculus. Cambridge University Press, 1999.
J. Misra and K. M. Chandy. Proofs of networks of processes. IEEE Transactions on Software Engineering, SE-7(4):417–426, 1981.
H. R. Nielson and F. Nielson. Higher-order concurrent programs with finite communication topology. In POPL’94: Principles of Programming Languages, pages 84–97. ACM, 1994.
F. Puntigam and C. Peter. Changeable interfaces and promised messages for concurrent components. In SAC’99: Symposium on Applied Computing, pages 141–145. ACM, 1999.
S. K. Rajamani and J. Rehof. A behavioral module system for the Pi-calculus. Technical report, Microsoft Research, 2001.
A. Ravara and V. Vasconcelos. Typing non-uniform concurrent objects. In CON-CUR’00: Concurrency Theory, LNCS 1877, pages 474–488. Springer-Verlag, 2000.
N. Yoshida. Graph types for monadic mobile processes. In FSTTCS: Software Technology and Theoretical Computer Science, LNCS 1180, pages 371–387. Springer-Verlag, 1996.
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2001 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Rajamani, S.K., Rehof, J. (2001). A Behavioral Module System for the Pi-Calculus. In: Cousot, P. (eds) Static Analysis. SAS 2001. Lecture Notes in Computer Science, vol 2126. Springer, Berlin, Heidelberg. https://doi.org/10.1007/3-540-47764-0_22
Download citation
DOI: https://doi.org/10.1007/3-540-47764-0_22
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-42314-0
Online ISBN: 978-3-540-47764-8
eBook Packages: Springer Book Archive