Parallelism in Python

Transcription

1 Multithreading or Multiprocessing? Mathematics Department Mercyhurst University May 5, 2017

2 Table of Contents 1 Parallel Computing 2 3

3 Understanding Parallelism in Programming Before we go into Python specifically... We need to understand parallel computing As a concept A brief history of it

4 Serial Computing In a time long, long ago, there was only serial processing CPUs only had a single core One instruction/calculation at a time Extremely slow Imagine if the DMV only had a single employee

5 Parallel Computing Definition Parallel computing is a type of computation that runs multiple instructions and calculations simultaneously Modern computing thrives in no small part due to this Additional CPUs and cores add a second dimension of sorts Lighter tasks no longer stuck behind larger tasks Allows simultaneous programs to communicate Allows for increasingly complex programming

6 Serial vs. Parallel Computing Figure: An analogy of serial computing vs parallel computing as shown by poorly drawn highways

7 Threading Definition A thread is a series of instructions that can be managed independently by an operating system s scheduler Multiple threads can exist within a single process Often share resources Efficient usage of resources Easy communication with other threads

8 Threading and CPUs The operating system s scheduler allocates resources Allocates CPU time Moves threads to different CPUs/cores Threads can be placed on different cores on the fly Multiple threads can still run on a single core Asynchronous Not truly parallel

9 Multithreading Diagram Main Thread First Thread Second Thread Third Thread Figure: Example diagram of a multithreaded program

10 Programming with Threads Common way of implementing parallel computing Languages that support concurrent threads C family of languages (C/C++/C#) Java Rust Scala Python supports multithreading, however...

11 Multithreading in Python Threads in Python are not concurrent Does not matter if there are multiple processors Threads can still run asynchronously Not truly parallel Only gives the illusion of concurrency

12 CPython Interpreter Definition An interpreter is a program that executes a high-level language without previously compiling it Nonconcurrency is a problem with the default CPython Interpreter Other Python interpreters include Jython IronPython PyPy Alternative interpreters have their downsides

13 Global Interpreter Lock The Global Interpreter Lock (GIL) prevents threads from running simultaneously CPython s memory management is not safe for threads GIL has become a bottleneck for multithreaded programs

14 Burn the GIL! Many have tried to kill the GIL...

15 Burn the GIL! Many have tried to kill the GIL... none have succeeded

16 Burn the GIL! Many have tried to kill the GIL... none have succeeded In 1999, Greg Stein implemented the "free threading" patch to Python 1.5

17 Burn the GIL! Many have tried to kill the GIL... none have succeeded In 1999, Greg Stein implemented the "free threading" patch to Python 1.5 Enabled concurrent threads via finer locking of resources

18 Burn the GIL! Many have tried to kill the GIL... none have succeeded In 1999, Greg Stein implemented the "free threading" patch to Python 1.5 Enabled concurrent threads via finer locking of resources Single thread performance suffered 40% decrease in speed Patch was rejected and lost to the passage of time

19 Burn the GIL! Many have tried to kill the GIL... none have succeeded In 1999, Greg Stein implemented the "free threading" patch to Python 1.5 Enabled concurrent threads via finer locking of resources Single thread performance suffered 40% decrease in speed Patch was rejected and lost to the passage of time Figure: Greg Stein: A for effort

20 Multiprocessing One of the most common ways to bypass the GIL Creates entirely different processes instead of threads Separate space in memory Slower to create than a thread More difficult to communicate with each other Otherwise, functions similarly to threads

21 Multiprocessing cont. Utilization of multiple cores is a major selling point Consistency of the multiprocessing model also helps Processes are more clearly defined Threads differ between implementations Leaves a lot of legwork up to the operating system s scheduler

22 Let s Do! Python 3 with the following libraries: threading multiprocessing Using a quad core CPU Two benchmarks: CPU intensive task Lighter asynchronous task

23 Generating Threads def create_threads(num_thread, thread_target=none): if thread_target: objs = [threading.thread(target=thread_target) for i in range(num_thread)] else: objs = [threading.thread() for i in range(num_thread)] return objs Figure: Function to generate thread object list

24 Generating Processes def create_processes(num_process, process_target=none): if process_target: objs = [multiprocessing.process(target=process_targe for i in range(num_process)] else: objs = [multiprocessing.process() for i in range(num_process)] return objs Figure: Function to generate process object list

25 Benchmark 1 def large_exp(): begin = time.time() x = 1000** print("integer Length:", len(str(x)), end=" ") end = time.time() print("time:", end - begin, "\n") Figure: Function for CPU intensive benchmark

26 Benchmark 1: Threading thread_objs = create_threads(4, large_exp) for obj in thread_objs: obj.start() Figure: Benchmark 1: Threading

27 Benchmark 1: Threading Results Thread 1 Thread 2 Thread 3 Thread 4 Total Time Figure: Benchmark 1: Threading Results

28 Benchmark 1: Multiprocessing process_objs = create_processes(4, large_exp) for obj in process_objs: obj.start() Figure: Benchmark 1: Multiprocessing

29 Benchmark 1: Multiprocessing Results Process 1 Process 2 Process 3 Process 4 Total Time Figure: Benchmark 1: Multiprocessing Results

30 Benchmark 2 def smaller_exp(): begin = time.time() x = 1000**20000 print("integer Length:", len(str(x)), end=" ") end = time.time() print("time:", end - begin, "\n") Figure: Function for light benchmark

31 Benchmark 2: Threading thread_objs = create_threads(4, smaller_exp) for obj in thread_objs: obj.start() Figure: Benchmark 2: Threading

32 Benchmark 2: Threading Results Thread 1 Thread 2 Thread 3 Thread 4 Total Time Figure: Benchmark 2: Threading Results

33 Benchmark 2: Multiprocessing process_objs = create_processes(4, smaller_exp) for obj in process_objs: obj.start() Figure: Benchmark 2: Multiprocessing

34 Benchmark 2: Multiprocessing Results Process 1 Process 2 Process 3 Process 4 Total Time Figure: Benchmark 2: Multiprocessing Results

35 Key Findings Multiprocessing performed better overall Parallel computing Utilized four cores Speed in light tasks may have been due to CPU Speed made difference in object spawn times negligible Created a bottleneck elsewhere

36 GIL Going Forward Multithreading still has its uses Easier communication between objects Less resources used because of shared resources Multiprocessing likely to remain primary GIL workaround GIL will continue to be one of Python s hardest problems

37 GIL Going Forward Multithreading still has its uses Easier communication between objects Less resources used because of shared resources Multiprocessing likely to remain primary GIL workaround GIL will continue to be one of Python s hardest problems Figure: David Beazley: The hero Python deserves

38 Thank you. Any questions?