首页 > 最新文献

Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation最新文献

英文 中文
BLeak: automatically debugging memory leaks in web applications 暗淡:自动调试web应用程序的内存泄漏
J. Vilk, E. Berger
Despite the presence of garbage collection in managed languages like JavaScript, memory leaks remain a serious problem. In the context of web applications, these leaks are especially pervasive and difficult to debug. Web application memory leaks can take many forms, including failing to dispose of unneeded event listeners, repeatedly injecting iframes and CSS files, and failing to call cleanup routines in third-party libraries. Leaks degrade responsiveness by increasing GC frequency and overhead, and can even lead to browser tab crashes by exhausting available memory. Because previous leak detection approaches designed for conventional C, C++ or Java applications are ineffective in the browser environment, tracking down leaks currently requires intensive manual effort by web developers. This paper introduces BLeak (Browser Leak debugger), the first system for automatically debugging memory leaks in web applications. BLeak's algorithms leverage the observation that in modern web applications, users often repeatedly return to the same (approximate) visual state (e.g., the inbox view in Gmail). Sustained growth between round trips is a strong indicator of a memory leak. To use BLeak, a developer writes a short script (17-73 LOC on our benchmarks) to drive a web application in round trips to the same visual state. BLeak then automatically generates a list of leaks found along with their root causes, ranked by return on investment. Guided by BLeak, we identify and fix over 50 memory leaks in popular libraries and apps including Airbnb, AngularJS, Google Analytics, Google Maps SDK, and jQuery. BLeak's median precision is 100%; fixing the leaks it identifies reduces heap growth by an average of 94%, saving from 0.5 MB to 8 MB per round trip. We believe BLeak's approach to be broadly applicable beyond web applications, including to GUI applications on desktop and mobile platforms.
尽管在JavaScript等托管语言中存在垃圾收集,但内存泄漏仍然是一个严重的问题。在web应用程序的上下文中,这些泄漏尤其普遍且难以调试。Web应用程序内存泄漏有多种形式,包括未能处理不需要的事件侦听器、反复注入iframe和CSS文件,以及未能调用第三方库中的清理例程。泄漏会增加GC频率和开销,从而降低响应性,甚至会耗尽可用内存,导致浏览器选项卡崩溃。由于以前为传统的C、c++或Java应用程序设计的泄漏检测方法在浏览器环境中是无效的,因此目前跟踪泄漏需要web开发人员进行大量的手工工作。本文介绍了Browser Leak debugger(浏览器泄漏调试器),这是第一个自动调试web应用程序内存泄漏的系统。萧普的算法利用了在现代网络应用中,用户经常反复返回到相同(近似)的视觉状态(例如,Gmail的收件箱视图)的观察结果。往返之间的持续增长是内存泄漏的强烈指示。要使用暗淡,开发人员需要编写一个简短的脚本(在我们的基准测试中是17-73 LOC)来驱动web应用程序往返于相同的视觉状态。然后,萧普会自动生成一份泄漏列表,以及它们的根本原因,并根据投资回报率进行排名。在BLeak的指导下,我们在流行的库和应用程序中识别并修复了50多个内存泄漏,包括Airbnb、AngularJS、Google Analytics、Google Maps SDK和jQuery。萧普的中位数精度是100%;修复它所识别的泄漏可以平均减少94%的堆增长,每次往返节省0.5 MB到8 MB。我们相信,萧普的方法将广泛适用于web应用之外的领域,包括桌面和移动平台上的GUI应用。
{"title":"BLeak: automatically debugging memory leaks in web applications","authors":"J. Vilk, E. Berger","doi":"10.1145/3192366.3192376","DOIUrl":"https://doi.org/10.1145/3192366.3192376","url":null,"abstract":"Despite the presence of garbage collection in managed languages like JavaScript, memory leaks remain a serious problem. In the context of web applications, these leaks are especially pervasive and difficult to debug. Web application memory leaks can take many forms, including failing to dispose of unneeded event listeners, repeatedly injecting iframes and CSS files, and failing to call cleanup routines in third-party libraries. Leaks degrade responsiveness by increasing GC frequency and overhead, and can even lead to browser tab crashes by exhausting available memory. Because previous leak detection approaches designed for conventional C, C++ or Java applications are ineffective in the browser environment, tracking down leaks currently requires intensive manual effort by web developers. This paper introduces BLeak (Browser Leak debugger), the first system for automatically debugging memory leaks in web applications. BLeak's algorithms leverage the observation that in modern web applications, users often repeatedly return to the same (approximate) visual state (e.g., the inbox view in Gmail). Sustained growth between round trips is a strong indicator of a memory leak. To use BLeak, a developer writes a short script (17-73 LOC on our benchmarks) to drive a web application in round trips to the same visual state. BLeak then automatically generates a list of leaks found along with their root causes, ranked by return on investment. Guided by BLeak, we identify and fix over 50 memory leaks in popular libraries and apps including Airbnb, AngularJS, Google Analytics, Google Maps SDK, and jQuery. BLeak's median precision is 100%; fixing the leaks it identifies reduces heap growth by an average of 94%, saving from 0.5 MB to 8 MB per round trip. We believe BLeak's approach to be broadly applicable beyond web applications, including to GUI applications on desktop and mobile platforms.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"10 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"87097867","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 22
Partial control-flow linearization 部分控制流线性化
Simon Moll, Sebastian Hack
If-conversion is a fundamental technique for vectorization. It accounts for the fact that in a SIMD program, several targets of a branch might be executed because of divergence. Especially for irregular data-parallel workloads, it is crucial to avoid if-converting non-divergent branches to increase SIMD utilization. In this paper, we present partial linearization, a simple and efficient if-conversion algorithm that overcomes several limitations of existing if-conversion techniques. In contrast to prior work, it has provable guarantees on which non-divergent branches are retained and will never duplicate code or insert additional branches. We show how our algorithm can be used in a classic loop vectorizer as well as to implement data-parallel languages such as ISPC or OpenCL. Furthermore, we implement prior vectorizer optimizations on top of partial linearization in a more general way. We evaluate the implementation of our algorithm in LLVM on a range of irregular data analytics kernels, a neutronics simulation benchmark and NAB, a molecular dynamics benchmark from SPEC2017 on AVX2, AVX512, and ARM Advanced SIMD machines and report speedups of up to 146 % over ICC, GCC and Clang O3.
if转换是向量化的基本技术。它解释了这样一个事实,即在SIMD程序中,分支的几个目标可能因为分歧而被执行。特别是对于不规则的数据并行工作负载,避免if转换非发散分支以增加SIMD利用率是至关重要的。在本文中,我们提出了部分线性化,一种简单而有效的中频转换算法,克服了现有中频转换技术的几个局限性。与之前的工作相比,它具有可证明的保证,可以保留非发散的分支,并且永远不会复制代码或插入额外的分支。我们展示了如何在经典的循环矢量器中使用我们的算法,以及如何实现数据并行语言,如ISPC或OpenCL。此外,我们以更一般的方式在部分线性化的基础上实现了先验矢量器优化。我们在一系列不规则数据分析内核上评估了我们的算法在LLVM中的实现,其中包括一个中子模拟基准和NAB(来自AVX2, AVX512和ARM Advanced SIMD机器上的SPEC2017的分子动力学基准),并报告了比ICC, GCC和Clang O3的速度高达146%。
{"title":"Partial control-flow linearization","authors":"Simon Moll, Sebastian Hack","doi":"10.1145/3192366.3192413","DOIUrl":"https://doi.org/10.1145/3192366.3192413","url":null,"abstract":"If-conversion is a fundamental technique for vectorization. It accounts for the fact that in a SIMD program, several targets of a branch might be executed because of divergence. Especially for irregular data-parallel workloads, it is crucial to avoid if-converting non-divergent branches to increase SIMD utilization. In this paper, we present partial linearization, a simple and efficient if-conversion algorithm that overcomes several limitations of existing if-conversion techniques. In contrast to prior work, it has provable guarantees on which non-divergent branches are retained and will never duplicate code or insert additional branches. We show how our algorithm can be used in a classic loop vectorizer as well as to implement data-parallel languages such as ISPC or OpenCL. Furthermore, we implement prior vectorizer optimizations on top of partial linearization in a more general way. We evaluate the implementation of our algorithm in LLVM on a range of irregular data analytics kernels, a neutronics simulation benchmark and NAB, a molecular dynamics benchmark from SPEC2017 on AVX2, AVX512, and ARM Advanced SIMD machines and report speedups of up to 146 % over ICC, GCC and Clang O3.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"24 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"72894933","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 33
Advanced automata-based algorithms for program termination checking 先进的基于自动机的程序终止检查算法
Yu-Fang Chen, Matthias Heizmann, Ondřej Lengál, Yong Li, M. Tsai, Andrea Turrini, Lijun Zhang
In 2014, Heizmann et al. proposed a novel framework for program termination analysis. The analysis starts with a termination proof of a sample path. The path is generalized to a Büchi automaton (BA) whose language (by construction) represents a set of terminating paths. All these paths can be safely removed from the program. The removal of paths is done using automata difference, implemented via BA complementation and intersection. The analysis constructs in this way a set of BAs that jointly "cover" the behavior of the program, thus proving its termination. An implementation of the approach in Ultimate Automizer won the 1st place in the Termination category of SV-COMP 2017. In this paper, we exploit advanced automata-based algorithms and propose several non-trivial improvements of the framework. To alleviate the complementation computation for BAs---one of the most expensive operations in the framework---, we propose a multi-stage generalization construction. We start with generalizations producing subclasses of BAs (such as deterministic BAs) for which efficient complementation algorithms are known, and proceed to more general classes only if necessary. Particularly, we focus on the quite expressive subclass of semideterministic BAs and provide an improved complementation algorithm for this class. Our experimental evaluation shows that the proposed approach significantly improves the power of termination checking within the Ultimate Automizer framework.
2014年,Heizmann等人提出了一个新的程序终止分析框架。分析从样本路径的终止证明开始。该路径被推广为一个自动机(BA),其语言(通过构造)表示一组终止路径。所有这些路径都可以安全地从程序中删除。路径的移除是使用自动差分来完成的,通过BA互补和交集来实现。分析以这种方式构建了一组ba,这些ba共同“覆盖”了程序的行为,从而证明了程序的终止。该方法在Ultimate Automizer中的实现获得了2017年SV-COMP终止类的第一名。在本文中,我们利用先进的基于自动机的算法,并提出了框架的几个重要改进。为了减轻框架中最昂贵的操作之一ba的互补计算,我们提出了一种多阶段泛化构造。我们从生成已知有效互补算法的ba(如确定性ba)子类的泛化开始,并仅在必要时进行更一般的类。特别地,我们重点研究了半确定性ba的极具表现力的子类,并为该类提供了一种改进的互补算法。我们的实验评估表明,所提出的方法显着提高了最终自动化框架内的终止检查能力。
{"title":"Advanced automata-based algorithms for program termination checking","authors":"Yu-Fang Chen, Matthias Heizmann, Ondřej Lengál, Yong Li, M. Tsai, Andrea Turrini, Lijun Zhang","doi":"10.1145/3192366.3192405","DOIUrl":"https://doi.org/10.1145/3192366.3192405","url":null,"abstract":"In 2014, Heizmann et al. proposed a novel framework for program termination analysis. The analysis starts with a termination proof of a sample path. The path is generalized to a Büchi automaton (BA) whose language (by construction) represents a set of terminating paths. All these paths can be safely removed from the program. The removal of paths is done using automata difference, implemented via BA complementation and intersection. The analysis constructs in this way a set of BAs that jointly \"cover\" the behavior of the program, thus proving its termination. An implementation of the approach in Ultimate Automizer won the 1st place in the Termination category of SV-COMP 2017. In this paper, we exploit advanced automata-based algorithms and propose several non-trivial improvements of the framework. To alleviate the complementation computation for BAs---one of the most expensive operations in the framework---, we propose a multi-stage generalization construction. We start with generalizations producing subclasses of BAs (such as deterministic BAs) for which efficient complementation algorithms are known, and proceed to more general classes only if necessary. Particularly, we focus on the quite expressive subclass of semideterministic BAs and provide an improved complementation algorithm for this class. Our experimental evaluation shows that the proposed approach significantly improves the power of termination checking within the Ultimate Automizer framework.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"26 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"75901012","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 35
Certified concurrent abstraction layers 认证并发抽象层
Ronghui Gu, Zhong Shao, Jieung Kim, Xiongnan Wu, Jérémie Koenig, Vilhelm Sjöberg, Hao Chen, D. Costanzo, T. Ramananandro
Concurrent abstraction layers are ubiquitous in modern computer systems because of the pervasiveness of multithreaded programming and multicore hardware. Abstraction layers are used to hide the implementation details (e.g., fine-grained synchronization) and reduce the complex dependencies among components at different levels of abstraction. Despite their obvious importance, concurrent abstraction layers have not been treated formally. This severely limits the applicability of layer-based techniques and makes it difficult to scale verification across multiple concurrent layers. In this paper, we present CCAL---a fully mechanized programming toolkit developed under the CertiKOS project---for specifying, composing, compiling, and linking certified concurrent abstraction layers. CCAL consists of three technical novelties: a new game-theoretical, strategy-based compositional semantic model for concurrency (and its associated program verifiers), a set of formal linking theorems for composing multithreaded and multicore concurrent layers, and a new CompCertX compiler that supports certified thread-safe compilation and linking. The CCAL toolkit is implemented in Coq and supports layered concurrent programming in both C and assembly. It has been successfully applied to build a fully certified concurrent OS kernel with fine-grained locking.
由于多线程编程和多核硬件的普及,并发抽象层在现代计算机系统中无处不在。抽象层用于隐藏实现细节(例如,细粒度同步),并减少不同抽象级别的组件之间的复杂依赖关系。尽管并发抽象层的重要性显而易见,但它们并没有得到正式的处理。这严重限制了基于层的技术的适用性,并使跨多个并发层扩展验证变得困难。在本文中,我们介绍了CCAL——一个在CertiKOS项目下开发的完全机械化的编程工具包——用于指定、组合、编译和链接认证并发抽象层。CCAL由三个技术创新组成:一个新的博弈论,基于策略的并发组合语义模型(及其相关的程序验证器),一组用于组合多线程和多核并发层的正式链接定理,以及一个新的支持经过认证的线程安全编译和链接的CompCertX编译器。CCAL工具包是用Coq实现的,支持C语言和汇编语言的分层并发编程。它已经成功地应用于构建具有细粒度锁定的完全认证的并发操作系统内核。
{"title":"Certified concurrent abstraction layers","authors":"Ronghui Gu, Zhong Shao, Jieung Kim, Xiongnan Wu, Jérémie Koenig, Vilhelm Sjöberg, Hao Chen, D. Costanzo, T. Ramananandro","doi":"10.1145/3192366.3192381","DOIUrl":"https://doi.org/10.1145/3192366.3192381","url":null,"abstract":"Concurrent abstraction layers are ubiquitous in modern computer systems because of the pervasiveness of multithreaded programming and multicore hardware. Abstraction layers are used to hide the implementation details (e.g., fine-grained synchronization) and reduce the complex dependencies among components at different levels of abstraction. Despite their obvious importance, concurrent abstraction layers have not been treated formally. This severely limits the applicability of layer-based techniques and makes it difficult to scale verification across multiple concurrent layers. In this paper, we present CCAL---a fully mechanized programming toolkit developed under the CertiKOS project---for specifying, composing, compiling, and linking certified concurrent abstraction layers. CCAL consists of three technical novelties: a new game-theoretical, strategy-based compositional semantic model for concurrency (and its associated program verifiers), a set of formal linking theorems for composing multithreaded and multicore concurrent layers, and a new CompCertX compiler that supports certified thread-safe compilation and linking. The CCAL toolkit is implemented in Coq and supports layered concurrent programming in both C and assembly. It has been successfully applied to build a fully certified concurrent OS kernel with fine-grained locking.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"122 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"87974004","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 74
Typed closure conversion for the calculus of constructions 构造演算的类型化闭包转换
W. J. Bowman, Amal J. Ahmed
Dependently typed languages such as Coq are used to specify and verify the full functional correctness of source programs. Type-preserving compilation can be used to preserve these specifications and proofs of correctness through compilation into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In essence, the problem is that dependent type systems are designed around high-level compositional abstractions to decide type checking, but compilation interferes with the type-system rules for reasoning about run-time terms. We develop a type-preserving closure-conversion translation from the Calculus of Constructions (CC) with strong dependent pairs (Σ types)—a subset of the core language of Coq—to a type-safe, dependently typed compiler intermediate language named CC-CC. The central challenge in this work is how to translate the source type-system rules for reasoning about functions into target type-system rules for reasoning about closures. To justify these rules, we prove soundness of CC-CC by giving a model in CC. In addition to type preservation, we prove correctness of separate compilation.
依赖类型语言(如Coq)用于指定和验证源程序的完整功能正确性。通过编译生成的目标语言程序,可以使用保类型编译来保留这些规范和正确性证明。不幸的是,依赖类型的类型保持编译是困难的。本质上,问题在于依赖类型系统是围绕高级组合抽象设计的,以决定类型检查,但是编译会干扰用于推断运行时术语的类型系统规则。我们开发了一种类型保持的闭包转换转换,从具有强依赖对(Σ类型)的构造演算(CC) - coq的核心语言的一个子集-到类型安全的,依赖类型的编译器中间语言CC-CC。这项工作的核心挑战是如何将用于推理函数的源类型系统规则转换为用于推理闭包的目标类型系统规则。为了证明这些规则的正确性,我们在CC中给出了一个模型,证明了CC-CC的合理性,并证明了单独编译的正确性。
{"title":"Typed closure conversion for the calculus of constructions","authors":"W. J. Bowman, Amal J. Ahmed","doi":"10.1145/3192366.3192372","DOIUrl":"https://doi.org/10.1145/3192366.3192372","url":null,"abstract":"Dependently typed languages such as Coq are used to specify and verify the full functional correctness of source programs. Type-preserving compilation can be used to preserve these specifications and proofs of correctness through compilation into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In essence, the problem is that dependent type systems are designed around high-level compositional abstractions to decide type checking, but compilation interferes with the type-system rules for reasoning about run-time terms. We develop a type-preserving closure-conversion translation from the Calculus of Constructions (CC) with strong dependent pairs (Σ types)—a subset of the core language of Coq—to a type-safe, dependently typed compiler intermediate language named CC-CC. The central challenge in this work is how to translate the source type-system rules for reasoning about functions into target type-system rules for reasoning about closures. To justify these rules, we prove soundness of CC-CC by giving a model in CC. In addition to type preservation, we prove correctness of separate compilation.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"67 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"86057650","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 10
Guarded impredicative polymorphism 保护谓词多态性
A. Serrano, Jurriaan Hage, Dimitrios Vytiniotis, S. P. Jones
The design space for type systems that support impredicative instantiation is extremely complicated. One needs to strike a balance between expressiveness, simplicity for both the end programmer and the type system implementor, and how easily the system can be integrated with other advanced type system concepts. In this paper, we propose a new point in the design space, which we call guarded impredicativity. Its key idea is that impredicative instantiation in an application is allowed for type variables that occur under a type constructor. The resulting type system has a clean declarative specification — making it easy for programmers to predict what will type and what will not —, allows for a smooth integration with GHC’s OutsideIn(X) constraint solving framework, while giving up very little in terms of expressiveness compared to systems like HMF, HML, FPH and MLF. We give a sound and complete inference algorithm, and prove a principal type property for our system.
支持预估实例化的类型系统的设计空间极其复杂。需要在表达性、最终程序员和类型系统实现者的简单性以及系统与其他高级类型系统概念集成的容易程度之间取得平衡。在本文中,我们提出了一个新的设计空间点,我们称之为保护不可预测性。它的关键思想是允许应用程序中的预判实例化出现在类型构造函数下的类型变量。最终的类型系统有一个清晰的声明性规范——使程序员可以很容易地预测什么类型可以输入,什么类型不可以输入——允许与GHC的OutsideIn(X)约束求解框架顺利集成,同时与HMF、HML、FPH和MLF等系统相比,在表达性方面放弃的很少。我们给出了一个完善的推理算法,并证明了系统的一个主类型性质。
{"title":"Guarded impredicative polymorphism","authors":"A. Serrano, Jurriaan Hage, Dimitrios Vytiniotis, S. P. Jones","doi":"10.1145/3192366.3192389","DOIUrl":"https://doi.org/10.1145/3192366.3192389","url":null,"abstract":"The design space for type systems that support impredicative instantiation is extremely complicated. One needs to strike a balance between expressiveness, simplicity for both the end programmer and the type system implementor, and how easily the system can be integrated with other advanced type system concepts. In this paper, we propose a new point in the design space, which we call guarded impredicativity. Its key idea is that impredicative instantiation in an application is allowed for type variables that occur under a type constructor. The resulting type system has a clean declarative specification — making it easy for programmers to predict what will type and what will not —, allows for a smooth integration with GHC’s OutsideIn(X) constraint solving framework, while giving up very little in terms of expressiveness compared to systems like HMF, HML, FPH and MLF. We give a sound and complete inference algorithm, and prove a principal type property for our system.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"57 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"76672015","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 22
A data-driven CHC solver 数据驱动的CHC求解器
He Zhu, Stephen Magill, S. Jagannathan
We present a data-driven technique to solve Constrained Horn Clauses (CHCs) that encode verification conditions of programs containing unconstrained loops and recursions. Our CHC solver neither constrains the search space from which a predicate's components are inferred (e.g., by constraining the number of variables or the values of coefficients used to specify an invariant), nor fixes the shape of the predicate itself (e.g., by bounding the number and kind of logical connectives). Instead, our approach is based on a novel machine learning-inspired tool chain that synthesizes CHC solutions in terms of arbitrary Boolean combinations of unrestricted atomic predicates. A CEGAR-based verification loop inside the solver progressively samples representative positive and negative data from recursive CHCs, which is fed to the machine learning tool chain. Our solver is implemented as an LLVM pass in the SeaHorn verification framework and has been used to successfully verify a large number of nontrivial and challenging C programs from the literature and well-known benchmark suites (e.g., SV-COMP).
我们提出了一种数据驱动技术来解决包含无约束循环和递归的程序的验证条件编码的约束角子句(CHCs)。我们的CHC求解器既不限制推断谓词组件的搜索空间(例如,通过限制变量的数量或用于指定不变量的系数值),也不固定谓词本身的形状(例如,通过限制逻辑连接词的数量和类型)。相反,我们的方法是基于一种新颖的机器学习启发的工具链,它根据不受限制的原子谓词的任意布尔组合来合成CHC解决方案。求解器内部基于cegar的验证循环逐步从递归chc中采样具有代表性的正数据和负数据,这些数据被馈送到机器学习工具链。我们的求解器在SeaHorn验证框架中作为LLVM通道实现,并已被用于成功验证大量来自文献和知名基准套件(例如SV-COMP)的重要且具有挑战性的C程序。
{"title":"A data-driven CHC solver","authors":"He Zhu, Stephen Magill, S. Jagannathan","doi":"10.1145/3192366.3192416","DOIUrl":"https://doi.org/10.1145/3192366.3192416","url":null,"abstract":"We present a data-driven technique to solve Constrained Horn Clauses (CHCs) that encode verification conditions of programs containing unconstrained loops and recursions. Our CHC solver neither constrains the search space from which a predicate's components are inferred (e.g., by constraining the number of variables or the values of coefficients used to specify an invariant), nor fixes the shape of the predicate itself (e.g., by bounding the number and kind of logical connectives). Instead, our approach is based on a novel machine learning-inspired tool chain that synthesizes CHC solutions in terms of arbitrary Boolean combinations of unrestricted atomic predicates. A CEGAR-based verification loop inside the solver progressively samples representative positive and negative data from recursive CHCs, which is fed to the machine learning tool chain. Our solver is implemented as an LLVM pass in the SeaHorn verification framework and has been used to successfully verify a large number of nontrivial and challenging C programs from the literature and well-known benchmark suites (e.g., SV-COMP).","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"333 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"80571432","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 58
VeriPhy: verified controller executables from verified cyber-physical system models VeriPhy:从经过验证的网络物理系统模型中验证的控制器可执行文件
Brandon Bohrer, Yong Kiam Tan, Stefan Mitsch, Magnus O. Myreen, André Platzer
We present VeriPhy, a verified pipeline which automatically transforms verified high-level models of safety-critical cyber-physical systems (CPSs) in differential dynamic logic (dL) to verified controller executables. VeriPhy proves that all safety results are preserved end-to-end as it bridges abstraction gaps, including: i) the gap between mathematical reals in physical models and machine arithmetic in the implementation, ii) the gap between real physics and its differential-equation models, and iii) the gap between nondeterministic controller models and machine code. VeriPhy reduces CPS safety to the faithfulness of the physical environment, which is checked at runtime by synthesized, verified monitors. We use three provers in this effort: KeYmaera X, HOL4, and Isabelle/HOL. To minimize the trusted base, we cross-verify KeYmaeraX in Isabelle/HOL. We evaluate the resulting controller and monitors on commodity robotics hardware.
我们提出了VeriPhy,一个经过验证的管道,它可以自动将差分动态逻辑(dL)中安全关键网络物理系统(cps)的经过验证的高级模型转换为经过验证的控制器可执行文件。VeriPhy证明,所有的安全结果都是端到端保存的,因为它弥合了抽象的差距,包括:i)物理模型中的数学实数与实现中的机器算法之间的差距,ii)真实物理与其微分方程模型之间的差距,以及iii)不确定性控制器模型与机器码之间的差距。VeriPhy将CPS安全性降低到物理环境的可靠性,在运行时由合成的、经过验证的监视器进行检查。我们在此工作中使用了三个证明器:KeYmaera X、HOL4和Isabelle/HOL。为了最小化可信基础,我们在Isabelle/HOL中交叉验证KeYmaeraX。我们在商用机器人硬件上评估由此产生的控制器和监视器。
{"title":"VeriPhy: verified controller executables from verified cyber-physical system models","authors":"Brandon Bohrer, Yong Kiam Tan, Stefan Mitsch, Magnus O. Myreen, André Platzer","doi":"10.1145/3192366.3192406","DOIUrl":"https://doi.org/10.1145/3192366.3192406","url":null,"abstract":"We present VeriPhy, a verified pipeline which automatically transforms verified high-level models of safety-critical cyber-physical systems (CPSs) in differential dynamic logic (dL) to verified controller executables. VeriPhy proves that all safety results are preserved end-to-end as it bridges abstraction gaps, including: i) the gap between mathematical reals in physical models and machine arithmetic in the implementation, ii) the gap between real physics and its differential-equation models, and iii) the gap between nondeterministic controller models and machine code. VeriPhy reduces CPS safety to the faithfulness of the physical environment, which is checked at runtime by synthesized, verified monitors. We use three provers in this effort: KeYmaera X, HOL4, and Isabelle/HOL. To minimize the trusted base, we cross-verify KeYmaeraX in Isabelle/HOL. We evaluate the resulting controller and monitors on commodity robotics hardware.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"47 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"76874127","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 73
Ryū: fast float-to-string conversion ryya:快速浮点到字符串的转换
Ulf Adams
We present Ryū, a new routine to convert binary floating point numbers to their decimal representations using only fixed-size integer operations, and prove its correctness. Ryū is simpler and approximately three times faster than the previously fastest implementation.
我们给出了ryui,一个仅使用固定大小的整数操作将二进制浮点数转换为十进制表示的新例程,并证明了它的正确性。ryyo比以前最快的实现更简单,大约快三倍。
{"title":"Ryū: fast float-to-string conversion","authors":"Ulf Adams","doi":"10.1145/3192366.3192369","DOIUrl":"https://doi.org/10.1145/3192366.3192369","url":null,"abstract":"We present Ryū, a new routine to convert binary floating point numbers to their decimal representations using only fixed-size integer operations, and prove its correctness. Ryū is simpler and approximately three times faster than the previously fastest implementation.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"21 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"80034005","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 6
To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries 对多还是对一?一体化!具有类型异构哈希尝试的高效纯功能多映射
M. Steindorfer, J. Vinju
An immutable multi-map is a many-to-many map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in compilers, runtimes of programming languages, or in static analysis of object-oriented systems. Collection data structures are assumed to carefully balance execution time of operations with memory consumption characteristics and need to scale gracefully from a few elements to multiple gigabytes at least. When processing larger in-memory data sets the overhead of the data structure encoding itself becomes a memory usage bottleneck, dominating the overall performance. In this paper we propose AXIOM, a novel hash-trie data structure that allows for a highly efficient and type-safe multi-map encoding by distinguishing inlined values of singleton sets from nested sets of multi-mappings. AXIOM strictly generalizes over previous hash-trie data structures by supporting the processing of fine-grained type-heterogeneous content on the implementation level (while API and language support for type-heterogeneity are not scope of this paper). We detail the design and optimizations of AXIOM and further compare it against state-of-the-art immutable maps and multi-maps in Java, Scala and Clojure. We isolate key differences using microbenchmarks and validate the resulting conclusions on a case study in static analysis. AXIOM reduces the key-value storage overhead by 1.87x; with specializing and inlining across collection boundaries it improves by 5.1x.
不可变多映射是一种多对多映射数据结构,具有预期的快速插入和查找操作。此数据结构用于处理图形或多对多关系的应用程序,如在编译器、编程语言的运行时或面向对象系统的静态分析中应用的应用程序。假定集合数据结构仔细地平衡了操作的执行时间和内存消耗特征,并且需要从几个元素优雅地扩展到至少多个gb。当处理较大的内存数据集时,数据结构编码本身的开销就会成为内存使用的瓶颈,影响整体性能。在本文中,我们提出了AXIOM,这是一种新颖的哈希-trie数据结构,它通过区分单例集的内联值和多映射的嵌套集来实现高效和类型安全的多映射编码。AXIOM通过在实现级别上支持处理细粒度类型异构的内容,对以前的散列数据结构进行了严格的泛化(而API和语言对类型异构的支持不在本文的讨论范围之内)。我们详细介绍了AXIOM的设计和优化,并进一步将其与Java、Scala和Clojure中最先进的不可变映射和多映射进行比较。我们使用微基准测试隔离关键差异,并在静态分析的案例研究中验证得出的结论。AXIOM减少了1.87倍的键值存储开销;通过跨集合边界的专门化和内联,性能提高了5.1倍。
{"title":"To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries","authors":"M. Steindorfer, J. Vinju","doi":"10.1145/3192366.3192420","DOIUrl":"https://doi.org/10.1145/3192366.3192420","url":null,"abstract":"An immutable multi-map is a many-to-many map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in compilers, runtimes of programming languages, or in static analysis of object-oriented systems. Collection data structures are assumed to carefully balance execution time of operations with memory consumption characteristics and need to scale gracefully from a few elements to multiple gigabytes at least. When processing larger in-memory data sets the overhead of the data structure encoding itself becomes a memory usage bottleneck, dominating the overall performance. In this paper we propose AXIOM, a novel hash-trie data structure that allows for a highly efficient and type-safe multi-map encoding by distinguishing inlined values of singleton sets from nested sets of multi-mappings. AXIOM strictly generalizes over previous hash-trie data structures by supporting the processing of fine-grained type-heterogeneous content on the implementation level (while API and language support for type-heterogeneity are not scope of this paper). We detail the design and optimizations of AXIOM and further compare it against state-of-the-art immutable maps and multi-maps in Java, Scala and Clojure. We isolate key differences using microbenchmarks and validate the resulting conclusions on a case study in static analysis. AXIOM reduces the key-value storage overhead by 1.87x; with specializing and inlining across collection boundaries it improves by 5.1x.","PeriodicalId":20583,"journal":{"name":"Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation","volume":"5 1","pages":""},"PeriodicalIF":0.0,"publicationDate":"2018-06-11","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"81800500","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 1
期刊
Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation
全部 Acc. Chem. Res. ACS Applied Bio Materials ACS Appl. Electron. Mater. ACS Appl. Energy Mater. ACS Appl. Mater. Interfaces ACS Appl. Nano Mater. ACS Appl. Polym. Mater. ACS BIOMATER-SCI ENG ACS Catal. ACS Cent. Sci. ACS Chem. Biol. ACS Chemical Health & Safety ACS Chem. Neurosci. ACS Comb. Sci. ACS Earth Space Chem. ACS Energy Lett. ACS Infect. Dis. ACS Macro Lett. ACS Mater. Lett. ACS Med. Chem. Lett. ACS Nano ACS Omega ACS Photonics ACS Sens. ACS Sustainable Chem. Eng. ACS Synth. Biol. Anal. Chem. BIOCHEMISTRY-US Bioconjugate Chem. BIOMACROMOLECULES Chem. Res. Toxicol. Chem. Rev. Chem. Mater. CRYST GROWTH DES ENERG FUEL Environ. Sci. Technol. Environ. Sci. Technol. Lett. Eur. J. Inorg. Chem. IND ENG CHEM RES Inorg. Chem. J. Agric. Food. Chem. J. Chem. Eng. Data J. Chem. Educ. J. Chem. Inf. Model. J. Chem. Theory Comput. J. Med. Chem. J. Nat. Prod. J PROTEOME RES J. Am. Chem. Soc. LANGMUIR MACROMOLECULES Mol. Pharmaceutics Nano Lett. Org. Lett. ORG PROCESS RES DEV ORGANOMETALLICS J. Org. Chem. J. Phys. Chem. J. Phys. Chem. A J. Phys. Chem. B J. Phys. Chem. C J. Phys. Chem. Lett. Analyst Anal. Methods Biomater. Sci. Catal. Sci. Technol. Chem. Commun. Chem. Soc. Rev. CHEM EDUC RES PRACT CRYSTENGCOMM Dalton Trans. Energy Environ. Sci. ENVIRON SCI-NANO ENVIRON SCI-PROC IMP ENVIRON SCI-WAT RES Faraday Discuss. Food Funct. Green Chem. Inorg. Chem. Front. Integr. Biol. J. Anal. At. Spectrom. J. Mater. Chem. A J. Mater. Chem. B J. Mater. Chem. C Lab Chip Mater. Chem. Front. Mater. Horiz. MEDCHEMCOMM Metallomics Mol. Biosyst. Mol. Syst. Des. Eng. Nanoscale Nanoscale Horiz. Nat. Prod. Rep. New J. Chem. Org. Biomol. Chem. Org. Chem. Front. PHOTOCH PHOTOBIO SCI PCCP Polym. Chem.
×
引用
GB/T 7714-2015
复制
MLA
复制
APA
复制
导出至
BibTeX EndNote RefMan NoteFirst NoteExpress
×
0
微信
客服QQ
Book学术公众号 扫码关注我们
反馈
×
意见反馈
请填写您的意见或建议
请填写您的手机或邮箱
×
提示
您的信息不完整,为了账户安全,请先补充。
现在去补充
×
提示
您因"违规操作"
具体请查看互助需知
我知道了
×
提示
现在去查看 取消
×
提示
确定
Book学术官方微信
Book学术文献互助
Book学术文献互助群
群 号:481959085
Book学术
文献互助 智能选刊 最新文献 互助须知 联系我们:info@booksci.cn
Book学术提供免费学术资源搜索服务,方便国内外学者检索中英文文献。致力于提供最便捷和优质的服务体验。
Copyright © 2023 Book学术 All rights reserved.
ghs 京公网安备 11010802042870号 京ICP备2023020795号-1