Book Image

Python Parallel Programming Cookbook

By : Giancarlo Zaccone
Book Image

Python Parallel Programming Cookbook

By: Giancarlo Zaccone

Overview of this book

This book will teach you parallel programming techniques using examples in Python and will help you explore the many ways in which you can write code that allows more than one process to happen at once. Starting with introducing you to the world of parallel computing, it moves on to cover the fundamentals in Python. This is followed by exploring the thread-based parallelism model using the Python threading module by synchronizing threads and using locks, mutex, semaphores queues, GIL, and the thread pool. Next you will be taught about process-based parallelism where you will synchronize processes using message passing along with learning about the performance of MPI Python Modules. You will then go on to learn the asynchronous parallel programming model using the Python asyncio module along with handling exceptions. Moving on, you will discover distributed computing with Python, and learn how to install a broker, use Celery Python Module, and create a worker. You will understand anche Pycsp, the Scoop framework, and disk modules in Python. Further on, you will learnGPU programming withPython using the PyCUDA module along with evaluating performance limitations.

Related Content you might be interested in

Current Title:

Small book image
Python Parallel Programming Cookbook
Giancarlo Zaccone
Aug, 2015 | 286 pages
No titles found
Table of Contents (13 chapters)
Python Parallel Programming Cookbook
Python Parallel Programming Cookbook
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Getting Started with Parallel Computing and Python
Getting Started with Parallel Computing and Python
Introduction
The parallel computing memory architecture
Memory organization
Parallel programming models
How to design a parallel program
How to evaluate the performance of a parallel program
Introducing Python
Python in a parallel world
Introducing processes and threads
Start working with processes in Python
Start working with threads in Python
2
Thread-based Parallelism
Thread-based Parallelism
Introduction
Using the Python threading module
How to define a thread
How to determine the current thread
How to use a thread in a subclass
Thread synchronization with Lock and RLock
Thread synchronization with RLock
Thread synchronization with semaphores
Thread synchronization with a condition
Thread synchronization with an event
Using the with statement
Thread communication using a queue
Evaluating the performance of multithread applications
3
Process-based Parallelism
Process-based Parallelism
Introduction
How to spawn a process
How to name a process
How to run a process in the background
How to kill a process
How to use a process in a subclass
How to exchange objects between processes
How to synchronize processes
How to manage a state between processes
How to use a process pool
Using the mpi4py Python module
Point-to-point communication
Avoiding deadlock problems
Collective communication using broadcast
Collective communication using scatter
Collective communication using gather
Collective communication using Alltoall
The reduction operation
How to optimize communication
4
Asynchronous Programming
Asynchronous Programming
Introduction
Using the concurrent.futures Python modules
Event loop management with Asyncio
Handling coroutines with Asyncio
Task manipulation with Asyncio
Dealing with Asyncio and Futures
5
Distributed Python
Distributed Python
Introduction
Using Celery to distribute tasks
How to create a task with Celery
Scientific computing with SCOOP
Handling map functions with SCOOP
Remote Method Invocation with Pyro4
Chaining objects with Pyro4
Developing a client-server application with Pyro4
Communicating sequential processes with PyCSP
Using MapReduce with Disco
A remote procedure call with RPyC
6
GPU Programming with Python
GPU Programming with Python
Introduction
Using the PyCUDA module
How to build a PyCUDA application
Understanding the PyCUDA memory model with matrix manipulation
Kernel invocations with GPUArray
Evaluating element-wise expressions with PyCUDA
The MapReduce operation with PyCUDA
GPU programming with NumbaPro
Using GPU-accelerated libraries with NumbaPro
Using the PyOpenCL module
How to build a PyOpenCL application
Evaluating element-wise expressions with PyOpenCl
Testing your GPU application with PyOpenCL
Index
Index

Using the with statement

Python's with statement was introduced in Python 2.5. It's useful when you have two related operations that must be executed as a pair with a block of code in between. Also, with the with statement, you can allocate and release some resource exactly where you need it; for this reason, the with statement is called a context manager. In the threading module, all the objects provided by the acquire() and release() methods may be used in a with statement block.

So the following objects can be used as context managers for a with statement:

  • Lock

  • RLock

  • Condition

  • Semaphore

Getting ready

In this example, we simply test all the objects using the with statement.

How to do it…

This example shows the basic use of the with statement. We have a set with the most important synchronization primitives. So, we test them by calling each one with the with statement:

import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                   format='(%(threadName)-10s) %(message...
Previous Section
End of Section 12
Next Section