Emulating and evaluating hybrid memory for managed languages on NUMA hardware

Non-volatile memory (NVM) has the potential to become a mainstream memory technology and challenge DRAM. Researchers evaluating the speed, endurance, and abstractions of hybrid memories with DRAM and NVM typically use simulation, making it easy to evaluate the impact of different hardware technologies and parameters. Simulation is, however, extremely slow, limiting the applications and datasets in the evaluation. Simulation also precludes critical workloads, especially those written in managed languages such as Java and C#. Good methodology embraces a variety of techniques for evaluating new ideas, expanding the experimental scope, and uncovering new insights. This paper introduces a platform to emulate hybrid memory for managed languages using commodity NUMA servers. Emulation complements simulation but offers richer software experimentation. We use a thread-local socket to emulate DRAM and a remote socket to emulate NVM. We use standard C library routines to allocate heap memory on the DRAM and NVM sockets for use with explicit memory management or garbage collection. We evaluate the emulator using various configurations of write-rationing garbage collectors that improve NVM lifetimes by limiting writes to NVM, using 15 applications and various datasets and workload configurations. We show emulation and simulation confirm each other's trends in terms of writes to NVM for different software configurations, increasing our confidence in predicting future system effects. Emulation brings novel insights, such as the non-linear effects of multi-programmed workloads on NVM writes, and that Java applications write significantly more than their C++ equivalents. We make our software infrastructure publicly available to advance the evaluation of novel memory management schemes on hybrid memories

Ciceronian Rhetoric and the Art of Medieval French Hagiography

In the lives of the saints, it is clear that medieval hagiography reflects the statement, "Antiquity has a twofold life in the Middle Ages: reception and transformation." The vernacular poems of the virgin martyrs (Clemence of Barking's The Life of St. Catherine and the anonymous lives of St. Agnes and St. Barbara) as well as the prose biographies of the Beguines (Jacques de Vitry's The Life of Marie d'Oignies and Philippine de Porcellet's The Life of Saint Douceline) are testaments to this process as they reveal medieval perspectives on such topics as pagan learning and religion. Hagiography from the 12th to the 14th centuries presents a privileged view of a society defining itself against the past. Medieval hagiography is a product of writers trained in or somehow familiar with the treatises of the Ciceronian rhetorical tradition that were the standard textbooks of the time. Although often dismissed for their similarities, these works should be carefully considered by students of French literature given their precise following of precepts that govern their structure and content. Simply put, rhetoric once represented the whole of literary criticism, and one cannot read these texts without an appreciation for this fact. A rhetorical analysis of these texts highlights their literary value and illustrates their role in the history of ideas

Crystal gazer : profile-driven write-rationing garbage collection for hybrid memories

Non-volatile memories (NVM) offer greater capacity than DRAM but suffer from high latency and low write endurance. Hybrid memories combine DRAM and NVM to form scalable memory systems with the promise of high capacity, low energy consumption, and high endurance. Automatically managing hybrid NVM-DRAM memories to achieve their promise without changing user applications or their programming models remains an open question. This paper uses garbage collection in managed languages to exploit NVM capacity while preventing NVM wear out in hybrid memories with no changes to the programming model. We introduce profile-driven write-rationing garbage collection. Allocation sites that produce frequently written objects are predicted based on previous program executions. Objects are initially allocated in a DRAM nursery space. The collector copies surviving nursery objects from highly written sites to a mature DRAM space and read-mostly objects to a mature NVM space.Write-intensity prediction for 15 Java benchmarks accurately places objects in the correct space, eliminating expensive object monitoring from prior write-rationing garbage collectors. Furthermore, our technique exposes a Pareto tradeoff between DRAM usage and NVM lifetime, unlike prior work. Experimental results on NUMA hardware that emulates hybrid NVM-DRAM memory demonstrates that profile-driven write-rationing garbage collection reduces the number of writes to NVM compared to prior work to extend its lifetime, maximizes the use of NVM for its capacity, and achieves good performance

Beltway: Getting Around Garbage Collection Gridlock

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 first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware. The increasing reliance on garbage collected languages such as Java requires that the collector perform well. We show that the generality of Beltway enables us to design and implement new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which we are aware by up to 40%, and on average by 5 to 10%, for small to moderate heap sizes. New garbage collection algorithms are rare, and yet we define not just one, but a new family of collectors that subsumes previous work. This generality enables us to explore a larger design space and build better collectors

Cooperative cache scrubbing

Managing the limited resources of power and memory bandwidth while improving performance on multicore hardware is challeng-ing. In particular, more cores demand more memory bandwidth, and multi-threaded applications increasingly stress memory sys-tems, leading to more energy consumption. However, we demon-strate that not all memory traffic is necessary. For modern Java pro-grams, 10 to 60 % of DRAM writes are useless, because the data on these lines are dead- the program is guaranteed to never read them again. Furthermore, reading memory only to immediately zero ini-tialize it wastes bandwidth. We propose a software/hardware coop-erative solution: the memory manager communicates dead and zero lines with cache scrubbing instructions. We show how scrubbing instructions satisfy MESI cache coherence protocol invariants and demonstrate them in a Java Virtual Machine and multicore simula-tor. Scrubbing reduces average DRAM traffic by 59%, total DRAM energy by 14%, and dynamic DRAM energy by 57 % on a range of configurations. Cooperative software/hardware cache scrubbing reduces memory bandwidth and improves energy efficiency, two critical problems in modern systems

A garbage collection design and bakeoff in JMTk: An efficient extensible Java memory management toolkit

In this paper, we describe the design, implementation, and evaluation of a new garbage collection framework called the Java Memory Management Toolkit (JMTk). The goals of JMTk are to provide an efficient, composable, extensible, and portable toolkit for quickly building and evaluating new and existing garbage collection algorithms. Our design clearly demarcates the external interface between the collector and the compiler for portability. For extensibility, JMTk provides a selection of allocators, garbage identification, collection, pointer tracking, and other mechanisms that are efficient and that a wide variety garbage collection algorithms can compose and share. For instance, our mark-sweep and reference counting collectors share the free list implementation. We perform a comprehensive and detailed study of collectors including copying, mark-sweep, reference counting, copying generational, and hybrid generational collectors using JMTk in Jikes RVM on a uniprocessor. We find that the performance of collectors in JMTk is comparable to the highly tuned original Jikes collectors. In a study of full heap and generational collectors, we confirm the significant benefits of generational collectors on a wide variety of heap sizes, and reveal that on very small heaps, collection time is enormous. These experiments add other new insights, such as firmly establishing that for a variety of generational collectors, a variable-size nursery which is allowed to grow to fill all the space not in use by the older generation performs better than a fixed-size nursery. We thus show the utility of extensive collector comparisons and establish the benefits of our design