Ian Glen Neal

I am a third year PhD student studying Computer Science at the University of Michigan. I am advised by Professor Baris Kasikci.

In my research, I want to eliminate the intellectual barrier-to-entry for developers who want to use emerging hardware to develop efficient and reliable systems. To this end, I aim to create tools which developers can use to automatically reason about the characteristics of new hardware so that they can better leverage its capabilities without sacrificing the correctness of their applications. My current focus is in the development of efficient and reliable systems using emerging persistent main memory technologies. I am also interested in developing verifiably secure hardware systems and tools which allow for easier development of secure systems.

News

Mar 13, 2021	Our work (led by Tanvir Ahmed Khan), “DMon: Efficient Detection and Correction of Data Locality Problems using Selective Profiling”, has been accepted to OSDI ‘21!
Jan 29, 2021	My talk, “Towards Bug-free Persistent Memory Applications”, will be presented at NVMW ‘21!
Jan 9, 2021	Agamotto has been recognized with an IEEE Micro Top Picks Honorable Mention!
Dec 21, 2020	I accepted an invitation to serve as a member of JSys’s Student Editorial Board!
Dec 11, 2020	My publication, “Rethinking File Mapping Structures for Persistent Memory”, has been accepted to FAST ‘21!

See all events

Selected Publications

ASPLOS’21

HIPPOCRATES: Healing Persistent Memory Bugs Without Doing Any Harm

Ian Neal, Andrew Quinn, and Baris Kasikci

In (to appear) Proceedings of the Twenty-Sixth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS)
April 2021

Abs Extended Abs (PDF) PDF Url

Persistent memory (PM) technologies aim to revolutionize storage systems, providing persistent storage at near-DRAM speeds. Alas, programming PM systems is error-prone, as the misuse or omission of the durability mechanisms (i.e., cache flushes and memory fences) can lead to durability bugs (i.e., unflushed updates in CPU caches that violate crash consistency). PM-specific testing and debugging tools can help developers find these bugs, however even with such tools, fixing durability bugs can be challenging. To determine the reason behind this difficulty, we first study durability bugs and find that although the solution to a durability bug seems simple, the actual reasoning behind the fix can be complicated and timeconsuming. Overall, the severity of these bugs coupled with the difficultly of developing fixes for them motivates us to consider automated approaches to fixing durability bugs. We introduce Hippocrates, a system that automatically fixes durability bugs in PM systems. Hippocrates automatically performs the complex reasoning behind durability bug fixes, relieving developers of time-consuming bug fixes. Hippocrates’s fixes are guaranteed to be safe, as they are guaranteed to not introduce new bugs (“do no harm”). We use Hippocrates to automatically fix 23 durability bugs in real-world and research systems. We show that Hippocrates produces fixes that are functionally equivalent to developer fixes. We then show that solely using Hippocrates’s fixes, we can create a PM port of Redis which has performance rivaling and exceeding the performance of a manually-developed PM-port of Redis.
FAST’21

Rethinking File Mapping for Persistent Memory

Ian Neal, Gefei Zuo, Eric Shiple, Tanvir Ahmed Khan, Youngjin Kwon, Simon Peter, and Baris Kasikci

In 19th USENIX Conference on File and Storage Technologies (FAST 21)
February 2021

Abs PDF Url

Persistent main memory (PM) dramatically improves IO performance. We find that this results in file systems on PM spending as much as 70% of the IO path performing file mapping (mapping file offsets to physical locations on storage media) on real workloads. However, even PM-optimized file systems perform file mapping based on decades-old assumptions. It is now critical to revisit file mapping for PM. We explore the design space for PM file mapping by building and evaluating several file-mapping designs, including different data structure, caching, as well as meta-data and block allocation approaches, within the context of a PM-optimized file system. Based on our findings, we design HashFS, a hash-based file mapping approach. HashFS uses a single hash operation for all mapping and allocation operations, bypassing the file system cache, instead prefetching mappings via SIMD parallelism and caching translations explicitly. HashFS’s resulting low latency provides superior performance compared to alternatives. HashFS increases the throughput of YCSB on LevelDB by up to 45% over page-cached extent trees in the state-of-the-art Strata PM-optimized file system.
OSDI’20

AGAMOTTO: How Persistent is your Persistent Memory Application?

Ian Neal, Ben Reeves, Ben Stoler, Andrew Quinn, Youngjin Kwon, Simon Peter, and Baris Kasikci

In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20)
November 2020

Abs PDF Url

Awarded IEEE Micro Top Picks 2021 Honorable Mention!

Persistent Memory (PM) can be used by applications to directly and quickly persist any data structure, without the overhead of a file system. However, writing PM applications that are simultaneously correct and efficient is challenging. As a result, PM applications contain correctness and performance bugs. Prior work on testing PM systems has low bug coverage as it relies primarily on extensive test cases and developer annotations. In this paper we aim to build a system for more thoroughly testing PM applications. We inform our design using a detailed study of 63 bugs from popular PM projects. We identify two application-independent patterns of PM misuse which account for the majority of bugs in our study and can be detected automatically. The remaining application-specific bugs can be detected using compact custom oracles provided by developers. We then present AGAMOTTO, a generic and extensible system for discovering misuse of persistent memory in PM applications. Unlike existing tools that rely on extensive test cases or annotations, AGAMOTTO symbolically executes PM systems to discover bugs. AGAMOTTO introduces a new symbolic memory model that is able to represent whether or not PM state has been made persistent. AGAMOTTO uses a state space exploration algorithm, which drives symbolic execution towards program locations that are susceptible to persistency bugs. AGAMOTTO has so far identified 84 new bugs in 5 different PM applications and frameworks while incurring no false positives.

See all publications