tcsc 2016 Luca Brianza 1 Luca Brianza 19/07/16 INFN & University of Milano-Bicocca

Transcription

1 tcsc INFN & University of Milano-Bicocca

2 Outlook Amdahl s law Different ways of parallelism: - Asynchronous task execution - Threads Resource protection/thread safety - The problem - Low-level solution: locks, TLS - High-level solution: atomic operation

3 Amdahl s law Amdahl s law Maximum speed achievable by parallelizing a code: Bottom line: no need of cores!!!

4 Asynchronous task execution Asynchronous task execution (std::async) The easiest example Provided in the standard library std::future #include <future> #include <iostream> int lenghtycalculation(){ ; int main(){ std::future<int> result = std::async(lenghtycalculation); //do other work std::cout << result: << result.get() << std::endl; Calculation done in a separate thread, result retrieved when needed

5 Threads - Process: isolated instance of a program, with its own space in memory - Thread: light-weight process, which share memory with other threads living in the same process std::thread -> more powerful than std::async #include <thread> #include <iostream> void dosomething(void) { std::cout<< ciao <<std::endl; int main(){ std::thread t (dosomething); //do some work t.join(); return 0; Potential risk: they share the same memory! (see next slide)

6 Pitfalls #include <thread> #include <iostream> #include <vector> int counter=0; void f(void) { counter++; int main(){ std::vector<std::thread> v; v.reserve(10); for (int i=0; i<10; i++) v.emplace_back(std::thread(f)); for (auto& t:v) t.join(); std::cout<< counter: <<counter<<std::endl; $ g++ -o prog.cpp -std=c++14 -lpthread counter: 10 counter: 9 Undesired (and non-reproducible) results in execution Problem: threads share the same memory Different threads are accessing counter at the same time

7 Low-level solution: lock std::mutex gmutex; void g() { std::lock(gmutex); dowork(); std::unlock(gmutex); - The thread acquire the lock on the mutex -> only that thread can access it - The thread release the lock when work is done > Risk: deadlocks!! - Scoped locks: the proper way - When the scope is left, the object destroyed and the lock released std::mutex gmutex; void g() { std::lock_guard <std::mutex> lg(gmutex); dowork(); - In any case: not the smartest approach

8 Thread Local Storage (TLS) A private copy of the shared data is replicated for each thread Cons: memory usage In any case, still using the lockrelease mechanism.. #include <thread> #include <iostream> #include <vector> #include <mutex> thread_local int gcounter=0; std::mutex gmutex; void f(void) { gcounter++; std::lock_guard <std::mutex> lg(gmutex); int main(){ std::vector<std::thread> v; v.reserve(10); $ g++ -o prog.cpp -std=c++14 -lpthread counter: 10 counter: 10 for (int i=0; i<10; i++) v.emplace_back(std::thread(f)); for (auto& t:v) t.join(); std::cout<< counter: <<gcounter<<std::endl;

9 High-level solution: atomic operations Atomic operations: seen as a single-step by the other threads Resources protection: other threads cannot see the operation until it is done > two threads cannot work on gcounter at the same time Can be used with different types T #include <thread> #include <iostream> #include <vector> #include <atomic> int counter=0; thread_local int gcounter=0; void f(void) { counter++; gcounter++; int main(){ std::vector<std::thread> v; v.reserve(10); for (int i=0; i<10; i++) v.emplace_back(std::thread(f)); $ g++ -o prog.cpp -std=c++14 -lpthread counter: 10, atomic counter: 10 counter: 9, atomic counter: 10 for (auto& t:v) t.join(); std::cout<< counter: <<counter <<, atomic counter: <<gcounter<<std::endl;

10 Possible applications? WW analysis: ntuplizer starts from some big trees, apply some selections, and produce smaller trees for the lvj final state Idea: read multiple events at the same time Calibration: E/p code Idea: read multiple electrons at the same time