Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
125 tokens/sec
GPT-4o
47 tokens/sec
Gemini 2.5 Pro Pro
43 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
47 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

WaveCert: Translation Validation for Asynchronous Dataflow Programs via Dynamic Fractional Permissions (2312.09326v2)

Published 14 Dec 2023 in cs.PL and cs.AR

Abstract: Coarse-grained reconfigurable arrays (CGRAs) have gained attention in recent years due to their promising power efficiency compared to traditional von Neumann architectures. To program these architectures using ordinary languages such as C, a dataflow compiler must transform the original sequential, imperative program into an equivalent dataflow graph, composed of dataflow operators running in parallel. This transformation is challenging since the asynchronous nature of dataflow graphs allows out-of-order execution of operators, leading to behaviors not present in the original imperative programs. We address this challenge by developing a translation validation technique for dataflow compilers to ensure that the dataflow program has the same behavior as the original imperative program on all possible inputs and schedules of execution. We apply this method to a state-of-the-art dataflow compiler targeting the RipTide CGRA architecture. Our tool uncovers 8 compiler bugs where the compiler outputs incorrect dataflow graphs, including a data race that is otherwise hard to discover via testing. After repairing these bugs, our tool verifies the correct compilation of all programs in the RipTide benchmark suite.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (51)
  1. Ackerman. 1982. Data Flow Languages. Computer 15, 2 (1982), 15–25. https://doi.org/10.1109/MC.1982.1653938
  2. Dataflow Architectures. Annual Reviews Inc., USA, 225–253.
  3. Franz Baader and Tobias Nipkow. 1998. Term Rewriting and All That. Cambridge University Press, UK. https://doi.org/10.1017/CBO9781139172752
  4. Verifying distributed programs via canonical sequentialization. Proceedings of the ACM on Programming Languages 1 (2017), 1 – 27. https://api.semanticscholar.org/CorpusID:23362468
  5. A Survey of Symbolic Execution Techniques. ACM Comput. Surv. 51, 3, Article 50 (may 2018), 39 pages. https://doi.org/10.1145/3182657
  6. Amar Bouali. 1998. Xeve, an Esterel verification environment. In Computer Aided Verification, Alan J. Hu and Moshe Y. Vardi (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 500–504.
  7. A Formally Verified Compiler for Lustre. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (Barcelona, Spain) (PLDI 2017). Association for Computing Machinery, New York, NY, USA, 586–601. https://doi.org/10.1145/3062341.3062358
  8. John Boyland. 2013. Fractional Permissions. Springer Berlin Heidelberg, Berlin, Heidelberg, 270–288. https://doi.org/10.1007/978-3-642-36946-9_10
  9. Stephen Brookes. 2006. Variables as Resource for Shared-Memory Programs: Semantics and Soundness. Electronic Notes in Theoretical Computer Science 158 (2006), 123–150. https://doi.org/10.1016/j.entcs.2006.04.008 Proceedings of the 22nd Annual Conference on Mathematical Foundations of Programming Semantics (MFPS XXII).
  10. Maude: Specification and programming in rewriting logic. Theoretical Computer Science 285, 2 (2002), 187–243. https://doi.org/10.1016/S0304-3975(01)00359-0 Rewriting Logic and its Applications.
  11. Brad Conte. 2024. Basic implementations of standard cryptography algorithms. https://github.com/B-Con/crypto-algorithms.
  12. Leonardo De Moura and Nikolaj Bjørner. 2008. Z3: An Efficient SMT Solver. In Proceedings of the Theory and Practice of Software, 14th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (Budapest, Hungary) (TACAS’08/ETAPS’08). Springer-Verlag, Berlin, Heidelberg, 337–340.
  13. Jack B. Dennis and David P. Misunas. 1974. A Preliminary Architecture for a Basic Data-Flow Processor. In Proceedings of the 2nd Annual Symposium on Computer Architecture (ISCA ’75). Association for Computing Machinery, New York, NY, USA, 126–132. https://doi.org/10.1145/642089.642111
  14. Ground confluence of order-sorted conditional specifications modulo axioms. Journal of Logical and Algebraic Methods in Programming 111 (2020), 100513. https://doi.org/10.1016/j.jlamp.2019.100513
  15. Kahn Gilles. 1974. The semantics of a simple language for parallel programming. Information processing 74, 471-475 (1974), 15–28.
  16. Snafu: an ultra-low-power, energy-minimal CGRA-generation framework and architecture. In Proceedings of the 48th Annual International Symposium on Computer Architecture (Virtual Event, Spain) (ISCA ’21). IEEE Press, New York, NY, USA, 1027–1040. https://doi.org/10.1109/ISCA52012.2021.00084
  17. RipTide: A Programmable, Energy-Minimal Dataflow Compiler and Architecture. In Proceedings of the 55th Annual IEEE/ACM International Symposium on Microarchitecture (Chicago, Illinois, USA) (MICRO ’22). IEEE Press, New York, NY, USA, 546–564. https://doi.org/10.1109/MICRO56248.2022.00046
  18. PipeRench: A reconfigurable architecture and compiler. Computer 33, 4 (2000), 70–77. https://doi.org/10.1109/2.839324
  19. Paul Govereau. 2012. Denotational Translation Validation. Ph. D. Dissertation. Harvard University, USA. Advisor(s) Morrisett, John G. AAI3495610.
  20. George Hagen and Cesare Tinelli. 2008. Scaling Up the Formal Verification of Lustre Programs with SMT-Based Techniques. In 2008 Formal Methods in Computer-Aided Design. IEEE Press, USA, 1–9. https://doi.org/10.1109/FMCAD.2008.ECP.19
  21. The synchronous data flow programming language LUSTRE. Proc. IEEE 79, 9 (1991), 1305–1320. https://doi.org/10.1109/5.97300
  22. Advances in dataflow programming languages. ACM Comput. Surv. 36, 1 (mar 2004), 1–34. https://doi.org/10.1145/1013208.1013209
  23. Iris from the ground up: A modular foundation for higher-order concurrent separation logic. Journal of Functional Programming 28 (2018), e20. https://doi.org/10.1017/S0956796818000151
  24. Richard M. Karp and Rayamond E. Miller. 1966. Properties of a Model for Parallel Computations: Determinacy, Termination, Queueing. SIAM J. Appl. Math. 14, 6 (1966), 1390–1411. https://doi.org/10.1137/0114108 arXiv:https://doi.org/10.1137/0114108
  25. Language-Parametric Compiler Validation with Application to LLVM. In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (Virtual, USA) (ASPLOS ’21). Association for Computing Machinery, New York, NY, USA, 1004–1019. https://doi.org/10.1145/3445814.3446751
  26. Donald E. Knuth and Peter B. Bendix. 1970. Simple Word Problems in Universal Algebras. In Computational Problems in Abstract Algebra. Pergamon, Oxford, UK, 263–297. https://doi.org/10.1016/B978-0-08-012975-4.50028-X
  27. Inductive sequentialization of asynchronous programs. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (London, UK) (PLDI 2020). Association for Computing Machinery, New York, NY, USA, 227–242. https://doi.org/10.1145/3385412.3385980
  28. Proving Optimizations Correct Using Parameterized Program Equivalence. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (Dublin, Ireland) (PLDI ’09). Association for Computing Machinery, New York, NY, USA, 327–337. https://doi.org/10.1145/1542476.1542513
  29. Leslie Lamport. 2001. Paxos Made Simple. ACM SIGACT News (Distributed Computing Column) 4, 32 (December 2001), 51–58. https://www.microsoft.com/en-us/research/publication/paxos-made-simple/
  30. Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In Proceedings of the International Symposium on Code Generation and Optimization: Feedback-Directed and Runtime Optimization (Palo Alto, California) (CGO ’04). IEEE Computer Society, USA, 75.
  31. Verus: Verifying Rust Programs using Linear Ghost Types. Proc. ACM Program. Lang. 7, OOPSLA1, Article 85 (apr 2023), 30 pages. https://doi.org/10.1145/3586037
  32. Xavier Leroy. 2009. Formal Verification of a Realistic Compiler. Commun. ACM 52, 7 (jul 2009), 107–115. https://doi.org/10.1145/1538788.1538814
  33. GitHub Repository. https://github.com/secure-foundations/riptide-verification.
  34. A Survey of Coarse-Grained Reconfigurable Architecture and Design: Taxonomy, Challenges, and Applications. ACM Comput. Surv. 52, 6, Article 118 (Oct 2019), 39 pages. https://doi.org/10.1145/3357375
  35. LLVM. 2024a. Clang: a C language family frontend for LLVM. https://clang.llvm.org/.
  36. LLVM. 2024b. LLVM Language Reference Manual. https://llvm.org/docs/LangRef.html.
  37. Alive2: Bounded Translation Validation for LLVM. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (Virtual, Canada) (PLDI 2021). Association for Computing Machinery, New York, NY, USA, 65–79. https://doi.org/10.1145/3453483.3454030
  38. Provably Correct Peephole Optimizations with Alive. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation (Portland, OR, USA) (PLDI ’15). Association for Computing Machinery, New York, NY, USA, 22–32. https://doi.org/10.1145/2737924.2737965
  39. Robin Milner. 1999. Communicating and Mobile Systems: The π𝜋\piitalic_π-calculus. Cambridge University Press, United States.
  40. Viper: A Verification Infrastructure for Permission-Based Reasoning. In Verification, Model Checking, and Abstract Interpretation, Barbara Jobstmann and K. Rustan M. Leino (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 41–62.
  41. George C. Necula. 2000. Translation Validation for an Optimizing Compiler. In Proceedings of the ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (Vancouver, British Columbia, Canada) (PLDI ’00). Association for Computing Machinery, New York, NY, USA, 83–94. https://doi.org/10.1145/349299.349314
  42. Translation validation. In Tools and Algorithms for the Construction and Analysis of Systems, Bernhard Steffen (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 151–166.
  43. A. W. Roscoe. 1997. The Theory and Practice of Concurrency. Prentice Hall PTR, USA.
  44. Davide Sangiorgi and David Walker. 2001. PI-Calculus: A Theory of Mobile Processes. Cambridge University Press, USA.
  45. Pipestitch: An energy-minimal dataflow architecture with lightweight threads. In Proceedings of the 56th Annual IEEE/ACM International Symposium on Microarchitecture (Toronto, ON, Canada) (MICRO ’23). Association for Computing Machinery, New York, NY, USA, 1409–1422. https://doi.org/10.1145/3613424.3614283
  46. Data-Driven Equivalence Checking. In Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages & Applications (Indianapolis, Indiana, USA) (OOPSLA ’13). Association for Computing Machinery, New York, NY, USA, 391–406. https://doi.org/10.1145/2509136.2509509
  47. WaveScalar. In Proceedings of the 36th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO 36). IEEE Computer Society, USA, 291.
  48. Equality Saturation: A New Approach to Optimization. In Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Savannah, GA, USA) (POPL ’09). Association for Computing Machinery, New York, NY, USA, 264–276. https://doi.org/10.1145/1480881.1480915
  49. Evaluating Value-Graph Translation Validation for LLVM. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (San Jose, California, USA) (PLDI ’11). Association for Computing Machinery, New York, NY, USA, 295–305. https://doi.org/10.1145/1993498.1993533
  50. Pretend synchrony: synchronous verification of asynchronous distributed programs. Proceedings of the ACM on Programming Languages 3 (2019), 1 – 30. https://api.semanticscholar.org/CorpusID:57757310
  51. Hybrid Dataflow/von-Neumann Architectures. IEEE Transactions on Parallel and Distributed Systems 25, 6 (2014), 1489–1509. https://doi.org/10.1109/TPDS.2013.125

Summary

We haven't generated a summary for this paper yet.

Ai Sparkles Streamline Icon: https://streamlinehq.com Summarize Now