A case for relativistic programming

Authors:
Philip W. Howard;Jonathan Walpole
Affiliations:
West Virginia University Institute of Technology, Montgomery, WV, USA;Portland State University, Portland, OR, USA
Venue:
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
Year:
2012

Citing 15
Cited 0

Linearizability: a correctness condition for concurrent objects

ACM Transactions on Programming Languages and Systems (TOPLAS)
Lightweight causal and atomic group multicast

ACM Transactions on Computer Systems (TOCS)
A methodology for implementing highly concurrent data objects

ACM Transactions on Programming Languages and Systems (TOPLAS)
The process group approach to reliable distributed computing

Communications of the ACM
Global serializability of concurrent programs

Theoretical Computer Science
Sequentially consistent versus linearizable counting networks

Proceedings of the eighteenth annual ACM symposium on Principles of distributed computing
Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels

Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels
Linearizable counting networks

Distributed Computing
Proving correctness of highly-concurrent linearisable objects

Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming
The read-copy-update mechanism for supporting real-time applications on shared-memory multiprocessor systems with Linux

IBM Systems Journal
Scalable concurrent hash tables via relativistic programming

ACM SIGOPS Operating Systems Review
Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated

Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A relativistic enhancement to software transactional memory

HotPar'11 Proceedings of the 3rd USENIX conference on Hot topic in parallelism
Resizable, scalable, concurrent hash tables via relativistic programming

USENIXATC'11 Proceedings of the 2011 USENIX conference on USENIX annual technical conference
User-Level Implementations of Read-Copy Update

IEEE Transactions on Parallel and Distributed Systems

Quantified Score

Hi-index	0.00

Visualization

Abstract

Programmers traditionally assume we live and program in a sequentially consistent world. Hardware developers have long since abandoned sequential consistency in order to develop higher performance computers. In this paper, we argue that the natural world maintains causal consistency not sequential consistency. From that observation, we argue that concurrent programs only need to maintain causal consistency. Since causal consistency does not require a total order on operations, it can be implemented with less impact on scalability than more strict ordering guarantees.