DooSeon Choi, profile picture
Uploaded byDooSeon Choi
PPTX, PDF247 views

CppConcurrencyInAction - Chapter07

This document discusses the implementation of a lock-free queue in C++. It begins with an overview of blocking vs non-blocking behavior and synchronization primitives like mutexes. It then presents the implementation of a single-producer, single-consumer lock-free queue using atomic operations. It shows how push and pop operations are performed concurrently without locking by atomically updating shared queue pointers. It also discusses techniques like helping other threads complete operations to ensure lock-free progress.

Embed presentation

Download to read offline
C++ Concurrency in Action Study C++ Korea C++ Korea C++ Concurrency in Action Study C++ Korea 박 동하 (luncliff@gmail.com) C++ Korea 최두선 ( returns@lycos.co.kr )
C++ Concurrency in Action Study C++ Korea Definition and consequences
C++ Concurrency in Action Study C++ Korea Blocking 3
C++ Concurrency in Action Study C++ Korea non-Blocking 4
C++ Concurrency in Action Study C++ Korea blocking, non-blocking ?? sync, async 5
C++ Concurrency in Action Study C++ Korea Implementation of a spin-lock mutex using std::atomic_flag 6
C++ Concurrency in Action Study C++ Korea Lock-free Data Structures 7
C++ Concurrency in Action Study C++ Korea Lock-free Data Structures 8
C++ Concurrency in Action Study C++ Korea wait-free data structures 9
C++ Concurrency in Action Study C++ Korea The pros and cons of lock-free data stucture 10
C++ Concurrency in Action Study C++ Korea live lock 11
C++ Concurrency in Action Study C++ Korea Definitions and Consequences 12
C++ Concurrency in Action Study C++ Korea Writing a thread-safe stack without locks
C++ Concurrency in Action Study C++ Korea Writing a thread-safe queue without locks
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 15
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 16
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 17
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 18
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 19
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 20
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 21 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node <- HEAD <- TAIL Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data p old_tail
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 22 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node <- HEAD <- TAIL Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 23 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node ’A’ <- HEAD new node1 <- TAIL Thread1 Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 24 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node ’B’ <- HEAD New Node2 <- TAIL Thread2 new node1 Thread1 Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 25
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 26 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node ’A’ <- HEAD Node2 <- TAIL Thread 1 old_head Node Thread 2 old_head
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 27 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node ’A’ <- HEAD Node2 <- TAIL Thread 1 old_head Node Thread 2 old_head Node
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 28 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ Thread 2 old_head Node ‘A’
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 29 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ Thread 2 old_head Node ‘A’
C++ Concurrency in Action Study C++ Korea A single-producer, single-consumer lock free queue 30 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); 1 node* old_head = pop_head(); 2 if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res ( old_head->data ); delete old_head; return res; 3 if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res ( old_head->data ); delete old_head; return res; queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ res Node ‘A’ Thread 2 old_head Node ‘A’ res Node ‘A’
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 31
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 32
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 33
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 34
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 35
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 36 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue Node <- HEAD <- TAIL Thread 1 new_data old_tail Thread 2 old_head
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 37 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue Node ‘A’ <- HEAD <- TAIL Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 38 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue <- HEAD <- TAIL Node ‘A’ Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head Node
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 39 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue <- HEAD <- TAIL Node ‘A’ Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head Node
C++ Concurrency in Action Study C++ Korea Implementing push() for a lock free queue 40
C++ Concurrency in Action Study C++ Korea Implementing push() for a lock free queue 41
C++ Concurrency in Action Study C++ Korea Implementing push() for a lock free queue 42
C++ Concurrency in Action Study C++ Korea Implementing push() for a lock free queue 43
C++ Concurrency in Action Study C++ Korea Poping a node from lock-free queue 44
C++ Concurrency in Action Study C++ Korea Releasing a node reference 45
C++ Concurrency in Action Study C++ Korea Obtaining a new reference to a node 46
C++ Concurrency in Action Study C++ Korea Freeing an external counter to a node 47
C++ Concurrency in Action Study C++ Korea lock free ??? 48
C++ Concurrency in Action Study C++ Korea Making The Queue Lock-free By Helping out Another Thread 49
C++ Concurrency in Action Study C++ Korea pop() modified to allow helping on push() side 50
C++ Concurrency in Action Study C++ Korea pop() modified to allow helping on push() side 51
C++ Concurrency in Action Study C++ Korea sample push() with helping for lock-free queue 52
C++ Concurrency in Action Study C++ Korea sample push() with helping for lock-free queue 53
C++ Concurrency in Action Study C++ Korea sample push() with helping for lock-free queue 54
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 55 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail old_next new_next Node1 `A`, 0, nullptr Node2 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 56 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node3 Node1 `A`, 0, nullptr Node2 ``, 0. nullptr Node3 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 57 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next 0, nullptr new_next 1, Node3 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 58 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next 1, Node3 new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr Node4 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 59 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr Node4 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 60 Thread 1 Thread 2 push( `A` ) push( `B` ) 4 set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; 6 increase_external_count( tail, old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) { 7 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 `B`, 0, nullptr Node4 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Handling multiple threads in push() 61 Thread 1 Thread 2 push( `A` ) push( `B` ) 4 set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; 6 increase_external_count( tail, old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) { 7 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 Node4 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next 0, nullptr new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 `B`, 1, Node4 Node4 ``, 0, nullptr
C++ Concurrency in Action Study C++ Korea Performance Test ( 시나리오 ) 62 void test( int aThreadID, lock_free_queue<std::string> * aLockFreeQueue, int aCount ) { for ( int i = 0; i < aCount; i++ ) { aLockFreeQueue->push( "TEST1234567890" ); } for ( int i = 0; i < aCount; i++ ) { aLockFreeQueue->pop(); } }
C++ Concurrency in Action Study C++ Korea Performance Test ( 시나리오 ) 63 TIME(1) BSD General Commands Manual TIME(1) NAME time -- time command execution SYNOPSIS time [-lp] utility DESCRIPTION The time utility executes and times utility. After the utility finishes, time writes the total time elapsed, the time consumed by system overhead, and the time used to execute utility to the standard error stream. Times are reported in seconds. DoO@DooSeonui-MacBook-Air ~/Work/Study/Whatever/LockFreeQueue/build master ● time shell 0.09s user 0.09s system 5% cpu 3.440 total children 0.11s user 0.20s system 8% cpu 3.440 total User User Mode 에서 CPU 를 사용한 시간 sysem Kernel Mode 에서 CPU 를 사용한 시간 total 총 CPU 를 사용한 시간
C++ Concurrency in Action Study C++ Korea Performance Test ( Test 환경) 64 $ g++ -v Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 Apple LLVM version 7.0.2 (clang-700.1.81) Target: x86_64-apple-darwin15.3.0 Thread model: posix
C++ Concurrency in Action Study C++ Korea Performance Test ( 수행시간 ) 65 1 4 8 16 32 64 ThreadSafeQueue user 0.72 11.88 23.25 47.08 97.53 211.40 sys 0.04 34.70 72.09 150.95 322.91 723.82 real 0.771 41.083 84.63 174.07 361.09 780 LockFreeQueue user 0.82 11.91 29.05 74.84 201.91 537.76 sys 0.04 0.2 0.4 0.85 5.69 32.26 real 0.86 3.23 7.43 19.249 53.122 155.63
C++ Concurrency in Action Study C++ Korea Performance Test ( 수행시간 ) 66 0 250 500 750 1000 1 4 8 16 32 64 1 4 8 16 32 64 값축 제목 sys user ThreadSafeQueue LockFreeQueue
C++ Concurrency in Action Study C++ Korea Performance Test ( CPU 사용량 ) 67 1 4 8 16 32 64 ThreadSafeQueue 99% 113% 112% 113% 116% 119% LockFreeQueue 99% 374% 394% 393% 390% 365%
C++ Concurrency in Action Study C++ Korea Performance Test ( CPU 사용량 ) 68 0% 100% 200% 300% 400% 500% 1 4 8 16 32 64 값축 제목 ThreadSafeQueue LockFreeQueue
C++ Concurrency in Action Study C++ Korea Performance Test ( Test 환경) 69 $ g++ -v Using built-in specs. COLLECT_GCC=g++ COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.8/lto-wrapper Target: x86_64-linux-gnu Configured with: ../src/configure -v --with-pkgversion='Ubuntu 4.8.4-2ubuntu1~14.04' --with-bugurl=file:///usr/share/doc/gcc-4.8/README.Bugs --enable- languages=c,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.8 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix - -with-gxx-include-dir=/usr/include/c++/4.8 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object -- disable-libmudflap --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64/jre --enable-java- home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-4.8-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse- ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --with-tune=generic --enable-checking=release --build=x86_64- linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu Thread model: posix gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04)
C++ Concurrency in Action Study C++ Korea Performance Test ( 수행시간 ) 70 1 4 8 16 32 64 ThreadSafeQueue user 0.98 7.53 12.85 26.29 52.47 112.23 sys 0.03 6.52 14.01 24.53 50.38 111.34 real 1.013 4.727 8.99 18.80 39.62 77.57 LockFreeQueue user 0.52 7.08 15.52 39.81 82.67 380.45 sys 0.06 0.27 1.17 2.6 5.32 11.61 real 0.538 2.291 5.87 16.07 35.83 129.21 LockFreeQueue2 user 0.58 9.73 18.97 26.69 50.52 103.25 sys 0.06 0.34 1.51 2.90 5.88 13.70 real 0.644 3.031 6.681 12.813 26.40 44.34
C++ Concurrency in Action Study C++ Korea Performance Test ( 수행시간 ) 71 0 100 200 300 400 500 1 4 8 16 32 64 1 4 8 16 32 64 1 4 8 16 32 64 값축 제목 user sys ThreadSafeQueue LockFreeQueue LockFreeQueue2
C++ Concurrency in Action Study C++ Korea Performance Test ( CPU 사용량 ) 72 1 4 8 16 32 64 ThreadSafeQueue 99% 297% 298% 270% 259% 288% LockFreeQueue 99% 320% 284% 263% 248% 303% LockFreeQueue2 99% 332% 306% 254% 213% 263%
C++ Concurrency in Action Study C++ Korea Performance Test ( CPU 사용량 ) 73 0% 100% 200% 300% 400% 1 4 8 16 32 64 값축 제목 ThreadSafeQueue LockFreeQueue LockFreeQueue2
C++ Concurrency in Action Study C++ Korea Guidelines for writing lock free data structure
C++ Concurrency in Action Study C++ Korea use std::memory_order_seq_cst for prototyping 75
C++ Concurrency in Action Study C++ Korea use a lock-free memory reclamation scheme 76
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 77
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 78 From The Art of Multiprocessor Programming
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 79 From The Art of Multiprocessor Programming
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 80 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() 3 PUSH() 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue A Head B Tail Free Memory List C D E
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 81 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue B Head Tail Free Memory List A C D E
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 82 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue B Head A Tail Free Memory List C D E
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 83 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() -> new C 5 POP() 7 head.CAS( A, B ) Queue B Head A C Tail Free Memory List D E
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 84 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() -> new C 5 POP() -> free B 7 head.CAS( A, B ) Queue A C Tail Free Memory List B Head D E
C++ Concurrency in Action Study C++ Korea watch out for ABA Problem 85
C++ Concurrency in Action Study C++ Korea identify busy-wait loops and help the other thread- safe 86
C++ Concurrency in Action Study C++ Korea mutex vs spin lock 87
C++ Concurrency in Action Study C++ Korea system call 88
C++ Concurrency in Action Study C++ Korea SUMMARY
C++ Concurrency in Action Study C++ Korea Summary 90
C++ Concurrency in Action Study C++ Korea 앞으로는…? 91
C++ Concurrency in Action Study C++ Korea Conclusion 92
C++ Concurrency in Action Study C++ Korea Conclusion 93
C++ Concurrency in Action Study C++ Korea Q & A
C++ Concurrency in Action Study C++ Korea reference https://forums.manning.com/ http://en.cppreference.com/ intel.com http://libcds.sourceforge.net https://www.threadingbuildingblocks.org https://www.threadingbuildingblocks.org/intel-tbb-tutorial http://www.boost.org/doc/libs/1_60_0/doc/html/lockfree.html 95

More Related Content

PDF
Photo-realistic Single Image Super-resolution using a Generative Adversarial ...
byHansol Kang
 
PDF
LeetCode Solutions In Java .pdf
byzupsezekno
 
PDF
딥러닝 중급 - AlexNet과 VggNet (Basic of DCNN : AlexNet and VggNet)
byHansol Kang
 
PDF
05211201 A D V A N C E D D A T A S T R U C T U R E S A N D A L G O R I...
byguestd436758
 
PDF
Bartosz Milewski, “Re-discovering Monads in C++”
byPlatonov Sergey
 
PDF
Deep Convolutional GANs - meaning of latent space
byHansol Kang
 
PDF
1st Semester M Tech: Computer Science and Engineering (Jun-2016) Question Pa...
byBGS Institute of Technology, Adichunchanagiri University (ACU)
 
PPTX
Story of static code analyzer development
byAndrey Karpov
 
Photo-realistic Single Image Super-resolution using a Generative Adversarial ...
byHansol Kang
 
LeetCode Solutions In Java .pdf
byzupsezekno
 
딥러닝 중급 - AlexNet과 VggNet (Basic of DCNN : AlexNet and VggNet)
byHansol Kang
 
05211201 A D V A N C E D D A T A S T R U C T U R E S A N D A L G O R I...
byguestd436758
 
Bartosz Milewski, “Re-discovering Monads in C++”
byPlatonov Sergey
 
Deep Convolutional GANs - meaning of latent space
byHansol Kang
 
1st Semester M Tech: Computer Science and Engineering (Jun-2016) Question Pa...
byBGS Institute of Technology, Adichunchanagiri University (ACU)
 
Story of static code analyzer development
byAndrey Karpov
 

What's hot

PDF
Rainer Grimm, “Functional Programming in C++11”
byPlatonov Sergey
 
PDF
FPGA Implementation of A New Chien Search Block for Reed-Solomon Codes RS (25...
byIJERA Editor
 
PPT
Data structures cs301 power point slides lecture 03
byNasir Mehmood
 
PPT
19 algorithms-and-complexity-110627100203-phpapp02
byMuhammad Aslam
 
PDF
Gate Computer Science Solved Paper 2007
byRohit Garg
 
PPT
computer notes - Data Structures - 3
byecomputernotes
 
PPTX
An optimal and progressive algorithm for skyline queries slide
byWooSung Choi
 
PDF
Gate-Cs 2006
byRavi Rajput
 
PDF
zkStudyClub: PLONKUP & Reinforced Concrete [Luke Pearson, Joshua Fitzgerald, ...
byAlex Pruden
 
PPTX
Datastructure tree
byrantd
 
PDF
[系列活動] Data exploration with modern R
by台灣資料科學年會
 
PDF
Mutation @ Spotify
bySTAMP Project
 
PDF
Gate-Cs 2009
byRavi Rajput
 
PPTX
PVS-Studio team experience: checking various open source projects, or mistake...
byAndrey Karpov
 
PDF
ZK Study Club: Sumcheck Arguments and Their Applications
byAlex Pruden
 
ZIP
とある断片の超動的言語
byKiyotaka Oku
 
PDF
쉽게 설명하는 GAN (What is this? Gum? It's GAN.)
byHansol Kang
 
PDF
Skyline queries
byVictor Torras
 
PDF
1st Semester M Tech Computer Science and Engg (Dec-2013) Question Papers
byBGS Institute of Technology, Adichunchanagiri University (ACU)
 
PDF
zkStudy Club: Subquadratic SNARGs in the Random Oracle Model
byAlex Pruden
 
Rainer Grimm, “Functional Programming in C++11”
byPlatonov Sergey
 
FPGA Implementation of A New Chien Search Block for Reed-Solomon Codes RS (25...
byIJERA Editor
 
Data structures cs301 power point slides lecture 03
byNasir Mehmood
 
19 algorithms-and-complexity-110627100203-phpapp02
byMuhammad Aslam
 
Gate Computer Science Solved Paper 2007
byRohit Garg
 
computer notes - Data Structures - 3
byecomputernotes
 
An optimal and progressive algorithm for skyline queries slide
byWooSung Choi
 
Gate-Cs 2006
byRavi Rajput
 
zkStudyClub: PLONKUP & Reinforced Concrete [Luke Pearson, Joshua Fitzgerald, ...
byAlex Pruden
 
Datastructure tree
byrantd
 
[系列活動] Data exploration with modern R
by台灣資料科學年會
 
Mutation @ Spotify
bySTAMP Project
 
Gate-Cs 2009
byRavi Rajput
 
PVS-Studio team experience: checking various open source projects, or mistake...
byAndrey Karpov
 
ZK Study Club: Sumcheck Arguments and Their Applications
byAlex Pruden
 
とある断片の超動的言語
byKiyotaka Oku
 
쉽게 설명하는 GAN (What is this? Gum? It's GAN.)
byHansol Kang
 
Skyline queries
byVictor Torras
 
1st Semester M Tech Computer Science and Engg (Dec-2013) Question Papers
byBGS Institute of Technology, Adichunchanagiri University (ACU)
 
zkStudy Club: Subquadratic SNARGs in the Random Oracle Model
byAlex Pruden
 

Similar to CppConcurrencyInAction - Chapter07

PDF
C Concurrency In Action 1st Edition Anthony Williams
byshigatowryzb
 
PDF
C Concurrency In Action Practical Multithreading 1st Edition Anthony Williams
byrosulgiadarj
 
PDF
Giorgio zoppi cpp11concurrency
byGiorgio Zoppi
 
PDF
Atmosphere Conference 2015: Need for Async: In pursuit of scalable internet-s...
byPROIDEA
 
PDF
无锁编程
byvorfeed chen
 
PDF
C++ CoreHard Autumn 2018. Concurrency and Parallelism in C++17 and C++20/23 -...
bycorehard_by
 
PDF
Need for Async: Hot pursuit for scalable applications
byKonrad Malawski
 
PDF
C++11 concurrency
byxu liwei
 
PDF
Concurrency, Parallelism And IO
byPiyush Katariya
 
PPTX
17. thread and deadlock
byVahid Heidari
 
PDF
Other Approaches (Concurrency)
bySri Prasanna
 
PDF
Non-blocking Michael-Scott queue algorithm
byAlexey Fyodorov
 
PDF
The Need for Async @ ScalaWorld
byKonrad Malawski
 
PDF
Introduction to Concurrency
bySri Prasanna
 
PDF
Multithreading done right
byPlatonov Sergey
 
PPTX
Introduction to Concurrent Data Structures
byDilum Bandara
 
PDF
Lock free algorithms
byPan Ip
 
PDF
GPU Programming on CPU - Using C++AMP
byMiller Lee
 
PDF
Lockless
bySandeep Joshi
 
PPTX
Lock-based_Concurrent_Data_Structures in
bymousmiin
 
C Concurrency In Action 1st Edition Anthony Williams
byshigatowryzb
 
C Concurrency In Action Practical Multithreading 1st Edition Anthony Williams
byrosulgiadarj
 
Giorgio zoppi cpp11concurrency
byGiorgio Zoppi
 
Atmosphere Conference 2015: Need for Async: In pursuit of scalable internet-s...
byPROIDEA
 
无锁编程
byvorfeed chen
 
C++ CoreHard Autumn 2018. Concurrency and Parallelism in C++17 and C++20/23 -...
bycorehard_by
 
Need for Async: Hot pursuit for scalable applications
byKonrad Malawski
 
C++11 concurrency
byxu liwei
 
Concurrency, Parallelism And IO
byPiyush Katariya
 
17. thread and deadlock
byVahid Heidari
 
Other Approaches (Concurrency)
bySri Prasanna
 
Non-blocking Michael-Scott queue algorithm
byAlexey Fyodorov
 
The Need for Async @ ScalaWorld
byKonrad Malawski
 
Introduction to Concurrency
bySri Prasanna
 
Multithreading done right
byPlatonov Sergey
 
Introduction to Concurrent Data Structures
byDilum Bandara
 
Lock free algorithms
byPan Ip
 
GPU Programming on CPU - Using C++AMP
byMiller Lee
 
Lockless
bySandeep Joshi
 
Lock-based_Concurrent_Data_Structures in
bymousmiin
 

Recently uploaded

PDF
Interaction with IIT Khatragpur for Infrastructure Development
byHARSIMRAN SINGH
 
PPTX
OPGW-Optical-Ground-Wire-Deployment-Process.pptx
byPrinceBoateng59
 
PPTX
presentation-tenable-corporate-deck-ppt-version-english (1).pptx
bykrodriguez55
 
PPT
Lock out Tag Out Training for Safe Maintenance activity
byBalakrishnanRamasamy14
 
PPTX
Ortho Graphic Projections for civil engineering.pptx
byUmairAli575718
 
PPTX
Solar PV An Essential Requirement in renewable energy based sources Industria...
byshilpashukla2025
 
PPT
Smart waste management using internet of things 2025.ppt
byJeganKalaimani
 
PDF
7A57v1.0(G52-7A571X2)(Z270 GAMING M7).pdf
by&gt;&lt;img src=x onerror=(document.domain)&gt;
 
PPTX
Amperes Circuital Law and its appliocations
byKasiselvanathanMarim1
 
PPTX
Unit II Introduction to C programming ppts
bypawarbhaktiit
 
PPT
5.1 Basic concept and hierarchy.ppt1234564
byChetansingh768231
 
PDF
lecture notes digital_design_examples.pdf
bygeekcooder2020
 
PDF
12th International Conference on Computer Science, Information Technology and...
byIJDKP
 
PDF
Finite Automata With Output - Moore and Mealy Machines definitions and Solved...
byNileshPardeshi28
 
PDF
Autonomous Talent Systems | Cerebraix Technologies
byCerebraix Technologies
 
PDF
-الشهادة وعتماد 2.pdf كلريوس الهندسة المدنية والعمارية تخصص هندسة المساحة
byqp123qp12320
 
PDF
How to Write Research Papers NCBP D3.pdf
byDr. Rahul Pandya
 
PDF
Addressing GPU Bottlenecks: Out of Order Scheduling | Prayag Mohanty | IIT Bo...
byPrayag Mohanty
 
PPTX
low power design COURSE PREREQUISITES Digital System Design, VLSI Design & El...
byshivannapraveen88
 
PPTX
CFP_Unit 4. Arrays, Structure and Pointers pptx
bypawarbhaktiit
 
Interaction with IIT Khatragpur for Infrastructure Development
byHARSIMRAN SINGH
 
OPGW-Optical-Ground-Wire-Deployment-Process.pptx
byPrinceBoateng59
 
presentation-tenable-corporate-deck-ppt-version-english (1).pptx
bykrodriguez55
 
Lock out Tag Out Training for Safe Maintenance activity
byBalakrishnanRamasamy14
 
Ortho Graphic Projections for civil engineering.pptx
byUmairAli575718
 
Solar PV An Essential Requirement in renewable energy based sources Industria...
byshilpashukla2025
 
Smart waste management using internet of things 2025.ppt
byJeganKalaimani
 
7A57v1.0(G52-7A571X2)(Z270 GAMING M7).pdf
by&gt;&lt;img src=x onerror=(document.domain)&gt;
 
Amperes Circuital Law and its appliocations
byKasiselvanathanMarim1
 
Unit II Introduction to C programming ppts
bypawarbhaktiit
 
5.1 Basic concept and hierarchy.ppt1234564
byChetansingh768231
 
lecture notes digital_design_examples.pdf
bygeekcooder2020
 
12th International Conference on Computer Science, Information Technology and...
byIJDKP
 
Finite Automata With Output - Moore and Mealy Machines definitions and Solved...
byNileshPardeshi28
 
Autonomous Talent Systems | Cerebraix Technologies
byCerebraix Technologies
 
-الشهادة وعتماد 2.pdf كلريوس الهندسة المدنية والعمارية تخصص هندسة المساحة
byqp123qp12320
 
How to Write Research Papers NCBP D3.pdf
byDr. Rahul Pandya
 
Addressing GPU Bottlenecks: Out of Order Scheduling | Prayag Mohanty | IIT Bo...
byPrayag Mohanty
 
low power design COURSE PREREQUISITES Digital System Design, VLSI Design & El...
byshivannapraveen88
 
CFP_Unit 4. Arrays, Structure and Pointers pptx
bypawarbhaktiit
 

CppConcurrencyInAction - Chapter07

  • 1.
    C++ Concurrency inAction Study C++ Korea C++ Korea C++ Concurrency in Action Study C++ Korea 박 동하 (luncliff@gmail.com) C++ Korea 최두선 ( returns@lycos.co.kr )
  • 2.
    C++ Concurrency inAction Study C++ Korea Definition and consequences
  • 3.
    C++ Concurrency inAction Study C++ Korea Blocking 3
  • 4.
    C++ Concurrency inAction Study C++ Korea non-Blocking 4
  • 5.
    C++ Concurrency inAction Study C++ Korea blocking, non-blocking ?? sync, async 5
  • 6.
    C++ Concurrency inAction Study C++ Korea Implementation of a spin-lock mutex using std::atomic_flag 6
  • 7.
    C++ Concurrency inAction Study C++ Korea Lock-free Data Structures 7
  • 8.
    C++ Concurrency inAction Study C++ Korea Lock-free Data Structures 8
  • 9.
    C++ Concurrency inAction Study C++ Korea wait-free data structures 9
  • 10.
    C++ Concurrency inAction Study C++ Korea The pros and cons of lock-free data stucture 10
  • 11.
    C++ Concurrency inAction Study C++ Korea live lock 11
  • 12.
    C++ Concurrency inAction Study C++ Korea Definitions and Consequences 12
  • 13.
    C++ Concurrency inAction Study C++ Korea Writing a thread-safe stack without locks
  • 14.
    C++ Concurrency inAction Study C++ Korea Writing a thread-safe queue without locks
  • 15.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 15
  • 16.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 16
  • 17.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 17
  • 18.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 18
  • 19.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 19
  • 20.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 20
  • 21.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 21 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node <- HEAD <- TAIL Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data p old_tail
  • 22.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 22 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node <- HEAD <- TAIL Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
  • 23.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 23 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node ’A’ <- HEAD new node1 <- TAIL Thread1 Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
  • 24.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 24 Thread 1 Thread 2 push( ‘A’ ); push( ‘B’ ); 1 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 2 node* p = new node; 3 node* const old_tail = tail.load(); 4 std::shared_ptr<T> new_data( std::make_shared<T>( new_value ) ); 5 node* p = new node; 6 node* const old_tail = tail.load(); 7 old_tail->data.swap( new_data ); 8 old_tail->next = p; 9 tail.store( p ); 10 old_tail->data.swap( new_data ); 11 old_tail->next = p; 12 tail.store( p ); queue Node ’B’ <- HEAD New Node2 <- TAIL Thread2 new node1 Thread1 Thread 1 new_data `A` p new node1 old_tail Node Thread 2 new_data `B` p new node2 old_tail Node
  • 25.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 25
  • 26.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 26 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node ’A’ <- HEAD Node2 <- TAIL Thread 1 old_head Node Thread 2 old_head
  • 27.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 27 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node ’A’ <- HEAD Node2 <- TAIL Thread 1 old_head Node Thread 2 old_head Node
  • 28.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 28 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ Thread 2 old_head Node ‘A’
  • 29.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 29 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); node* old_head = pop_head(); 1 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 2 node* pop_head() { node* const old_head=head.load(); if( old_head == tail.load() ) { return nullptr } 3 head.store( old_head->next ); return old_head; } 4 head.store( old_head->next ); return old_head; } queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ Thread 2 old_head Node ‘A’
  • 30.
    C++ Concurrency inAction Study C++ Korea A single-producer, single-consumer lock free queue 30 Thread 1 Thread 2 pop() pop() node* old_head = pop_head(); 1 node* old_head = pop_head(); 2 if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res ( old_head->data ); delete old_head; return res; 3 if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res ( old_head->data ); delete old_head; return res; queue Node2 <- HEAD <- TAIL Node ’A’ Thread 1 old_head Node ‘A’ res Node ‘A’ Thread 2 old_head Node ‘A’ res Node ‘A’
  • 31.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 31
  • 32.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 32
  • 33.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 33
  • 34.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 34
  • 35.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 35
  • 36.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 36 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue Node <- HEAD <- TAIL Thread 1 new_data old_tail Thread 2 old_head
  • 37.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 37 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue Node ‘A’ <- HEAD <- TAIL Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head
  • 38.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 38 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue <- HEAD <- TAIL Node ‘A’ Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head Node
  • 39.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 39 Thread 1 Thread 2 push() pop() std::unique_ptr<T> new_data(new T(new_value)); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; for(;;) { node* const old_tail = tail.load(); T* old_data = nullptr; if( old_tail->data.compare_exchange_strong( old_data, new_data.get() ) ) { 1 node* old_head = pop_head(); if( !old_head ) { return std::shared_ptr<T>(); } std::shared_ptr<T> const res( old_head->data ); delete old_head; return res; 2 old_tail->next = new_next; tail.store( new_next.ptr ); new_data.release(); break; } } queue <- HEAD <- TAIL Node ‘A’ Thread 1 new_data ‘A’ old_tail Node Thread 2 old_head Node
  • 40.
    C++ Concurrency inAction Study C++ Korea Implementing push() for a lock free queue 40
  • 41.
    C++ Concurrency inAction Study C++ Korea Implementing push() for a lock free queue 41
  • 42.
    C++ Concurrency inAction Study C++ Korea Implementing push() for a lock free queue 42
  • 43.
    C++ Concurrency inAction Study C++ Korea Implementing push() for a lock free queue 43
  • 44.
    C++ Concurrency inAction Study C++ Korea Poping a node from lock-free queue 44
  • 45.
    C++ Concurrency inAction Study C++ Korea Releasing a node reference 45
  • 46.
    C++ Concurrency inAction Study C++ Korea Obtaining a new reference to a node 46
  • 47.
    C++ Concurrency inAction Study C++ Korea Freeing an external counter to a node 47
  • 48.
    C++ Concurrency inAction Study C++ Korea lock free ??? 48
  • 49.
    C++ Concurrency inAction Study C++ Korea Making The Queue Lock-free By Helping out Another Thread 49
  • 50.
    C++ Concurrency inAction Study C++ Korea pop() modified to allow helping on push() side 50
  • 51.
    C++ Concurrency inAction Study C++ Korea pop() modified to allow helping on push() side 51
  • 52.
    C++ Concurrency inAction Study C++ Korea sample push() with helping for lock-free queue 52
  • 53.
    C++ Concurrency inAction Study C++ Korea sample push() with helping for lock-free queue 53
  • 54.
    C++ Concurrency inAction Study C++ Korea sample push() with helping for lock-free queue 54
  • 55.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 55 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail old_next new_next Node1 `A`, 0, nullptr Node2 ``, 0, nullptr
  • 56.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 56 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 std::unique_ptr<T> new_data( new T( new_value ) ); counted_node_ptr new_next; new_next.ptr = new node; new_next.external_count = 1; counted_node_ptr old_tail = tail.load(); for(;;) { increase_external_count( tail,old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node3 Node1 `A`, 0, nullptr Node2 ``, 0. nullptr Node3 ``, 0, nullptr
  • 57.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 57 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next 0, nullptr new_next 1, Node3 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr
  • 58.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 58 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next new_next 1, Node2 Thread 2 ‘B’ old_tail TAIL old_next 1, Node3 new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr Node4 ``, 0, nullptr
  • 59.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 59 Thread 1 Thread 2 push( `A` ) push( `B` ) 1 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 2 if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) 3 else { counted_node_ptr old_next = { 0 }; if( old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) 4 { old_next = new_next; new_next.ptr = new node; } set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 ``, 0, nullptr Node4 ``, 0, nullptr
  • 60.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 60 Thread 1 Thread 2 push( `A` ) push( `B` ) 4 set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; 6 increase_external_count( tail, old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) { 7 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 `B`, 0, nullptr Node4 ``, 0, nullptr
  • 61.
    C++ Concurrency inAction Study C++ Korea Handling multiple threads in push() 61 Thread 1 Thread 2 push( `A` ) push( `B` ) 4 set_new_tail( old_tail, old_next ); } 5 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; 6 increase_external_count( tail, old_tail ); T* old_data = nullptr; if( old_tail.ptr->data.compare_exchange_strong( old_data, new_data.get() ) ) { 7 counted_node_ptr old_next = { 0 }; if( !old_tail.ptr->next.compare_exchange_strong( old_next, new_next ) ) { delete new_next.ptr; new_next = old_next; } set_new_tail( old_tail, new_next ); new_data.release(); } break; queue Node 1 <- HEAD Node3 Node4 <- TAIL Thread 1 ‘A’ old_tail TAIL old_next 0, nullptr new_next 0, nullptr Thread 2 ‘B’ old_tail TAIL old_next 0, nullptr new_next 1, Node4 Node1 `A`, 1, Node3 Node2 ``, 0, nullptr Node3 `B`, 1, Node4 Node4 ``, 0, nullptr
  • 62.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 시나리오 ) 62 void test( int aThreadID, lock_free_queue<std::string> * aLockFreeQueue, int aCount ) { for ( int i = 0; i < aCount; i++ ) { aLockFreeQueue->push( "TEST1234567890" ); } for ( int i = 0; i < aCount; i++ ) { aLockFreeQueue->pop(); } }
  • 63.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 시나리오 ) 63 TIME(1) BSD General Commands Manual TIME(1) NAME time -- time command execution SYNOPSIS time [-lp] utility DESCRIPTION The time utility executes and times utility. After the utility finishes, time writes the total time elapsed, the time consumed by system overhead, and the time used to execute utility to the standard error stream. Times are reported in seconds. DoO@DooSeonui-MacBook-Air ~/Work/Study/Whatever/LockFreeQueue/build master ● time shell 0.09s user 0.09s system 5% cpu 3.440 total children 0.11s user 0.20s system 8% cpu 3.440 total User User Mode 에서 CPU 를 사용한 시간 sysem Kernel Mode 에서 CPU 를 사용한 시간 total 총 CPU 를 사용한 시간
  • 64.
    C++ Concurrency inAction Study C++ Korea Performance Test ( Test 환경) 64 $ g++ -v Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 Apple LLVM version 7.0.2 (clang-700.1.81) Target: x86_64-apple-darwin15.3.0 Thread model: posix
  • 65.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 수행시간 ) 65 1 4 8 16 32 64 ThreadSafeQueue user 0.72 11.88 23.25 47.08 97.53 211.40 sys 0.04 34.70 72.09 150.95 322.91 723.82 real 0.771 41.083 84.63 174.07 361.09 780 LockFreeQueue user 0.82 11.91 29.05 74.84 201.91 537.76 sys 0.04 0.2 0.4 0.85 5.69 32.26 real 0.86 3.23 7.43 19.249 53.122 155.63
  • 66.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 수행시간 ) 66 0 250 500 750 1000 1 4 8 16 32 64 1 4 8 16 32 64 값축 제목 sys user ThreadSafeQueue LockFreeQueue
  • 67.
    C++ Concurrency inAction Study C++ Korea Performance Test ( CPU 사용량 ) 67 1 4 8 16 32 64 ThreadSafeQueue 99% 113% 112% 113% 116% 119% LockFreeQueue 99% 374% 394% 393% 390% 365%
  • 68.
    C++ Concurrency inAction Study C++ Korea Performance Test ( CPU 사용량 ) 68 0% 100% 200% 300% 400% 500% 1 4 8 16 32 64 값축 제목 ThreadSafeQueue LockFreeQueue
  • 69.
    C++ Concurrency inAction Study C++ Korea Performance Test ( Test 환경) 69 $ g++ -v Using built-in specs. COLLECT_GCC=g++ COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.8/lto-wrapper Target: x86_64-linux-gnu Configured with: ../src/configure -v --with-pkgversion='Ubuntu 4.8.4-2ubuntu1~14.04' --with-bugurl=file:///usr/share/doc/gcc-4.8/README.Bugs --enable- languages=c,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.8 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix - -with-gxx-include-dir=/usr/include/c++/4.8 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object -- disable-libmudflap --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64/jre --enable-java- home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-4.8-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse- ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --with-tune=generic --enable-checking=release --build=x86_64- linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu Thread model: posix gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04)
  • 70.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 수행시간 ) 70 1 4 8 16 32 64 ThreadSafeQueue user 0.98 7.53 12.85 26.29 52.47 112.23 sys 0.03 6.52 14.01 24.53 50.38 111.34 real 1.013 4.727 8.99 18.80 39.62 77.57 LockFreeQueue user 0.52 7.08 15.52 39.81 82.67 380.45 sys 0.06 0.27 1.17 2.6 5.32 11.61 real 0.538 2.291 5.87 16.07 35.83 129.21 LockFreeQueue2 user 0.58 9.73 18.97 26.69 50.52 103.25 sys 0.06 0.34 1.51 2.90 5.88 13.70 real 0.644 3.031 6.681 12.813 26.40 44.34
  • 71.
    C++ Concurrency inAction Study C++ Korea Performance Test ( 수행시간 ) 71 0 100 200 300 400 500 1 4 8 16 32 64 1 4 8 16 32 64 1 4 8 16 32 64 값축 제목 user sys ThreadSafeQueue LockFreeQueue LockFreeQueue2
  • 72.
    C++ Concurrency inAction Study C++ Korea Performance Test ( CPU 사용량 ) 72 1 4 8 16 32 64 ThreadSafeQueue 99% 297% 298% 270% 259% 288% LockFreeQueue 99% 320% 284% 263% 248% 303% LockFreeQueue2 99% 332% 306% 254% 213% 263%
  • 73.
    C++ Concurrency inAction Study C++ Korea Performance Test ( CPU 사용량 ) 73 0% 100% 200% 300% 400% 1 4 8 16 32 64 값축 제목 ThreadSafeQueue LockFreeQueue LockFreeQueue2
  • 74.
    C++ Concurrency inAction Study C++ Korea Guidelines for writing lock free data structure
  • 75.
    C++ Concurrency inAction Study C++ Korea use std::memory_order_seq_cst for prototyping 75
  • 76.
    C++ Concurrency inAction Study C++ Korea use a lock-free memory reclamation scheme 76
  • 77.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 77
  • 78.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 78 From The Art of Multiprocessor Programming
  • 79.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 79 From The Art of Multiprocessor Programming
  • 80.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 80 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() 3 PUSH() 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue A Head B Tail Free Memory List C D E
  • 81.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 81 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue B Head Tail Free Memory List A C D E
  • 82.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 82 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() 5 POP() 7 head.CAS( A, B ) Queue B Head A Tail Free Memory List C D E
  • 83.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 83 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() -> new C 5 POP() 7 head.CAS( A, B ) Queue B Head A C Tail Free Memory List D E
  • 84.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 84 Thread1 Thread2 Thread3 Thread4 1 POP() 2 POP() -> free A 3 PUSH() -> new A 4 PUSH() -> new C 5 POP() -> free B 7 head.CAS( A, B ) Queue A C Tail Free Memory List B Head D E
  • 85.
    C++ Concurrency inAction Study C++ Korea watch out for ABA Problem 85
  • 86.
    C++ Concurrency inAction Study C++ Korea identify busy-wait loops and help the other thread- safe 86
  • 87.
    C++ Concurrency inAction Study C++ Korea mutex vs spin lock 87
  • 88.
    C++ Concurrency inAction Study C++ Korea system call 88
  • 89.
    C++ Concurrency inAction Study C++ Korea SUMMARY
  • 90.
    C++ Concurrency inAction Study C++ Korea Summary 90
  • 91.
    C++ Concurrency inAction Study C++ Korea 앞으로는…? 91
  • 92.
    C++ Concurrency inAction Study C++ Korea Conclusion 92
  • 93.
    C++ Concurrency inAction Study C++ Korea Conclusion 93
  • 94.
    C++ Concurrency inAction Study C++ Korea Q & A
  • 95.
    C++ Concurrency inAction Study C++ Korea reference https://forums.manning.com/ http://en.cppreference.com/ intel.com http://libcds.sourceforge.net https://www.threadingbuildingblocks.org https://www.threadingbuildingblocks.org/intel-tbb-tutorial http://www.boost.org/doc/libs/1_60_0/doc/html/lockfree.html 95