lockless

While reading Albahari's Threading in C# , I've noticed that the "lock free update" pattern uses a SpinWait at the end of the cycle: static void LockFreeUpdate<T> (ref T field, Func <T, T> updateFunction) where T : class { var spinWait = new SpinWait(); while (true) { // read T snapshot1 = field; // apply transformation T calc = updateFunction (snapshot1); // compare if not preempted T snapshot2 = Interlocked.CompareExchange (ref field, calc, snapshot1); // if succeeded, we're done if (snapshot1 == snapshot2) return; // otherwise spin spinWait.SpinOnce(); } } Note the spinWait.SpinOnce() call

I am designing a new improved Logger component (.NET 3.5, C#). I would like to use a lock-free implementation. Logging events will be sent from (potentially) multiple threads, although only a single thread will do the actual output to file/other storage medium. In essence, all the writers are * enqueuing* their data into some queue, to be retrieves by some other process (LogFileWriter). Can this be achieved in a lock-less manner? i could not find a direct reference to this particular problem on the net. If you find that using a lock in this case is too slow, you have a much bigger problem. A

I have been trying to Google my question but I honestly don't know how to succinctly state the question. Suppose I have two threads in a multi-core Intel system. These threads are running on the same NUMA node. Suppose thread 1 writes to X once, then only reads it occasionally moving forward. Suppose further that, among other things, thread 2 reads X continuously. If I don't use a memory fence, how long could it be between thread 1 writing X and thread 2 seeing the updated value? I understand that the write of X will go to the store buffer and from there to the cache, at which point MESIF will