Article

Analysis of Multithreaded Programs

Author:

Martin C. RinardAuthors Info & Claims

SAS '01: Proceedings of the 8th International Symposium on Static Analysis

Pages 1 - 19

Published: 16 July 2001 Publication History

Abstract

The field of program analysis has focused primarily on sequential programming languages. But multithreading is becoming increasingly important, both as a program structuring mechanism and to support efficient parallel computations. This paper surveys research in analysis for multithreaded programs, focusing on ways to improve the efficiency of analyzing interactions between threads, to detect data races, and to ameliorate the impact of weak memory consistency models. We identify two distinct classes of multithreaded programs, activity management programs and parallel computing programs, and discuss how the structure of these kinds of programs leads to different solutions to these problems. Specifically, we conclude that augmented type systems are the most promising approach for activity management programs, while targeted program analyses are the most promising approach for parallel computing programs.

References

[1]

S. Adve and K. Gharachorloo. Shared memory consistency models: a tutorial. IEEE Computer, 29(12):66-76, Dec. 1996.

[2]

A. Aiken and D. Gay. Barrier inference. In Proceedings of the 25th Annual ACM Symposium on the Principles of Programming Languages, Paris, France, Jan. 1998. ACM.

[3]

J. Aldrich, C. Chambers, E. Sirer, and S. Eggers. Static analyses for eliminating unnecessary synchronization from Java programs. In Proceedings of the 6th International Static Analysis Symposium, Sept. 1999.

[4]

L. O. Andersen. Program Analysis and Specialization for the C Programming Language. PhD thesis, DIKU, University of Copenhagen, May 1994.

[5]

D. Bacon, S. Graham, and O. Sharp. Compiler transformations for high-performance computing. ACM Computing Surveys, 26(4):345-420, Dec. 1994.

[6]

D. Bacon, R. Strom, and A. Tarafdar. Guava: A dialect of Java without data races. In Proceedings of the 15th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Portland, OR, Oct. 2000.

[7]

V. Balasundaram and K. Kennedy. A technique for summarizing data access and its use in parallelism enhancing transformations. In Proceedings of the SIGPLAN '89 Conference on Program Language Design and Implementation, Portland, OR, June 1989.

[8]

U. Banerjee. Dependence Analysis for Supercomputing. Kluwer Academic Publishers, Boston, MA, 1988.

[9]

U. Banerjee, R. Eigenmann, A. Nicolau, and D. Padua. Automatic program parallelization. Proceedings of the IEEE, 81(2):211-243, Feb. 1993.

[10]

A. Birrell. Systems Programming with Modula-3, chapter An Introduction to Programming with Threads. Prentice-Hall, Englewood Cliffs, N.J., 1991.

[11]

B. Blanchet. Escape analysis for object oriented languages. application to Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO, Nov. 1999.

[12]

J. Blieberger, B. Burgstaller, and B. Scholz. Symbolic dataflow analysis for detecting deadlocks in Ada tasking programs. In Proceedings of the 5th International Conference on Reliable Software Technologies Ada-Europe 2000, June 2000.

[13]

J. Bogda and U. Hoelzle. Removing unnecessary synchronization in Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO, Nov. 1999.

[14]

C. Boyapati and M. Rinard. A parameterized type system for race-free Java programs. In Proceedings of the 16th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Tampa Bay, FL, Oct. 2001.

[15]

P. Brinch-Hansen. The programming language Concurrent Pascal. IEEE Transactions on Software Engineering, SE-1(2):199-207, June 1975.

[16]

E. Bruneton and J. Pradat-Peyre. Automatic verification of concurrent Ada programs. In Proceedings of the 4th International Conference on Reliable Software Technologies Ada-Europe 1999, June 2000.

[17]

D. Callahan, K. Kennedy, and J. Subhlok. Analysis of event synchronization in a parallel programming tool. In Proceedings of the 2nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Seattle, WA, Mar. 1990.

[18]

D. Callahan and J. Subhlok. Static analysis of low-level synchronization. In Proceedings of the ACM SIGPLAN and SIGOPS Workshop on Parallel and Distributed Debugging, Madison, WI, May 1988.

[19]

D. Chase, M. Wegman, and F. Zadek. Analysis of pointers and structures. In Proceedings of the SIGPLAN '90 Conference on Program Language Design and Implementation, pages 296-310, White Plains, NY, June 1990. ACM, New York.

[20]

G. Cheng, M. Feng, C. Leiserson, K. Randall, and A. Stark. Detecting data races in Cilk programs that use locks. In Proceedings of the 10th Annual ACM Symposium on Parallel Algorithms and Architectures, June 1998.

[21]

J. Choi, M. Gupta, M. Serrano, V. Sreedhar, and S. Midkiff. Escape analysis for Java. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO, Nov. 1999.

[22]

J. Chow and W. Harrison III. Compile time analysis of programs that share memory. In Proceedings of the 19th Annual ACM Symposium on the Principles of Programming Languages, Albuquerque, NM, Jan. 1992. ACM, New York.

[23]

J. Chow and W. Harrison III. State space reduction in abstract interpretation of parallel programs. In Proceedings of the 1994 IEEE International Conference on Computer Language, May 1994.

[24]

J. Corbett. Evaluating deadlock detection methods for concurrent software. IEEE Transactions on Software Engineering, 22(3), Mar. 1996.

[25]

J. Corbett. Using shape analysis to reduce finite-state models of concurrent Java programs. In Proceedings of the International Symposium on Software Testing and Analysis, Mar. 1998.

[26]

P. Cousot and R. Cousot. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. In Conference Record of the 4th Annual ACM Symposium on the Principles of Programming Languages, Los Angeles, CA, 1977.

[27]

P. Cousot and R. Cousot. Automatic Program Construction Techniques, chapter Invariance Proof Methods and Analysis Techniques for Parallel Programs. Macmillan Publishing Company, New York, NY, 1984.

[28]

D. Detlefs, K. R. Leino, G. Nelson, and J. Saxe. Extended static checking. Technical Report 159, Compaq Systems Research Center, 1998.

[29]

L. Dillon. Using symbolic execution for verification of Ada tasking programs. ACM Transactions on Programming Languages and Systems, 12(4), 1990.

[30]

P. Diniz and M. Rinard. Synchronization transformations for parallel computing. In Proceedings of the 24th Annual ACM Symposium on the Principles of Programming Languages, pages 187-200, Paris, France, Jan. 1997. ACM, New York.

[31]

P. Diniz and M. Rinard. Lock coarsening: Eliminating lock overhead in automatically parallelized object-based programs. Journal of Parallel and Distributed Computing, 49(2):2218-244, Mar. 1998.

[32]

A. Dinning and E. Schonberg. Detecting access anomalies in programs with critical sections. In Proceedings of the ACM/ONR Workshop on Parallel and Distributed Debugging, Santa Cruz, CA, May 1991.

[33]

E. Duesterwald and M. Soffa. Concurrency analysis in the presence of procedures using a data-flow analysis framework. In Proceedings of the ACM Symposium on Analysis, Verification, and Testing, Victoria, B.C., Oct. 1991.

[34]

S. Duri, U. Buy, R. Devarapalli, and S. Shatz. Application and experimental evaluation of state space reduction methods for deadlock analysis in Ada. ACM Transactions on Software Engineering and Methodology, 3(4), Oct. 1994.

[35]

M. Dwyer and L. Clarke. Data-flow analysis for verifying properties of concurrent programs. In Proceedings of the 2nd ACM SIGSOFT Symposium on the Foundations of Software Engineering, New Orleans, LA, Dec. 1994.

[36]

P. Emrath, S. Ghosh, and D. Padua. Event synchronization analysis for debugging parallel programs. In Proceedings of Supercomputing '89, Reno, NV, Nov. 1989. IEEE Computer Society Press, Los Alamitos, Calif.

[37]

M. Fahndrich, J. Foster, Z. Su, and A. Aiken. Partial online cycle elimination in inclusion constraint graphs. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal, Canada, June 1998.

[38]

P. Feautrier. Compiling for massively parallel architectures: A perspective. Micro-programming and Microprocessors, 1995.

[39]

A. Fisher and A. Ghuloum. Parallelizing complex scans and reductions. In Proceedings of the SIGPLAN '94 Conference on Program Language Design and Implementation, pages 135-144, Orlando, FL, June 1994. ACM, New York.

[40]

C. Flanagan and M. Abadi. Types for safe locking. In Proceedings of the 8th European Symposium on Programming, Amsterdam, The Netherlands, Mar. 2000.

[41]

C. Flanagan and S. Freund. Type-based race detection for Java. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada, June 2000.

[42]

M. Frigo, C. Leiserson, and K. Randall. The implementation of the Cilk-5 multithreaded language. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal, Canada, June 1998.

[43]

R. Ghiya and L. Hendren. Is it a tree, a DAG or a cyclic graph? A shape analysis for heap-directed pointers in C. In Proceedings of the 23rd Annual ACM Symposium on the Principles of Programming Languages, pages 1-15, Jan. 1996.

[44]

A. Ghuloum and A. Fisher. Flattening and parallelizing irregular, recurrent loop nests. In Proceedings of the 5th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, pages 58-67, Santa Barbara, CA, July 1995 ACM, New York.

[45]

P. Godefroid and P. Wolper. A partial approach to model checking. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, Amsterdam, The Netherlands, July 1991.

[46]

D. Grunwald and H. Srinivasan. Data flow equations for explicitly parallel programs. In Proceedings of the 4th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, CA, May 1993.

[47]

M. Gupta, S. Mukhopadhyay, and N. Sinha. Automatic parallelization of recursive procedures. In Proceedings of the 1999 Conference on Parallel Algorithms and Compilation Techniques (PACT) '99, Newport Beach, CA, Oct. 1999.

[48]

M. Hall, S. Amarasinghe, B. Murphy, S. Liao, and M. Lam. Detecting coarsegrain parallelism using an interprocedural parallelizing compiler. In Proceedings of Supercomputing '95, San Diego, CA, Dec. 1995. IEEE Computer Society Press, Los Alamitos, Calif.

[49]

C. Hauser, C. Jacobi, M. Theimer, B. Welch, and M. Weiser. Using threads in interactive systems: A case study. In Proceedings of the Fourteenth Symposium on Operating Systems Principles, Asheville, NC, Dec. 1993.

[50]

P. Havlak and K. Kennedy. An implementation of interprocedural bounded regular section analysis. IEEE Transactions on Parallel and Distributed Systems, 2(3):350-360, July 1991.

[51]

L. Hendren, J. Hummel, and A. Nicolau. Abstractions for recursive pointer data structures: Improving the analysis and transformation of imperative programs. In Proceedings of the SIGPLAN '92 Conference on Program Language Design and Implementation, San Francisco, CA, June 1992. ACM, New York.

[52]

M. Hill. Multiprocessors should support simple memory consistency models. IEEE Computer, 31(8), Aug. 1998.

[53]

F. Irigoin and R. Triolet. Supernode partitioning. In Proceedings of the 15th Annual ACM Symposium on the Principles of Programming Languages, San Diego, CA, Jan. 1988.

[54]

J. Kam and J. Ullman. Global data flow analysis and iterative algorithms. Journal of the ACM, 23(1):159-171, Jan. 1976.

[55]

G. Kildall. A unified approach to global program optimization. In Conference Record of the Symposium on Principles of Programming Languages. ACM, Jan. 1973.

[56]

J. Knoop and B. Steffen. Code motion for explicitly parallel programs. In Proceedings of the 7th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Atlanta, GA, May 1999.

[57]

J. Knoop, B. Steffen, and J. Vollmer. Parallelism for free: Efficient and optimal bitvector analyses for parallel programs. ACM Transactions on Programming Languages and Systems, 18(3):268-299, May 1996.

[58]

A. Krishnamurthy, D. Culler, A. Dusseau, S. Goldstein, S. Lumetta, T. von Eicken, and K. Yelick. Parallel programming in Split-C. In Proceedings of Supercomputing '93, Nov. 1993.

[59]

A. Krishnamurthy and K. Yelick. Analyses and optimizations for shared address space programs. Journal of Parallel and Distributed Computing, 38(2), Nov. 1996.

[60]

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988. ACM, New York.

[61]

D. Lea. Concurrent Programming in Java: Design Principles and Patterns. Addison-Wesley, Reading, Mass., San Mateo, CA, 1996.

[62]

J. Lee, S. Midkiff, and D. Padua. A constant propagation algorithm for explicitly parallel programs. International Journal of Parallel Programming, 26(5), 1998.

[63]

J. Lee and D. Padua. Hiding relaxed memory consistency with compilers. In Proceedings of the 2000 International Conference on Parallel Algorithms and Compilation Techniques, Philadelphia, PA, Oct. 2000.

[64]

J. Lee, D. Padua, and S. Midkiff. Basic compiler algorithms for parallel programs. In Proceedings of the 7th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Atlanta, GA, May 1999.

[65]

B. Liblit and A. Aiken. Type systems for distributed data structures. In Proceedings of the 27th Annual ACM Symposium on the Principles of Programming Languages, Boston, MA, Jan. 2000.

[66]

D. Long and L. Clarke. Data flow analysis of concurrent systems that use the rendezvous model of synchronization. In Proceedings of the ACM Symposium on Analysis, Verification, and Testing, Victoria, B.C., Oct. 1991.

[67]

J. Maessen, Arvind, and X. Shen. Improving the Java memory model using CRF. In Proceedings of the 15th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Portland, OR, Oct. 2000.

[68]

J. Manson and W. Pugh. Core multithreaded semantics for Java. In Proceedings of the Joint ACM Java Grande - ISCOPE 2001 Conference, Stanford, CA, June 2001.

[69]

S. Masticola and B. Ryder. Static infinite wait anomaly detection in polynomial time. In Proceedings of the 1990 International Conference on Parallel Processing, St. Charles, IL, Aug. 1990.

[70]

S. Masticola and B. Ryder. Non-concurrency analysis. In Proceedings of the 4th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, CA, May 1993.

[71]

S. Midkiff and D. Padua. Compiler algorithms for synchronization. IEEE Transactions on Computers, 36(12):1485-1495, Dec. 1987.

[72]

S. Midkiff and D. Padua. Issues in the optimization of parallel programs. In Proceedings of the 1990 International Conference on Parallel Processing, pages II-105-113, 1990.

[73]

G. Naumovich, G. Avrunin, and L. Clarke. Data flow analysis for checking properties of concurrent Java programs. In Proceedings of the 21st International conference on Software Engineering, Los Angeles, CA, May 1999.

[74]

G. Naumovich, G. Avrunin, and L. Clarke. An efficient algorithm for computing MHP information for concurrent Java programs. In Proceedings of the 7th ACM SIGSOFT Symposium on the Foundations of Software Engineering, Toulouse, France, Sept. 1999.

[75]

G. Naumovich, L. Clarke, and J. Cobleigh. Using partial order techniques to improve performance of data flow analysis based verification. In Proceedings of the ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering, Toulouse, France, Sept. 1999.

[76]

J. Ousterhout. Why threads are a bad idea (for most purposes). Invited Talk at the 1996 USENIX Technical Conference.

[77]

W. Pugh. A practical algorithm for exact array dependence analysis. Commun. ACM, 35(8):102-114, Aug. 1992.

[78]

W. Pugh. Fixing the Java memory model. In Proceedings of the ACM 1999 Java Grande Conference, San Francisco, CA, June 1999.

[79]

M. Rinard. Effective fine-grain synchronization for automatically parallelized programs using optimistic synchronization primitives. ACM Transactions on Computer Systems, 17(4):337-371, Nov. 1999.

[80]

M. Rinard and P. Diniz. Commutativity analysis: A new analysis technique for parallelizing compilers. ACM Transactions on Programming Languages and Systems, 19(6):941-992, Nov. 1997.

[81]

M. Rinard and M. Lam. The design, implementation, and evaluation of jade. ACM Transactions on Programming Languages and Systems, 20(3):483-545, May 1998.

[82]

E. Ruf. Effective synchronization removal for Java. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada, June 2000.

[83]

R. Rugina and M. Rinard. Pointer analysis for multithreaded programs. In Proceedings of the SIGPLAN '99 Conference on Program Language Design and Implementation, Atlanta, GA, May 1999.

[84]

R. Rugina and M. Rinard. Symbolic bounds analysis of pointers, array indexes, and accessed memory regions. In Proceedings of the SIGPLAN '00 Conference on Program Language Design and Implementation, Vancouver, Canada, June 2000.

[85]

M. Sagiv, T. Reps, and R. Wilhelm. Solving shape-analysis problems in languages with destructive updating. ACM Transactions on Programming Languages and Systems, 20(1):1-50, Jan. 1998.

[86]

A. Salcianu and M. Rinard. Pointer and escape analysis for multithreaded Java programs. In Proceedings of the 8th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Snowbird, UT, June 2001.

[87]

V. Sarkar and B. Simons. Parallel program graphs and their classification. In Proceedings of the Sixth Workshop on Languages and Compilers for Parallel Computing, Portland, OR, Aug. 1993.

[88]

S. Savage, M. Burrows, G. Nelson, P. Solbovarro, and T. Anderson. Eraser: A dynamic race detector for multi-threaded programs. In Proceedings of the Sixteenth Symposium on Operating Systems Principles, Saint-Malo, France, Oct. 1997.

[89]

D. Scales and M. S. Lam. The design and evaluation of a shared object system for distributed memory machines. In Proceedings of the 1st USENIX Symposium on Operating Systems Design and Implementation. ACM, New York, Nov. 1994.

[90]

D. Shasha and M. Snir. Efficient and correct execution of parallel programs that share memory. ACM Transactions on Programming Languages and Systems, 10(2), Apr. 1988.

[91]

H. Srinivasan, J. Hook, and M. Wolfe. Static single assignment for explicitly parallel programs. In Proceedings of the 20th Annual ACM Symposium on the Principles of Programming Languages, Jan. 1993.

[92]

G. Steele. Making asynchronous parallelism safe for the world. In Proceedings of the 17th Annual ACM Symposium on the Principles of Programming Languages, pages 218-231, San Francisco, CA, Jan. 1990. ACM, New York.

[93]

B. Steensgaard. Points-to analysis in almost linear time. In Proceedings of the 23rd Annual ACM Symposium on the Principles of Programming Languages, St. Petersburg Beach, FL, Jan. 1996.

[94]

N. Sterling. Warlock: A static data race analysis tool. In Proceedings of the 1993 Winter Usenix Conference, Jan. 1994.

[95]

R. N. Taylor. A general purpose algorithm for analyzing concurrent programs. Commun. ACM, 26(5):362-376, May 1983.

[96]

C. Tseng. Compiler optimizations for eliminating barrier synchronization. In Proceedings of the 5th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, pages 144-155, Santa Barbara, CA, July 1995.

[97]

A. Valmari. A stubborn attack on state explosion. In Proceedings of the 2nd International Workshop on Computer Aided Verification, New Brunswick, NJ, June 1990.

[98]

J. Whaley and M. Rinard. Compositional pointer and escape analysis for Java programs. In Proceedings of the 14th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Denver, CO, Nov. 1999.

[99]

M. Young and R. Taylor. Combining static concurrency analysis with symbolic execution. IEEE Transactions on Software Engineering, 14(10), Oct. 1988.

[100]

H. Zhu and L. Hendren. Communication optimizations for parallel C programs. In Proceedings of the SIGPLAN '98 Conference on Program Language Design and Implementation, Montreal, Canada, June 1998.

Cited By

Heinricher AWilliams RKlingbeil AJordan ADo LUrban C(2021)Weldr: fusing binaries for simplified analysisProceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis10.1145/3460946.3464320(25-30)Online publication date: 22-Jun-2021
https://dl.acm.org/doi/10.1145/3460946.3464320
Cai YYao PZhang CFreund SYahav E(2021)Canary: practical static detection of inter-thread value-flow bugsProceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation10.1145/3453483.3454099(1126-1140)Online publication date: 19-Jun-2021
https://dl.acm.org/doi/10.1145/3453483.3454099
Lambers LStrüber DTaentzer GBorn KHuebert JChaudron MCrnkovic IChechik MHarman M(2018)Multi-granular conflict and dependency analysis in software engineering based on graph transformationProceedings of the 40th International Conference on Software Engineering10.1145/3180155.3180258(716-727)Online publication date: 27-May-2018
https://dl.acm.org/doi/10.1145/3180155.3180258
Show More Cited By

Recommendations

Analysis of synchronization errors for multithreaded programs
Runtime Analysis of Atomicity for Multithreaded Programs

Atomicity is a correctness condition for concurrent systems. Informally, atomicity is the property that every concurrent execution of a set of transactions is equivalent to some serial execution of the same transactions. In multithreaded programs, ...
Debugging Multithreaded Programs that Incorporate User-Level Locking

Comments

Information & Contributors

Information

Published In

cover image Guide Proceedings

SAS '01: Proceedings of the 8th International Symposium on Static Analysis

July 2001

436 pages

ISBN:3540423141

Editor:
Patrick Cousot

Publisher

Springer-Verlag

Berlin, Heidelberg

Publication History

Published: 16 July 2001

Qualifiers

Article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

40
Total Citations
View Citations
0
Total Downloads

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

Reflects downloads up to 10 Aug 2024

Other Metrics

View Author Metrics

Citations

Cited By

Heinricher AWilliams RKlingbeil AJordan ADo LUrban C(2021)Weldr: fusing binaries for simplified analysisProceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis10.1145/3460946.3464320(25-30)Online publication date: 22-Jun-2021
https://dl.acm.org/doi/10.1145/3460946.3464320
Cai YYao PZhang CFreund SYahav E(2021)Canary: practical static detection of inter-thread value-flow bugsProceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation10.1145/3453483.3454099(1126-1140)Online publication date: 19-Jun-2021
https://dl.acm.org/doi/10.1145/3453483.3454099
Lambers LStrüber DTaentzer GBorn KHuebert JChaudron MCrnkovic IChechik MHarman M(2018)Multi-granular conflict and dependency analysis in software engineering based on graph transformationProceedings of the 40th International Conference on Software Engineering10.1145/3180155.3180258(716-727)Online publication date: 27-May-2018
https://dl.acm.org/doi/10.1145/3180155.3180258
Reaves BBowers JGorski III SAnise OBobhate RCho RDas HHussain SKarachiwala HScaife NWright BButler KEnck WTraynor P(2016)*droidACM Computing Surveys10.1145/299635849:3(1-30)Online publication date: 21-Oct-2016
https://dl.acm.org/doi/10.1145/2996358
Kroening DPoetzl DSchrammel PWachter BLo DApel SKhurshid S(2016)Sound static deadlock analysis for C/PthreadsProceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering10.1145/2970276.2970309(379-390)Online publication date: 25-Aug-2016
https://dl.acm.org/doi/10.1145/2970276.2970309
Kusano MWang CZimmermann TCleland-Huang JSu Z(2016)Flow-sensitive composition of thread-modular abstract interpretationProceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering10.1145/2950290.2950291(799-809)Online publication date: 1-Nov-2016
https://dl.acm.org/doi/10.1145/2950290.2950291
Lee DKolan TMorgenshtein ASokhin VMorad RZiv ABertacco V(2016)Probabilistic bug-masking analysis for post-silicon tests in microprocessor verificationProceedings of the 53rd Annual Design Automation Conference10.1145/2897937.2898072(1-6)Online publication date: 5-Jun-2016
https://dl.acm.org/doi/10.1145/2897937.2898072
Li LLi DBartel ABissyandé TKlein JTraon YOssowski S(2016)Towards a generic framework for automating extensive analysis of Android applicationsProceedings of the 31st Annual ACM Symposium on Applied Computing10.1145/2851613.2851784(1460-1465)Online publication date: 4-Apr-2016
https://dl.acm.org/doi/10.1145/2851613.2851784
Bergan TGrossman DCeze L(2014)Symbolic execution of multithreaded programs from arbitrary program contextsACM SIGPLAN Notices10.1145/2714064.266020049:10(491-506)Online publication date: 15-Oct-2014
https://dl.acm.org/doi/10.1145/2714064.2660200
Bergan TGrossman DCeze LBlack AMillstein T(2014)Symbolic execution of multithreaded programs from arbitrary program contextsProceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications10.1145/2660193.2660200(491-506)Online publication date: 15-Oct-2014
https://dl.acm.org/doi/10.1145/2660193.2660200
Show More Cited By

View Options

View options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

Media

Figures

Other

Tables

View Table of Contents