The process group approach to reliable distributed computing
Communications of the ACM
Kernel korner: using RCU in the Linux 2.5 kernel
Linux Journal
Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels
Enforcing isolation and ordering in STM
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Privatization techniques for software transactional memory
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Transactional boosting: a methodology for highly-concurrent transactional objects
Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming
Scalable Techniques for Transparent Privatization in Software Transactional Memory
ICPP '08 Proceedings of the 2008 37th International Conference on Parallel Processing
Software Transactional Memory: Why Is It Only a Research Toy?
Queue - The Concurrency Problem
Stretching transactional memory
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
NOrec: streamlining STM by abolishing ownership records
Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
Transactional predication: high-performance concurrent sets and maps for STM
Proceedings of the 29th ACM SIGACT-SIGOPS symposium on Principles of distributed computing
Scalable concurrent hash tables via relativistic programming
ACM SIGOPS Operating Systems Review
Why STM can be more than a research toy
Communications of the ACM
Resizable, scalable, concurrent hash tables via relativistic programming
USENIXATC'11 Proceedings of the 2011 USENIX conference on USENIX annual technical conference
A case for relativistic programming
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
| Hi-index | 0.00 |
Relativistic Programming is a technique that allows low overhead, linearly-scalable concurrent reads. It also allows joint access parallelism between readers and a writer. Unfortunately, it has so far been limited to a single writer so it does not scale on the write side. Software Transactional Memory (STM) is a technique that allows programs to take advantage of disjoint access parallelism on both the read-side and write-side. Unfortunately, STM systems have a higher overhead than many other synchronization mechanisms so although STM scales, STM starts from a lower baseline. We propose combining relativistic programming and software transactional memory in a way that gets the best of both worlds: low-overhead linearly-scalable reads that never conflict with writes and scalable disjoint access parallel writes. We argue for the correctness of our approach and present performance data that shows an actual implementation that delivers the promised performance characteristics.