Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages最新文献_第10页

Sigma*: symbolic learning of input-output specifications Sigma*:输入-输出规范的符号学习

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429123

M. Botincan, Domagoj Babic

{"title":"Sigma*: symbolic learning of input-output specifications","authors":"M. Botincan, Domagoj Babic","doi":"10.1145/2429069.2429123","DOIUrl":"https://doi.org/10.1145/2429069.2429123","url":null,"abstract":"We present Sigma*, a novel technique for learning symbolic models of software behavior. Sigma* addresses the challenge of synthesizing models of software by using symbolic conjectures and abstraction. By combining dynamic symbolic execution to discover symbolic input-output steps of the programs and counterexample guided abstraction refinement to over-approximate program behavior, Sigma* transforms arbitrary source representation of programs into faithful input-output models. We define a class of stream filters---programs that process streams of data items---for which Sigma* converges to a complete model if abstraction refinement eventually builds up a sufficiently strong abstraction. In other words, Sigma* is complete relative to abstraction. To represent inferred symbolic models, we use a variant of symbolic transducers that can be effectively composed and equivalence checked. Thus, Sigma* enables fully automatic analysis of behavioral properties such as commutativity, reversibility and idempotence, which is useful for web sanitizer verification and stream programs compiler optimizations, as we show experimentally. We also show how models inferred by Sigma* can boost performance of stream programs by parallelized code generation.","PeriodicalId":20683,"journal":{"name":"Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages","volume":"19 1","pages":"443-456"},"PeriodicalIF":0.0,"publicationDate":"2013-01-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"89501930","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}

引用次数: 64

High-level separation logic for low-level code 低级代码的高级分离逻辑

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429105

J. B. Jensen, Nick Benton, A. Kennedy

{"title":"High-level separation logic for low-level code","authors":"J. B. Jensen, Nick Benton, A. Kennedy","doi":"10.1145/2429069.2429105","DOIUrl":"https://doi.org/10.1145/2429069.2429105","url":null,"abstract":"Separation logic is a powerful tool for reasoning about structured, imperative programs that manipulate pointers. However, its application to unstructured, lower-level languages such as assembly language or machine code remains challenging. In this paper we describe a separation logic tailored for this purpose that we have applied to x86 machine-code programs.\u0000 The logic is built from an assertion logic on machine states over which we construct a specification logic that encapsulates uses of frames and step indexing. The traditional notion of Hoare triple is not applicable directly to unstructured machine code, where code and data are mixed together and programs do not in general run to completion, so instead we adopt a continuation-passing style of specification with preconditions alone. Nevertheless, the range of primitives provided by the specification logic, which include a higher-order frame connective, a novel read-only frame connective, and a 'later' modality, support the definition of derived forms to support structured-programming-style reasoning for common cases, in which standard rules for Hoare triples are derived as lemmas. Furthermore, our encoding of scoped assembly-language labels lets us give definitions and proof rules for powerful assembly-language 'macros' such as while loops, conditionals and procedures.\u0000 We have applied the framework to a model of sequential x86 machine code built entirely within the Coq proof assistant, including tactic support based on computational reflection.","PeriodicalId":20683,"journal":{"name":"Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages","volume":"54 1","pages":"301-314"},"PeriodicalIF":0.0,"publicationDate":"2013-01-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"86187491","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

Checking NFA equivalence with bisimulations up to congruence 用双模拟检验NFA等价直到同余

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429124

F. Bonchi, D. Pous

引用次数: 161

HALO: haskell to logic through denotational semantics HALO:通过指称语义来理解逻辑

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429121

Dimitrios Vytiniotis, S. Jones, Koen Claessen, Dan Rosén

引用次数: 64

Deadlock-freedom-by-design: multiparty asynchronous global programming 死锁自由设计:多方异步全局编程

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429101

Marco Carbone, F. Montesi

引用次数: 181

Quantitative relaxation of concurrent data structures 并发数据结构的定量松弛

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429109

T. Henzinger, C. Kirsch, H. Payer, A. Sezgin, A. Sokolova

{"title":"Quantitative relaxation of concurrent data structures","authors":"T. Henzinger, C. Kirsch, H. Payer, A. Sezgin, A. Sokolova","doi":"10.1145/2429069.2429109","DOIUrl":"https://doi.org/10.1145/2429069.2429109","url":null,"abstract":"There is a trade-off between performance and correctness in implementing concurrent data structures. Better performance may be achieved at the expense of relaxing correctness, by redefining the semantics of data structures. We address such a redefinition of data structure semantics and present a systematic and formal framework for obtaining new data structures by quantitatively relaxing existing ones. We view a data structure as a sequential specification S containing all \"legal\" sequences over an alphabet of method calls. Relaxing the data structure corresponds to defining a distance from any sequence over the alphabet to the sequential specification: the k-relaxed sequential specification contains all sequences over the alphabet within distance k from the original specification. In contrast to other existing work, our relaxations are semantic (distance in terms of data structure states). As an instantiation of our framework, we present two simple yet generic relaxation schemes, called out-of-order and stuttering relaxation, along with several ways of computing distances. We show that the out-of-order relaxation, when further instantiated to stacks, queues, and priority queues, amounts to tolerating bounded out-of-order behavior, which cannot be captured by a purely syntactic relaxation (distance in terms of sequence manipulation, e.g. edit distance). We give concurrent implementations of relaxed data structures and demonstrate that bounded relaxations provide the means for trading correctness for performance in a controlled way. The relaxations are monotonic which further highlights the trade-off: increasing k increases the number of permitted sequences, which as we demonstrate can lead to better performance. Finally, since a relaxed stack or queue also implements a pool, we actually have new concurrent pool implementations that outperform the state-of-the-art ones.","PeriodicalId":20683,"journal":{"name":"Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages","volume":"19 1","pages":"317-328"},"PeriodicalIF":0.0,"publicationDate":"2013-01-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"81930972","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}

引用次数: 97

Automatic detection of floating-point exceptions 自动检测浮点异常

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429133

Earl T. Barr, Thanh Vo, Vu Le, Z. Su

{"title":"Automatic detection of floating-point exceptions","authors":"Earl T. Barr, Thanh Vo, Vu Le, Z. Su","doi":"10.1145/2429069.2429133","DOIUrl":"https://doi.org/10.1145/2429069.2429133","url":null,"abstract":"It is well-known that floating-point exceptions can be disastrous and writing exception-free numerical programs is very difficult. Thus, it is important to automatically detect such errors. In this paper, we present Ariadne, a practical symbolic execution system specifically designed and implemented for detecting floating-point exceptions. Ariadne systematically transforms a numerical program to explicitly check each exception triggering condition. Ariadne symbolically executes the transformed program using real arithmetic to find candidate real-valued inputs that can reach and trigger an exception. Ariadne converts each candidate input into a floating-point number, then tests it against the original program. In general, approximating floating-point arithmetic with real arithmetic can change paths from feasible to infeasible and vice versa. The key insight of this work is that, for the problem of detecting floating-point exceptions, this approximation works well in practice because, if one input reaches an exception, many are likely to, and at least one of them will do so over both floating-point and real arithmetic. To realize Ariadne, we also devised a novel, practical linearization technique to solve nonlinear constraints. We extensively evaluated Ariadne over 467 scalar functions in the widely used GNU Scientific Library (GSL). Our results show that Ariadne is practical and identifies a large number of real runtime exceptions in GSL. The GSL developers confirmed our preliminary findings and look forward to Ariadne's public release, which we plan to do in the near future.","PeriodicalId":20683,"journal":{"name":"Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages","volume":"14 1","pages":"549-560"},"PeriodicalIF":0.0,"publicationDate":"2013-01-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"74784943","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}

引用次数: 96

Cache and I/O efficent functional algorithms 缓存和I/O高效的函数算法

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429077

G. Blelloch, R. Harper

{"title":"Cache and I/O efficent functional algorithms","authors":"G. Blelloch, R. Harper","doi":"10.1145/2429069.2429077","DOIUrl":"https://doi.org/10.1145/2429069.2429077","url":null,"abstract":"The widely studied I/O and ideal-cache models were developed to account for the large difference in costs to access memory at different levels of the memory hierarchy. Both models are based on a two level memory hierarchy with a fixed size primary memory(cache) of size M, an unbounded secondary memory organized in blocks of size B. The cost measure is based purely on the number of block transfers between the primary and secondary memory. All other operations are free. Many algorithms have been analyzed in these models and indeed these models predict the relative performance of algorithms much more accurately than the standard RAM model. The models, however, require specifying algorithms at a very low level requiring the user to carefully lay out their data in arrays in memory and manage their own memory allocation.\u0000 In this paper we present a cost model for analyzing the memory efficiency of algorithms expressed in a simple functional language. We show how some algorithms written in standard forms using just lists and trees (no arrays) and requiring no explicit memory layout or memory management are efficient in the model. We then describe an implementation of the language and show provable bounds for mapping the cost in our model to the cost in the ideal-cache model. These bound imply that purely functional programs based on lists and trees with no special attention to any details of memory layout can be as asymptotically as efficient as the carefully designed imperative I/O efficient algorithms. For example we describe an O(n_B logM/Bn_B)cost sorting algorithm, which is optimal in the ideal cache and I/O models.","PeriodicalId":20683,"journal":{"name":"Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages","volume":"12 1","pages":"39-50"},"PeriodicalIF":0.0,"publicationDate":"2013-01-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"82013053","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}

引用次数: 20

Library abstraction for C/C++ concurrency C/ c++并发的库抽象

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429099

Mark Batty, Mike Dodds, Alexey Gotsman

引用次数: 92

Automating relatively complete verification of higher-order functional programs 自动化相对完整的高阶功能程序验证

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages Pub Date : 2013-01-23 DOI: 10.1145/2429069.2429081

Hiroshi Unno, Tachio Terauchi, N. Kobayashi

引用次数: 49