Eliot B. Moss

Eliot B. Moss
University of Massachusetts Amherst | UMass Amherst · College of Information and Computer Sciences

PhD

About

203
Publications
26,010
Reads
How we measure 'reads'
A 'read' is counted each time someone views a publication summary (such as the title, abstract, and list of authors), clicks on a figure, or views or downloads the full-text. Learn more
9,999
Citations
Additional affiliations
September 1985 - May 2016
University of Massachusetts Amherst
Position
  • Professor (Full)
May 1985 - May 2015
University of Massachusetts Amherst
Position
  • Professor (Full)

Publications

Publications (203)
Article
Full-text available
We describe the design and prototype implementation of a dialect of Java, XJ, that supports both closed and open nested transactions. As we have previously advocated, open nesting most naturally attaches to the class as the primary abstraction mechanism of Java. The resulting design allows natural expression of layered abstractions for concurrent d...
Conference Paper
We present Elephant Tracks (ET), a dynamic program analysis tool for Java that produces detailed traces of garbage collection-related events, including object allocations, object deaths, and pointer updates. Like prior work, our tracing tool is based on the Merlin algorithm [6,7], but offers several substantial new capabilities. First, it is much m...
Article
The Communications Web site, http://cacm.acm.org, features more than a dozen bloggers in the BLOG@CACM community. In each issue of Communications, we'll publish selected posts or excerpts.twitterFollow us on ...
Conference Paper
We present Elephant Tracks (ET), a dynamic program analysis tool for Java that produces detailed traces of garbage collection-related events, including object allocations, object deaths, and pointer updates. Like prior work, our tracing tool is based on the Merlin algorithm [6,7], but offers several substantial new capabilities. First, it is much m...
Article
We introduce Elephant Tracks (ET), a dynamic program analysis tool for producing traces of garbage collection events, including object allocations, object deaths, and pointer updates. Like prior work, our tracing tool is based on the Merlin algorithm Hertz et al. [2002], but offers several substantial new capabilities. First, it is much more precis...
Article
Full-text available
The indirection of object accesses is a common theme for target domains as diverse as transparent distribution, persistence, and program instrumentation. Virtualizing accesses to fields and methods (by redirecting calls through accessor and indirection methods) allows interposition of arbitrary code, extending the functionality of an application be...
Conference Paper
Full-text available
We describe our progress building the program Reduction- Finder, which uses o-the-shelf SAT solvers together with the Cmodels system to automatically search for reductions between decision problems described in logic.
Article
Full-text available
The transformation of large, off-the-shelf Java applications to support complex new functionality essentially requires generation of an entirely new application that retains the execution semantics of the original. We describe such a whole-program modification in the context of RuggedJ, a dynamic transparent Java distribution system.We discuss the...
Conference Paper
Full-text available
The power of high-level languages lies in their abstraction over hardware and software complexity, leading to greater security, bet- ter reliability, and lower development costs. However, opaque ab- stractions are often show-stoppers for systems programmers, forc- ing them to either break the abstraction, or more often, simply give up and use a dif...
Conference Paper
Full-text available
The indirection of object accesses is a common theme for target domains as diverse as transparent distribution, persistence, and pro- gram instrumentation. Virtualizing accesses to fields and methods (by redirecting calls through accessor and indirection methods) al- lows interposition of arbitrary code, extending the functionality of an applicatio...
Article
We introduce CASL, the CoGenT Architecture Specification Language, a mixed behavioral–structure architecture description language designed to facilitate fast-prototyping and tool generation for computer architectures with deep pipelines and complicated timing. We motivate a number of CASL features using examples drawn from modeling the IBM Cell Bro...
Article
Full-text available
Evaluation methodology underpins all innovation in experimental computer science. It requires relevant workloads, appropriate experimental design, and rigorous analysis. Unfortunately, methodology is not keeping pace with the changes in our field. The rise of managed languages such as Java, C#, and Ruby in the past decade and the imminent rise of c...
Conference Paper
One of the most difficult tasks a compiler writer faces is the construction of the code generator. The code generator is that part of the compiler that translates compiler intermediate representation (IR) into instructions for a target machine. Unfortunately, implementing a code generator "by hand" is a difficult, time consuming, and error prone ta...
Conference Paper
While modern workloads are increasingly interactive and resource-intensive (e.g., graphical user interfaces, browsers, and multimedia players), current operating sys- tems have not kept up. These operating systems, which evolved fromcore designs that date to the 1970s and 1980s, provide good support for batch and command-line applica- tions, but th...
Conference Paper
This panel will explore the reasons that Women, to this day, are still an under represented minority in Computing. The OOPSLA Community will acquire insight on how to attract and retain women into the industry, by learning from successful women and men working in the field today.
Article
Full-text available
Modern JVM implementations interleave execution with compilation of “hot” methods to achieve reasonable performance. Since compilation overhead impacts the execution time of the application and induces run-time pauses, we explore offloading compilation onto a compilation server. In this article, we present the design, implementation, and evaluation...
Conference Paper
Full-text available
We overview CASL, the CoGenT architecture specification language, a mixed behavioral-structure architecture description language designed to facilitate fast prototyping and tool generation for computer architectures with deep pipelines and complicated timing. We show how CASL can describe pipelines, dynamic information contexts, and contention usin...
Conference Paper
Full-text available
Transactional memory (TM) promises to simplify concurrent programming while providing scalability competitive to fine-grained locking. Language-based constructs allow programmers to denote atomic regions declaratively and to rely on the underlying system to provide transactional guarantees along with concurrency. In contrast with fine-grained locki...
Article
Full-text available
Pretenuring can reduce copying costs in garbage collectors by allocating long-lived objects into regions that the garbage collector will rarely, if ever, collect. We extend p revious work on pretenuring as follows. (1) We produce pretenuring advice that is neutral with respect to the garba ge collector algorithm and configuration. We thus can and d...
Article
We offer a reference model for nested transactions at the level of memory accesses, and sketch possible hardware architecture designs that implement that model. We describe both closed and open nesting. The model is abstract in that it does not relate to hardware, such as caches, but describes memory as seen by each transaction, memory access confl...
Conference Paper
Since benchmarks drive computer science research and industry product development, which ones we use and how we evaluate them are key questions for the community. Despite complex runtime tradeoffs due to dynamic compilation and garbage collection required for Java programs, many evaluations still use methodologies developed for C, C++, and Fortran....
Article
Full-text available
Since benchmarks drive computer science research and industry product development, which ones we use and how we evaluate them are key questions for the community. Despite complex runtime tradeoffs due to dynamic compilation and garbage collection required for Java programs, many evaluations still use methodologies developed for C, C++, and Fortran....
Article
Compiler optimizations are difficult to implement and add complexity to a compiler. For this reason, compiler writers are selective about implementing them: they implement only the ones that they believe will be beneficial. To support compiler writers in this, we describe a method for measuring the cost and benefits of compiler optimizations, both...
Conference Paper
Full-text available
We introduce a new class of compiler heuristics: hybrid optimizations. Hybrid optimizations choose dynamically at compile time which optimization algorithm to apply from a set of different algorithms that implement the same optimization. They use a heuristic to predict the most appropriate algorithm for each piece of code being optimized. Specifica...
Article
Full-text available
Programmers are writing a rapidly growing number of programs in object-oriented languages, such as Java and C#, that require garbage collection. Garbage collection traces and simulation speed up research by enabling deeper understandings of object lifetime behavior and quick exploration and design of new garbage collection algorithms. When gene...
Conference Paper
Full-text available
Existing virtual memory systems usually work well with applications written in C and C++, but they do not provide adequate support for garbage-collected applications. The performance of garbage-collected applications is sensitive to heap size. Larger heaps reduce the frequency of garbage collections, making them run several times faster. How- ever,...
Article
Full-text available
We describe semantics for serializable (safe) open nested transactions. Given these semantics, we then suggest hardware necessary to support them directly. We further consider some useful, but not seri-alizable, applications for open nesting, and their hardware implications. We focus primarily on linear nesting, which we previously argued to be mor...
Article
Full-text available
It is currently difficult fully to understand the perfor- mance of a modern dynamic programming language system, such as Java. One must observe execution in the context of specific architectures in order to evaluate the effects of op- timizations. To do this we require simulators and compiler back-ends for a wide variety of machines that are capabl...
Article
Full-text available
This paper is based on a five-day workshop on "Atomicity in System Design and Execution" that took place in Schloss Dagstuhl in Germany [5] in April 2004 and was attended by 32 people from different scientific communities. The participants included researchers from the four areas of• database and transaction processing systems, • fault tolerance an...
Article
Full-text available
This paper is based on a five-day workshop on "Atomicity in System Design and Execution" that took place in Schloss Dagstuhl in Germany [5] in April 2004 and was attended by 32 people from different scientific communities. The participants included researchers from the four areas of• database and transaction processing systems,• fault tolerance and...
Article
Full-text available
We argue that atomicity, i.e., atomic actions with most of the traditional "ACID" prop- erties, namely atomicity, consistency, and isolation but perhaps not durability, should be provided as a fundamental first class resource in computer systems. This implies coherent, convenient, and well-engineered support from the hardware, through the run-time...
Article
Full-text available
This paper describes the evolution of the Jikes™ Research Virtual Machine project from an IBM internal research project, called Jalapeño, into an open-source project. After summarizing the original goals of the project, we discuss the motivation for releasing it as an open-source project and the activities performed to ensure the success of the pro...
Article
Full-text available
Java is becoming an important platform for memory-constrained consumer devices such as PDAs and cellular phones, because it provides safety and portability. Since Java uses garbage collection, efficient garbage collectors that run in constrained memory are essential. Typical collection techniques used on these devices are mark-sweep and mark-compac...
Article
Full-text available
DSSWattch is a powerful tool that allows users of the Dynamic SimpleScalar (DSS) toolset to obtain cycle-accurate power estimates in a detailed out-of-order simulation environment. DSSWattch is an adap-tation of Wattch, originaly for SimpleScalar on the Alpha and PISA architectures, to DSS for the PowerPC architecture.
Conference Paper
Full-text available
Instruction scheduling is a compiler optimization that can improve program speed, sometimes by 10% or more, but it can also be expensive. Furthermore, time spent optimizing is more important in a Java just-in-time (JIT) compiler than in a traditional one because a JIT compiles code at run time, adding to the running time of the program. We found th...
Article
Full-text available
The selection of heap size has an enormous impact on the performance of applications that use garbage collection. A heap that barely meets the application's minimum requirements will result in excessive garbage collection overhead, while a heap that exceeds physical memory will cause paging. Choosing the best heap size a priori is impossible in mul...
Article
Programmers are writing a large and rapidly growing number of programs in object-oriented languages such as Java that require garbage collection (GC). To explore the design and evaluation of GC algorithms quickly, researchers are using simulation based on traces of object allocation and lifetime behavior. The brute force method generates perfect tr...
Conference Paper
Full-text available
Abstract It is currently difficult fully to understand the perfor - mance of a modern dynamic programming language system, such as Java One must observe execution in the context of
Conference Paper
Full-text available
As improvements in processor speed continue to outpace improve- ments in cache and memory speed, poor locality increasingly degrades performance. Because copying garbage collectors move objects, they have an opportunity to improve locality. However, no static copy- ing order is guaranteed to match program traversal orders. This pa- per introduces o...
Article
Full-text available
Java is becoming an important platform for memory-constrained con-sumer devices such as PDAs and cellular phones, because it provides safety and portability. Since Java uses garbage collection, efficient garbage collectors that run in constrained memory are essential. Typ-ical collection techniques used on these devices are mark-sweep and mark-comp...
Article
Heap size has a huge impact on the performance of garbage collected applications. A heap that barely meets the application's needs causes excessive GC overhead, while a heap that exceeds physical memory induces paging. Choosing the best heap size a priori is impossible in multiprogrammed environments, where physical memory allocations to processes...
Article
Copying garbage collectors have a number of advantages over non-copying collectors, including cheap allocation and avoiding fragmentation. However, in order to provide completeness (the guarantee to reclaim each garbage object eventually), standard copying collectors require space equal to twice the size of the maximum live data for a program. We p...
Article
COOPERATIVE HARDWARE/SOFTWARE CACHING FOR The memory system remains a major performance bottleneck in modern and future architectures. In this dissertation, we propose a hardware/software cooperative approach and demonstrate its effectiveness. This approach combines the global yet imperfect view of the compiler with the timely yet narrow-scope cont...
Conference Paper
Full-text available
Copying garbage collectors have a number of advantages over non-copying collectors, including cheap allocation and avoiding fragmentation. However, in order to provide completeness (the guarantee to reclaim each garbage object eventually), standard copying collectors require space equal to twice the size of the maximum live data for a program. We p...
Article
Full-text available
Pretenuring can reduce copying costs in garbage collectors by allocating long-lived objects into regions that the garbage collector will rarely, if ever, collect. We extend previous work on pretenuring as follows. (1) We produce pretenuring advice that is neutral with respect to the garbage collector algorithm and configuration. We thus can and do...
Article
While the design of garbage collection algorithms has come of age, the analysis of these algorithms is still in its infancy. Current analyses are limited to merely documenting costs of individual collector executions; conclusive results, measuring across entire programs, require a theoretical foundation from which proofs can be offered. A theoretic...
Conference Paper
Full-text available
To understand the performance of modern Java systems one must observe execution in the context of specific architectures. It is also important that we make these observations using a compiler that is capable of producing optimizations that are specialized to the target machine. Current architectural simulators, however, provide little or no support...
Article
The growing use in concurrent systems of languages that require garbage collection (GC), such as Java, is raising practical interest in concurrent GC. Sapphire is a new algorithm for concurrent copying GC for Java. It stresses minimizing the amount of time any given application thread may need to block to support the collector. In particular, Sapph...
Article
Full-text available
Current user-mode machine simulators typically do not support simulation of dynamic compilation, threads, or garbage collection, all of which Java Virtual Machines (JVMs) require. In this paper, we describe, evaluate, and validate Dynamic SimpleScalar (DSS). DSS is a tool that simulates Java programs running on a JVM, using just-in-time compilation...
Article
EFFECTIVE COMPILE-TIME ANALYSIS FOR DATA SEPTEMBER 2002 BRENDON D. CAHOON B.A., CLARK UNIVERSITY M.S., UNIVERSITY OF MASSACHUSETTS, AMHERST Ph.D., UNIVERSITY OF MASSACHUSETTS AMHERST Directed by: Professor Kathryn S. McKinley The memory hierarchy in modern architectures continues to be a major performance bottleneck. Many existing techniques for im...
Article
Full-text available
We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in...
Article
Full-text available
Until recently, the best performing copying garbage collectors used a generational policy which repeatedly collects the very youngest objects, copies any survivors to an older space, and then infrequently collects the older space. A previous study that used garbage collection simulation pointed to potential improvements by using an Older-First copy...
Article
Full-text available
Modem handheld computers are certainly capable of running general purpose applications, such as Java virtual machines. However, short battery life rather than computational capability often limits the usefulness of handheld computers. This paper considers how to reduce the energy consumption of Java applications. Broadly speaking, there are three i...
Conference Paper
Full-text available
We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts , collects belts independently, and collects increments on a belt in...
Article
Modern generational garbage collectors look for garbage among the young objects, because they have high mortality; however, these objects include the very youngest objects, which clearly are still live. We introduce new garbage collection algorithms, called age-based, some of which postpone consideration of the youngest objects. Collecting less tha...
Article
Full-text available
Many concurrent garbage collection (GC) algorithms have been devised, but few have been implemented and evaluated, particularly for the Java programming language. Sapphire is an algorithm we have devised for concurrent copying GC. Sapphire stresses minimizing the amount of time any given application thread may need to block to support the collector...
Article
DATA REORGANIZATION FOR IMPROVING CACHE FEBRUARY 2002 SHARAD KUMAR SINGHAI B.E., UNIVERSITY OF BHOPAL, BHOPAL M.S., INDIAN INSTITUTE OF TECHNOLOGY, MADRAS Ph.D., UNIVERSITY OF MASSACHUSETTS AMHERST Directed by: Professor Kathryn S. M c Kinley Hardware trends have increased the disparity of processor and main memory performance. Processors are becom...
Conference Paper
Full-text available
While the design of garbage collection algorithms has come of age, the analysis of these algorithms is still in its infancy. Current analyses are limited to merely documenting costs of individual collector executions; conclusive results, measuring across entire programs, require a theoretical foundation from which proofs can be offered. A theoretic...
Conference Paper
Full-text available
Programmers are writing a large and rapidly growing number of programs in object-oriented languages such as Java that require garbage collection (GC). To explore the design and evaluation of GC algorithms quickly, researchers are using simulation based on traces of object allocation and lifetime behavior. The traces by collecting only periodically,...
Conference Paper
Full-text available
Modern handheld computers are certainly capable of running general purpose applications, such as Java virtual machines. However, short battery life rather than computational capability often limits the usefulness of handheld computers. This paper considers how to reduce the energy consumption of Java applications.Broadly speaking, there are three i...
Conference Paper
Until recently, the best performing copying garbage collectors used a generational policy which repeatedly collects the very youngest objects, copies any survivors to an older space, and then infrequently collects the older space. A previous study that used garbage-collection simulation pointed to potential improvements by using an Older-First copy...
Article
Full-text available
Object-oriented programming languages provide many software engineering benefits, but these often come at a performance cost. Object-oriented programs make extensive use of method invocations and pointer dereferences, both of which are potentially costly on modern machines. We show how to use types to produce effective, yet simple, techniques that...
Article
Full-text available
collector copying for generational and older-first collectors. 1. MOTIVATION AND APPROACH Generational copying garbage collection partitions the heap into age-based generations of objects, where age is measured in the amount of allocation (the accepted practice in the garbage collection literature). Collection consists of three phases: (1) identify...
Article
Full-text available
Visual applications need to represent, manipulate, store, and retrieve both raw and processed visual data. Existing relational and object-oriented database systems fail to offer satisfactory visual data management support because they lack the kinds of representations, storage structures, indices, access methods, and query mechanisms needed for vis...
Article
Full-text available
A visual application is an application that manipulates visual data as part of its processing. Visual applications need to represent, manipulate, store, and retrieve both raw and processed visual data. Existing relational and object-oriented database systems fail to offer satisfactory visual data management support because they lack the kinds of re...
Conference Paper
Full-text available
We propose an effective methodology in which a distributed garbage collector may be derived from a distributed termination algorithm and a centralized garbage collector in a manner that preserves interesting properties of the original collector, such as completeness. To illustrate our technique, we show how two distributed termination algorithms, c...
Article
Full-text available
The IA-64, Intel's 64-bit instruction set architecture, exhibits a number of interesting architectural features. Here we consider those features as they relate to supporting garbage collection (GC). We aim to assist GC and compiler implementors by describing how one may exploit features of the IA-64. Along the way, we record some previously unpubli...
Article
Full-text available
. Defining persistence in terms of reachability is fundamental to achieving orthogonality of persistence. It is implicit to the principles of orthogonal persistence and is a part of the ODMG 3.0 data objects standard. Although space reclamation in the context of persistence by reachability can be achieved automatically using garbage collection, rel...