Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels
Reordering constraints for pthread-style locks
Proceedings of the 12th ACM SIGPLAN symposium on Principles and practice of parallel programming
How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs
IEEE Transactions on Computers
Foundations of the C++ concurrency memory model
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
On Validity of Program Transformations in the Java Memory Model
ECOOP '08 Proceedings of the 22nd European conference on Object-Oriented Programming
Stretching transactional memory
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
x86-TSO: a rigorous and usable programmer's model for x86 multiprocessors
Communications of the ACM
Memory models: a case for rethinking parallel languages and hardware
Communications of the ACM
Lock elision for read-only critical sections in Java
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Performance implications of fence-based memory models
Proceedings of the 2011 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness
A case for an SC-preserving compiler
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
How to miscompile programs with "benign" data races
HotPar'11 Proceedings of the 3rd USENIX conference on Hot topic in parallelism
Clarifying and compiling C/C++ concurrency: from C++11 to POWER
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Position paper: nondeterminism is unavoidable, but data races are pure evil
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
Library abstraction for C/C++ concurrency
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiler aided manual speculation for high performance concurrent data structures
Proceedings of the 18th ACM SIGPLAN symposium on Principles and practice of parallel programming
CDSchecker: checking concurrent data structures written with C/C++ atomics
Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications
Making the java memory model safe
ACM Transactions on Programming Languages and Systems (TOPLAS)
| Hi-index | 0.00 |
Seqlocks are an important synchronization mechanism and represent a significant improvement over conventional reader-writer locks in some contexts. They avoid the need to update a synchronization variable during a reader critical section, and hence improve performance by avoiding cache coherence misses on the lock object itself. Unfortunately, they rely on speculative racing loads inside the critical section. This makes them an interesting problem case for programming-language-level memory models that emphasize data-race-free programming. We analyze a variety of implementation alternatives within the C++11 memory model, and briefly address the corresponding issue in Java. In the process, we observe that there may be a use for "read-dont-modify-write" operations, i. e. read-modify-write operations that atomically write back the original value, without modifying it, solely for the memory model consequences, and that it may be useful for compilers to optimize such operations.