lock-free

Can LLVM, QEMU, GDB, Bochs, OpenStack or the like be used to unit test lock-free concurrent code on an open-source platform? Has anyone achieved this? If you answer by recommending software, I don't mind, but I mention LLVM, QEMU and the others because these function at various different levels. I should like to learn at which level practical success has been found at interleaving threads under unit-test control. I am aware of SPIN/Promela, incidentally. That is fine software but one cannot compile C++, Rust, etc., onto a SPIN/Promela target as far as I know. Examples of existing, open-source

I am reading C++ Concurrency in Action by Anthony Williams. Currently I at point where he desribes memory_order_consume. After that block there is: Now that I’ve covered the basics of the memory orderings, it’s time to look at the more complex parts It scares me a little bit, because I don't fully understand several things: How dependency-ordered-before differs from synchronizes-with? They both create happens-before relationship. What is exact difference? I am confused about following example: int global_data[]={ … }; std::atomic<int> index; void f() { int i=index.load(std::memory_order

for a simple pointer-increment allocator (do they have an official name?) I am looking for a lock-free algorithm. It seems trivial, but I'd like to get soem feedback whether my implementaiton is correct. not threadsafe implementation: byte * head; // current head of remaining buffer byte * end; // end of remaining buffer void * Alloc(size_t size) { if (end-head < size) return 0; // allocation failure void * result = head; head += size; return head; } My attempt at a thread safe implementation: void * Alloc(size_t size) { byte * current; do { current = head; if (end - current < size) return 0;

I only read a little bit about this topic, but it seems that the only benefit is to get around contention problems but it will not have any important effect on the deadlock problem as the code which is lock free is so small and fundamental (fifos, lifos, hash) that there was never a deadlock problem. So it's all about performance - is this right? Lock-free programming is (as far as I can see) always about performance, otherwise using a lock is in most cases much simpler, and therefore preferable. Note however that with lock-free programming you can end up trading deadlock for live-lock, which

I am new to .net and would like to know whether .net has the java equivalent of AtomicInteger, ConcurrentLinkedQueue, etc? I did a bit of search and couldnt come up with anything. The lock free algorithms need some sort of a CAS instruction, which is provided through the undocumented Unsafe class in Java, does .net have anything equivalent? In .NET there is the Interlocked class, with static methods Interlocked.Increment() and Interlocked.Decrement(). See http://msdn.microsoft.com/en-us/library/system.threading.interlocked.aspx . You will also find other atomic och synchronization constructs

First result in Google for "lock free vector" is a research paper cowritten by Damian Dechev, Peter Pirkelbauer and Bjarne Stroustrup describing a theoretical lock-free vector. Has this, or any other lock-free vector, been implemented? MS provides ppl::concurrent_vector and Intel provides tbb::concurrent_vector. On Windows at least ppl and tbb are part of the C-Runtime. I've just looked up what a vector is, in the wikipedia. I think (only a minute or two of thinking, mind) a fully lock-free version is a bit problematic. Consider; you create the array, access it as per normal, etc. For this you