Optimizing the Read and Write Barriers for Orthogonal Persistence

Persistent programming languages manage volatile memory as a cache for stable storage, imposing a read barrier on operations that access the cache, and a write barrier on updates to the cache. The read barrier checks the cache residency of the target object while the write barrier marks the target as dirty in the cache to support a write-back policy that defers updates to stable storage until eviction or stabilization. These barriers may also subsume additional functionality, such as negotiation of locks on shared objects to support concurrency control. Compilers for persistent programming languages generate barrier code to protect all
accesses to possibly persistent objects. Orthogonal persistence imposes this cost on every object access, since all objects are potentially persistent, at significant overhead to execution. We have designed a new suite of compiler optimizations, focusing on partial redundancy elimination of pointer-based access expressions, that significantly reduce this impact. These are implemented in an analysis and optimization framework for Java bytecodes, in support of orthogonal persistence for Java. In experiments with the traversal portions of the OO7 benchmark suite our optimizations reduce the number of read and write barriers executed by an average of 83% and 25%, respectively.