European Conference on Object-Oriented Programming最新文献

{"title":"CROCHET: Checkpoint and Rollback via Lightweight Heap Traversal on Stock JVMs","authors":"Jonathan Bell, Luís Pina","doi":"10.4230/LIPIcs.ECOOP.2018.17","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2018.17","url":null,"abstract":"Checkpoint/rollback (CR) mechanisms create snapshots of the state of a running application, allowing it to later be restored to that checkpointed snapshot. Support for checkpoint/rollback enables many program analyses and software engineering techniques, including test generation, fault tolerance, and speculative execution.\u0000Fully automatic CR support is built into some modern operating systems. However, such systems perform checkpoints at the coarse granularity of whole pages of virtual memory, which imposes relatively high overhead to incrementally capture the changing state of a process, and makes it difficult for applications to checkpoint only some logical portions of their state. CR systems implemented at the application level and with a finer granularity typically require complex developer support to identify: (1) where checkpoints can take place, and (2) which program state needs to be copied. A popular compromise is to implement CR support in managed runtime environments, e.g. the Java Virtual Machine (JVM), but this typically requires specialized, non-standard runtime environments, limiting portability and adoption of this approach.\u0000In this paper, we present a novel approach for Checkpoint ROllbaCk via lightweight HEap Traversal (Crochet), which enables fully automatic fine-grained lightweight checkpoints within unmodified commodity JVMs (specifically Oracle's HotSpot and OpenJDK). Leveraging key insights about the internal design common to modern JVMs, Crochet works entirely through bytecode rewriting and standard debug APIs, utilizing special proxy objects to perform a lazy heap traversal that starts at the root references and traverses the heap as objects are accessed, copying or restoring state as needed and removing each proxy immediately after it is used. We evaluated Crochet on the DaCapo benchmark suite, finding it to have very low runtime overhead in steady state (ranging from no overhead to 1.29x slowdown), and that it often outperforms a state-of-the-art system-level checkpoint tool when creating large checkpoints.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"142 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2018-07-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125831873","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}

{"title":"Transient Typechecks Are (Almost) Free","authors":"Richard Roberts, Stefan Marr, Michael Homer, J. Noble","doi":"10.4230/LIPIcs.ECOOP.2019.5","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2019.5","url":null,"abstract":"Transient gradual typing imposes run-time type tests that typically cause a linear slowdown in programs' performance. This performance impact discourages the use of type annotations because adding types to a program makes the program slower. A virtual machine can employ standard just-in-time optimizations to reduce the overhead of transient checks to near zero. These optimizations can give gradually-typed languages performance comparable to state-of-the-art dynamic languages, so programmers can add types to their code without affecting their programs' performance.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"25 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2018-07-02","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131180869","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}

{"title":"Targeted Test Generation for Actor Systems","authors":"Sihan Li, Farah Hariri, G. Agha","doi":"10.4230/LIPIcs.ECOOP.2018.8","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2018.8","url":null,"abstract":"This paper addresses the problem of targeted test generation for actor systems. Specifically, we propose a method to support generation of system-level tests to cover a given code location in an actor system. The test generation method consists of two phases. First, static analysis is used to construct an abstraction of an entire actor system in terms of a message flow graph (MFG). An MFG captures potential actor interactions that are defined in a program. Second, a backwards symbolic execution (BSE) from a target location to an “entry point” of the actor system is performed. BSE uses the MFG constructed in the first phase of our targeted test generation method to guide execution across actors. Because concurrency leads to a huge search space which can potentially be explored through BSE, we prune the search space by using two heuristics combined with a feedback-directed technique. We implement our method in Tap, a tool for Java Akka programs, and evaluate Tap on the Savina benchmarks as well as four open source projects. Our evaluation shows that the Tap achieves a relatively high target coverage (78% on 1,000 targets) and detects six previously unreported bugs in the subjects. 2012 ACM Subject Classification Software and its engineering → Software testing and debugging","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2018-07-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128578727","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}

{"title":"A Characteristic Study of Parameterized Unit Tests in .NET Open Source Projects","authors":"Wing Lam, Siwakorn Srisakaokul, Blake Bassett, P. Mahdian, Tao Xie, Pratap Lakshman, J. D. Halleux","doi":"10.4230/LIPIcs.ECOOP.2018.5","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2018.5","url":null,"abstract":"In the past decade, parameterized unit testing has emerged as a promising method to specify program behaviors under test in the form of unit tests. Developers can write parameterized unit tests (PUTs), unit-test methods with parameters, in contrast to conventional unit tests, without parameters. The use of PUTs can enable powerful test generation tools such as Pex to have strong test oracles to check against, beyond just uncaught runtime exceptions. In addition, PUTs have been popularly supported by various unit testing frameworks for .NET and the JUnit framework for Java. However, there exists no study to offer insights on how PUTs are written by developers in either proprietary or open source development practices, posing barriers for various stakeholders to bring PUTs to widely adopted practices in software industry. To fill this gap, we first present categorization results of the Microsoft MSDN Pex Forum posts (contributed primarily by industrial practitioners) related to PUTs. We then use the categorization results to guide the design of the first characteristic study of PUTs in .NET open source projects. We study hundreds of PUTs that open source developers wrote for these open source projects. Our study findings provide valuable insights for various stakeholders such as current or prospective PUT writers (e.g., developers), PUT framework designers, test-generation tool vendors, testing researchers, and testing educators.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"124 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2018-07-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131990325","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}

{"title":"Don't Panic! Better, Fewer, Syntax Errors for LR Parsers","authors":"Lukas Diekmann, L. Tratt","doi":"10.4230/LIPIcs.ECOOP.2020.6","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2020.6","url":null,"abstract":"Syntax errors are generally easy to fix for humans, but not for parsers in general nor LR parsers in particular. Traditional 'panic mode' error recovery, though easy to implement and applicable to any grammar, often leads to a cascading chain of errors that drown out the original. More advanced error recovery techniques suffer less from this problem but have seen little practical use because their typical performance was seen as poor, their worst case unbounded, and the repairs they reported arbitrary. In this paper we introduce the CPCT+ algorithm, and an implementation of that algorithm, that address these issues. First, CPCT+ reports the complete set of minimum cost repair sequences for a given location, allowing programmers to select the one that best fits their intention. Second, on a corpus of 200,000 real-world syntactically invalid Java programs, CPCT+ is able to repair 98.37% of files within a timeout of 0.5s. Finally, CPCT+ uses the complete set of minimum cost repair sequences to reduce the cascading error problem, where incorrect error recovery causes further spurious syntax errors to be identified. Across the test corpus, CPCT+ reports 435,812 error locations to the user, reducing the cascading error problem substantially relative to the 981,628 error locations reported by panic mode.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"27 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2018-04-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128246489","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}

{"title":"Mixed Messages: Measuring Conformance and Non-Interference in TypeScript","authors":"Jack Williams, J. Garrett Morris, P. Wadler, Jakub Zalewski","doi":"10.4230/LIPIcs.ECOOP.2017.28","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2017.28","url":null,"abstract":"TypeScript participates in the recent trend among programming \u0000languages to support gradual typing. The DefinitelyTyped Repository \u0000for TypeScript supplies type definitions for over 2000 popular \u0000JavaScript libraries. However, there is no guarantee that \u0000implementations conform to their corresponding declarations. \u0000 \u0000We present a practical evaluation of gradual typing for TypeScript. \u0000We have developed a tool for use with TypeScript, based on the \u0000polymorphic blame calculus, for monitoring JavaScript libraries and \u0000TypeScript clients against the TypeScript definition. We apply our \u0000tool, TypeScript TPD, to those libraries in the DefinitelyTyped \u0000Repository which had adequate test code to use. Of the 122 libraries \u0000we checked, 62 had cases where either the library or its tests \u0000failed to conform to the declaration. \u0000 \u0000Gradual typing should satisfy non-interference. Monitoring a program \u0000should never change its behaviour, except to raise a type error \u0000should a value not conform to its declared type. However, our \u0000experience also suggests serious technical concerns with the use of \u0000the JavaScript proxy mechanism for enforcing contracts. Of the 122 \u0000libraries we checked, 22 had cases where the library or its tests \u0000violated non-interference.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"27 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2017-06-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125790017","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}

{"title":"Type Abstraction for Relaxed Noninterference","authors":"R. Cruz, Tamara Rezk, Bernard P. Serpette, É. Tanter","doi":"10.4230/LIPIcs.ECOOP.2017.7","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2017.7","url":null,"abstract":"Information-flow security typing statically prevents confidential information to leak to public channels. The fundamental information flow property, known as noninterference, states that a public observer cannot learn anything from private data. As attractive as it is from a theoretical viewpoint, noninterference is impractical: real systems need to intentionally declassify some information, selectively. Among the different information flow approaches to declassification, a particularly expressive approach was proposed by Li and Zdancewic, enforcing a notion of relaxed noninterference by allowing programmers to specify declassification policies that capture the intended manner in which public information can be computed from private data. This paper shows how we can exploit the familiar notion of type abstraction to support expressive declassification policies in a simpler, yet more expressive manner. In particular, the type-based approach to declassification—which we develop in an object-oriented setting—addresses several issues and challenges with respect to prior work, including a simple notion of label ordering based on subtyping, support for recursive declassification policies, and a local, modular reasoning principle for relaxed noninterference. This work paves the way for integrating declassification policies in practical security-typed languages.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2017-06-18","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130123715","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}

{"title":"Mailbox Abstractions for Static Analysis of Actor Programs","authors":"Quentin Stiévenart, Jens Nicolay, W. Meuter, Coen De Roover","doi":"10.4230/LIPIcs.ECOOP.2017.25","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2017.25","url":null,"abstract":"Properties such as the absence of errors or bounds on mailbox sizes are hard to deduce statically for actor-based programs. \u0000This is because actor-based programs exhibit several sources of unboundedness, in addition to the non-determinism that is inherent to the concurrent execution of actors. \u0000We developed a static technique based on abstract interpretation to soundly reason in a finite amount of time about the possible executions of an actor-based program. \u0000We use our technique to statically verify the absence of errors in actor-based programs, and to compute upper bounds on the actors' mailboxes. \u0000Sound abstraction of these mailboxes is crucial to the precision of any such technique. \u0000We provide several mailbox abstractions and categorize them according to the extent to which they preserve message ordering and multiplicity of messages in a mailbox. \u0000We formally prove the soundness of each mailbox abstraction, and empirically evaluate their precision and performance trade-offs on a corpus of benchmark programs. \u0000The results show that our technique can statically verify the absence of errors for more benchmark programs than the state-of-the-art analysis.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2017-06-13","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126049399","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}

{"title":"An Empirical Study on Deoptimization in the Graal Compiler","authors":"Y. Zheng, L. Bulej, Walter Binder","doi":"10.4230/LIPIcs.ECOOP.2017.30","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2017.30","url":null,"abstract":"Managed language platforms such as the Java Virtual Machine or the Common Language Runtime rely on a dynamic compiler to achieve high performance. Besides making optimization decisions based on the actual program execution and the underlying hardware platform, a dynamic compiler is also in an ideal position to perform speculative optimizations. However, these tend to increase the compilation costs, because unsuccessful speculations trigger deoptimization and recompilation of the affected parts of the program, wasting previous work. Even though speculative optimizations are widely used, the costs of these optimizations in terms of extra compilation work has not been previously studied. In this paper, we analyze the behavior of the Graal dynamic compiler integrated in Oracle's HotSpot Virtual Machine. We focus on situations which cause program execution to switch from machine code to the interpreter, and compare application performance using three different deoptimization strategies which influence the amount of extra compilation work done by Graal. Using an adaptive deoptimization strategy, we managed to improve the average start-up performance of benchmarks from the DaCapo, ScalaBench, and Octane benchmark suites, mostly by avoiding wasted compilation work. On a single-core system, we observed an average speed-up of 6.4% for the DaCapo and ScalaBench workloads, and a speed-up of 5.1% for the Octane workloads; the improvement decreases with an increasing number of available CPU cores. We also find that the choice of a deoptimization strategy has negligible impact on steady-state performance. This indicates that the cost of speculation matters mainly during start-up, where it can disturb the delicate balance between executing the program and the compiler, but is quickly amortized in steady state.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"26 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2017-06-13","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114372244","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}

{"title":"A Co-contextual Type Checker for Featherweight Java","authors":"Edlira Kuci, Sebastian Erdweg, Oliver Bracevac, Andi Bejleri, M. Mezini","doi":"10.4230/LIPIcs.ECOOP.2017.18","DOIUrl":"https://doi.org/10.4230/LIPIcs.ECOOP.2017.18","url":null,"abstract":"This paper addresses compositional and incremental type checking for object-oriented programming languages. Recent work achieved incremental type checking for structurally typed functional languages through co-contextual typing rules, a constraint-based formulation that removes any context dependency for expression typings. However, that work does not cover key features of object-oriented languages: Subtype polymorphism, nominal typing, and implementation inheritance. Type checkers encode these features in the form of class tables, an additional form of typing context inhibiting incrementalization. In the present work, we demonstrate that an appropriate co-contextual notion to class tables exists, paving the way to efficient incremental type checkers for object-oriented languages. This yields a novel formulation of Igarashi et al.'s Featherweight Java (FJ) type system, where we replace class tables by the dual concept of class table requirements and class table operations by dual operations on class table requirements. We prove the equivalence of FJ's type system and our co-contextual formulation. Based on our formulation, we implemented an incremental FJ type checker and compared its performance against javac on a number of realistic example programs.","PeriodicalId":172012,"journal":{"name":"European Conference on Object-Oriented Programming","volume":"49 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2017-05-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130003412","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}