Modern Multithreading: Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs

Modern Multithreading: Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs

Volumn , Issue , 2005, Pages 1-465

  Carver, Richard H ^a   Tai, Kuo Chung ^b  

^a George Mason University   (United States)

^b NONE

Author keywords

[No Author keywords available]

Indexed keywords

COMPUTER SOFTWARE; JAVA PROGRAMMING LANGUAGE; LIBRARIES; MESSAGE PASSING; PROGRAM DEBUGGING; STUDENTS; TEXTBOOKS;

APPLICATIONS PROGRAMMING INTERFACES; CONCURRENT PROGRAMMING; DISTRIBUTED PROGRAM; MULTITHREADED PROGRAMMING; PRACTICAL MATERIALS; PROBLEM SOLVING SKILLS; TESTING AND DEBUGGING; TOOLS AND TECHNIQUES;

C++ (PROGRAMMING LANGUAGE);

EID: 84889331714     PISSN: None     EISSN: None     Source Type: Book    
DOI: 10.1002/0471744174     Document Type: Book

References (196)

1. Anderson, T. E., E. D. Lazowska, and Henry M. Levy (1989). The performance implications of thread management alternatives for shared-memory multiprocessors. IEEE Transactions on Computers, Vol. 38, No. 12, pp. 1631-1644.
2. Andrews, Gregory R. (2000). Foundations of Multithreaded, Parallel, and Distributed Programming. Reading, MA: Addison-Wesley.
3. Beveridge, Jim, and R. Wiener (1997). Multithreading Programming Techniques inWin32: The Complete Guide to Threads. Reading, MA: Addison-Wesley.
4. Broadman, Allen, and Eric Shaw (1999). Executing a class member in its own thread. C/C++ Users Journal, December, pp. 57-62.
5. Butenhof, David R. (1997). Programming with POSIX Threads. Reading, MA: Addison-Wesley.
6. Calkins, Charles (2000). Integrating threads with template classes. C/C++ Users Journal, May, pp. 32-35.
7. Cohen, A., and M. Woodring (1997). Win32 Multithreaded Programming. Sebastopol, CA: O'Reilly & Associates.
8. Coulouris, George, Jean Dollimore, and Tim Kindberg (2001). Distributed Systems: Concepts and Design. Reading, MA: Addison-Wesley.
9. Empath, P. A., S. Ghosh, and D. A. Padua (1992). Detecting nondeterminacy in parallel programs. IEEE Software, Vol. 9, No. 1, pp. 69-77.
10. Fidge, C. (1996). Fundamentals of distributed system observation. IEEE Software, Vol. 13, No. 6, pp. 77-83.
11. Friesen, Jeff (2002). Achieving strong performance with threads: Parts 1-4. http://www.javaworld.com.
12. Gait, J. (1986). A probe effect in concurrent programs. Software: Practice and Experience, Vol. 16, No. 3, pp. 225-233.
13. Harrington, John (1999).Win32 multithreading made easy. C/C++ Users Journal, August, pp. 48-56.
14. Hart, Johnson M. (2000). Win32 System Programming: A Windows 2000 Application Developer's Guide. Reading, MA: Addison-Wesley.
15. Holub, Allen (2000). Taming Java Threads. Berkely: Apress.
16. Huber, Andreas (2001). Elegant function call wrappers. C/C++ Users Journal, May, pp. 8-16.
17. Hush, Andy (2002). A template class to encapsulate Win32 threading. Windows Developer Magazine, December, pp. 18-25.
18. Hyde, Paul (1999). Java Thread Programming. Howard W. Sams, Indianapolis, IN.
19. IEEE88 (1988). STD 982.1-1988, IEEE Standard Dictionary of Measures to Produce Reliable Software. New York: IEEE Press.
20. IEEE90 (1990). STD 610.12-1990, IEEE Standard Glossary of Software Engineering Terminology. New York: IEEE Press.
21. Kempf, Bill (2002). The Boost threads library. C/C++ Users Journal, May, pp. 6-13.
22. Kougiouris, Panos, and Marco Framba (1997). A portable multithreading framework. C/C++ Users Journal, August, pp. 61-71.
23. Lea, Doug (1999). Concurrent Programming in Java, 2nd ed. Reading, MA: Addison-Wesley.
24. LeDoux, C. H., and D. Stott Parker (1985). Saving traces for Ada debugging. Proc. 1985 International Ada Conference, pp. 97-108.
25. Lewis, Bill, and Daniel J. Berg (1997). Multithreaded Programming with PThreads. Upper Saddle River, NJ: Prentice Hall.
26. Lewis, Bill, and Daniel J. Berg (1999). Multithreaded Programming with Java Technology. Upper Saddle River, NJ: Pearson Education.
27. Netzer, Robert H. B., and Barton P. Miller (1992).What are race conditions? Some issues and formalizations. ACM Letters on Programming Languages and Systems, Vol. 1, No. 1, pp. 74-88.
28. Oaks, Scott, and Henry Wong (1999). Java Threads, 2nd ed. Sebastopol, CA: O'Reilly & Associates.
29. Pee, James (2003). Multithreaded programming with the command pattern. Windows Developer Magazine, January, pp. 20-25.
30. Peterson, Mark (2000). Self-destructing threads. C/C++ Users Journal, December, p. 44.
31. Petzold, Charles (1998). Programming Windows, 5th ed. Redmond, WA: Microsoft Press.
32. Schmidt, Douglas C., and Stephen D. Huston (2002). C++ Network Programming: Mastering Complexity Using ACE and Patterns. Reading, MA: Addison-Wesley.
33. Silberschatz, Abraham, Peter Baer Galvin, and Greg Gagne (2001). Operating System Concepts, 6th ed. New York: Wiley.
34. Tai, K. C. (1985). On testing concurrent programs. Proc. COMPSAC'85, pp. 310-317.
35. Tannenbaum, Andrew (2001). Modern Operating Systems, 2nd ed. Upper Saddle River, NJ: Prentice Hall.
36. Tennberg, Patrick (1998). Creating active data types via multithreading. C/C++ Users Journal, January, pp. 45-47.
37. Tsai, J., Y. Bi, S. Yang, and R. Smith (1996). Distributed Real-Time Systems: Monitoring, Debugging, and Visualization. New York: Wiley.
38. Adve, Sarita V., and K. Gharachorloo (1995). Shared Memory Consistency Models: A Tutorial. Western Research Laboratory Research Report 95/7. http://www.research.digital.com/wrl/home.html.
39. Anderson, J. (2001). Lamport on mutual exclusion: 27 years of planting seeds. Proc. 20th Annual ACM Symposium on Principles of Distributed Computing, pp. 3-12.
40. Andrews, Gregory R. (1991). Concurrent Programming: Principles and Practice. Redwood City, CA: Benjamin-Cummings.
41. Choi, J., and H. Srinivasan (1998). Deterministic replay of Java multithreaded applications. Proc. ACM Sigmetrics Symposium on Parallel and Distributed Tools, pp. 48-59.
42. deBruijn, N. G. (1967). Additional comments on a problem in concurrent programming. Communications of the ACM, Vol. 10, No. 3, pp. 137-138.
43. Dijkstra, Edsger W. (1965). Solution of a problem in concurrent programming control. Communications of the ACM, Vol. 8, No. 9 (September), p. 569.
44. Dijkstra, Edsger W. (1968). Cooperating sequential processes. In F. Genuys (Ed.), Programming Languages. New York: Academic Press, pp. 43-112.
45. Dubois, M., C. Scheurich, and F. A. Briggs (1988). Synchronization, coherence, and event ordering in multiprocessors. IEEE Computer, Vol. 21, No. 2, pp. 9-21.
46. Eisenberg, M. A., and M. R. McGuire (1972). Further comments on Dijkstra's concurrent programming control problem. Communications of the ACM, Vol. 15, No. 11 (November), p. 999.
47. Knuth, D. (1966). Additional comments on a problem in concurrent programming. Communications of the ACM, Vol. 9, No. 5 (May), pp. 321-322.
48. Lamport, L. (1974). A new solution of Dijkstra's concurrent programming problem. Communications of the ACM, Vol. 17, No. 8 (August), pp. 453-455.
49. Lamport, L. (1979). How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Transactions on Computers, Vol. 28, No. 9 (September), pp. 690-691.
50. LeBlanc, T. J., and J. M. Mellor-Crummey (1987). Debugging parallel programs with Instant Replay. IEEE Transactions on Computers, Vol. 36, No. 4 (April), pp. 471-482.
51. Mellor-Crummey, John M., and Michael L. Scott (1991). Algorithms for scalable synchronization on shared-memory multiprocessors. ACM Transactions on Computer Systems, Vol. 9, No. 1 (February), pp. 21-65.
52. Meyers, Scott, and Andrei Alexandrescu (2004a), C++ and the perils of double-checked locking: Part I. Dr. Dobb's Journal, August, pp. 46-49.
53. Meyers, Scott, and Andrei Alexandrescu (2004b), C++ and the perils of double-checked locking: Part II. Dr. Dobb's Journal, September, pp. 57-61.
54. Pugh, William (2000). The Java memory model is fatally flawed. Concurrency: Practice and Experience, Vol. 12, No. 1 (January), pp. 1-11.
55. Silberschatz, A., J. L. Peterson, and P. Galvin (1991). Operating Systems Concepts. Reading, MA: Addison-Wesley.
56. Abramson, Tomer (2002). Performing multiple read/write locks. C/C++ Users Journal, May, pp. 25-27.
57. Abramson, Tomer (2003). Detecting deadlocks in C++ using a locks monitor. Windows Developer Magazine, April, pp. 32-37.
58. Andrews, Gregory R. (1989). A method for solving synchronization problems. Science of Computer Programming, Vol. 13, No. 1 (January), pp. 1-21.
59. Andrews, Gregory R. (2000). Foundations of Multithreaded, Parallel, and Distributed Programming. Reading, MA: Addison-Wesley.
60. Becker, Thomas (1999). A semaphore with priorities for Win32. C/C++ Users Journal, August, pp. 18-30.
61. Beveridge, Jim, and R. Wiener (1997). Multithreading Programming Techniques inWin32: The Complete Guide to Threads. Reading, MA: Addison-Wesley.
62. Carver, Richard H. (1985). Reproducible testing of concurrent programs based on shared variables. Master's thesis, Computer Science Department, North Carolina State University, Raleigh, NC.
63. Carver, Richard H., and K. C. Tai (1986). Reproducible testing of concurrent programs based on shared variables. Proc. 6th International Conference on Distributed Computing Systems, pp. 428-433.
64. Carver, R. H., and K. C. Tai (1991). Replay and testing for concurrent programs. IEEE Software, Vol. 8, No. 2, pp. 66-74.
65. Chaudry, Puneesh (2002). A per-thread singleton class. C/C++ Users Journal, May, pp. 14-19.
66. Courtois, P. J., F. Heymans, and D. L. Parnas (1971). Concurrent control with readers and writers. Communications of the ACM, Vol. 14, No. 10 (October), pp. 667-668.
67. Dijkstra, Edsger W. (1965). Solution of a problem in concurrent programming control. Communications of the ACM, Vol. 8, No. 9 (September), p. 569.
68. Dijkstra, Edsger W. (1968). Cooperating sequential processes. In F. Genuys (Ed.), Programming Languages. New York: Academic Press, pp. 43-112.
69. Dijkstra, Edsger W. (1971). Hierarchical ordering of sequential processes. Acta Informatica, Vol. 1, pp. 115-138.
70. Feitelson, D. G. (1991). Deadlock detection without wait-for graphs. Parallel Computing, Vol. 17, No. 12 (December), pp. 1377-1383.
71. Goetz, Brian (2001). Double-checked locking: clever, but broken. http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html.
72. Hart, Johnson M. (2000a). Win32 System Programming: A Windows 2000 Application Developer's Guide, 2nd ed. Reading, MA: Addison-Wesley.
73. Hart, Johnson M. (2000b). Online supplement to Win32 System Programming: A Windows 2000 Application Developer's Guide, 2nd ed. Reading, MA: Addison-Wesley, http://world.std.com/~jmhart/csmutx.htm.
74. Havelund, K., and T. Pressburger (2000). Model checking Java programs using Java PathFinder. International Journal on Software Tools for Technology Transfer, Vol. 2, No. 4 (April), pp. 366-381.
75. Howard, David M. (2000). Using predicates with Win32 threads. C/C++ Users Journal, May, pp. 18-30.
76. Hwang, Gwan-Hwan, Kuo-Chung Tai, and Ting-Lu Huang (1995). Reachability testing: an approach to testing concurrent software. International Journal of Software Engineering and Knowledge Engineering, Vol. 5, No. 4, pp. 493-510.
77. Khamsi, Sarir (2003). A class for handling shared memory under Win32. C/C++ Users Journal, May, p. 34.
78. Kleber, Jeff (2000). Thread-safe access to collections. C/C++ Users Journal, May, pp. 36-39.
79. LaPlante, John (2003). Efficient thread coordination. C/C++ Users Journal, May, pp. 6-19.
80. Lowy, Juval (2000). Making primitive objects thread safe. C/C++ Users Journal, March, pp. 85-86.
81. Manley, Kevin (1999). Improving performance with thread-private heaps. C/C++ Users Journal, September, pp. 50-62.
82. Meyers, Scott, and Andrei Alexandrescu (2004a). C++ and the perils of double-checked locking: Part I. Dr. Dobb's Journal, August, pp. 46-49.
83. Meyers, Scott, and Andrei Alexandrescu (2004b). C++ and the perils of double-checked locking: Part II. Dr. Dobb's Journal, September, pp. 57-61.
84. Nonaka, Yusuka, Kazuo Ushijima, Hibiki Serizawa, Shigeru Murata, and Jingde Cheng (2001). A run-time deadlock detector for concurrent Java programs. Proc. 8th Asia-Pacific Software Engineering Conference (APSEC'01), pp. 45-52.
85. Petzold, Charles (1998). Programming Windows, 5th ed. Redmond, WA: Microsoft Press.
86. Pugh, William (1999). Fixing the Java memory model. Proc. ACM Java Grande Conference, pp. 89-98.
87. Ringle, Jon (1999a). Singleton creation: the thread-safe way. C/C++ Users Journal, October, pp. 43-49.
88. Ringle, Jon (1999b). We Have Mail: letter. C/C++ Users Journal, December.
89. Savage, S., M. Burrows, G. Nelson, P. Sobalvarro, and T. E. Anderson (1997). Eraser: a dynamic data race detector for multithreaded programs. ACM Transactions on Computer Systems, Vol. 15, No. 4 (April), pp. 391-411.
90. Silberschatz, Abraham, Peter Baer Galvin, and Greg Gagne (2001). Operating System Concepts, 6th ed. New York: Wiley.
91. Sun Microsystems (2002). Java virtual machines. http://java.sun.com/j2se/1.4.2/docs/guide/vm.
92. Tai, K. C., and R. H. Carver (1996). VP: a new operation for semaphores. ACM Operating Systems Review, Vol. 30, No. 3, pp. 5-11.
93. Anderson, T. E., E. D. Lazowska, and Henry M. Levy (1989). The performance implications of thread management alternatives for shared-memory multiprocessors. IEEE Transactions on Computers, Vol. 38. No. 12, pp. 1631-1644.
94. Andrews, Gregory, R. (1991). Concurrent Programming: Principles and Practice. Redwood City, CA: Benjamin-Cummings.
95. Andrews, Gregory, R. (2000). Foundations of Multithreaded, Parallel, and Distributed Programming. Reading, MA: Addison-Wesley.
96. Boddy, D. E. (1983). Implementing data abstractions and monitors in UCSD Pascal. SIGPLAN Notices, Vol. 18, No. 5 (May), pp. 15-24.
97. Brinch Hansen, P. (1973). Testing a multiprogramming system. Software: Practice and Experience, Vol. 3, No. 2 (February), pp. 145-150.
98. Brinch Hansen, P. (1975). The programming language concurrent Pascal. IEEE Transactions on Software Engineering, Vol. 1, No. 2 (February), pp. 199-207.
99. Brinch Hansen, P. (1978). Reproducible testing of monitors. Software: Practice and Experience, Vol. 8, No. 6, pp. 721-729.
100. Brinch Hansen, P. (2002). The Origin of Concurrent Programming: From Semaphores to Remote Procedure Calls. New York: Springer-Verlag.
101. Butenhof, David R. (1997). Programming with POSIX Threads. Reading, MA: Addison-Wesley.
102. Carver, R. H. (1985). Reproducible testing of concurrent programs based on shared variables. Master's thesis, Computer Science Department, North Carolina State University, Raleigh, NC, 1985.
103. Carver, R. H., and K. C. Tai (1986). Reproducible testing of concurrent programs based on shared variables. Proc. 6th International Conference on Distributed Computing Systems, pp. 428-433.
104. Carver R. H., and K. C. Tai (1991). Replay and testing for concurrent programs. IEEE Software, Vol. 8. No. 2, pp. 66-74.
105. Choi, J., and H. Srinivasan (1998). Deterministic replay of Java multithreaded applications. Proc. ACM Sigmetrics Symposium on Parallel and Distributed Tools, pp. 48-59.
106. Dahl, Ole-Johan (2000). A note on monitor versions. In Jim Davies, A. W. Roscoe, and Jim Woodcock (Eds.), Millennial Perspectives in Computer Science: Proceedings of the 1999 Oxford-Microsoft Symposium in Honour of Sir Tony Hoare. Upper Saddle River, NJ: Prentice Hall.
107. Dahl, Ole-Johan, B. Myhrhaug, and K. Nygaard (1970). The SIMULA 67 Common Base Language. Technical Report, Publication S-22. Oslo, Norway: Norwegian Computing Center.
108. Hamburger, Henry, and Dana Richards (2002). Logic and Language Models for Computer Science. Upper Saddle River, NJ: Prentice Hall.
109. Hartley, Steven J. (1999). Alfonse, wait here for my signal! Proc. SIGCSE'99, pp. 58-62.
110. Hoare, C. A. R. (1974). Monitors: an operating system structure concept. Communication of the ACM, Vol. 17, No. 10 (October), pp. 549-557.
111. Howard, John H. (1976). Proving monitors, Communications of the ACM, Vol. 19, No. 5 (May), pp. 273-279.
112. JSR-133 (2004). Java memory model and thread specification. http://www.jcp.org/aboutJava/communityprocess/review/jsr133/.
113. Lampson, Butler W., and David D. Redell (1980). Experience with processes and monitors in Mesa. Communications of the ACM, Vol. 23, No. 2 (February), pp. 105-117.
114. Lea, Doug (1999) Personal communication from Doug Lea to Steven J. Hartley in Hartley [1999].
115. Magee, Jeff, and Jeff Kramer (1999). Concurrency: State Models and Java Programs. New York: Wiley.
116. Parnas, D. L. (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM, Vol. 15, No. 12 (December), pp. 1053-1058.
117. Robbins, Steven (2001). Starving philosophers: experimentation with monitor synchronization. Proc. 32nd SIGCSE Technical Symposium on Computer Science Education, pp. 317-321.
118. Turski, W. M. (1991). On starvation and some related issues. Information Processing Letters, Vol. 37, pp. 171-174.
119. Ada Language ReferenceManual (1983). ANSI/MIL-STD-1815A-1983. New York: American National Standards Institute.
120. Hartley, Steven J. (1998). Concurrent Programming: The Java Programming Language. New York: Oxford University Press.
121. Magee, Jeff, and Jeff Kramer (1999). Concurrency: State Models and Java Programs. New York: Wiley.
122. Tai, K. C. (1985a). Reproducible testing of concurrent Ada programs. Proc. Softfair II, pp. 114-120.
123. Tai, K. C. (1985b). On testing concurrent programs. Proc. COMPSAC'85, pp. 310-317.
124. Tai, K. C., R. H. Carver, and E. Obaid (1991). Debugging concurrent Ada programs by deterministic execution. IEEE Transactions on Software Engineering, Vol. 17, No. 1 (January), pp. 45-63.
125. Taylor, R. N., D. L. Levine, and C. D. Kelly (1992). Structural testing of concurrent programs. IEEE Transactions on Software Engineering, Vol. 18, No. 3 (March), pp. 206-215.
126. Andrews, Gregory R. (2000). Foundations of Multithreaded, Parallel, and Distributed Programming. Reading, MA: Addison-Wesley.
127. Baldoni, R., and M. Raynal (2002). Fundamentals of distributed computing: a practical tour of vector clock systems. IEEE Distributed Systems Online, http://dsonline.computer.org.
128. Bartlet, K. A., R. A. Scantlebury, and P. T. Wilkinson (1969). A note on reliable fullduplex transmission over half duplex lines. Communications of the ACM, Vol. 12, No. 5 (May), pp. 260-261.
129. Bechini, Alessio, and K. C. Tai (1998). Timestamps for programs using messages and shared variables. Proc. International Conference on Distributed Computing Systems, pp. 266-273.
130. Brzezinski, Jerszy, Jean-Michel, Helary, and Michel Raynal (1993). Distributed termination detection: general models and algorithms. Proc. 13th IEEE International Conference on Distributed Computing Systems.
131. Choi, J., and H. Srinivasan (1998). Deterministic replay of Java multithreaded applications. Proc. ACM Sigmetrics Symposium on Parallel and Distributed Tools, pp. 48-59.
132. Fidge, C. (1991). Logical time in distributed computing systems. IEEE Computer, Vol. 24, August, pp. 8-33.
133. Fidge, C. (1996). Fundamentals of distributed system observation. IEEE Software, Vol. 13, No. 6 (November), pp. 77-83.
134. Garg, Vijay K. (2002). Elements of Distributed Computing. Hoboken, NJ: Wiley.
135. Gleason, Mike (2001). The ephemeral port range. http://www.ncftpd.com/ncftpd/doc/misc/ephemeralports.html#Windows
136. Hartley, Steven J. (1998). Concurrent Programming: The Java Programming Language. New York: Oxford University Press.
137. Konuru, R., H. Srinivasan, and J. -D. Choi (2000). Deterministic replay of distributed Java applications. Proc. 14th International Parallel and Distributed Processing Symposium (IPDPS'00), pp. 219-228.
138. Lamport, L. (1978). Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, Vol. 21, No. 7 (July), pp. 558-565.
139. Mattern, F. (1989). Virtual time and global states of distributed systems. In M. Cosnard et al. (Eds.), Proc. International Workshop on Parallel and Distributed Algorithms. Amsterdam: Elsevier North-Holland, pp. 215-226.
140. Netzer, R. B., and B. P. Miller (1993). Optimal tracing and replay for debugging sharedmemory parallel programs. Proc. 3rd ACM/ONR Workshop on Parallel and Distributed Debugging, pp. 1-11.
141. Pee, James (2001). Guidelines for wrapping sockets in classes. C/C++ Users Journal, December, pp. 10-16.
142. Plouzeau, N., and M. Raynal (1992). Elements for a course on the design of distributed algorithms. SIGCSE Bulletin, Vol. 24, No. 2, pp. 35-40.
143. Raynal, M. (1988). Distributed Algorithms and Protocols. New York: Wiley.
144. Ricart, G., and A. K. Agrawala (1981). An optimal algorithm for mutual exclusion in computer networks. Communications of the ACM, Vol. 24, No. 1 (January), pp. 9-17.
145. Schmidt, Douglas C., and Stephen D. Huston (2002). C++ Network Programming: Mastering Complexity Using ACE and Patterns. Reading, MA: Addison-Wesley.
146. Schwarz, R., and F. Mattern (1994). Detecting causal relationships in distributed computations: in search of the Holy Grail. Distributed Computing, Vol. 7, No. 3, pp. 149-174.
147. Smerka, Richard (2001). Two classes for simple socket programming. C/C++ Users Journal, May, pp. 34-41.
148. Sobczak, Maciej (2001). An IOStream compatible socket wrapper. C/C++ Users Journal, December, pp. 18-27.
149. Andrews, Gregory R. (1991). Concurrent Programming: Principles and Practice. Redwood City, CA: Benjamin-Cummings.
150. Avrunin, G. A., U. A. Buy, J. C. Corbett, L. K. Dillon, and J. C. Wileden (1991). Automated analysis of concurrent systems with the constrained expression toolset. IEEE Transactions on Software Engineering, Vol. 17, No. 11 (November), pp. 1204-1222.
151. Baase, Sara (1988). Computer Algorithms: Introduction to Design and Analysis, 2nd ed. Reading, MA: Addison-Wesley.
152. Beizer, B. (1979). Software Testing Techniques, 2nd ed. New York: Van Nostrand Reinhold.
153. Carver, Richard H., and Y. Lei (2004). A general model for reachability testing of concurrent programs. Proc. International Conference on Formal Engineering Methods, pp. 76-98.
154. Cheng, J. (1991). A survey of tasking deadlock detection methods. ACM Ada Letters, Vol. 11, No. 1 (January-February), pp. 82-91.
155. Choi, J., and H. Srinivasan (1998). Deterministic replay of Java multithreaded applications. Proc. ACM Sigmetrics Symposium on Parallel and Distributed Tools, pp. 48-59.
156. Chung, I. S., B. M. Kim, and H. S. Kim (2000). A new approach to deterministic execution testing for concurrent programs. Proc. ICDS Workshop on Distributed System Validation and Verification, pp. E59-E66.
157. Deitel, H. M. (1984). An Introduction to Operating Systems. Reading, MA: Addison-Wesley.
158. DeMillo, R. A., R. J. Lipton, and F. G. Sayward (1979). Program mutation: a new approach to program testing. In E. F. Miller (Ed.), Software Testing, Vol. 2, Invited Papers. Infotech International, Maidenhead, England, pp. 107-128.
159. Duran, J. W., and S. Ntafos (1984). An evaluation of random testing. IEEE Transactions on Software Engineering, Vol. SE-10, pp. 438-444.
160. Empath, P. A., S. Ghosh, and D. A. Padua (1992). Detecting nondeterminacy in parallel programs. IEEE Software, Vol. 9, No. 1, pp. 69-77.
161. Frankl, P. and E. Weyuker (1988). An applicable family of data flow testing criteria. IEEE Transactions on Software Engineering, Vol. 14, No. 10 (October), pp. 1483-1498.
162. Gait, J. (1986). A probe effect in concurrent programs. Software: Practice and Experience, Vol. 16, No. 3, pp. 225-233.
163. German, S. M., (1984).Monitoring for deadlock and blocking in Ada tasking. IEEE Transactions on Software Engineering, Vol. 10, No. 6 (November), pp. 764-777.
164. Hamlett, R. G. (1977). Testing programs with the aid of a compiler. IEEE Transactions on Software Engineering, Vol. 3, No. 4, pp. 279-290.
165. Helmbold, D., and D. Luckham (1985). Debugging Ada tasking programs. IEEE Software, Vol. 2, No. 2 (March), pp. 47-57.
166. Holzmann, G. J. (1991). Design and Validation of Computer Protocols. Englewood Cliffs, NJ: Prentice Hall.
167. Hwang, G., K. C. Tai, and T. Huang (1995). Reachability testing: an approach to testing concurrent software. Journal of Software Engineering and Knowledge Engineering, Vol. 5, No. 4, pp. 493-510.
168. IEEE90 (1990). STD 610.12-1990, IEEE Standard Glossary of Software Engineering Terminology. New York: IEEE Press.
169. Karam, G., and R. J. A. Buhr (1991). Temporal logic-based deadlock analysis for Ada. IEEE Transactions on Software Engineering, Vol. 17, No. 10 (October), pp. 1109-1125.
170. King, K. N., and A. J. Offutt (1991). A Fortran language system for mutation-based software testing. Software: Practice and Experience, Vol. 21, No. 7 (July), pp. 685-718.
171. Konuru, R., H. Srinivasan, and J. -D. Choi (2000). Deterministic replay of distributed Java applications. Proc. 14th International Parallel and Distributed Processing Symposium (IPDPS'00), pp. 219-228.
172. Koppol, Pramod V., Richard H. Carver, and Kuo-Chung Tai (2002). Incremental integration testing of concurrent programs. IEEE Transactions on Software Engineering, Vol. 28, No. 6, pp. 607-623.
173. LeDoux, C. H., and D. Stott Parker (1985). Saving traces for Ada debugging. Proc. 1985 International Ada Conference, pp. 97-108.
174. Lei, Yu, and Richard H. Carver (2004a). Reachability testing of semaphore-based programs. Proc. 28th Computer Software and Applications Conference (COMPSAC), pp. 312-317.
175. Lei, Yu, and Richard H. Carver (2004b). Reachability testing of monitor-based programs. Proc. 8th IASTED International Conference on Software Engineering and Applications, pp. 312-317.
176. Lei, Yu, and Richard H. Carver (2005). A new algorithm for reachability testing of concurrent programs. Technical Report GMU-CS-TR-2005-1.
177. Lei, Yu, and Kuo-Chung Tai (2002). Efficient reachability testing of asynchronous messagepassing programs. Proc. 8th IEEE International Conference on Engineering for Complex Computer Systems, pp. 35-44.
178. Masticola, S. P., and B. G. Ryder (1991). A model of Ada programs for static deadlock detection in polynomial time. Proc. Workshop on Parallel and Distributed Debugging, pp. 97-107.
179. Mellor-Crummey, J., and T. LeBlanc (1989). A software instruction counter. Proc. 3rd Symposium on Architectural Support for Programming Languages and Operating Systems, pp. 78-86.
180. Myers, Glenford (1979). The Art of Software Testing. New York: Wiley.
181. Netzer, R. B., and B. P. Miller (1994). Optimal tracing and replay for debugging messagepassing parallel programs. Journal of Supercomputing, Vol. 8, No. 4, pp. 371-388.
182. Offutt, A. Jefferson, and Jeffrey M. Voas (1996). Subsumption of Condition Coverage Techniques by Mutation Testing. Technical Report ISSE-TR-96-01. Department of Information and Software Systems Engineering, http://www.isse.gmu.edu/techrep/1996.
183. Parrish, A. S., and S. H. Zweben (1995). On the relationships among the all-uses, alldu-paths, and all-edges testing criteria. IEEE Transactions on Software Engineering, Vol. 21, No. 12 (December), pp. 1006-1009.
184. Silberschatz, A., J. L. Peterson, and P. Galvin (1991). Operating Systems Concepts. Reading, MA: Addison-Wesley.
185. Stoller, S. D. (2002). Testing concurrent Java programs using randomized scheduling. Proc. 2nd Workshop on Runtime Verification (RV), Vol. 70, No. 4. Electronic Notes in Theoretical Computer Science. Amsterdam: Elsevier.
186. Tai, K. C. (1994). Definitions and detection of deadlock, livelock, and starvation in concurrent programs. Proc. 1994 International Conference on Parallel Processing, pp. 69-72.
187. Tai, K. C. (1997). Reachability testing of asynchronous message-passing programs. Proc. 2nd International Workshop on Software Engineering for Parallel and Distributed Systems, pp. 50-61.
188. Tai, K. C., R. H. Carver, and E. Obaid (1991). Debugging concurrent Ada programs by deterministic execution. IEEE Transactions on Software Engineering, Vol. 17, No. 1 (January), pp. 45-63.
189. Tannenbaum, A. S. (1992). Modern Operating Systems. Englewood Cliffs, NJ: Prentice Hall.
190. Turski, W. M. (1991). On starvation and some related issues. Information Processing Letters, Vol. 37, No. 3, pp. 171-174.
191. Taylor, R. N. (1983). A general-purpose algorithm for analyzing concurrent programs. Communications of the ACM, Vol. 26, No. 5, pp. 362-376.
192. Taylor, R. N., D. L. Levine, and C. D. Kelly (1992). Structural testing of concurrent programs. IEEE Transactions on Software Engineering, Vol. 18, No. 3, pp. 206-215.
193. Tsai, J., Y. Bi, S. Yang, and R. Smith (1996). Distributed Real-Time Systems: Monitoring, Debugging, and Visualization. New York: Wiley.
194. Vissers, C. A., G. Scollo, Mv. Sinderen, and E. Brinksma (1991). Specification styles in distributed systems design and verification. Theoretical Computer Science, Vol. 89, pp. 179-206.
195. Vouk, M. A., M. L. Helsabeck, D. F. McAllister, and K. C. Tai (1986). On testing of functionally equivalent components of fault-tolerant software. Proc. COMPSAC'86, October, pp. 414-419.
196. Yang, C., and L. L. Pollock (1997). The challenges in automated testing of multithreaded programs. Proc. 14th International Conference on Testing Computer Software, pp. 157-166.