A detailed VM profiler for the Cog VM

International audienceCode profiling enables a user to know where in an application or function the execution time is spent. The Pharo ecosystem offers several code profilers. However, most of the publicly available profilers (MessageTally, Spy, GadgetPro-filer) largely ignore the activity carried out by the virtual machine , thus incurring inaccuracy in the gathered information and missing important information, such as the Just-in-time compiler activity. This paper describes the motivations and the latest improvements carried out in VMProfiler, a code execution pro-filer hooked into the virtual machine, that performs its analysis by monitoring the virtual machine execution. These improvements address some limitations related to assessing the activity of native functions (resulting from a Just-in-time compiler operation): as of now, VMProfiler provides more detailed profiling reports, showing for native code functions in which bytecode range the execution time is spent

Deep into Pharo

International audienceThis is a book on Pharo a programming language available at http://www.pharo.or

Bridging the Gap between Machine and Language using First-Class Building Blocks

High-performance virtual machines (VMs) are increasingly reused for programming languages for which they were not initially designed. Unfortunately, VMs are usually tailored to specific languages, offer only a very limited interface to running applications, and are closed to extensions. As a consequence, extensions required to support new languages often entail the construction of custom VMs, thus impacting reuse, compatibility and performance. Short of building a custom VM, the language designer has to choose between the expressiveness and the performance of the language. In this dissertation we argue that the best way to open the VM is to eliminate it. We present Pinocchio, a natively compiled Smalltalk, in which we identify and reify three basic building blocks for object-oriented languages. First we define a protocol for message passing similar to calling conventions, independent of the actual message lookup mechanism. The lookup is provided by a self-supporting runtime library written in Smalltalk and compiled to native code. Since it unifies the meta- and base-level we obtain a metaobject protocol (MOP). Then we decouple the language-level manipulation of state from the machine-level implementation by extending the structural reflective model of the language with object layouts, layout scopes and slots. Finally we reify behavior using AST nodes and first-class interpreters separate from the low-level language implementation. We describe the implementations of all three first-class building blocks. For each of the blocks we provide a series of examples illustrating how they enable typical extensions to the runtime, and we provide benchmarks validating the practicality of the approaches

Bridging the Gap between Machine and Language using First-Class Building Blocks

High-performance virtual machines (VMs) are increasingly reused for programming languages for which they were not initially designed. Unfortunately, VMs are usually tailored to specific languages, offer only a very limited interface to running applications, and are closed to extensions. As a consequence, extensions required to support new languages often entail the construction of custom VMs, thus impacting reuse, compatibility and performance. Short of building a custom VM, the language designer has to choose between the expressiveness and the performance of the language. In this dissertation we argue that the best way to open the VM is to eliminate it. We present Pinocchio, a natively compiled Smalltalk, in which we identify and reify three basic building blocks for object-oriented languages. First we define a protocol for message passing similar to calling conventions, independent of the actual message lookup mechanism. The lookup is provided by a self-supporting runtime library written in Smalltalk and compiled to native code. Since it unifies the meta- and base-level we obtain a metaobject protocol (MOP). Then we decouple the language-level manipulation of state from the machine-level implementation by extending the structural reflective model of the language with object layouts, layout scopes and slots. Finally we reify behavior using AST nodes and first-class interpreters separate from the low-level language implementation. We describe the implementations of all three first-class building blocks. For each of the blocks we provide a series of examples illustrating how they enable typical extensions to the runtime, and we provide benchmarks validating the practicality of the approaches

Deep into Pharo

International audienceThis is a book on Pharo a programming language available at http://www.pharo.or

Reification as the key to augmenting software development: an object is worth a thousand words

Software development has become more and more pervasive, with influence in almost every human activity. To be able to fit in so many different scenarios and constantly implement new features, software developers adopted methodologies with tight development cycles, sometimes with more than one release per day. With the constant growth of modern software projects and the consequent expansion of development teams, understanding all the components of a system becomes a task too big to handle. In this context understanding the cause of an error or identifying its source is not an easy task, and correcting the erroneous behavior can lead to unexpected downtime of vital services. Being able to keep track of software defects, usually referred to as bugs, is crucial in the development of a project and in containing maintenance costs. For this purpose, the correctness and completeness of the information available has a great impact on the time required to understand and solve a problem. In this thesis we present an overview of the current techniques commonly used to report software defects. We show why we believe that the state of the art needs to be improved, and present a set of approaches and tools to collect data from software failures, model it, and turn it into actionable knowledge. Our goal is to show that data generated from errors can have a great impact on daily software development, and how it can be employed to augment the development environment to assist software engineers to build and maintain software systems

Supporting Concurrency Abstractions in High-level Language Virtual Machines

During the past decade, software developers widely adopted JVM and CLI as multi-language virtual machines (VMs). At the same time, the multicore revolution burdened developers with increasing complexity. Language implementers devised a wide range of concurrent and parallel programming concepts to address this complexity but struggle to build these concepts on top of common multi-language VMs. Missing support in these VMs leads to tradeoffs between implementation simplicity, correctly implemented language semantics, and performance guarantees. Departing from the traditional distinction between concurrency and parallelism, this dissertation finds that parallel programming concepts benefit from performance-related VM support, while concurrent programming concepts benefit from VM support that guarantees correct semantics in the presence of reflection, mutable state, and interaction with other languages and libraries. Focusing on these concurrent programming concepts, this dissertation finds that a VM needs to provide mechanisms for managed state, managed execution, ownership, and controlled enforcement. Based on these requirements, this dissertation proposes an ownership-based metaobject protocol (OMOP) to build novel multi-language VMs with proper concurrent programming support. This dissertation demonstrates the OMOP's benefits by building concurrent programming concepts such as agents, software transactional memory, actors, active objects, and communicating sequential processes on top of the OMOP. The performance evaluation shows that OMOP-based implementations of concurrent programming concepts can reach performance on par with that of their conventionally implemented counterparts if the OMOP is supported by the VM. To conclude, the OMOP proposed in this dissertation provides a unifying and minimal substrate to support concurrent programming on top of multi-language VMs. The OMOP enables language implementers to correctly implement language semantics, while simultaneously enabling VMs to provide efficient implementations

Predicting unstable software benchmarks using static source code features

Software benchmarks are only as good as the performance measurements they yield. Unstable benchmarks show high variability among repeated measurements, which causes uncertainty about the actual performance and complicates reliable change assessment. However, if a benchmark is stable or unstable only becomes evident after it has been executed and its results are available. In this paper, we introduce a machine-learning-based approach to predict a benchmark’s stability without having to execute it. Our approach relies on 58 statically-computed source code features, extracted for benchmark code and code called by a benchmark, related to (1) meta information, e.g., lines of code (LOC), (2) programming language elements, e.g., conditionals or loops, and (3) potentially performance-impacting standard library calls, e.g., file and network input/output (I/O). To assess our approach’s effectiveness, we perform a large-scale experiment on 4,461 Go benchmarks coming from 230 open-source software (OSS) projects. First, we assess the prediction performance of our machine learning models using 11 binary classification algorithms. We find that Random Forest performs best with good prediction performance from 0.79 to 0.90, and 0.43 to 0.68, in terms of AUC and MCC, respectively. Second, we perform feature importance analyses for individual features and feature categories. We find that 7 features related to meta-information, slice usage, nested loops, and synchronization application programming interfaces (APIs) are individually important for good predictions; and that the combination of all features of the called source code is paramount for our model, while the combination of features of the benchmark itself is less important. Our results show that although benchmark stability is affected by more than just the source code, we can effectively utilize machine learning models to predict whether a benchmark will be stable or not ahead of execution. This enables spending precious testing time on reliable benchmarks, supporting developers to identify unstable benchmarks during development, allowing unstable benchmarks to be repeated more often, estimating stability in scenarios where repeated benchmark execution is infeasible or impossible, and warning developers if new benchmarks or existing benchmarks executed in new environments will be unstable

프로그래밍 언어 런타임에서의 응용프로그램 시작 가속을 위한 최적화

학위논문 (박사)-- 서울대학교 대학원 : 전기·컴퓨터공학부, 2015. 8. 문수묵.자바나 자바스크립트와 같은 프로그래밍 언어를 수행하는 런타임 환경은 응용프로그램의 이식성을 장점으로 하여 임베디드 소프트웨어 플랫폼으로써 널리 사용되고 있다. 자바 응용프로그램은 바이트코드의 형태로 배포되어 디지털 텔레비전이나 안드로이드 플랫폼에서 동작하며 자바스크립트는 소스 코드 형태로 웹 플랫폼에서 수행된다. 그러나 프로그래밍 언어 런타임에 의한 이식성은 본질적으로 성능 문제를 야기할 수 있는데, 하드웨어가 아닌 인터프리터와 같은 소프트웨어에 의해 응용프로그램의 바이트코드나 소스 코드를 수행하기 때문이다. 따라서 더 나은 성능을 얻기 위해 수행 중 바이트코드나 소스 코드를 기계어로 번역하는 적시 컴파일러나 inline caching과 같이 반복 수행되는 동작에 특화된 최적화를 프로그래밍 언어 런타임에 적용하기도 한다. 한편, 임베디드 시스템에서 동작하는 자바 응용프로그램이나 웹페이지의 로딩 중 수행되는 자바스크립트는 안정된 상태에서의 동작보다는 급격한 변화를 수반하는 시작 과정의 행태가 더 두드러진다. 따라서 비교적 짧은 수행시간을 가지고, 동일한 동작을 반복하는 경향이 낮으며, 수행시간에서의 비중이 높은 핫스팟이 드문 특징을 가진다. 그러나 핫스팟에 효과적인 적시 컴파일러나 반복되는 동작에 특화된 최적화는 이와 같은 응용프로그램 시동의 행태에 대하여 성능을 향상시키기 어려울 수 밖에 없다. 이 논문을 통하여 기존의 방식 보다 정교하게 추정한 수행시간을 근거로 작동하는 핫스팟 감지 기법을 제안함으로써 핫스팟이 불분명한 상황에서 자바 적시 컴파일러에 의한 수행 속도의 향상을 꾀하었다. 그 결과 응용프로그램 시작의 행태를 보이는 벤치마크 프로그램의 첫번째 수행시간을 기존의 HotSpot 자바 가상머신의 핫스팟 감지 기법 대비 약 10% 가속화할 수 있었다. 그리고 실제 응용프로그램으로서 디지털 방송에 의해 배포된 Xlet의 시작에 걸리는 수행시간 역시 약 7%가 개선되었다. 또한, 자바스크립트 적시 컴파일러에서 생성되는 기계어의 용량을 줄이기 위하여 축소된 명령어 집합에 최적화된 기계어를 생성하는 기법을 제안하였다. 이를 통하여 약 29%에 해당하는 기계어의 크기를 줄일 수 있었고, 이 결과는 웹페이지 자바스크립트의 시작 과정에서 수행되는 대량의 자바스크립트에서 더욱 효과적일 수 있다. 그리고 적시 컴파일러만을 사용하여 자바스크립트를 수행하는 환경에서 웹페이지 자바스크림트 시작 속도의 성능 저하가 나타남을 발견하였고, 이를 개선하기 위하여 인터프리터 수행을 기반으로 선택적 컴파일을 시도함으로써 적시 컴파일러에 의한 성능 저하를 최소화 하였다. 마지막으로 웹페이지 자바스크립트 시작의 수행 행태에 대하여 분석을 실시한 결과, 빈번하게 발생하는 객체에 대한 접근을 가속화할 수 있는 바이트코드 수준의 최적화를 제안한다. 인터프리터 수행에 적시 컴파일러를 추가로 적용하여도 웹페이지 자바스크립트 시작의 성능 향상은 없었던 반면, 제안한 바이트코드 수준의 최적화는 수행시간을 약 3% 가속화함으로써 웹페이지 자바스크립트 시작에 더 효과적인 것을 확인할 수 있었다.Chapter 1. Introduction 1 1.1 Hot Spot Detection 1 1.2 Memory Consumption of JIT Compiled Code 4 1.3 Web Page JavaScript Performance with JITC 5 Chapter 2. Enhanced Hot Spot Detection 8 2.1 Previous Approaches to Hot Spot Detection 8 2.1.1 Simple Heuristic 8 2.1.2 Hot Heuristic 9 2.1.3 Static Analysis Heuristic 10 2.2 Flow-Sensitive Runtime Estimation 11 2.3 Static-FSRE for First-Invocation Compilation 15 2.4 Merged Heuristic of Dynamic and Static FSRE 18 2.4.1 Threshold of FSRE 18 2.4.2 Merged Heuristic 19 2.5 Experimental Results 19 2.5.1 Benchmark Results 19 2.5.1.1 Experimental Environment 19 2.5.1.2 Evaluation Heuristics 20 2.1.1.3 Performance of the Five Heuristics 21 2.1.1.4 Preciseness of Hot Spot Detection 23 2.1.1.5 Hot Spot Detection Time 28 2.1.1.6 Hot Spot Detection Overhead 29 2.5.2 Digital TV Java Xlet Results 31 2.5.2.1 DTV Environment and Java Xlet application 31 2.5.2.2 Heuristic Adjustments 33 2.5.2.3 Performance Improvement and Comparison 33 Chapter 3. Code Size Optimization for JITC 40 3.1 JavaScript JITC in SFX and Thumb2 40 3.1.1 JavaScript and Execution Semantics 40 3.1.2 SquirrelFish Extreme and the Bytecode 41 3.1.3 SFX JITC Architecture 43 3.1.4 JITC Code Generation for Thumb2 45 3.2 SFX JITC Optimizations for Thumb2 45 3.2.1 Code Generation with Register Re-map 45 3.2.2 Constant Pool Aggregation 46 3.2.3 Patching PC-relative Branches 49 3.3 Experimental Result 52 3.3.1 Experimental Environment 52 3.3.2 Code Size Result 52 3.3.3 Performance Result 55 Chapter 4. Selective JITC for Web Page JavaScript 56 4.1 JavaScript and SFX JITC 56 4.1.1 JavaScript and Interaction with DOM 56 4.1.2 SFX JITC and Its Architecture 59 4.1.3 Benchmark JavaScript and Web Page JavaScript 62 4.2 Selective JITC for the SFX 64 4.2.1 Selective JITC 64 4.2.2 Selective JITC Implementation for the SFX 65 4.3 Experimental Result 66 4.3.1 Experiment Environment 66 4.3.2 Web Page JavaScript and SunSpider Benchmark 66 4.3.3 Web page JavaScript Execution Time 71 4.3.4 Comparison to Benchmark Execution Time 73 4.3.5 Evaluation of the Selective JITC Heuristic 74 4.3.6 Discussions 76 Chapter 5. Bytecode Level Optimizations 78 5.1 Analysis on Web Page JavaScript Execution 78 5.2 Overhead in Property Accesses 82 5.3 Super-Bytecode Construction (SBC) 85 5.4 Bytecode Chaining (BC) 86 5.5 Experimental Evaluation 87 5.5.1 Performance Result 88 5.5.2 Performance Analysis 89 5.5.2.1 Optimized Runtime Services with SBC 89 5.5.2.2 Removed Runtime Services with BC 90 Chapter 6. Related Work 92 Chapter 7. Conclusion 94 Bibliography 97 Abstract 103Docto

Modeling User-Affected Software Properties for Open Source Software Supply Chains

Background: Open Source Software development community relies heavily on users of the software and contributors outside of the core developers to produce top-quality software and provide long-term support. However, the relationship between a software and its contributors in terms of exactly how they are related through dependencies and how the users of a software affect many of its properties are not very well understood. Aim: My research covers a number of aspects related to answering the overarching question of modeling the software properties affected by users and the supply chain structure of software ecosystems, viz. 1) Understanding how software usage affect its perceived quality; 2) Estimating the effects of indirect usage (e.g. dependent packages) on software popularity; 3) Investigating the patch submission and issue creation patterns of external contributors; 4) Examining how the patch acceptance probability is related to the contributors\u27 characteristics. 5) A related topic, the identification of bots that commit code, aimed at improving the accuracy of these and other similar studies was also investigated. Methodology: Most of the Research Questions are addressed by studying the NPM ecosystem, with data from various sources like the World of Code, GHTorrent, and the GiHub API. Different supervised and unsupervised machine learning models, including Regression, Random Forest, Bayesian Networks, and clustering, were used to answer appropriate questions. Results: 1) Software usage affects its perceived quality even after accounting for code complexity measures. 2) The number of dependents and dependencies of a software were observed to be able to predict the change in its popularity with good accuracy. 3) Users interact (contribute issues or patches) primarily with their direct dependencies, and rarely with transitive dependencies. 4) A user\u27s earlier interaction with the repository to which they are contributing a patch, and their familiarity with related topics were important predictors impacting the chance of a pull request getting accepted. 5) Developed BIMAN, a systematic methodology for identifying bots. Conclusion: Different aspects of how users and their characteristics affect different software properties were analyzed, which should lead to a better understanding of the complex interaction between software developers and users/ contributors