Take two languages, Julia and Fortress, designed to solve similar problems with similar mechanisms and compare the approaches that led the one to being adopted and the other to being discontinued. What lessons are there for language designers? Can the designs be reconciled? Can we somehow turn the beast that is into the beauty that could have been? This talk is a snapshot of our investigations into Julia with more open questions than definitive answers. Julia’ design is a pragmatic effort driven by use-cases and user feedback. In contrast, Fortress followed a principled, formally grounded, approach that aimed for type soundness. We will marvel at the efficacy of Julia's compiler — a one-trick pony that works surprisingly well in practice. We will inspect the multi-dispatch feature of Julia and puzzle at the subtype relation that is at its heart. The takeaway of the talk is a list of language features that are key to performance and usability. The talk is based on papers to appear at OOPSLA’18.

Jan Vitek loves to engineer software, sometimes teaches software engineering, often hacks single-file LaTeX documents, always complains about Git, never uses Coq, and is partly to blame for the artifact evaluation process used in many SIGPLAN conferences. He has an office at Northeastern University.

It is well-known that a program’s execution can be partitioned into different phases. Because of their impact on micro-architectural components such as caches and branch predictors, phases are an important aspect of dynamic program behavior that is useful in analyzing performance [Xian et al., 2007, Roh et al., 2009, Gu and Verbrugge, 2008] and energy consumption. They are also relevant to detecting whether a program is executing as expected, which helps software engineers in program analysis and understanding [Peleg and Mendelson, 2007, Singer and Kirkham, 2008, Pirzadeh et al., 2011, Benomar et al., 2014]. We develop here a method for run-time phase prediction for Python programs. After training on different runs of each program of interest, our method can predict the future phase k steps later, for k = 1, ..., at run time, for a new run of the same program but on different inputs, with good precision and recall (compared with a “ground truth” definition of phases) and with small run-time over-head (average less than 1%).

Java programs can contain non-counted loops, that is, loops for which the iteration count can neither be determined at compile time nor at run time. State-of-the-art compilers do not aggressively optimize them, since unrolling non-counted loops often involves duplicating also a loop’s exit condition, which thus only improves run-time performance if subsequent compiler optimizations can optimize the unrolled code.

This paper presents an unrolling approach for non-counted loops that uses simulation at run time to determine whether unrolling such loops enables subsequent compiler optimizations. Simulating loop unrolling allows the compiler to determine performance and code size effects for each potential transformation prior to performing it.

We implemented our approach on top of the GraalVM, a high-performance virtual machine for Java, and evaluated it with a set of Java and JavaScript benchmarks in terms of peak performance, compilation time and code size increase. We show that our approach can improve performance by up to 150% while generating a median code size and compile-time increase of not more than 25%. Our results indicate that fast-path unrolling of non-counted loops can be used in practice to increase the performance of Java applications.

Virtual machines for mobile and embedded devices often use the romization technique when the VM is loaded from a preinitialized state, previously saved as an image. This way some of the initialization work can be avoided in a resource constrained environment. For Java, one of the initialization activities which can be moved from execution time to romization time is class initialization.

The preinitialized image can be optimized in different ways. For instance, redundancy elimination transformations, which include elimination of unused methods, fields, and classes, can be applied to reduce the static and the dynamic footprint of the image. We consider the problem of redundancy elimination in the presence of romization time class initialization.

There is a circular dependency between class initialization and method reachability analysis. On the one hand, class initialization reduces the set of reachable methods as the methods used solely for the initialization become unreachable. On the other hand, eager initialization of classes which are not used by the reachable methods can increase the size of the image by creating reachable but unused objects in the heap.

We propose a method reachability analysis algorithm which breaks this circular dependency by performing selective class initialization during the analysis. The algorithm keeps track of the classes which can be initialized by the reachable methods and initializes a subset of these classes. A simple heuristic is used to choose the classes which are safe to preinitialize.

We also found that elimination of initialized but unused reference fields in Java can affect finalization semantics. The elimination of a field might cause some objects to be collected by the GC, which can be observed by the application. We present an algorithm for elimination of unused fields which preserves finalization behavior.

The proliferation of heterogeneous hardware in recent years means that every system we program is likely to include a mix of compute elements; each with different characteristics. By utilizing these available hardware resources, developers can improve the performance and energy efficiency of their applications. However, existing tools for heterogeneous programming neglect developers who do not have the time or inclination to switch programming languages or learn the intricacies of a specific piece of hardware.

This paper presents a framework that enables Java applications to be deployed across a variety of heterogeneous systems while exploiting any available multi- or many-core processor. The novel aspect of our approach is that it does not require any a priori knowledge of the hardware, or for the developer to worry about managing disparate memory spaces. Java applications are transparently compiled and optimized for the hardware at run-time.

We also present a performance evaluation of our just-in-time (JIT) compiler using a framework to accelerate SLAM, a complex computer vision application entirely written in Java. We show that we can accelerate SLAM up to 150x compared to the Java reference implementation, rendering 107 frames per second (FPS).

It is attractive to host new or existing language implementations on top of, or reusing components of, existing managed language runtimes such as the Java Virtual Machine (JVM) or the Microsoft Common Language Infrastructure (CLI). A benefit is that software development effort may be reduced, as only one managed language runtime needs to be optimised and maintained, instead of a separate compiler/runtime for each language implementation. For example, the Trule framework combined with a JVM offers support for executing Javascript, Ruby, R, LLVM IR-compiled languages, etc., as well as supporting the execution of applications combining multiple programming languages within a Polyglot application. In trying to understand the runtime performance of Su-long (i.e. the Trule project which enables LLVM IR execution), we found a lack of tools and guidance. A similar situation is found for benchmarks written in Ruby and R when executed as Trule hosted languages. Further, it is non-trivial to relate performance back to the hosted language source code, and to determine whether JVM service overheads, such as garbage collection or JIT compilation, are significant.

We describe how to visually analyse the performance of Trule-hosted languages based on Flamegraphs, allowing time to be related to sampled call-stacks. We use the Linux tool perf and the JVM agent perf-map-agent, along with enhancements to the Graal JIT compiler that map sampled call-stacks onto JVM-hosted guest language source code. This paper demonstrates the ease and flexibility of using these modified tools, with low overhead during execution time. We also illustrate applicability of the techniques to understand the performance of Polyglot applications.

JavaScript is the most widely used language for web programming, and now increasingly becoming popular for high performance computing, data-intensive applications, and deep learning. More recently, WebAssembly has been introduced as a typed low-level bytecode representation which promises to enable better performance. Sparse matrix-vector multiplication (SpMV) is an important kernel that is considered critical for the performance of compute-intensive applications. In SpMV, the optimal selection of storage format is one of the key aspects of enabling the best performance.

This paper describes the distinctive nature of the performance and choice of optimal sparse matrix storage format for sequential SpMV for the managed languages JavaScript and WebAssembly, as compared to native languages like C. We performed exhaustive experiments with 2000 real-life sparse matrices. To evaluate the experimental data in a rigorous manner we introduced the notion of x%-affinity which allows us to identify with certainty those storage formats that are at least x% better than all other formats.

We explored three main research questions. First, we examined the difference in performance between native C and both JavaScript and WebAssembly, for two major browsers, Firefox and Chrome. For JavaScript, we observed that the best performing browser demonstrated a slowdown of only 2.2x to 5.8x versus C. Somewhat surprisingly, for WebAssembly, we observed similar or better performance as compared to C, for the best performing browser. Second, we explored the performance of single-precision versus double-precision SpMV. In contrast to C, in JavaScript and WebAssembly, we found that double-precision is often more efficient than single-precision. Lastly, we examined the choice of optimal storage format. Interestingly, the best format choices are very different for C as compared to both JavaScript and WebAssembly, and even quite different between the two browsers.

Register allocation is a mandatory task for almost every compiler and consumes a significant portion of compile time. In a just-in-time compiler, compile time is a particular issue because compilation happens during program execution and contributes to the overall application run time. Parallelization can help here. We developed a theoretical model for parallel register allocation and show that it can be used in practice without a negative impact on the quality of the allocation result. Doing so reduces compilation latency, i.e., the duration until the result of a compilation is available.

Our analysis shows that parallelization can theoretically decrease allocation latency by almost 50%. We implemented an initial prototype which reduces the register allocation latency by 28% when using four threads, compared to the single-threaded allocation.

Virtualization enables datacenter operators to safely run computations that belong to untrusted tenants. An ideal virtual machine has three properties: a small memory footprint; strong isolation from other VMs and the host OS; and the ability to maintain in-memory state across client requests. Unfortunately, modern virtualization technologies cannot provide all three properties at once. In this paper, we explain why, and propose a new virtualization approach, called Alto, that virtualizes at the layer of a managed runtime interface. Through careful design of (1) the application-facing managed interface and (2) the internal runtime architecture, Alto provides VMs that are small, secure, and stateful. Conveniently, Alto also simplifies VM operations like suspension, migration, and resumption. We provide several details about the proposed design, and discuss the remaining challenges that must be solved to fully realize the Alto vision.

Modern compilers and interpreters provide code optimizations before and during run-time to stay competitive with alternative execution environments, thus moving required domain knowledge about the compilation process away from the developer and speeding up resulting software. These optimizations are often based on formal proof, or alternatively have recovery paths as backup.

This publication proposes an architecture utilizing abstract syntax trees (ASTs) to optimize the runtime performance of code with stochastic - search based - machine learning techniques. From these AST modifying optimizations a pattern mining approach attempts to find transformation patterns which are applicable to a software language. The application of these patterns happens during the parsing process or the programs run-time.

Future work consists of implementing and extending the presented architecture, with a considerable focus on the mining of transformation patterns.

Ropes are an immutable data structure for representing character strings via a binary tree of operation-labeled nodes. Ropes were designed to perform well with large strings, and in particular, concatenation of large strings. We present our findings in using ropes to implement mutable strings in TruffleRuby, an implementation of the Ruby programming language using a self-specializing abstract syntax tree interpreter and dynamic compilation. We extend ropes to support Ruby language features such as encodings and refine operations to better support typical Ruby programs. Finally, we evaluate the performance of our implementation of ropes and demonstrate that they perform 0.9× – 9.4× as fast as byte array-based strings in benchmarks of common Ruby string operations.

Byte-addressable non-volatile memory is poised to become prevalent in the near future. Thanks to device-level technological advances, hybrid systems of traditional dynamic random-access memory (DRAM) coupled with non-volatile random-access memory (NVRAM) are already present and are expected to be commonplace soon. NVRAM offers orders of magnitude performance improvements over existing storage devices. Due to NVRAM’s low overheads, many future applications are expected to leverage the fine-grain durable storage provided by NVRAM.

Many frameworks for programming NVRAM have been proposed. Unfortunately, these existing frameworks closely mirror the underlying hardware. This lack of abstraction hurts programmer productivity, makes it easy to write buggy code, and limits the compiler’s effectiveness. Furthermore, this low level of abstraction does not match the expectations of managed language users.

To rectify this situation, in this paper we describe a new high-level NVRAM programming model amenable to managed languages. Because our model is defined at a high level, it is intuitive, not prone to user bugs, and is flexible enough to allow language implementers to perform many optimizations while still adhering to the model.

In addition to proposing this model, we also briefly describe how Java can be extended to support our new model. Finally, we present some initial results on the performance overheads of creating durable applications in NVRAM and describe what future work we intend to complete.

Many dynamic programming languages such as Ruby and Python enable developers to use so called native extensions, code implemented in typically statically compiled languages like C and C++. However, debuggers for these dynamic languages usually lack support for also debugging these native extensions. GraalVM can execute programs implemented in various dynamic programming languages and, by using the LLVM-IR interpreter Sulong, also their native extensions. We added support for source-level debugging to Sulong based on GraalVM’s debugging framework by associating run-time debug information from the LLVM-IR level to the original program code. As a result, developers can now use GraalVM to debug source code written in multiple LLVM-based programming languages as well as programs implemented in various dynamic languages that invoke it in a common debugger front-end.

Conventional back-in-time debuggers fashion a record and replay approach to facilitate inspecting all events in the past execution. This usually implies a significant performance overhead for tracing and storing information. Furthermore the recording only becomes available after the monitored code has terminated. In other words, conventional back-in-time-debuggers operate offline.

In this paper we present a novel approach of online back-in-time debugging, called Back-in-Time Evaluation (BITE). It offers the capabilities to evaluate code-snippets in the context of previous execution states. Thus, we can focus the trace recording on execution contexts accessible in online debugging, to meet the higher requirements for responsiveness of the debugger.

For this purpose, BITE only collects the results of operations that potentially yield different results when they are reevaluated. These are initially stored in the call frame of the executing method, which has a performance overhead of at most 5%. The downside is that once a frame is popped from the stack, the contained trace is disposed of as well. Therefore, BITE also allows to persist the trace collected in a frame before it is popped, at the cost of potentially increasing the overhead. The performance impact of this depends on the amount of trace information that needs to be persisted, as well as the strategy for storing this information. When storing the information in-memory, the overhead induced ranges from having no additional impact at all, up to a factor of 50x. Since memory capabilities are not unlimited, our approach allows for optionally serializing these objects. However, this induces a higher performance overhead.

Complex software systems often suffer from performance problems caused by memory anomalies such as memory leaks. While the proliferation of objects is rather easy to detect using state-of-the-art memory monitoring tools, extracting a leak’s root cause, i.e., identifying the objects that keep the accumulating objects alive, is still poorly supported. Most state-of-the-art tools rely on the dominator tree of the object graph and thus only support single-object ownership analysis. Multi-object ownership analysis, e.g., when the leaking objects are contained in multiple collections, is not possible by merely relying on the dominator tree. We present an efficient approach to continuously collect GC root information (e.g., static fields or thread-local variables) in a trace-based memory monitoring tool, as well as algorithms that use this information to calculate the transitive closure (i.e., all reachable objects) and the GC closure (i.e., objects that are kept alive) for arbitrary heap object groups. These closures allow to derive various metrics for heap object groups that can be used to guide the user during memory leak analysis. We implemented our approach in AntTracks, an offline memory monitoring tool, and demonstrate its usefulness by comparing it with other widely used tools for memory leak detection such as the Eclipse Memory Analyzer. Our evaluation shows that collecting GC root information tracing introduces about 1% overhead, in terms of run time as well as trace file size.

A cloud deployment consists of many separate components, such as load balancers, object stores, application servers and databases, and a single application depends on many such components together. Managing, debugging, and optimizing across all of those components is a challenge. GraalVM is a new technology from Oracle Labs that is both embeddable and multilingual, and can help improve that state of affairs. GraalVM has been embedded in multiple databases, a load balancer, with at least one known project to embed in an object store, as well as running in application runtimes like the Java HotSpot VM. If the same execution engine is embedded across all of those cloud components, cloud-level optimizations such as automatically moving code between components (across the network) becomes possible, and a unified VM and development environment for the cloud becomes possible.

Eric Sedlar is Vice President and Technical Director of Oracle Labs. This position entails figuring out how to transfer research results from Labs research into Oracle products and services, as well as setting overall technical direction for new research projects in Oracle Labs. Eric manages over 160 fulltime researchers working on over a dozen separate research areas.

With the ubiquity of parallel commodity hardware, developers turn to high-level concurrency models such as the actor model to lower the complexity of concurrent software. However, debugging concurrent software is hard, especially for concurrency models with a limited set of supporting tools. Such tools often deal only with the underlying threads and locks, which obscures the view on e.g. actors and messages and thereby introduces additional complexity. To improve on this situation, we present a low-overhead record & replay approach for actor languages. It allows one to debug concurrency issues deterministically based on a previously recorded trace. Our evaluation shows that the average run-time overhead for tracing on benchmarks from the Savina suite is 10% (min. 0%, max. 20%). For Acme-Air, a modern web application, we see a maximum increase of 1% in latency for HTTP requests and about 1.4 MB/s of trace data. These results are a first step towards deterministic replay debugging of actor systems in production.

DynSem is a domain-specific language for concise specification of the dynamic semantics of programming languages, aimed at rapid experimentation and evolution of language designs. DynSem specifications can be executed to interpret programs in the language under development. To enable fast turnaround during language development, we have developed a meta-interpreter for DynSem specifications, which requires minimal processing of the specification. In addition to fast development time, we also aim to achieve fast run times for interpreted programs.

In this paper we present the design of a meta-interpreter for DynSem and report on experiments with JIT compiling the application of the meta-interpreter on the Graal VM. By interpreting specifications directly, we have minimal compilation overhead. By specializing pattern matches, maintaining call-site dispatch chains and using native control-flow constructs we gain significant run-time performance. We evaluate the performance of the meta-interpreter when applied to the Tiger language specification running a set of common benchmark programs. Specialization enables the Graal VM to JIT compile the meta-interpreter giving speedups of up to factor 15 over running on the standard Oracle Java VM.

The complex architecture of browser technologies and dynamic characteristics of JavaScript make it difficult to ensure security in client-side web applications. Browser-level security policies alone are not sufficient because it is difficult to apply them correctly and they can be bypassed. As a result, they need to be completed by application-level security policies.

In this paper, we survey existing solutions for specifying and enforcing application-level security policies for client-side web applications, and distill a number of desirable features. Based on these features we developed Guardia, a framework for declaratively specifying and dynamically enforcing application-level security policies for JavaScript web applications without requiring VM modifications. We describe Guardia enforcement mechanism by means of JavaScript reflection with respect to three important security properties (transparency, tamper-proofness, and completeness). We also use Guardia to specify and deploy 12 access control policies discussed in related work in three experimental applications that are representative of real-world applications. Our experiments indicate that Guardia is correct, transparent, and tamper-proof, while only incurring a reasonable runtime overhead.

Providing vectors of run-time determined length as opaque value types is a good interface between the machine-level SIMD instructions and portable application-oriented programming languages. Implementing vector operations requires a loop that breaks the vector into SIMD-register-sized chunks. A compiler can fuse the loops of several vector operations together. However, during normal compilation this is only easy if no other control structures are involved. This paper explores an alternative: collect a trace of vector operations at run-time (following the program control flow during this collecting step), and then perform the combined vector loop. This arrangement has a certain run-time overhead, but its implementation is simpler and can happen independently, in a library. Preliminary performance results indicate that the overhead makes this approach beneficial only for long vectors (> 1KB). For shorter vectors, unfused loops should be used in a library setting. Fortunately, this choice can be made at run time, individually for each vector operation.