Lock free Algorithm for Multi-core architecture. SDY Corporation Hiromasa Kanda SDY

Transcription

1 Lock free Algorithm for Multi-core architecture Corporation Hiromasa Kanda

2 1.Introduction Background needed Multi-Thread Problem of Multi-Thread program What's Lock free? Lock-free algorithm performance 2.Lock free Algorithm Atomic operation Lock-free Algorithm basic concept Lock-free queue (using arrangement ) Lock-free queue (liner ) Queue performance Lock-free hash-map Hash-map performance 3.Summary Contents

3 1.Introduction Background needed Multi-Thread Multi-core and SMT(HT) Limited CMOS scaling Manage memory access and CPU clock What is needed in application? Micro Parallelization Multi-Process Multi-Thread Amdahl's law The speedup of a program using multiple processors in parallel computing is limited Problem of Multi-thread Shared resource synchronization

4 1.Introduction Problem of Multi-Thread program 1/2 There was resources problem that share it when concurrent access multi-thread. Thread 1 queue Thread 2 dequeue dequeue dequeue(); dequeue; 30 competition

5 1.Introduction Problem of Multi-Thread program 2/2 The traditional approach to multi-thread programming is using locks synchronize access to shared resources. Mutex,Semaphore lock wait Thread 1 lock q; q.dequeue(); unlock q 10 lock 1 2 dequeue 3 unlock queue q lock 2' dequeue 4 Thread 2 lock q; q.dequeue(); 20 unlock 5 unlock q

6 What's Lock free? 1.Introduction Lock-free is "non-blocking" algorithm that doesn't break value when access each thread at the same time. Thread 1 queue q Thread 2 dequeue 1 10 dequeue q.dequeue(); enqueue 20 q.dequeue(); q.enqueue(40); 3 Lock-free algorithm Thread Safe!

7 1.Introduction Lock-free algorithm performance Lock-free algorithm performance is better than that of mutex lock algorithm, 100 times from 10 times. The difference extends further for more CPUs.

8 2.Lock free Algorithm Queue performance Measurement 4core CPU 3GHz X86-64 clock frequency(rdtsc) /thread num std queue(use mutex) lock-free queue(liner) lock-free queue(vector) SLOW FAST Thread num

9 2.Lock free Algorithm Lock-free hash-map performance Measurement 4core CPU 3GHz X86-64 clock frequency(rdtsc) /thread num std map(use mutex) lock-free hash-map SLOW FAST Thread num

10 2.Lock free Algorithm Lock-free algorithm elements Lock-free algorithm use 2 elements. 1) atomic operation. Not use memory barrier. Blocked small memory address. This new feature permits applications to use atomically update memory without using other synchronization primitives. gcc4.1 support this operation on user space. 2) key-value transaction Atomic operation is uses one key value. Small memory address transaction composes lockfree algorithm data statement.

11 2.Lock free Algorithm Lock-free Algorithm basic concept 1/3 Basic concept while(true){ 1.Data(pointer) collect 2.Some operation 3.Data(pointer) compare & update use CAS If (CAS = true) break; Exclusive Loop end case of CAS true

12 2.Lock free Algorithm Lock-free Algorithm basic concept 2/3 Thread 1 int i Thread 2 while(true){ int j = i; int k = j + 10; collect 10 update i = 20; if(cas(&i, j, k){ break; false retry 20

13 2.Lock free Algorithm Lock-free Algorithm basic concept 3/3 Thread 1 while(true){ int j = i; int k = j + 10; retry collect int i 10 if(cas(&i, j, k){ break; true update 20 30

14 2.Lock free Algorithm Lock-free queue ( using arrangement ) 1/3 Vector lock-free queue (using arrangement) head number 0 tail number M enqueue head number 0 tail number 2 0 A 1 B M

15 2.Lock free Algorithm Lock-free queue ( using arrangement ) 2/3 enqueue(value) while(true){ tail = tail_number; Data collect (tail pointer) if ( CAS(&tail_number, tail, tail + 1 ) ) break; Loop end case of tail pointer value is equal to tail node[tail].value = value; Set value

16 2.Lock free Algorithm Lock-free queue ( using arrangement ) 3/3 dequeue(value) while(true){ head = head_number ; if(!(node[head].value) ){ if( head_number == tail pointer ) return false; else { if( CAS(&head_number, head, head + 1 ) ){ value = node[head].value; Break; Data collect (head pointer) Queue is empty? Loop end case of head pointer value is equal to head node[head].value = ; return true; Erase value

17 2.Lock free Algorithm Lock-free queue ( liner ) 1/5 Liner Lock-free queue algorithm head pointer A tail pointer X node A next B value data A node B next C value data B node C next D value data C node X next X value data X Initial state head pointer dummy tail pointer dummy dummy node next dummy value

18 2.Lock free Algorithm Lock-free queue ( liner ) 2/5 enqueue head pointer dummy tail pointer dummy 2 head pointer dummy tail pointer A dummy node next dummy value 1 node A next dummy value data A dummy node next A value node A next dummy value data A head pointer dummy tail pointer A 2 head pointer dummy tail pointer B dummy node next A value node A next dummy value data A 1 node B next dummy value data B dummy node next A value node A next B value data A node B next dummy value data B

19 Lock-free queue ( liner ) 3/5 enqueue(value) new_node = new node_type(); new_node->value = value; new_node->next = dummy; 2.Lock free Algorithm Create node. while( true ){ tail = tail_pointer; if( CAS(&tail_pointer->next, dummy, new_node) ){ TAS(&tail_pointer, new_node); break; Data collect (tail pointer). Loop end case of tail pointer's next value is equal to dummy. Update tail pointer. return true;

20 2.Lock free Algorithm Lock-free queue ( liner ) 4/5 Dequeue pattan1 Node A next dummy value data A Head pointer dummy dummy node next A value 1 tail pointer A node A next dummy value 3 Update dummy case tail = head->next Head pointer dummy dummy node next dummy value tail pointer dummy Dequeue pattan2 Update dummy 2 2 Update dummy case tail = head Node A next B value data A Head pointer B dummy node next dummy value 1 tail pointer C node B next C value data B node C next dummy value data C head pointer C dummy node next dummy tail pointer C node C next dummy value data C

21 2.Lock free Algorithm Lock-free queue ( liner ) 5/5 dequeue(value) while( true ){ head = head_pointer; next = head_pointer->next; if( head == dummy ){ if( next == dummy ) return false; if( CAS(&head_pointer, head, next->next) ){ TAS(&dummy->next,dummy); CAS(&tail_pointer, next, dummy ); value = next->value; delete next; break; else { if( CAS(&head_pointer, head, next) ){ CAS(&tail_pointer, head, dummy); value = head->value; delete head; break; return true; Data collect (head pointer,next pointer). Queue empty? Case Pattan1 Loop end case of head pointer value is equal to collect head. Case Pattan2 Loop end case of head pointer value is equal to collect head.

22 Lock-free hash-map 1/4 Lock-free hash-map algorithm hash-map 2.Lock free Algorithm key value M Hash function Key A Value A hash-map key value A M A

23 Lock-free hash-map 2/4 2.Lock free Algorithm Insert( key, value ) hashvalue = get_hashvalue( key ); pre_key = do{ for(;;){ if(!hashmap[hashvalue].key ) break; if( hashmap[hashvalue].key == key ){ pre_key = hashmap[hashvalue].key; break; else{ hashmap[hashvalue].rehash = true; hashvalue = get_rehashvalue( hashvalue ); while(!cas( &hashmap[hashvalue].key, pre_key, key ) ); Get hash value Break arrangement key is null Break arrangement key equal to key Retry re-hash Loop end CAS true TAS(&hashmap[hashvalue].value,value); Set value

24 Lock-free hash-map 3/4 2.Lock free Algorithm return value find( key ) hashvalue = get_hashvalue( key ); for(;;){ if( hashmap[hashvalue].key == key ){ return hashmap[hashvalue].value; else{ if(!hashmap[hashvalue].rehash ) return ; Get hash value Return value case arrangement key is equal to key Return null(false) Case key is not equal to key hashvalue = get_rehashvalue( hashvalue ); Retry after get rehash value

25 Lock-free hash-map 4/4 erase( key ) 2.Lock free Algorithm hashvalue = get_hashvalue( key ); do{ for(;;){ if( hashmap[hashvalue].key == key ){ pre_key = hashmap[hashvalue].key; break; else{ if(!hashmap[hashvalue].rehash ) return false; hashvalue = get_rehashvalue( hashvalue ); while(!cas( &hashmap[hashvalue].key, pre_key, ) ); TAS(&hashmap[hashvalue].value,); return true; Get hash value Data collect Not find key Retry after get rehash value Erase key and value

26 4.Summary Possible simple coding on userspace application Possible access faster than use mutex-lock I plan to create lock-free list. Present,considering some method that is find(),delete().. base on liner queue. See source forge website: