multiprocessing¶
11/29/2022¶
Parallel Programming¶
There are several parallel programming models enabled by a variety of hardware (multicore, cloud computing, supercomputers, GPU).
Threads vs. Processes¶
A thread of execution is the smallest sequence of programmed instructions that can be managed independently by an operating system scheduler.
A process is an instance of a computer program.
Address Spaces¶
A process has its own address space. An address space is a mapping of virtual memory addresses to physical memory addresses managed by the operating system.
Address spaces prevent processes from crashing other applications or the operating system - they can only access their own memory.
Threads vs. Processes¶
What do we expect to print out?
The Answer¶
Threads vs. Processes¶
The Answer¶
Threads/Process Objects¶
Thread and Process Objects have the same interface
start- start running thetargetfunction with (optional)argsjoin- wait for thread to finish before doing anything elseis_alive- returns true if thread is still running
Example¶
Synchronization¶
When two threads update the same resource, their access to that resource needs to be gated.
There are a variety of synchronization primitives provided for both threads and processes (although they usually aren't needed for processes):
Lock¶
Can be acquired by exactly one thread (calling acquire twice from the same thread will hang). Must be released to be acquired by another thread. Basically, just wrap the critical section with an acquire-release pair.
RLock¶
A recursive lock. This is a lock that can be acquired multiple times by the same thread (and then must be released exactly the same number times). This is especially useful for modular programming. For example, you can acquire/release a lock around a function call without working about what that function is doing with the lock.
Lock Example¶
Communication¶
Threads communicate through their shared address space, and use locks to protect sensitive state. Several classes provide a simplified interface for communication (these are available with processes as well, but the underlying implementation is different).
Queue¶
Queue.Queue (multiprocess.Queue for processes) provides a simple, thread-safe, first-in-first-out queue.
put: put an element on the queue. This will block if the queue has filled upget: get an element from the queue. This will block if the queue is empty.
Communication¶
Pipe¶
A pipe is a communication channel between processes that can send and receive messages. Unlike a queue, it is not okay for multiple threads to write to the same end of the pipe at the same time.
Pipe() return a tuple of Connection objects representing the ends of the pipe. Each connection object has the following methods:
send: sends data to other end of the piperecv: waits for data from other end of the pipe (unless pipe closed, thenEOFError)close: close the pipe
Communication¶
Since they don't have a shared address space, it is recommended the processes use exclusively either multiprocess.Queue or multiprocess.Pipe to communicate.
Use a pipe for communication between two processes (server-client architecture).
Use a queue for one-way communication between many threads (producer-consumer architecture).
Pipes¶
Pools¶
multiprocess supports the concept of a pool of workers. You initialize with the number of processes you want to run in parallel (the default is the number of CPUs on your system) and they are available for doing parallel work:
map: the most important function - just like the built-in map, this will map a function to an iterable and return the result, but the mapping will be done in parallel. Blocks until the full result is computed and the result is in the proper order.map_async: map without blockingimap: parallel imap - returns iterable instead of list. Thenext()method of the returned iterable will block if necessary.imap_unordered: same as imap but returns values in order they are computedclose: close the pool to prevent additional jobs from being submittedjoin: must callclosefirst; waits for all jobs to complete
Pool Example¶
Producer/Consumer¶
Bad Example¶
You should not produce and consume in the same thread. If outQ fills up, inQ will fill up and the put will block.
The empty/full methods of the Queue class are pretty much useless since their result depends on when they are called. Here, no values had been generated when it was called so nothing is printed.
In order communicate that there are no more values, you must send a sentinal value.
Threads or Processes?¶
Normally, the choice between threads and processes depends on how data will be accessed and the level of communication between parallel tasks etc.
However, in Python, the answer is almost always use multiprocessing, not threading.
Why? The CPython interpretter has a Global Interpretter Lock. This means that only one thread of python code is actually executed at any given time when using threads. With processes, each process has its own interpretter (with its own lock).
Embarassingly Parallel¶
Writing correct, high performance parallel code can be difficult, but some in some cases it's trivial.
A problem is embarassingly parallel if it can be easily separated into independent subtasks (i.e., no need to communicate between threads) each of which does a substantial amount of computation.
Fortunately this is often the case.
- Apply this filter to 1000 images
- Process these 5000 protein structures
- Compute RMSDs of all frames in a trajectory
In cases like these, using Pools will get you a significant speedup (by however many cores you have).
Key Concepts¶
- You can run many things at the same time with threads/processes
- This is an easy way to make things faster, but can get complicated
- Use
multiprocessnot threads - Processes can communicate with Queues/Pipes
- 90% of the time all you need are Pools, and they are not complicated
Project¶
- Take a search term as an argument
- Use biopython to search the NCBI protein database for entries that match this term and are in the pdb
- Extract the PDB entries
- For each PDB entry, use ProDy to calculate the ANM modes (this can be done in parallel)
- Sort the results based on the highest fractional variance in the first mode
- Print out the top ten PDBs with the fractional variance of their first three modes