How can I write a lock free structure?

Question

In my multithreaded application and I see heavy lock contention in it, preventing good scalability across multiple cores. I have decided to use lock free programming to solv

Answer 1

If you read several implementations and papers regarding the subject, you'll notice there is the following common theme:

1) Shared state objects are lisp/clojure style inmutable: that is, all write operations are implemented copying the existing state in a new object, make modifications to the new object and then try to update the shared state (obtained from a aligned pointer that can be updated with the CAS primitive). In other words, you NEVER EVER modify an existing object that might be read by more than the current thread. Inmutability can be optimized using Copy-on-Write semantics for big, complex objects, but thats another tree of nuts

2) you clearly specify what allowed transitions between current and next state are valid: Then validating that the algorithm is valid become orders of magnitude easier

3) Handle discarded references in hazard pointer lists per thread. After the reference objects are safe, reuse if possible

See another related post of mine where some code implemented with semaphores and mutexes is (partially) reimplemented in a lock-free style: Mutual exclusion and semaphores