Digital Comprehensive Summaries of Uppsala Dissertations from the Faculty of Science and Technology 1745 Model Checking of Software Systems under Weak Memory Models

When a program is compiled and run on a modern architecture, different optimizations may be applied to gain in efficiency. In particular, the access operations (e.g., read and write) to the shared ...

[1]  Todd Millstein,et al.  Simplified semantics and debugging of concurrent programs via targeted race detection , 2011 .

[2]  Patrice Godefroid,et al.  Partial-Order Methods for the Verification of Concurrent Systems , 1996, Lecture Notes in Computer Science.

[3]  Edmund M. Clarke,et al.  Design and Synthesis of Synchronization Skeletons Using Branching-Time Temporal Logic , 1981, Logic of Programs.

[4]  Salvatore La Torre,et al.  Lazy-CSeq: A Context-Bounded Model Checking Tool for Multi-threaded C-Programs , 2015, 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[5]  Roland Meyer,et al.  Checking and Enforcing Robustness against TSO , 2013, ESOP.

[6]  Salvatore La Torre,et al.  Bounded Model Checking of Multi-threaded C Programs via Lazy Sequentialization , 2014, CAV.

[7]  Viktor Schuppan,et al.  Liveness Checking as Safety Checking , 2002, FMICS.

[8]  Salvatore La Torre,et al.  Verifying Concurrent Programs by Memory Unwinding , 2015, TACAS.

[9]  Anton Podkopaev,et al.  Promising Compilation to ARMv8 POP , 2017, ECOOP.

[10]  Parosh Aziz Abdulla,et al.  Optimal stateless model checking under the release-acquire semantics , 2018, Proc. ACM Program. Lang..

[11]  David Aspinall,et al.  On Validity of Program Transformations in the Java Memory Model , 2008, ECOOP.

[12]  Sylvain Conchon,et al.  Cubicle- W : Parameterized Model Checking on Weak Memory , 2018, IJCAR.

[13]  Sylvain Conchon,et al.  Compiling Parameterized X86-TSO Concurrent Programs to Cubicle- W , 2017, ICFEM.

[14]  Edsger W. Dijkstra,et al.  Hierarchical ordering of sequential processes , 1971, Acta Informatica.

[15]  Randal E. Bryant,et al.  Symbolic Boolean manipulation with ordered binary-decision diagrams , 1992, CSUR.

[16]  Jeehoon Kang,et al.  A promising semantics for relaxed-memory concurrency , 2017, POPL.

[17]  Edsger W. Dijkstra,et al.  The humble programmer , 1972, CACM.

[18]  Gerard J. Holzmann,et al.  The SPIN Model Checker , 2003 .

[19]  Maged M. Michael,et al.  Idempotent work stealing , 2009, PPoPP '09.

[20]  Keir Fraser,et al.  Practical lock-freedom , 2003 .

[21]  Patrick Lam,et al.  SATCheck: SAT-directed stateless model checking for SC and TSO , 2015, OOPSLA.

[22]  Leslie Lamport,et al.  Time, clocks, and the ordering of events in a distributed system , 1978, CACM.

[23]  Bengt Jonsson,et al.  Optimal Dynamic Partial Order Reduction with Observers , 2018, TACAS.

[24]  Roberto Guanciale,et al.  Provably secure memory isolation for Linux on ARM , 2016, J. Comput. Secur..

[25]  Salvatore La Torre,et al.  Reducing Context-Bounded Concurrent Reachability to Sequential Reachability , 2009, CAV.

[26]  Alkis Gotovos,et al.  Systematic Testing for Detecting Concurrency Errors in Erlang Programs , 2013, 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation.

[27]  Nancy G. Leveson,et al.  Safeware - system safety and computers: a guide to preventing accidents and losses caused by technology , 1995 .

[28]  Ali Sezgin,et al.  Modelling the ARMv8 architecture, operationally: concurrency and ISA , 2016, POPL.

[29]  Jonathan Jacky,et al.  Model-Based Software Testing and Analysis with C#: Preface , 2007 .

[30]  Sebastian Burckhardt,et al.  The design of a task parallel library , 2009, OOPSLA.

[31]  David L. Weaver,et al.  The SPARC Architecture Manual , 2003 .

[32]  Helmut Veith,et al.  Counterexample-guided abstraction refinement for symbolic model checking , 2003, JACM.

[33]  Giorgio Delzanno.  Parameterized verification , 2016, International Journal on Software Tools for Technology Transfer.

[34]  Jeehoon Kang,et al.  Repairing sequential consistency in C/C++11 , 2017, PLDI.

[35]  Edmund M. Clarke,et al.  Model Checking and the State Explosion Problem , 2011, LASER Summer School.

[36]  Pierre Wolper,et al.  A Verification-Based Approach to Memory Fence Insertion in Relaxed Memory Systems , 2011, SPIN.

[37]  Viktor Vafeiadis,et al.  A Program Logic for C11 Memory Fences , 2016, VMCAI.

[38]  Josep Torrellas,et al.  WeeFence: toward making fences free in TSO , 2013, ISCA.

[39]  Edmund M. Clarke,et al.  Symbolic Model Checking: 10^20 States and Beyond , 1990, Inf. Comput..

[40]  Edmund M. Clarke,et al.  State space reduction using partial order techniques , 1999, International Journal on Software Tools for Technology Transfer.

[41]  Shengchao Qin,et al.  Reasoning about Fences and Relaxed Atomics , 2016, 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP).

[42]  Chao Wang,et al.  Dynamic partial order reduction for relaxed memory models , 2015, PLDI.

[43]  Gerard J. Holzmann,et al.  Design and validation of computer protocols , 1991 .

[44]  Edmund M. Clarke,et al.  Counterexample-guided abstraction refinement , 2003, 10th International Symposium on Temporal Representation and Reasoning, 2003 and Fourth International Conference on Temporal Logic. Proceedings..

[45]  Armin Biere,et al.  Symbolic Model Checking without BDDs , 1999, TACAS.

[46]  Jeremy Manson,et al.  The Java memory model , 2005, POPL '05.

[47]  Ori Lahav,et al.  Explaining Relaxed Memory Models with Program Transformations , 2016, FM.

[48]  Ori Lahav,et al.  Effective stateless model checking for C/C++ concurrency , 2017, Proc. ACM Program. Lang..

[49]  Robert S. Hanmer,et al.  Model checking without a model: an analysis of the heart-beat monitor of a telephone switch using VeriSoft , 1998, ISSTA '98.

[50]  Parosh Aziz Abdulla,et al.  Memorax, a Precise and Sound Tool for Automatic Fence Insertion under TSO , 2013, TACAS.

[51]  Thomas W. Reps,et al.  Reducing Concurrent Analysis Under a Context Bound to Sequential Analysis , 2008, CAV.

[52]  Ori Lahav,et al.  Strong Logic for Weak Memory: Reasoning About Release-Acquire Consistency in Iris , 2017, ECOOP.

[53]  Viktor Vafeiadis,et al.  Common Compiler Optimisations are Invalid in the C11 Memory Model and what we can do about it , 2015, POPL.

[54]  Viktor Vafeiadis.  Formal Reasoning about the C11 Weak Memory Model , 2015, CPP.

[55]  Jade Alglave,et al.  Synchronising C/C++ and POWER , 2012, PLDI.

[56]  Salvatore La Torre,et al.  Lazy Sequentialization for the Safety Verification of Unbounded Concurrent Programs , 2016, ATVA.

[57]  Ofer Strichman,et al.  Bounded model checking , 2003, Adv. Comput..

[58]  Gennaro Parlato,et al.  CSeq: A concurrency pre-processor for sequential C verification tools , 2013, 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[59]  Brian Demsky,et al.  CDSchecker: checking concurrent data structures written with C/C++ atomics , 2013, OOPSLA.

[60]  Ori Lahav,et al.  A Separation Logic for a Promising Semantics , 2018, ESOP.

[61]  Patrice Godefroid,et al.  Dynamic partial-order reduction for model checking software , 2005, POPL '05.

[62]  Salvatore La Torre,et al.  Lazy sequentialization for TSO and PSO via shared memory abstractions , 2016, 2016 Formal Methods in Computer-Aided Design (FMCAD).

[63]  Todd Millstein,et al.  Automatic predicate abstraction of C programs , 2001, PLDI '01.

[64]  Steven M. LaValle,et al.  Planning algorithms , 2006 .

[65]  Thomas A. Henzinger,et al.  The software model checker Blast , 2007, International Journal on Software Tools for Technology Transfer.

[66]  Chakraborty Soham,et al.  Formalizing the concurrency semantics of an LLVM fragment , 2017 .

[67]  Thomas Ball,et al.  Finding and Reproducing Heisenbugs in Concurrent Programs , 2008, OSDI.

[68]  Sylvain Conchon,et al.  Parameterized Model Checking Modulo Explicit Weak Memory Models , 2018, IMPEX/FM&MDD.

[69]  Rajeev Alur,et al.  An Axiomatic Memory Model for POWER Multiprocessors , 2012, CAV.

[70]  Parosh Aziz Abdulla,et al.  Replacing Store Buffers by Load Buffers in TSO , 2018, VECoS.

[71]  Roland Meyer,et al.  Robustness against Power is PSpace-complete , 2014, ICALP.

[72]  Antti Valmari,et al.  Stubborn sets for reduced state space generation , 1991, Applications and Theory of Petri Nets.

[73]  Jeehoon Kang,et al.  A formal C memory model supporting integer-pointer casts , 2015, PLDI.

[74]  Suresh Jagannathan,et al.  Relaxed-memory concurrency and verified compilation , 2011, POPL '11.

[75]  Suresh Jagannathan,et al.  CompCertTSO: A Verified Compiler for Relaxed-Memory Concurrency , 2013, JACM.

[76]  Peter Sewell,et al.  A Better x86 Memory Model: x86-TSO , 2009, TPHOLs.

[77]  Patrice Godefroid,et al.  Model checking for programming languages using VeriSoft , 1997, POPL '97.

[78]  Philippe Schnoebelen,et al.  Well-structured transition systems everywhere! , 2001, Theor. Comput. Sci..

[79]  Roland Meyer,et al.  Robustness against Relaxed Memory Models , 2014, Software Engineering.

[80]  Jeff Huang,et al.  Maximal causality reduction for TSO and PSO , 2016, OOPSLA.

[81]  Leslie Lamport,et al.  How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs , 2016, IEEE Transactions on Computers.

[82]  Viktor Vafeiadis,et al.  Verifying Fence Elimination Optimisations , 2011, SAS.

[83]  Koushik Sen.  DART: Directed Automated Random Testing , 2009, Haifa Verification Conference.

[84]  Jade Alglave,et al.  Understanding POWER multiprocessors , 2011, PLDI '11.

[85]  Sebastian Burckhardt,et al.  What's Decidable about Weak Memory Models? , 2012, ESOP.

[86]  Keijo Heljanko,et al.  Improving Dynamic Partial Order Reductions for Concolic Testing , 2012, 2012 12th International Conference on Application of Concurrency to System Design.

[87]  Koushik Sen,et al.  A Race-Detection and Flipping Algorithm for Automated Testing of Multi-threaded Programs , 2006, Haifa Verification Conference.

[88]  Michael Abrash,et al.  Michael Abrash's Graphics Programming Black Book, with CD: The Complete Works of Graphics Master, Michael Abrash , 1997 .

[89]  Roberto Guanciale,et al.  Machine code verification of a tiny ARM hypervisor , 2013, TrustED '13.

[90]  Jade Alglave,et al.  Herding cats: modelling, simulation, testing, and data-mining for weak memory , 2014, PLDI 2014.

[91]  Mark D. Hill,et al.  A Unified Formalization of Four Shared-Memory Models , 1993, IEEE Trans. Parallel Distributed Syst..

[92]  Francesco Zappa Nardelli,et al.  x86-TSO , 2010, Commun. ACM.

[93]  Ori Lahav,et al.  Taming release-acquire consistency , 2016, POPL.

[94]  Parosh Aziz Abdulla,et al.  Context-Bounded Analysis for POWER , 2017, TACAS.

[95]  Bart Jacobs,et al.  Reasoning about Java classes: preliminary report , 1998, OOPSLA '98.

[96]  Wang Yi,et al.  Uppaal in a nutshell , 1997, International Journal on Software Tools for Technology Transfer.

[97]  Edmund M. Clarke.  SAT-Based Counterexample Guided Abstraction Refinement , 2002, SPIN.

[98]  Patrice Godefroid,et al.  Refining Dependencies Improves Partial-Order Verification Methods (Extended Abstract) , 1993, CAV.

[99]  David A. Patterson,et al.  Computer Architecture - A Quantitative Approach, 5th Edition , 1996 .

[100]  Konstantinos Sagonas,et al.  Stateless model checking of the Linux kernel's hierarchical read-copy-update (tree RCU) , 2017, SPIN.

[101]  Mohamed Faouzi Atig,et al.  Context-Bounded Analysis of TSO Systems , 2014, FPS@ETAPS.

[102]  Jakob Rehof,et al.  Context-Bounded Model Checking of Concurrent Software , 2005, TACAS.

[103]  Parosh Aziz Abdulla,et al.  Stateless Model Checking for POWER , 2016, CAV.

[104]  Daniel Kroening,et al.  A Tool for Checking ANSI-C Programs , 2004, TACAS.

[105]  Parosh Aziz Abdulla,et al.  Stateless Model Checking for TSO and PSO , 2015, TACAS.

[106]  Gary T. Leavens,et al.  Formal Techniques for Java-Like Programs , 2003, ECOOP Workshops.

[107]  Leslie Lamport,et al.  Specifying Systems: The TLA+ Language and Tools for Hardware and Software Engineers [Book Review] , 2002, Computer.

[108]  Doron A. Peled,et al.  All from One, One for All: on Model Checking Using Representatives , 1993, CAV.

[109]  Viktor Vafeiadis,et al.  Validating optimizations of concurrent C/C++ programs , 2016, 2016 IEEE/ACM International Symposium on Code Generation and Optimization (CGO).

[110]  Parosh Aziz Abdulla,et al.  General decidability theorems for infinite-state systems , 1996, Proceedings 11th Annual IEEE Symposium on Logic in Computer Science.

[111]  Jonathan Jacky.  Model-Based Testing with Spec# , 2004, ICFEM.

[112]  Roland Meyer,et al.  Locality and Singularity for Store-Atomic Memory Models , 2017, NETYS.

[113]  Satish Narayanasamy,et al.  A case for an SC-preserving compiler , 2011, PLDI '11.

[114]  Ori Lahav,et al.  On Parallel Snapshot Isolation and Release/Acquire Consistency , 2018, ESOP.

[115]  Salvatore La Torre,et al.  Using Shared Memory Abstractions to Design Eager Sequentializations for Weak Memory Models , 2017, SEFM.

[116]  Shaked Flur,et al.  Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8 , 2017, Proc. ACM Program. Lang..

[117]  Parosh Aziz Abdulla,et al.  Counter-Example Guided Fence Insertion under TSO , 2012, TACAS.

[118]  Parosh Aziz Abdulla,et al.  Deciding Robustness against Total Store Ordering , 2011 .

[119]  Hassen Saïdi,et al.  Construction of Abstract State Graphs with PVS , 1997, CAV.

[120]  Madan Musuvathi,et al.  Iterative context bounding for systematic testing of multithreaded programs , 2007, PLDI '07.

[121]  Krishnendu Chatterjee,et al.  Data-centric dynamic partial order reduction , 2016, Proc. ACM Program. Lang..

[122]  Maurice Herlihy,et al.  The Art of Multiprocessor Programming, Revised Reprint , 2012 .

[123]  G.E. Moore,et al.  Cramming More Components Onto Integrated Circuits , 1998, Proceedings of the IEEE.

[124]  Marieke Huisman,et al.  Provably correct control flow graphs from Java bytecode programs with exceptions , 2016, International Journal on Software Tools for Technology Transfer.

[125]  Parosh Aziz Abdulla,et al.  Optimal dynamic partial order reduction , 2014, POPL.

[126]  Sarfraz Khurshid,et al.  Test input generation with java PathFinder , 2004, ISSTA '04.

[127]  Boris Beizer,et al.  Software testing techniques (2. ed.) , 1990 .

[128]  Parosh Aziz Abdulla,et al.  A Load-Buffer Semantics for Total Store Ordering , 2017, Log. Methods Comput. Sci..

[129]  Antoni W. Mazurkiewicz,et al.  Trace Theory , 1986, Advances in Petri Nets.

[130]  Daniel Kroening,et al.  Software Verification for Weak Memory via Program Transformation , 2012, ESOP.

[131]  Mohamed Faouzi Atig,et al.  Getting Rid of Store-Buffers in TSO Analysis , 2011, CAV.

[132]  Dennis Shasha,et al.  Efficient and correct execution of parallel programs that share memory , 1988, TOPL.

[133]  Scott Owens,et al.  Reasoning about the Implementation of Concurrency Abstractions on x86-TSO , 2010, ECOOP.

[134]  Parosh Aziz Abdulla,et al.  Source Sets , 2017, J. ACM.

[135]  Daniel Kroening,et al.  Don’t Sit on the Fence , 2013, ACM Trans. Program. Lang. Syst..

[136]  Parosh Aziz Abdulla,et al.  The Benefits of Duality in Verifying Concurrent Programs under TSO , 2017, CONCUR.

[137]  Patrice Godefroid,et al.  Software Model Checking: The VeriSoft Approach , 2005, Formal Methods Syst. Des..

[138]  Viktor Vafeiadis,et al.  Relaxed separation logic: a program logic for C11 concurrency , 2013, OOPSLA.

[139]  Kenneth L. McMillan,et al.  Symbolic model checking , 1992 .

[140]  Parosh Aziz Abdulla,et al.  Precise and Sound Automatic Fence Insertion Procedure under PSO , 2015, NETYS.

[141]  Sebastian Burckhardt,et al.  On the verification problem for weak memory models , 2010, POPL '10.

[142]  Parosh Aziz Abdulla,et al.  The Best of Both Worlds: Trading Efficiency and Optimality in Fence Insertion for TSO , 2015, ESOP.

[143]  Changhui Lin.  Imposing Minimal Memory Ordering on Multiprocessors , 2013 .

[144]  Jeff Huang,et al.  Stateless model checking concurrent programs with maximal causality reduction , 2015, PLDI.

[145]  Christel Baier,et al.  Principles of model checking , 2008 .

[146]  Brian Demsky,et al.  A Practical Approach for Model Checking C/C++11 Code , 2016, TOPL.