Scalable Computing model : Lock free protocol By Peeyush Agrawal 2010MCS3469 Guided By Dr. Kolin Paul

Problem: Programmer uses mutex in multi-threaded programming to prevent inconsistency in shared data. But mutex ( locks ) seems to be creating bottleneck : If we have many core system, then using mutex will create competition for lock that will keep threads/process out of ready queue (blocked, waiting for lock when waken up by other threads ).

Disadvantages of using mutex : * Taking few locks : It's common to forget to acquire lock before writing and end-up with multiple threads modifying same data. * Deadlock and live-lock: It is uncommon for a programmer to find out the situation when his system can go into deadlock. and programmer knows no-way to handle out deadlock situation. * Lost wake-ups : It is easy to forget to signal a conditional variable (lock object) on which thread is waiting.

Replacements of lock for multi-core system Atomic operations : knows as CAS ( compare and swap ), which is supported by modern processors. CAS (Value held in memory, Old value, New value) { Existing value = Value held in memory; if (Existing value == Old value) { Value held in memory = New value; return Old value ( success ); } else return Value held in memory ( fail ); }

Atomic operation... So updatation routine becomes: While ( CAS ( &address, oldValue, newValue ) ) ; Retry : if CAS is failed then we need to retry the operation.

Example of Atomic increment while(true){ old_val=sequenceNumber.get(); new_val=old_val+1; if(sequenceNumber.compareAndSet(old_val,new_val))//CAS break; }

Benchmark : Written in C++ and tested over 16 core linux server and 8 core Solaris system. The following benchmarks were tested : 1) Counting : Many threads are incrementing a shared variable. 2) Linked List : Insertion operation performed by multiple threads if key is not there. If( !found(head,node)) insert(head,node); 3) HashTable : Extension of linked list.

Benchmark HashTable: Contention : Many threads are inserting node in a same bucket. Advantage in using Atomic operation : If we have contention, then while one thread is doing insertion at the tail, another thread ( or many thread ) can proceed to search/scan the existing node.

Disadvantage of Atomic operation: * If the critical section ( writings ) is large, then there would be many retries, which would degrade the performance.

Conclusion : * Increasing number of thread beyond the number of physical cores does not gives us much improvement. Having too many buckets increase probability of having no contention, so atomic operation does not seems to be advantageous over mutex. Acquiring and releasing locks, does not create overhead. There is overhead only when there is contention.

References : Art of multiprocessor programming : Maurice Herlihy. A pragmatic Implementation of Non-blocking Linked-lists : Timothy L. Harris.