Types for atomicity: Static checking and inference for Java

ACM Transactions on Programming Languages and Systems

Volumn 30, Issue 4, 2008, Pages

  Flanagan, Cormac ^a,d   Freund, Stephen N ^b   Lifshin, Marina ^b   Qadeer, Shaz ^c,e  

^a UNIVERSITY OF CALIFORNIA   (United States)

^b WILLIAMS COLLEGE   (United States)

^c MICROSOFT RESEARCH   (United States)

^d University of California Santa Cruz   (United States)

^e Williams College ^*  (United States)

Author keywords

Atomicity; Concurrent programs; Type inference; Type systems

Indexed keywords

ATOMICITY; CONCURRENT PROGRAMS; JAVA LIBRARY; LOCAL DATA; MULTI-THREADED JAVA PROGRAMS; MULTI-THREADED PROGRAMMING; MULTI-THREADED PROGRAMS; PARAMETERIZED; RACE DETECTION; SERIAL EXECUTION; STATIC CHECKING; SUBSEQUENT ANALYSIS; TYPE CHECKER; TYPE INFERENCE; TYPE INFERENCES; TYPE SYSTEMS;

ATOMIC PHYSICS; ATOMS; COMPUTER PROGRAMMING LANGUAGES; COMPUTER SOFTWARE; INFERENCE ENGINES; INFORMATION RETRIEVAL SYSTEMS; MULTITASKING;

JAVA PROGRAMMING LANGUAGE;

EID: 49449116974     PISSN: 01640925     EISSN: 15584593     Source Type: Journal    
DOI: 10.1145/1377492.1377495     Document Type: Article

References (84)

1. ABADI, M., FLANAGAN, C., AND FREUND, S. N. 2006. Types for safe locking: Static race detection for Java. ACM Trans. Program. Lang. Syst. 28, 2, 207-255.
2. AGARWAL, R. AND STOLLER, S. D. 2004. Type inference for parameterized race-free Java. In Proceedings of the Conference on Verification, Model Checking, and Abstract Interpretation. 149-160.
3. AIKEN, A. AND GAY, D. 1998. Barrier inference. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 243-354.
4. ARTHO, C., HAVELUND, K., AND BIERE, A. 2003. High-level data races. In Proceedings of the First International Workshop on Verification and Validation of Enterprise Information Systems.
5. BACK, R.-J. 1989. A method for refining atomicity in parallel algorithms. In Proceedings of the Parallel Architectures and Languages Europe (PARLE'89). Lecture Notes in Computer Science, vol. 366. Springer-Verlag, 199-216.
6. BIRRELL, A. D. 1989. An introduction to programming with threads. Res. rep. 35, Digital Equipment Corporation Systems Research Center.
7. BOYAPATI, C., LEE, R., AND RINARD, M. 2002. A type system for preventing data races and deadlocks in Java programs. In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages and Applications. 211-230.
8. BOYAPATI, C. AND RINARD, M. 2001. A parameterized type system for race-free Java programs. In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages and Applications. 56-69.
9. BRUENING, D. 1999. Systematic testing of multithreaded Java programs. M.S. thesis, Massachusetts Institute of Technology.
10. BRYANT, R. 1986. Graph-based algorithms for boolean function manipulation. IEEE Trans. Comput. C-35, 8, 677-691.
11. BURROWS, M. AND LEINO, K. R. M. 2002. Finding stale-value errors in concurrent programs. Technical Note 2002-004, Compaq Systems Research Center.
12. ARDELLI, L. 1988. Typechecking dependent types and subtypes. Lecture Notes in Computer Science, Foundations of Logic and Functional Programming. 45-57.
13. HAMILLARD, A. T., CLARKE, L. A., AND AVRUNIN, G. S. 1996. An empirical comparison of static concurrency analysis techniques. Tech. rep. 96-084, Department of Computer Science, University of Massachusetts at Amherst.
14. HOI, J.-D., GUPTA, M., SERRANO, M. J., SREEDHAR, V. C., AND MIDKIFF, S. P. 1999. Escape analysis for Java. In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages and Applications. 1-19.
15. HOI, J.-D., LEE, K., LOGINOV, A., O'CALLAHAN, R., SARKAR, V., AND SRIDHARA, M. 2002. Efficient and precise datarace detection for multithreaded object-oriented programs. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 258-269.
16. OHEN, E. AND LAMPORT, L. 1998. Reduction in TLA. In Proceedings of the International Conference on Concurrency Theory. Lecture Notes in Computer Science, vol. 1466. Springer-Verlag, 317-331.
17. ORBETT, J. C. 1996. Evaluating deadlock detection methods for concurrent software. IEEE Trans. Softw. Eng. 22, 3, 161-180.
18. ELINE, R. AND FÄHNDRICH, M. 2001. Enforcing high-level protocols in low-level software. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 59-69.
19. ENG, X., DWYER, M., HATCLIPP, J., AND MIZUNO, M. 2002. Invariant-based specification, synthesis, and verification of synchronization in concurrent programs. In Proceedings of the International Conference on Software Engineering. 442-452.
20. ETLEFS, D. L., LEINO, K. R. M., AND NELSON, C. G. 1998. Wrestling with rep exposure. Research rep. 156, DEC Systems Research Center.
21. OEPPNER, JR., T. W. 1977. Parallel program correctness through refinement. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 155-169.
22. EPPINGER, J. L., MUMMERT, L. B., AND SPECTOR, A. Z. 1991. Camelot and Avalon: A Distributed Transaction Facility. Morgan Kaufmann.
23. FLANAGAN, C. 2004. Verifying commit-atomicity using model-checking. In Proceedings of the International SPIN Workshop on Model Checking of Software.
24. FLANAGAN, C. AND ABADI, M. 1999a. Object types against races. In Proceedings of the International Conference on Concurrency Theory. Lecture Notes in Computer Science, vol. 1664. 288-303.
25. FLANAGAN, C. AND ABADI, M. 1999b. Types for safe locking. In Proceedings of European Symposium on Programming. Lecture Notes in Computer Science, vol. 1576. 91-108.
26. FLANAGAN, C. AND FREUND, S. N. 2000. Type-based race detection for Java. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 219-232.
27. FLANAGAN, C. AND FREUND, S. N. 2004a. Atomizer: A dynamic atomicity checker for multithreaded programs. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 256-267.
28. FLANAGAN, C. AND FREUND, S. N. 2004b. Type inference against races. In Proceedings of the Static Analysis Symposium. 116-132.
29. FLANAGAN, C. AND FREUND, S. N. 2005. Automatic synchronization correction. In Proceedings of the Workshop on Synchronization and Concurrency in Object-Oriented Languages.
30. FLANAGAN, C., FREUND, S. N., AND LIFSHIN, M. 2005. Type inference for atomicity. In Proceedings of the ACM Workshop on Types in Language Design and Implementation. 47-58.
31. FLANAGAN, C., FREUND, S. N., AND QADEER, S. 2005. Exploiting purity for atomicity. IEEE Trans. Softw. Eng. 31, 4, 275-291.
32. FLANAGAN, C., LEINO, K. R. M., LILLIBRIDGE, M., NELSON, G., SAXE, J. B., AND STATA, R. 2002. Extended static checking for Java. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 234-245.
33. FLANAGAN, C. AND QADEER, S. 2003a. Transactions for software model checking. In Proceedings of the Worksshop on Software Model Checking.
34. FLANAGAN, C. AND QADEER, S. 2003b. A type and effect system for atomicity. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 338-349.
35. FLANAGAN, C. AND QADEER, S. 2003c. Types for atomicity. In Proceedings of the ACM Workshop on Types in Language Design and Implementation. 1-12.
36. FLATT, M., KRISHNAMURTHI, S., AND FELLEISEN, M. 1998. Classes and mixins. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 171-183.
37. FREUND, S. N. AND QADEER, S. 2004. Checking concise specifications for multithreaded software. J. Object Tech. 3, 6, 81-101.
38. GHARACHORLOO, K. 1995. Memory consistency models for shared-memory multiprocessors. Ph.D. thesis, Stanford University.
39. GOETZ, B., PEIERLS, T., BLOCH, J., BOWBEER, J., HOLMES, D., AND LEA, D. 2006. Java Concurrency in Practice. Addison-Wesley.
40. GOSLING, J., JOY, B., AND STEELE, G. 1996. The Java Language Specification. Addison-Wesley.
41. GROSSMAN, D. 2003. Type-safe multithreading in Cyclone. In Proceedings of the ACM Workshop on Types in Language Design and Implementation. 13-25.
42. HAACK, C. AND WELLS, J. B. 2003. Type error slicing in implicitly typed higher-order languages. In Proceedings of the European Symposium on Programming. 284-301.
43. HARRIS, T. AND FRASER, K. 2003. Language support for lightweight transactions. In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages and Applications. 388-402.
44. HATCLIFF, J., ROBBY, AND DWYER, M. B. 2004. Verifying atomicity specifications for concurrent object-oriented software using model-checking. In Proceedings of the International Conference on Verification, Model Checking and Abstract Interpretation. 175-190.
45. HERLIHY, M. P. AND WING, J. M. 1990. Linearizability: A correctness condition for concurrent objects. ACM Trans. Program. Lang. Syst. 12, 3, 463-492.
46. HICKS, M., FOSTER, J. S., AND PRATIKAKIS, P. 2006. Inferring locking for atomic sections. In Proceedings of the Workshop on Languages, Compilers, and Hardware Support for Transactional Computing.
47. HOARE, C. 1974. Monitors: an operating systems structuring concept. Comm. ACM 17, 10, 549-557.
48. HOARE, C. A. R. 1972. Towards a theory of parallel programming. In Operating Systems Techniques. A.P.I.C. Studies in Data Processing, vol. 9. 61-71.
49. JAVA GRANDE FORUM. 2003. Java Grande benchmark suite, http://www.javagrande.org/.
50. JAVASOFT. 2005. Java Developers Kit, version 1.4.0. http://Java.sun.com.
51. AMPORT, L. 1978. Time, clocks, and the ordering of events in a distributed system. Comm. ACM 21, 7, 558-565.
52. AMPORT, L. AND SCHNEIDER, F. B. 1989. Pretending atomicity. Research rep. 44, DEC Systems Research Center.
53. EA, D. 2004. The util. concurrent package, release 1.3.4. http://gee.cs.oswego.edu/dl/.
54. IPTON, R. J. 1975. Reduction: A method of proving properties of parallel programs. Comm. ACM 18, 12, 717-721.
55. ISKOV, B., CURTIS, D., JOHNSON, P., AND SCHEIFLER, R. 1987. Implementation of Argus. In Proceedings of the Symposium, on Operating Systems Principles. 111-122.
56. OMET, D. B. 1977. Process structuring, synchronization, andrecovery using atomic actions. Lang. Design Reliable Softw., 128-137.
57. UCASSEN, J. M. AND GIFFORD, D. K. 1988. Polymorphic effect systems. In Proceedings of the ACM Conference on Lisp and Functional Programming. 47-57.
58. ANSON, J., PUGH, W., AND ADVE, S. V. 2005. The Java memory model. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 378-391.
59. CCLOSKEY, B., ZHOU, F., GAY, D., AND BREWER, E. 2006. Autolocker: synchronization inference for atomic sections. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 346-358.
60. ISRA, J. 2001. A Discipline of Multiprogramming: Programming Theory for Distributed Applications. Springer-Verlag.
61. NAIK, M., AIKEN, A., AND WHALEY, J. 2006. Effective static race detection for Java. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 308-319.
62. O'CALLAHAN, R. AND CHOI, J.-D. 2003. Hybrid dynamic data race detection. In Proceedings of the ACM Symposium on Principles and Practice of Parallel Programming. 167-178.
63. PAPADIMITRIOU, C. 1986. The Theory of Database Concurrency Control. Computer Science Press.
64. POZNIANSKY, E. AND SCHUSTER, A. 2003. Efficient on-the-fly data race detection in multihreaded C++ programs. In Proceedings of the ACM Symposium on Principles and Practice of Parallel, Programming. 179-190.
65. PRATIKAKIS, P., FOSTER, J. S., AND HICKS, M. 2006. Context-sensitive correlation analysis for detecting races. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 320-331.
66. QADEER, S., RAJAMANI, S. K., AND REHOF, J. 2004. Summarizing procedures in concurrent programs. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 245-255.
67. RINGENBURG, M. F. AND GROSSMAN, D. 2005. AtomCaml: first-class atomicity via rollback. In Proceedings of the ACM International Conference on Functional Programming. 92-104.
68. SALCIANU, A. AND RINARD, M. 2001. Pointer and escape analysis for multithreaded programs. In Proceedings of the Symposium on Principles and Practice of Parallel Programming. 12-23.
69. SASTURKAR, A., AGARWAL, R., WANG, L., AND STOLLER, S. D. 2005. Automated type-based analysis of data races and atomicity. In Proceedings of the ACM Symposium on Principles and Practice of Parallel Programming. 83-94.
70. SAVAGE, S., BURROWS, M., NELSON, G., SOBALVARRO, P., AND ANDERSON, T. E. 1997. Eraser: A dynamic data race detector for multi-threaded programs. ACM Trans. Comput. Syst. 15, 4, 391-411.
71. SPEC. 2000. Standard Performance Evaluation Corporation JBB2000 Benchmark. Available from http://www.spec.org/osg/jbb2000/.
72. STERLING, N. 1993. Warlock: A static data race analysis tool. In Proceedings of the USENIX Winter Technical Conference. 97-106.
73. STOLLER, S. 2006. Personal communication.
74. STOLLER, S. D. 2000. Model-checking multi-threaded distributed Java programs. In Proceedings of the Workshop on Model Checking and Software Verification. Lecture Notes in Computer Science, vol. 1885. Springer-Verlag, 224-244.
75. TALPIN, J.-P. AND JOUVELOT, P. 1992. Polymorphic type, region and effect inference. J. Funct. Program. 2, 3, 245-271.
76. TOFTE, M. AND TALPIN, J.-P. 1994. Implementation of the typed call-by-value lambda-calculus using a stack of regions. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 188-201.
77. AZIRI, M., TIP, F., AND DOLBY, J. 2006. Associating synchronization constraints with data in an object-oriented language. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 334-345.
78. ON PRAUN, C. AND GROSS, T. 2001. Object race detection. In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages and Applications. 70-82.
79. ON PRAUN, C. AND GROSS, T. 2003. Static conflict analysis for multi-threaded object-oriented programs. In Proceedings of the ACM Conference on Programming Language Design and Implementation. 115-128.
80. WAND, M. 1986. Finding the source of type errors. In Proceedings of the ACM Symposium on the Principles of Programming Languages. 38-43.
81. WANG, L. AND STOLLER, S. D. 2003. Runtime analysis for atomicity. In Proceedings of the Workshop on Runtime Verification.
82. WANG, L. AND STOLLER, S. D. 2006. Runtime analysis of atomicity for multithreaded programs. IEEE Trans. Softw. Eng. 32, 2, 93-110.
83. WELC, A., JAGANNATHAN, S., AND HOSKING, A. L. 2004. Transactional monitors for concurrent objects. In Proceedings of the European Conference on Object-Oriented Programming. 519-542.
84. YANG, J., MICHAELSON, G., TRINDER, P., AND WELLS, J. B. 2000. Improved type error reporting. In Proceedings of the International Workshop on Implementation of Functional Languages. 71-86.