The Curious Engineer

All blogs / Concurrency

Concurrency Freaks

concurrencyfreaks.blogspot.com

A web site dedicated to Concurrent algorithms and patterns.

ConcurrencyAlgorithms / data structuresC++Java / JVM

’15’20’25
Posts
260 from 10 Jan 2013 to 21 Jan 2025
Posting
now and then
Kind
personal blog
Feed
http://concurrencyfreaks.blogspot.com/feeds/posts/default

2025 2

  1. Concurrency is Coordination and Sharing
  2. Can Transactions and Coroutines co-exist?

2023 3

  1. Why is Snapshot Isolation not enough?
  2. 50 years later, is Two-Phase Locking the best we can do?
  3. How to (not) invent concurrent algorithms

2021 2

  1. The importance of Correctness in concurrent algorithms
  2. The 4 laws of Durability

2020 4

  1. A Relaxed Guide do memory_order_relaxed
  2. HydraConf 2020
  3. You say read-committed, I say buggy-code, potatoe, potato, tomatoe, tomato
  4. Dealing with bugs in Concurrency and Durability

2019 17

  1. CX - Wait-Free Universal Construction
  2. Is Left-Right a generic concurrency control?
  3. How about RLU? Is RLU a generic concurrency control?
  4. Is RCU a generic concurrency control?
  5. Hydra 2019 talks are now online
  6. Why use a PTM in your application?
  7. What is a concurrent algorithm without order?
  8. Recovery on a hand-made durable data structure versus recovery on a Persistent Transactional Memory
  9. Atomic Durability - How do databases recover from a crash ?
  10. Leaks in Persistent Memory
  11. Can I use a volatile allocator in Persistent Memory?
  12. Hydra Conference
  13. OneFile and wait-free memory reclamation
  14. OneFile is also a database engine
  15. OneFile and wait-free balanced trees
  16. OneFile and Tail Latency
  17. OneFile - The world's first wait-free Software Transactional Memory

2018 5

  1. Why do we need to flush persistent memory?
  2. The difference between a Universal Construct and a Software Transactional Memory
  3. Can't protect a pointer without a store-load fence
  4. Optimization to Michael-Scott Persistent Lock-Free Queue
  5. A Lock-Free Persistent Queue

2017 23

  1. Software Transactional Memory is Simple
  2. Maged Michael on Non-Blocking Synchronization and Memory Management
  3. Is Parallel Programming still hard?
  4. Dawn of the Universal Constructs
  5. Why is memory reclamation so important?
  6. Lock-Free Memory Reclamation by Erez Petrank
  7. What do blockchains and wait-free universal constructs have in common?
  8. URCUs with Maged-Harris Lock-Free Linked Lists
  9. What is Eventual Consistency ?
  10. Left-Right and C-RW-WP with Flat Combining
  11. Good ideas may be hard to recognize, but they re-surface many times
  12. Hazard Eras source code
  13. Battle of the Userspace RCUs: GraceVersion and TwoPhase versus BulletProof and Memory Barrier
  14. Hazard Eras - Non-Blocking Memory Reclamation
  15. 2-thread algorithms
  16. MultiList - A MPSC Wait-Free Queue
  17. BitNext - A Lock-Free queue
  18. Two posters at PPoPP 2016
  19. Cliff Click - A JVM Does That ???
  20. Nitsan Wakart on Lock-Free Queues
  21. DoubleLink - A Low-Overhead Lock-Free Queue
  22. LCRQ in C++ with Hazard Pointers
  23. Sim Queue in Java (part 2/2)

2016 31

  1. Sim Queue in Java (part 1/2)
  2. A C++ implementation of Kogan-Petrank wait-free queue with memory reclamation
  3. Two-Phase Grace Sharing Userspace RCU
  4. LCRQ and FAAArrayQueue are not good for all scenarios
  5. FAAArrayQueue - MPMC lock-free queue (part 4 of 4)
  6. LazyIndexArrayQueue - MPMC lock-free queue (part 3 of 4)
  7. Log2ArrayQueue - MPMC lock-free queue (part 2 of 4)
  8. LinearArrayQueue - MPMC lock-free queue (part 1 of 4)
  9. The Encapsulator Queue (part 3)
  10. The Encapsulator Queue (part 2)
  11. The Encapsulator Queue - A wait-free/lock-free queue for GC languages
  12. Are Hazard Pointers Lock-Free or Wait-Free ?
  13. CRTurn Queue - The first MPMC memory-unbounded wait-free queue with memory reclamation
  14. Dope! I should have thought of that!
  15. Self-linking and Latency + Life of a Twitter jvm engineer
  16. Wait-free Bounded vs Wait-free Unbounded
  17. URCU ReadersVersion in C++
  18. A simple Userspace RCU in Java
  19. What Happens When 4096 Cores All Do synchronize_rcu_expedited()?
  20. RCU Theory and Practice
  21. Hazard Pointers vs RCU
  22. Userspace RCU in GlusterD
  23. Concurrency talks at CppCon 2016
  24. Throughput vs Latency and Lock-Free vs Wait-Free
  25. Cliff Click on VM Design Choices
  26. The Dangers of Optimistic Concurrency
  27. Angelika Langer at GOTO 2014
  28. John Cairns Presents - Smashing Atomics
  29. Martin Kleppmann on “Sequential Consistency versus Linearizability”
  30. Michael Wong - The Landscape of Parallelism
  31. Understanding Concurrency - a whiteboard session with Nuri Halprin

2015 28

  1. The importance of Sequential Consistency
  2. Interviews for Channel9
  3. Left-Right Brief Announcement
  4. A good resource for programming with atomics
  5. Atomics and the Memory Model in C++1x
  6. Implementing a Reader-Writer Lock using RCU
  7. Talk at CppCon 2015
  8. Poor Man's URCU
  9. Fast lookups with memory_order_consume
  10. CppCon 2015 program
  11. Maurice Herlihy on Transactional Memory
  12. An example of atomic_thread_fence()
  13. Lamport's One bit solution in C11
  14. The Triple-Blocking problem in Actor Models
  15. The quest for the perfect load/store lock (part 2)
  16. The quest for the perfect load/store lock (part 1)
  17. Tidex white paper
  18. Left-Right and the (broken) peer-review system
  19. Presentation on Scalable Concurrent Data Structures
  20. Presentation on RCU
  21. Maurice Herlihy keynote at ICALP 2014
  22. Scalable Reader-Writer Lock in C++1x
  23. Resettable Linearizable Monotonic Statistical Counter
  24. Benchmarks for Ticket Lock AWN in C11
  25. Ticket Lock AWN - Spins on Both variant
  26. Ticket Lock AWN - Negative Egress variant
  27. Ticket Lock AWN - Ends on Egress variant
  28. Ticket Lock - Array of Waiting Nodes (AWN)

2014 62

  1. Tidex Mutex - No Pthread_Self variant
  2. Tidex Mutex in C11
  3. Tidex Mutex
  4. Left-Right Distributed Counters No Version variant
  5. Left-Right Atomic Long No Version variant
  6. Relaxed atomics on array of counters
  7. Scott Meyers at NDC Oslo 2014
  8. WriterReaderPhaser: What's (not) new about it?
  9. Martin Thompson - Responding in a Timely Manner
  10. Coroutines with await 2.0
  11. Left-Right GT variant
  12. A Catalog of Read Indicators
  13. Linked Lists: Locking, Lock-Free, and Beyond
  14. Harris with RTTI and AtomicMarkableReference
  15. Relaxed atomics, out-of-thin-air results, and ConcurrentLinkedQueueRelaxed
  16. Improved ConcurrentLinkedQueue for PowerPC (and ARM?)
  17. Doug Lea at SPLASH on Parallel Programming
  18. Relaxed Atomics Linked List on PowerPC
  19. How Ubisoft develops games for Multicore at CppCon
  20. The line between Research and Engineering
  21. Tony Van Eerd on "Lock-Free by Example"
  22. Concurrency Track of Eurosys 2014
  23. Linked Lists with wait-free reads in C++ (LRLinkedList and LRLinkedListSingle)
  24. The two sides of Wait-Free Population Oblivious
  25. Slides from CPPCON 2014
  26. Left-Right Memory usage
  27. Not all race conditions are bugs
  28. A Lock-Free Hash Table by Cliff Click
  29. Lock-Free Programming in C++1x by Tony Van Eerd
  30. Cliff Click on In-Memory Processing
  31. Purely Functional Data Structures
  32. How NOT to measure Latency
  33. C11 on Windows with gcc 4.9.1
  34. Lock-Free is not Starvation-Free
  35. Lock-Free definitions galore
  36. Martin Thompson on Top-10 performance myths
  37. CLLElectedUnlink - A Lock-Free List with Relaxed Atomics (part 2)
  38. CLLElectedUnlink - A Lock-Free List with Relaxed Atomics (part 1)
  39. Elected Pattern
  40. A Rosetta Stone for Atomics
  41. CLH Reader-Writer Lock
  42. Minimum number of barriers for a Lock
  43. CLH Mutex - An alternative to the MCS Lock
  44. Relaxed Atomics optimizations for the Ticket Lock
  45. C11 Atomics and MPSC Mutual Exclusion Lock
  46. Multi-Producer-Single-Consumer Queue
  47. Native Code Performance on Modern CPUs
  48. Arrays vs Linked Lists
  49. On std::atomic_compare_exchange_*
  50. Dave Dice on Pseudo Random Number Generators
  51. Hans Boehm on the C++11 Memory Model
  52. Harris with AtomicMarkableReference - remove
  53. C11 and GCC 4.9.0
  54. Harris with AtomicMarkableReference - add
  55. Harris's Linked List
  56. Left-Right: Reader's Version variant
  57. Concurrency Control Algorithms
  58. A dissertation on the progress conditions of LongAdder
  59. Left-Right: No Version (revisited)
  60. Thoughts on Double Instance Locking
  61. An interview with Maurice Herlihy
  62. Lambdas and the Left-Right technique

2013 83

  1. Martin Thompson on Lock-Free algorithms
  2. Left-Right: No Version variant
  3. Left-Right: State Machine
  4. Left-Right: Classical algorithm
  5. The Rise and Fall of x86
  6. IA Memory Ordering
  7. Concurrency vs Parallelism
  8. Left-Right: A Concurrency Control Technique with Wait-Free Population Oblivious Reads
  9. Understanding Java GC and what you can do about it
  10. StampedLock.tryOptimisticRead() and Invariants
  11. Double Instance Locking
  12. Tilera - Not all processors are x86
  13. Compiler Confidential - GoingNative2013
  14. Concurrency - The Good, the Bad, and the Ugly
  15. Concurrent Hash Table with Relativistic Programming
  16. Relativistic Programming
  17. Hans Boehm on Reader-Writer Locks
  18. 20 minutes with Martin Thompson
  19. 20 minutes on Java's Fork/Join
  20. Immutable data structures are not as good as you think they are
  21. Wait-Free is not enough
  22. Even more on Counters
  23. Concurrency Freaks Library 0.5
  24. Scalable RW Lock with a single LongAdder
  25. Clojure and Persistent Data Structures
  26. Combining the StampedLock and LongAdder to make a new RW-Lock
  27. LongAdder is not Sequentially Consistent
  28. LongAdder and DCLC
  29. Myth Busting presentation by Martin Thompson
  30. Using Java in Low-Latency environments
  31. Taleb's Principle and the Weirdo Principle
  32. Distributed Cache-Line Counter Scalable RW-Lock
  33. More on Counters
  34. Concurrency Pattern: Distributed Cache-Line Counter
  35. Concurrency Pattern: Off-by-X Counter
  36. Why does the code in java.util.concurrent look so different than that in an academic paper
  37. 11 practices for peer-review
  38. Concurrency is not Parallelism... Concurrency enables Parallelism
  39. Interrupt handler in C11 with Atomics
  40. Native Code Performance and Memory
  41. ScalableStampedRWLock on 32-core opteron
  42. The Future of the JVM
  43. Concurrency Freaks Library 0.4
  44. Why mobile web apps are slow
  45. Concurrency Pattern: Object Update (part 2)
  46. Concurrency Pattern: Object Update (part 1)
  47. Relaxed Atomics in Java
  48. Queues just aren't scalable
  49. How to micro-benchmark concurrent data structures?
  50. Lock-Free and Wait-Free, definition and examples
  51. Java - The Good the Bad and the Ugly
  52. Concurrency is Rocket Science
  53. NUMA-Aware reader-writer locks
  54. Performance plots of the Scalable-Stamped-Read-Write-Lock
  55. Java and Lambdas
  56. Bjarne Stroustrup on C++ Style at "Going Native"
  57. Optimizing exclusiveLock() in ScalableRWLock
  58. ScalableReentrantRWLock Performance Plots
  59. Video of a chat with Martin Thompson
  60. The End of multi-core Scalability is near
  61. Why is Wait-Free so important?
  62. False sharing and Cache Coherence
  63. Lock-Free isn't what it's cracked up to be
  64. ConcurrencyFreaks Library Release 0.2
  65. Scalable RW-Locks in ARMv7
  66. Optimizing Reentrant calls 2
  67. What's the minimum number of steps to do a read-only lock?
  68. The problem of not having a Garbage Collector
  69. Optimizing Reentrant calls
  70. Scalable RW-Lock without limitation on the number of threads
  71. The new memory model in C11 (and C++11)
  72. Why is the ScalableRWLock fast?
  73. Source code available at SourceForge
  74. Flowcharts for the 2-states Scalable RW-Lock
  75. Blocking, Lock-Free, and Wait-Free
  76. A Scalable RW-Lock with 2-state Readers
  77. Scalable RW Lock without thread-local-storage
  78. Async and Await in C#
  79. CPU Cache and its effects on concurrent algorithms
  80. Scalable and fast read write locks
  81. Why concurrency and object oriented
  82. Concurrency in C++11
  83. If you want to learn more about