CCICheck: Using μhb graphs to verify the coherence-consistency interface

In parallel systems, memory consistency models and cache coherence protocols establish the rules specifying which values will be visible to each instruction of parallel programs. Despite their central importance, verifying their correctness has remained a major challenge, due both to informal or incomplete specifications and to difficulties in scaling verification to cover their operations comprehensively. While coherence and consistency are often specified and verified independently at an architectural level, many systems implement performance enhancements that tightly interweave coherence and consistency at a micro architectural level in ways that make verification of consistency difficult. This paper introduces CCICheck, a tool and technique supporting static verification of the coherence-consistency interface (CCI). CCICheck enumerates and checks families of micro architectural happens-before (μhb) graphs that describe how a particular coherence protocol combines with a particular processor's pipelines and memory hierarchy to enforce the requirements of a given consistency model. To support tractable CCI verification, CCICheck introduces the ViCL (Value in Cache Lifetime), an abstraction which allows the μhb graphs to cleanly represent CCI events relevant to consistency verification, including demand fetching, cache line invalidation, coherence protocol windows of vulnerability, and partially incoherent cache hierarchies. We implement CCICheck as an automated tool and demonstrate its use on a number of case studies. We also show its tractability across a wide range of litmus tests.

[1]  Thomas J. Ashby,et al.  Software-Based Cache Coherence with Hardware-Assisted Selective Self-Invalidations Using Bloom Filters , 2011, IEEE Transactions on Computers.

[2]  Yue Yang,et al.  Analyzing the Intel Itanium Memory Ordering Rules Using Logic Programming and SAT , 2003, CHARME.

[3]  Michel Dubois,et al.  Memory access buffering in multiprocessors , 1998, ISCA '98.

[4]  Francesco Zappa Nardelli,et al.  The semantics of power and ARM multiprocessor machine code , 2009, DAMP '09.

[5]  Albert Meixner,et al.  Dynamic Verification of Memory Consistency in Cache-Coherent Multithreaded Computer Architectures , 2009, IEEE Transactions on Dependable and Secure Computing.

[6]  Allon Adir,et al.  Information-Flow Models for Shared Memory with an Application to the PowerPC Architecture , 2003, IEEE Trans. Parallel Distributed Syst..

[7]  Milo M. K. Martin,et al.  Formal verification and its impact on the snooping versus directory protocol debate , 2005, 2005 International Conference on Computer Design.

[8]  Arvind,et al.  Memory Model = Instruction Reordering + Store Atomicity , 2006, 33rd International Symposium on Computer Architecture (ISCA'06).

[9]  Ricardo Bianchini,et al.  Lazy Release Consistency for Hardware-Coherent Multiprocessors , 1995, Proceedings of the IEEE/ACM SC95 Conference.

[10]  Jade Alglave,et al.  Fences in Weak Memory Models , 2010, CAV.

[11]  Meng Zhang,et al.  Fractal Consistency: Architecting the Memory System to Facilitate Verification , 2010, IEEE Computer Architecture Letters.

[12]  Sridhar Narayanan,et al.  TSOtool: a program for verifying memory systems using the memory consistency model , 2004, Proceedings. 31st Annual International Symposium on Computer Architecture, 2004..

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

[14]  Somesh Jha,et al.  Verification of the Futurebus+ cache coherence protocol , 1993, Formal Methods Syst. Des..

[15]  Christine Paulin-Mohring,et al.  The coq proof assistant reference manual , 2000 .

[16]  Richard L. Sites,et al.  Alpha Architecture Reference Manual , 1995 .

[17]  David A. Wood,et al.  A Primer on Memory Consistency and Cache Coherence , 2012, Synthesis Lectures on Computer Architecture.

[18]  Margaret Martonosi,et al.  PipeCheck: Specifying and Verifying Microarchitectural Enforcement of Memory Consistency Models , 2014, 2014 47th Annual IEEE/ACM International Symposium on Microarchitecture.

[19]  David L Weaver,et al.  The SPARC architecture manual : version 9 , 1994 .

[20]  Anoop Gupta,et al.  Memory consistency and event ordering in scalable shared-memory multiprocessors , 1990, [1990] Proceedings. The 17th Annual International Symposium on Computer Architecture.

[21]  Jade Alglave,et al.  A formal hierarchy of weak memory models , 2012, Formal Methods in System Design.

[22]  Margaret Martonosi,et al.  Verifying Correct Microarchitectural Enforcement of Memory Consistency Models , 2015, IEEE Micro.

[23]  Anant Agarwal,et al.  Closing the window of vulnerability in multiphase memory transactions , 1992, ASPLOS V.

[24]  Francesco Zappa Nardelli,et al.  The semantics of power and ARM multiprocessor machine code (abstract only) , 2009, SIGP.

[25]  Stefanos Kaxiras,et al.  Complexity-effective multicore coherence , 2012, 2012 21st International Conference on Parallel Architectures and Compilation Techniques (PACT).

[26]  Kenneth L. McMillan,et al.  Parameterized Verification of the FLASH Cache Coherence Protocol by Compositional Model Checking , 2001, CHARME.

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

[28]  James R. Goodman,et al.  Cache Consistency and Sequential Consistency , 1991 .

[29]  Francisco Corella,et al.  Specification of the powerpc shared memory architecture , 1993 .

[30]  Anoop Gupta,et al.  Two Techniques to Enhance the Performance of Memory Consistency Models , 1991, ICPP.

[31]  Mark D. Hill,et al.  Weak ordering—a new definition , 1998, ISCA '98.

[32]  No License,et al.  Intel ® 64 and IA-32 Architectures Software Developer ’ s Manual Volume 3 A : System Programming Guide , Part 1 , 2006 .

[33]  Sarita V. Adve,et al.  DeNovo: Rethinking the Memory Hierarchy for Disciplined Parallelism , 2011, 2011 International Conference on Parallel Architectures and Compilation Techniques.

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

[35]  Vijay Nagarajan,et al.  TSO-CC: Consistency directed cache coherence for TSO , 2014, 2014 IEEE 20th International Symposium on High Performance Computer Architecture (HPCA).

[36]  Ganesh Gopalakrishnan,et al.  GPU Concurrency: Weak Behaviours and Programming Assumptions , 2015, ASPLOS.

[37]  Meng Zhang,et al.  PVCoherence: Designing flat coherence protocols for scalable verification , 2014, 2014 IEEE 20th International Symposium on High Performance Computer Architecture (HPCA).

[38]  Meng Zhang,et al.  Fractal Coherence: Scalably Verifiable Cache Coherence , 2010, 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture.

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

[40]  Harry D. Foster.  Trends in functional verification: A 2014 industry study , 2015, 2015 52nd ACM/EDAC/IEEE Design Automation Conference (DAC).

[41]  Robert Sims,et al.  Alpha architecture reference manual , 1992 .