Representative workloads and principled methodologies are the foundation of performance analysis, which in turn provides the empirical grounding for much of the innovation in systems research. However, benchmarks are hard to maintain, methodologies are hard to develop, and our field moves fast. The tension between our fast-moving fields and their need to maintain their methodological foundations is a serious challenge. This paper explores that challenge through the lens of Java performance analysis. Lessons we draw extend to other languages and other fields of computer science. In this paper we: i) introduce a complete overhaul of the DaCapo benchmark suite [6], characterizing 22 new and/or refreshed workloads across 47 dimensions, using principal components analysis to demonstrate their diversity, ii) demonstrate new methodologies and how they are integrated into an easy to use framework, iii) use this framework to conduct an analysis of the state of the art in production Java performance, and iv) motivate the need to invest in renewed methodologies and workloads, using as an example a review of contemporary production garbage collector performance. We highlight the danger of allowing methodologies to lag innovation and respond with a suite and new methodologies that nudge forward some of our field's methodological foundations. We offer guidance on maintaining the empirical rigor we need to encourage profitable research directions and quickly identify unprofitable ones.

Understanding the contribution of geophysical variables is vital for identifying the ore indicator regions. Both magnetometry and gamma-rays are used to identify the geophysical signatures of the rocks. Density is another key variable for tonnage estimation in mining and needs to be re-estimated in areas of change when a boundary update has been conducted. Modelling these geophysical variables in 3D will enable investigate the properties of the rocks and improve our understanding of the ore. Gaussian Process (GP) was previously used to generate 3D spatial models for grade estimation using geochemical assays. This study investigates the influence of the following two factors on the GP-based autonomously generated 3D geophysical models: the resolution of the input data and the number of nearest samples used in the training process. A case study was conducted on a typical Hammersley Ranges iron ore deposit using geophysical logs, including density, collected from the exploration holes.

For banded iron formation-hosted deposits accurate boundary modelling is critical to ore-grade estimation. Key to estimation fidelity is the accurate separation of the different domains within the ore body, requiring modelling of the boundaries between domains. This yields both theoretical and application challenges. We present a series of solutions for application challenges that arise when modelling large-scale boundaries employing a composition of Gaussian Process models on exploration and production hole data. We demonstrate these in the banded iron formation-hosted iron ore deposits in the Hamersley Province of Western Australia. We present solutions to several challenges: the inclusion of information derived from a geologist-defined boundary estimate to incorporate domain knowledge in data sparse regions, the incorporation of unassayed production holes that are implicitly defined as waste to augment production hole assay data, and a more holistic method of defining regional bounds and spatial rotations for Gaussian Process modelling of local spaces. Solution are evaluated against a range of metrics to show performance improvements over the manually performed estimation by an expert geologist of the boundaries delineating the ore body domains. Reconcilliation scores are used for evaluating the quality of predicted domain boundaries against measured production data. The predicted and in situ surfaces are also qualitatively evaluated against production data to ensure that the models were evaluated to be geologically sound by an expert in the field. In particular, better fidelity is shown when separating mineralised and non-mineralised ore, consequently improving the estimation of the ore-grades present in the mine site.

This article presents a Bayesian framework for manipulating mesh surfaces with the aim of improving the positional integrity of the geological boundaries that they seek to represent. The assumption is that these surfaces, created initially using sparse data, capture the global trend and provide a reasonable approximation of the stratigraphic, mineralization, and other types of boundaries for mining exploration, but they are locally inaccurate at scales typically required for grade estimation. The proposed methodology makes local spatial corrections automatically to maximize the agreement between the modeled surfaces and observed samples. Where possible, vertices on a mesh surface are moved to provide a clear delineation, for instance, between ore and waste material across the boundary based on spatial and compositional analysis using assay measurements collected from densely spaced, geo-registered blast holes. The maximum a posteriori (MAP) solution ultimately considers the chemistry observation likelihood in a given domain. Furthermore, it is guided by an a priori spatial structure that embeds geological domain knowledge and determines the likelihood of a displacement estimate. The results demonstrate that increasing surface fidelity can significantly improve grade estimation performance based on large-scale model validation.

When modelling a stratified orebody, accurately representing the dip and dip direction is important for accurate resource estimation. In the banded iron formation-hosted iron ore deposits in the Pilbara region of Western Australia, these quantities can be determined using marker shales from nearby holes. These marker shales are identified using natural gamma logs and are generally manually processed. Therefore, an automated method for matching natural gamma logs between holes is desirable. Dynamic time warping (DTW) can match two signals where there is stretching or distortion. This study presents a modified, iterative version of DTW for matching downhole natural gamma logs. This new method accounts for large differences in length of the two signals by comparing different segments of the signals. Several metrics were then used to rank potential matches between signals. The proposed iterative DTW method had an accuracy of 90%, compared with 67% for the standard DTW. Once matched, signals can be used to estimate the bedding angle at each hole. A point in one hole was matched to as many nearby holes as possible, creating a set of points located on the same surface. A localized plane was then fitted to these points. These bedding angles were used to reconstruct a surface representing the bedding. While the signal matching was accurate, the sparsity of correctly matched holes limits the accuracy of the calculated surface. Even with sparse gradient fields, a reasonable approximation of the bedding could be achieved.

To process real-world datasets, modern data-parallel systems often require extremely large amounts of memory, which are both costly and energy inefficient. Emerging non-volatile memory (NVM) technologies offer high capacity compared to DRAM and low energy compared to SSDs. Hence, NVMs have the potential to fundamentally change the dichotomy between DRAM and durable storage in Big Data processing. However, most Big Data applications are written in managed languages and executed on top of a managed runtime that already performs various dimensions of memory management. Supporting hybrid physical memories adds a new dimension, creating unique challenges in data replacement. This article proposes Panthera, a semantics-aware, fully automated memory management technique for Big Data processing over hybrid memories. Panthera analyzes user programs on a Big Data system to infer their coarse-grained access patterns, which are then passed to the Panthera runtime for efficient data placement and migration. For Big Data applications, the coarse-grained data division information is accurate enough to guide the GC for data layout, which hardly incurs overhead in data monitoring and moving. We implemented Panthera in OpenJDK and Apache Spark. Based on Big Data applications’ memory access pattern, we also implemented a new profiling-guided optimization strategy, which is transparent to applications. With this optimization, our extensive evaluation demonstrates that Panthera reduces energy by 32–53% at less than 1% time overhead on average. To show Panthera’s applicability, we extend it to QuickCached, a pure Java implementation of Memcached. Our evaluation results show that Panthera reduces energy by 28.7% at 5.2% time overhead on average.

Modern data-parallel systems such as Spark rely increasingly on in-memory computing that can significantly improve the efficiency of iterative algorithms. To process real-world datasets, modern data-parallel systems often require extremely large amounts of memory, which are both costly and energy-inefficient. Emerging non-volatile memory (NVM) technologies offers high capacity compared to DRAM and low energy compared to SSDs. Hence, NVMs have the potential to fundamentally change the dichotomy between DRAM and durable storage in Big Data processing. However, most Big Data applications are written in managed languages (e.g., Scala and Java) and executed on top of a managed runtime (e.g., the Java Virtual Machine) that already performs various dimensions of memory management. Supporting hybrid physical memories adds in a new dimension, creating unique challenges in data replacement and migration. This paper proposes Panthera, a semantics-aware, fully automated memory management technique for Big Data processing over hybrid memories. Panthera analyzes user programs on a Big Data system to infer their coarse-grained access patterns, which are then passed down to the Panthera runtime for efficient data placement and migration. For Big Data applications, the coarse-grained data division is accurate enough to guide GC for data layout, which hardly incurs data monitoring and moving overhead. We have implemented Panthera in OpenJDK and Apache Spark. An extensive evaluation with various datasets and applications demonstrates that Panthera reduces energy by 32 – 52% at only a 1 – 9% execution time overhead.

Due to the boom of big data applications,the amount of data being processed by servers is increasing rapidly.In order to improve processing and response speed,industry is deploying inmemory big data computing systems,such as Apache Spark.However,traditional DRAM memory cannot satisfy the large memory request of these systems for the following reasons:firstly,the energy consumption of DRAM can be as high as 40％ of the total;secondly,the scaling of DRAM manufacturing technology is hitting the limit.As a result,heterogeneous memory integrating DRAM and NVM (non-volatile memory) is a promising candidate for future memory systems.However,because of the longer latency and lower bandwidth of NVM compared with DRAM,it is necessary to place data in appropriate memory module to achieve ideal performance.This paper analyzes the memory access behavior of Spark applications and proposes a heterogeneous memory programming framework based on Spark.It is easy to apply this framework to existing Spark applications without rewriting the code.Experiments show that for Spark benchmarks,by utilizing our framework,only placing 20％～25％ data on DRAM and the remaining on NVM can reach 90％ of the performance when all the data is placed on DRAM.This leads to an improved performance-dollar ratio compared with DRAM-only servers and the potential support for larger scale in-memory computing applications.

Hybrid memory, which leverages the benefits of traditional DRAM and emerging memory technologies, is a promising alternative for future main memory design. However popular management policies through memory-access recording and page migration may invoke non-trivial overhead in execution time and hardware space. Nowadays, managed language applications are increasingly dominant in every kind of platform. Managed runtimes provide services for automatic memory management. So it is important to adapt them for the underlying hybrid memory.This paper explores two opportunities, heap partition placement and object promotion, inside managed runtimes for allocating hot data in a fast memory space (fast-space) without any access recording or data migration overhead. For heap partition placement, we quantitatively analyze LLC miss density and performance effect for each partition. Results show that LLC misses especially store misses mostly hit nursery partitions. Placing nursery in fast-space, which is 20% total memory footprint of tested benchmarks on average, causes only 10% performance difference from all memory footprint in fast-space. During object promotion, hot objects will be directly allocated to fast-space. We develop a tool to analyze the LLC miss density for each method of workloads, since we have found that the LLC misses are mostly triggered by a small percentage of the total set of methods. The objects visited by the top-ranked methods are recognized as hot. Results show that hot objects do have higher access density, more than 3 times of random distribution for SPECjbb and pmd, and placing them in fast-space further reduces their execution time by 6% and 13% respectively.

Almost all problems known to theoretical economics and econometrics crop up in some guise or other in housing analysis. This is both the beauty and the frustration of the subject. Furthermore, the field is multi-disciplinary. Sociologists or political scientists, for example, who are also heavily involved in housing, would probably be horrified by the approaches and models adopted in this book.

Since 1960, reference counting has been a popular means of ga rbage collection. Reference counters achieve low pause times by u sing local data to determine liveness, but the use of this local da t le ves the collector unable to collect cyclic garbage. Recent adva nces such as the use of coalescing and generations have dramatica lly improved the throughput of reference counting collectors. However, the efficient collection of cyclic garbage remains a st umbling block. This paper responds to this shortcoming with MSCD, a c oncurrent tracing algorithm that takes advantage of informat ion available within a reference counted environment. MSCD outperfo rms alternatives such as trial deletion and backup tracing by up to a factor of two. This advantage is the result of three insights: 1) objects subject to races during concurrent tracing are trivially id entified using data already established by the reference counter, 2) th e trace performed by the mark phase of the collector can safely omit o bjects statically identified as inherently acyclic, and 3) th e sweep phase of the collector can be reduced to just those objects wh ich are potentially cyclic garbage. We show that MSCD works with state of the art reference counting collectors — which allow large numbers of heap mutations to be ignored — without affecting t he correctness or completeness of the algorithm. We provide de tailed performance comparisons of concurrent and non-concurrent v rsions of our cycle collector, a simple mark-sweep cycle dete ctor, and a high-performance implementation of trial deletion.

A powerful feature of the Java programming language is its us er-definable class loading policy, which when combined with the namespace independence between class loa ders, llows portable implementation of semidynamic program transformations. Such transformations ca n be used for a range of purposes, including optimization and semantic extension. In this paper we present a framework for semantic extensions in Java. This framework consists of a number of simple but powerful transformations that, among o ther things, allow us to semantically extend Java to provide orthogonal persistence. The use of semi-dynamic program transformations lends our o rthogonally persistent Java a number of important qualities, including simplicity, portabilit y and a clean model of persistence. Significantly, our implementation is efficient, outperforming PJama, a wel l-known orthogonally persistent Java, which is based on a modified virtual machine. In addition to describing the application of these transfor mations to orthogonally persistent Java, we foreshadow their use in a number of other contexts, includin g implementing multiple inheritance for Java, and dynamic instance and class versioning.

dJVM provides a distributed Java virtual Machine (JVM) on a cluster. It hides the distributed nature of the underlying machine from a Java application by presenting a single system image (SSI) to that application. dJVM is based on the Jikes RVM [Alpern et al, 1999] (a JVM written entirely in Java) and is the first distributed implementation of the Jikes RVM. This provides a framework for exploring a range of distributed runtime support algorithms on large clusters. Implementing this system using the Jikes RVM raises a number of issues that are addressed in this paper.

Orthogonally persistent Java combines the power of abstraction over persistence with Java’s rich programming environment. In this paper we report our experience in designing and implementing orthogonally persistent Java. Our design approach is anchored by the view that any system that brings together Java and orthogonal persistence should as far as possible avoid diluting the strengths of Java or the principles of orthogonal persistence. Our approach is thus distinguished by three features: complete transparency of persistence, support for both intra and inter application concurrency through ACID transactions, and the preservation of Java’s property of portability. In addition to discussing design and implementation, we present results that show that our approach performs credibly.

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, relatively few papers address the problem of implementing garbage collection in a transactional storage system.Atransactional GC algorithm must operate correctly in the face of failure, and in particular must deal with the problem of transaction abort, which by undoing changes such as the deletion of references, subverts the GC reachability axiom of 'once garbage always garbage'.In this paper we make two key contributions. First, we present a generic approach to the design of transactional collectors that promotes clarity, generality, and understandability, and then using this approach, we present a new transactional garbage collection algorithm, TMOS. Our design approach brings together three independent components--a mutator, a transactional store, and a GC algorithm. TMOS represents the application of the Mature Object Space family of GC algorithms to the transactional context through our approach to transactional GC design.

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, credit recovery and task balancing, may be suitably described; and then map four centralized garbage collectors: reference counting; mark/scan; a generational scheme; and the Mature Object Space collector (MOS) onto this description. The advantage of our approach is that, by separating the issues of distribution and collection, we alleviate the difficulty of inventing, understanding, and comparing distributed garbage collection techniques.

This paper reports the design and implementation of Platypus, a transactional object store. The twin goals of flexibility and performance dominate the design of Platypus. The design includes: support for SMP concurrency; standalone, client-server and client-peer distribution configurations; configurable logging and recovery; and object management which can accommodate garbage collection and clustering mechanisms. The first implementation of Platypus incorporates a number of innovations. (1)A new recovery algorithm derived from ARIES that removes the need for log sequence numbers to be present in store pages. (2)A zero-copy memory-mapped buffer manager with controlled write-back behavior. (3)A data structure for highly concurrent map querying.We present performance results comparing Platypus with SSM, the storage layer of the SHORE object store. For both medium and small OO7 workloads Platypus outperforms SHORE across a wide range of benchmark operations in both 'hot' and 'cold' settings.

A powerful feature of the Java(TM) programming language is its user-definable class loading policy, which when combined with the namespace independence between class loaders, allows portable implementation of semi-dynamic program transformations. Such transformations can be used for a range of purposes, including optimization and semantic extension. In this paper we present a framework for semantic extensions in Java. This framework consists of a number of simple but powerful transformations that, among other things, allow us to semantically extend Java to provide orthogonal persistence. The use of semidynamic program transformations lends our orthogonally persistent Java a number of important qualities, including simplicity, portability and a clean model of persistence. Significantly, our implementations are efficient and can outperform (in some cases) PJama(TM), a well-known orthogonally persistent Java, which is based on a modified virtual machine. In addition to describing the application of these transformations to orthogonally persistent Java, we foreshadow their use in a number of other contexts, including dynamic instance versioning and instrumentation. Copyright (C) 2000 John Wiley & Sons, Ltd.

An orthogonally persistent system maintains data beyond an y program execution. The principle of persistence identification implies that persistence by reachability be used to de ermine which objects are to be maintained in the store. A particular execution may cause objects to become unreachab le—garbage. Any efficient implementation of a persistent system must incorporate a garbage collector to remove these objects. The availability of commodity machines and sophisticated n tworking technology makes it possible to construct low cost distributed memory machines. One way to harness the calability of these machines is with a single image object store. However, the resulting distribution of data i ncreases the system complexity. A distributed garbage collector must deal with safely updat ing meta-data across distributed processors as well as detecting cyclic garbage that exists on multiple process ors. DMOS [Hudson et al. 1997] is a distributed garbage collector that is derived from the MOS and PMOS garbage colle tors. DMOS is one of the few collectors that is distributed, asynchronous, non-disruptive and complete. DMOS involves several interacting protocols, making it dif ficult to understand and implement. Close examination of these protocols reveal deficiencies in the information pr opagated, and a race condition between the train isolation detection protocol and the reference information protocol . This paper addresses these issues, augments the informati n propagated and modifies the termination algorithm to ensure that the collector behavior is safe and correct. These corrections and additions enable the DMOS algorithm t o be realized. As a result, it is possible to approach the goal of implementing a complete distributed persistent object store.