To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual M...
详细信息
ISBN:
(纸本)9781450302036
To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. PINOCCHIO is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of PINOCCHIO through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.
Accurately predicting program behaviors (e. g., locality, dependency, method calling frequency) is fundamental for program optimizations and runtime adaptations. Despite decades of remarkable progress, prior studies h...
详细信息
ISBN:
(纸本)9781450302036
Accurately predicting program behaviors (e. g., locality, dependency, method calling frequency) is fundamental for program optimizations and runtime adaptations. Despite decades of remarkable progress, prior studies have not systematically exploited program inputs, a deciding factor for program behaviors. Triggered by the strong and predictive correlations between program inputs and behaviors that recent studies have uncovered, this work proposes to include program inputs into the focus of program behavior analysis, cultivating a new paradigm named input-centric program behavior analysis. This new approach consists of three components, forming a three-layer pyramid. At the base is program input characterization, a component for resolving the complexity in program raw inputs and the extraction of important features. In the middle is input-behavior modeling, a component for recognizing and modeling the correlations between characterized input features and program behaviors. These two components constitute input-centric program behavior analysis, which (ideally) is able to predict the large-scope behaviors of a program's execution as soon as the execution starts. The top layer of the pyramid is input-centric adaptation, which capitalizes on the novel opportunities that the first two components create to facilitate proactive adaptation for program optimizations. By centering on program inputs, the new approach resolves a proactivity-adaptivity dilemma inherent in previous techniques. Its benefits are demonstrated through proactive dynamic optimizations and version selection, yielding significant performance improvement on a set of Java and C programs.
Heterogeneous multi-core processors, such as the IBM Cell processor, can deliver high performance. However, these processors are notoriously difficult to program: different cores support different instruction set arch...
详细信息
ISBN:
(纸本)9781450302036
Heterogeneous multi-core processors, such as the IBM Cell processor, can deliver high performance. However, these processors are notoriously difficult to program: different cores support different instruction set architectures, and the processor as a whole does not provide coherence between the different cores' local memories. We present Hera-JVM, an implementation of the Java Virtual Machine which operates over the Cell processor, thereby making this platforms more readily accessible to mainstream developers. Hera-JVM supports the full Java language;threads from an unmodified Java application can be simultaneously executed on both the main PowerPC-based core and on the additional SPE accelerator cores. Migration of threads between these cores is transparent from the point of view of the application, requiring no modification to Java source code or bytecode. Hera-JVM supports the existing Java Memory Model, even though the underlying hardware does not provide cache coherence between the different core types. We examine Hera-JVM's performance under a series of real-world Java benchmarks from the SpecJVM, Java Grande and Dacapo benchmark suites. These benchmarks show a wide variation in relative performance on the different core types of the Cell processor, depending upon the nature of their workload. Execution of these benchmarks on Hera-JVM can achieve speedups of up to 2.25x by using one of the Cell processor's SPE accelerator cores, compared to execution on the main PowerPC-based core. When all six SPE cores are exploited, parallel workloads can achieve speedups of up to 13x compared to execution on the single PowerPC core.
programming forums are becoming the primary tools for programmers to find answers for their programming problems. Our empirical study of popular programming forums shows that the forum users experience long waiting pe...
详细信息
ISBN:
(纸本)9781450302036
programming forums are becoming the primary tools for programmers to find answers for their programming problems. Our empirical study of popular programming forums shows that the forum users experience long waiting period for answers and a small number of experts are often overloaded with questions. To improve the usage experience, we have designed and implemented G-Finder, both an algorithm and a tool that makes intelligent routing decisions as to which participant is the expert for answering a particular programming question. Our main approach is to leverage the source code information of the software systems that forums are dedicated to, and discover latent relationships between forums users. Our algorithms construct the concept networks and the user networks from the program source and the forum data. We use programming questions to dynamically integrate these two networks and present an adaptive ranking of the potential experts. Our evaluation of G-Finder, using the data from three large programming forums, takes a retrospective view to check if G-Finder can correctly predict the experts who provided answers to programming questions. The evaluation results show that G-Finder improves the prediction precision by 25% to 74%, compared to related approaches.
Since object-orientedprogramming has become dominant in application development, there has been the recurring issue of an impedance mismatch between the way programmers manipulate objects in memory, and the way they ...
详细信息
The proceedings contain 79 papers. The topics discussed include: agile architecture methodology: long term strategy interleaved with short term tactics;retaining comments when refactoring code;decentralized control of...
The proceedings contain 79 papers. The topics discussed include: agile architecture methodology: long term strategy interleaved with short term tactics;retaining comments when refactoring code;decentralized control of automatic guided vehicles: applying multi-agent systems in practice;NOAO imaging meta data quality improvement: a case study of the evolution of a service oriented system;performance pitfalls in large-scale Java applications translated from COBOL;processing heterogeneous abstract syntax trees with the mutable class pattern;a workload model of topic-based publish/subscribe systems;SyQL: an objectoriented, fuzzy, temporal query language for repositories of software artifacts;aspect weaving for OSGi;automated testing of non-functional requirements;compile-time type-checking for custom type qualifiers in Java;enforcing reference and object immutability in Java;and refactoring support for the groovy-eclipse plug-in.
The proceedings contain 36 papers. The topics discussed include: caching and incrementalisation in the Java query language;interprocedural query extraction for transparent persistence;deep typechecking and refactoring...
The proceedings contain 36 papers. The topics discussed include: caching and incrementalisation in the Java query language;interprocedural query extraction for transparent persistence;deep typechecking and refactoring;join patterns for visual basic;whiteoak: introducing structural typing into Java;mixing source and bytecode: a case for compilation by normalization;tolerating memory leaks;JOLT: lightweight dynamic analysis and removal of object churn;QVM: an efficient runtime for detecting defects in deployed systems;contention-aware scheduler: unlocking execution parallelism in multithreaded Java programs;dynamic optimization for efficient strong atomicity;jStar: towards practical verification for Java;verifying correct usage of atomic blocks and typestate;enforcing object protocols by combining static and runtime analysis;the impact of static-dynamic coupling on remodularization;and sound and extensible renaming for Java.
The proceedings contain 13 papers. The topics discussed include: tool support for refactoring functional programs;when refactoring acts like modularity - keeping options open with persistent condition checking;toward ...
ISBN:
(纸本)9781605583396
The proceedings contain 13 papers. The topics discussed include: tool support for refactoring functional programs;when refactoring acts like modularity - keeping options open with persistent condition checking;toward refactoring in a polyglot world - extending automated refactoring support across Java and XML;refactoring is not (yet) about transformation;towards a refactoring guideline using code clone classication;gathering refactoring data: a comparison of four methods;recommending refactorings when restructuring variabilities in software product lines;designing refactoring tools for developers;re-approaching the refactoring Rubicon;refactoring a language for parallel computational chemistry;a security oriented program transformation to add on policies to prevent injection attacks;and implementing refactorings in IntelliJ IDEA.
暂无评论