Erick Lavoie

Using JavaScript and WebCL for numerical computations: a comparative study of native and web technologies

From its modest beginnings as a tool to validate forms, JavaScript is now an industrial-strength language used to power online applications such as spreadsheets, IDEs, image editors and even 3D games. Since all modern web browsers support JavaScript, it provides a medium that is both easy to distribute for developers and easy to access for users. This paper provides empirical data to answer the question: Is JavaScript fast enough for numerical computations? By measuring and comparing the runtime performance of benchmarks representative of a wide variety of scientific applications, we show that sequential JavaScript is within a factor of 2 of native code. Parallel code using WebCL shows speed improvements of up to 2.28 over JavaScript for the majority of the benchmarks.

Portable and Efficient Run-time Monitoring of JavaScript Applications Using Virtual Machine Layering

Run-time monitoring of JavaScript applications is typically achieved either by instrumenting a browsers virtual machine, usually degrading performance to the level of a simple interpreter, or through complex ad hoc source-to-source transformations. This paper reports on an experiment in layering a portable JS VM on the host VM to expose implementation-level operations that can then be redefined at run-time to monitor an application execution. Our prototype, Photon, exposes object operations and function calls through a meta-object protocol. In order to limit the performance overhead, a dynamic translation of the client program selectively modifies source elements and run-time feedback optimizes monitoring operations. Photon introduces a 4.7× to 191× slowdown when executing benchmarks on popular web browsers. Compared to the Firefox interpreter, it is between 5.5× slower and 7× faster, showing the layering approach is competitive with the instrumentation of a browser VM while being faster and simpler than other source-to-source transformations.

Bootstrapping a self-hosted research virtual machine for JavaScript: an experience report

JavaScript is one of the most widely used dynamic languages. The performance of existing JavaScript VMs, however, is lower than that of VMs for static languages. There is a need for a research VM to easily explore new implementation approaches. This paper presents the Tachyon JavaScript VM which was designed to be flexible and to allow experimenting with new approaches for the execution of JavaScript. The Tachyon VM is itself implemented in JavaScript and currently supports a subset of the full language that is sufficient to bootstrap itself. The paper discusses the architecture of the system and in particular the bootstrapping of a self-hosted VM. Preliminary performance results indicate that our VM, with few optimizations, can already execute code faster than a commercial JavaScript interpreter on some benchmarks.

Pando: A Volunteer Computing Platform for the Web

Volunteer computing is currently successfully used to make hundreds of thousands of CPUs available free-of-charge to projects of general interest. However the effort and cost involved in participating in and launching such projects may explain why only a few high-profile projects use it and why only 0.1% of Internet users participate in them. We present Pando, a system designed to be easy to deploy and which does not require dedicated servers. It enables a thousand browser tabs to be used for computation. We have implemented a command-line version of Pando that makes it easy to launch volunteer computing projects on the Web as part of a Unix processing pipeline. Volunteers join by simply opening a Web page. We successfully tested the tool on the Grid5000 testbed and provide all scripts and procedures necessary to replicate our experiments.

Automatic Vectorization for MATLAB

Dynamic array-based languages such as MATLAB provide a wide range of built-in operations which can be efficiently applied to all elements of an array. Historically, MATLAB and Octave programmers have been advised to manually transform loops to equivalent “vectorized” computations in order to maximize performance. In this paper we present the techniques and tools to perform automatic vectorization, including handling for loops with calls to user-defined functions. We evaluate the technique on 9 benchmarks using two interpreters and two JIT-based platforms and show that automatic vectorization is extremely effective for the interpreters on most benchmarks, and moderately effective on some benchmarks in the JIT context.

Numerical computing on the web: benchmarking for the future

Recent advances in execution environments for JavaScript and WebAssembly that run on a broad range of devices, from workstations and mobile phones to IoT devices, provide new opportunities for portable and web-based numerical computing. Indeed, numerous numerical libraries and applications are emerging on the web, including Tensorflow.js, JSMapReduce, and the NLG Protein Viewer. This paper evaluates the current performance of numerical computing on the web, including both JavaScript and WebAssembly, over a wide range of devices from workstations to IoT devices. We developed a new benchmarking approach, which allowed us to perform centralized benchmarking, including benchmarking on mobile and IoT devices. Using this approach we performed four performance studies using the Ostrich benchmark suite, a collection of numerical programs representing the numerical dwarf categories identified by Colella. We studied the performance evolution of JavaScript, the relative performance of WebAssembly, the performance of server-side Node.js, and a comprehensive performance showdown for a wide range of devices.

Xor-Overlay Topology Management beyond Kademlia

Kademlia is a widely successful Distributed Hash Table (DHT) implementation, better known for its use in the BitTorrent protocol. In this paper, we revisit its overlay management separately from the DHT operations to allow it to be used with other distributed abstractions by providing an accurate and consistent view of the k-closest nodes to any given identifier. We then present invariants that avoid the irregularities that are necessary with the original k-bucket design and improve on later published solutions by not needing an additional parameter to tune. We then provide a specification of a distributed abstraction that provides the automatic management of routing tables using our invariants and a pseudo-code implementation of that abstraction. We finally sketch how our abstraction may be used for a security mechanism and how it could be combined with other known distributed abstractions to provide other services than file sharing in xor-based overlay networks enabling xor-based network overlays to go beyond their original Kademlia design.