Draining the Swamp: Micro Virtual Machines as Solid Foundation for Language Development

Many of today\u27s programming languages are broken. Poor performance, lack of features and hard-to-reason-about semantics can cost dearly in software maintenance and inefficient execution. The problem is only getting worse with programming languages proliferating and hardware becoming more complicated. An important reason for this brokenness is that much of language design is implementation-driven. The difficulties in implementation and insufficient understanding of concepts bake bad designs into the language itself. Concurrency, architectural details and garbage collection are three fundamental concerns that contribute much to the complexities of implementing managed languages. We propose the micro virtual machine, a thin abstraction designed specifically to relieve implementers of managed languages of the most fundamental implementation challenges that currently impede good design. The micro virtual machine targets abstractions over memory (garbage collection), architecture (compiler backend), and concurrency. We motivate the micro virtual machine and give an account of the design and initial experience of a concrete instance, which we call Mu, built over a two year period. Our goal is to remove an important barrier to performant and semantically sound managed language design and implementation

The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to Assessing Empirical Evaluations

An unsound claim can misdirect a field, encouraging the pursuit of unworthy ideas and the abandonment of promising ideas. An inadequate description of a claim can make it difficult to reason about the claim, for example to determine whether the claim is sound. Many practitioners will acknowledge the threat of un- sound claims or inadequate descriptions of claims to their field. We believe that this situation is exacerbated and even encouraged by the lack of a systematic approach to exploring, exposing, and addressing the source of unsound claims and poor exposition. This paper proposes a framework that identifies three sins of reasoning that lead to unsound claims and two sins of exposition that lead to poorly described claims. Sins of exposition obfuscate the objective of determining whether or not a claim is sound, while sins of reasoning lead directly to unsound claims. Our framework provides practitioners with a principled way of critiquing the integrity of their own work and the work of others. We hope that this will help individuals conduct better science and encourage a cultural shift in our research community to identify and promulgate sound claims

Lightweight Support for Fine-Grained Persistence on Stock Hardware

Persistent programming languages combine the features of database systems and programming languages to allow the seamless manipulation of both short- and long-term data, thus relieving programmers of the burden of distinguishing between data that is transient (temporarily allocated in main memory) or persistent (residing permanently on disk). Secondary storage concerns, including the representation and management of persistent data, are directly handled by the programming language implementation, rather than the programmer. Moreover, unlike traditional database systems, persistent programming languages extend to persistent data all the data structuring features supported by the language, not just those imposed by the underlying database system. Prototype persistent languages have until now focused more on functionality than performance. In contrast, this dissertation addresses performance issues in the language implementation. It presents an architecture and framework for persistence which allows programming language implementation techniques to be brought to bear on the problem of performance. Building on this framework, a prototype persistent programming language is implemented, and submitted to performance evaluation to obtain direct comparisons of the performance of several implementation alternatives for different aspects of persistence. The results of these performance evaluations, which use established benchmarks, indicate that persistence can be implemented on general-purpose machines without imposing significant overhead above and beyond the fundamental costs of data transfer to and from secondary storage. Moreover, the results show that software-mediated implementation techniques can be a competitive alternative to techniques that rely on low-level support from the operating system and hardware

Residency Check Elimination for Object- Oriented Persistent Languages

We explore the ramifications of object residency assumptions and their impact on residency checking for several subroutine dispatch scenarios: procedural, static object-oriented, and dynamic (virtual) object-oriented. We obtain dynamic counts of the residency checks necessary for execution of several benchmark persistent programs under each of these scenarios. The results reveal that significant reductions in the number of residency checks can be achieved through application of residency rules derived from the dispatch scenario under which a program executes, as well as additional constraints specific to the implementation language. Keywords: residency checks, optimization, object-orientation, static/dynamic dispatch 1 Introduction Persistent programming languages view permanent storage as a stable extension of volatile memory, in which objects may be dynamically allocated, but which persists from one invocation to the next. A persistent programming language and object store together..

Lightweight Write Detection and Checkpointing for Fine-Grained Persistence

Many systems must dynamically track writes to cached data, for the purpose of reconciling those updates with respect to the permanent or global state of the data. For example, distributed systems employ coherency protocols to ensure a consistent view of shared data. Similarly, database systems log updates both for concurrency control and to ensure the resilience of those updates in the face of system failures. Here, we measure and compare the absolute performance of several alternative mechanisms for the lightweight detection of writes to cached data in a persistent system, and the relative overhead to log those writes to stable storage in the form of a checkpoint. A checkpoint defines a consistent state to which the system will be restored in the event of any subsequent failure. The effcient detection and logging of updates is critical to the performance of persistent systems that embody a fine-grained data model, since per-object overheads are typically very low. Our results reveal a wide range of performance for the alternatives, indicating that the right choice of mechanism is important. They also demonstrate that software write detection mechanisms can significantly outperform approaches that rely solely on the hardware and operating system