{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Parallel programming with Python's multiprocessing library\n",
"\n",
"Here you will learn how to write programs that perform\n",
"several tasks in parallel using Python's built-in multiprocessing library. Please \n",
"consult documentation to learn more, or to answer any\n",
"detailed questions as we will only cover a small subset of the\n",
"library's functionality. Most of the material here is taken from [this tutorial](http://localhost:8888/?token=48ec7adcec6bfaaa914d17f70e47b9f8bd67f8cac78f4052)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Parallelism (aka parallel programming) is when two or more tasks run at the same time. There's important terminology to understand regarding parallelism too.\n",
"\n",
"A **thread** is an execution context for code.\n",
"\n",
"A **process** is a program and state of all threads executing in a program.\n",
"\n",
"One process can have several threads running at the same time. One program could also have several proccesses running at the same time."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"In Python, by default programs run as a single process with a single thread of execution; this uses just a single CPU.\n",
"\n",
"Examples parallelism can help with:\n",
"\n",
" * executing database queries\n",
" * pre-processing lots of images to use for machine learning\n",
" * web crawling"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Parallel programming models\n",
"\n",
"Parallel programming has been important to scientific computing for\n",
"decades as a way to decrease program run times, making more complex\n",
"analyses possible (e.g. climate modeling, gene sequencing,\n",
"pharmaceutical development, aircraft design).\n",
"\n",
"One of the motivations for parallel programming has been the\n",
"diminishing marginal increases in single CPU performance with each new\n",
"generation of CPU (see The Free Lunch is over ). In response, computer\n",
"makers have introduced multi-core processors that contain more than\n",
"one processing core. It's not uncommon for desktop, laptop, and even\n",
"tablets and smart phones to have two or more CPU cores."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import multiprocessing\n",
"\n",
"multiprocessing.cpu_count()"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### GPU and heterogeneous computing\n",
"\n",
"In addition to multi-core CPUs, **Graphics Processing Units (GPU)** have\n",
"become more powerful recently (often having hundreds of parallel\n",
"execution units). GPUs are increasingly being use not just for drawing\n",
"graphics to the screen, but for general purpose computation. GPUs can\n",
"even be used in conjunction with CPUs to boost parallel computing\n",
"performance (this is known as *heterogeneous computing*). GPUs are best\n",
"*suited to applying the same computation over arrays of data*, while\n",
"*CPUs are better suited to algorithms that include conditional branches\n",
"of execution* (e.g. different paths through the code based on if\n",
"statements). Emerging tools, such as OpenCL \n",
"help coordinate parallel execution across heterogeneous computer\n",
"platforms that contain differing CPU and GPU resources."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### CPU multi-processing / Distributed-memory parallelism\n",
"\n",
"Unfortunately, most computer programs cannot take advantage of\n",
"performance increases offered by GPUs or multi-core CPUs unless we\n",
"modify these programs. In this lesson we will develop an example\n",
"program that uses the Python multiprocessing library to simultaneously\n",
"execute tasks on a multi-core CPU, decreasing the overall program run\n",
"time."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Multi-processing is one way to execute tasks in parallel on a\n",
"multi-core CPU, or across multiple computers in a computing cluster.\n",
"In multi-processing, each task runs in its own process; each program\n",
"running on your computer is represented by one or more processes. For\n",
"example, if you are running a web browser, a text editor, and an\n",
"e-mail client, you are running at least three processes (and likely\n",
"many more background processes). On modern operating systems, each\n",
"process gets its own portion of your computer's memory, ensuring that\n",
"no process can interfere with the execution of another (though tools\n",
"like MPI and even Python's multiprocessing library can\n",
"be used to share data between processes running locally or in\n",
"distributed computing environments)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### CPU multi-threading (shared memory parallelism)\n",
"\n",
"Multi-processing is not to be confused with multi-threading, or\n",
"shared-memory parallelism. In modern operating systems, each process\n",
"contains one or more threads of execution. These threads share the\n",
"same portion of memory assigned to their parent process; each thread\n",
"can run in parallel if the computer has more than one CPU core. For\n",
"certain algorithms, multi-threading can be more efficient than\n",
"multi-processing (though multi-processing solutions such as MPI often\n",
"scale better to larger problem sizes). However, multi-threading is\n",
"more error-prone to program and is generally only done directly by\n",
"expert systems programmers. Tools such as OpenMP should in general\n",
"be used for multi-threading in scientific computing."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## Python's Global Interpreter Lock\n",
"\n",
"CPython (the standard python implementation) has something called the GIL (Global Interpreter Lock); the GIL prevents two threads from executing simultaneously in the same program. However, two threads can run concurrently and one can run code while another may be waiting.\n",
"\n",
"The GIL limits parallel programming in Python out of the box.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"# `map` Function and Example\n",
"\n",
"The use of `map` will be applied in our parallel programming examples later so we look at this a bit.\n",
"\n",
"Below we will see a function called `number_times_two` to take in a number, multiply it by two and return the result.\n",
"\n",
"`map` is a built-in Python function that helps us easily apply a function over every item in an iterable such as a list.\n",
"\n",
"We'll use the `map` function to apply `number_times_two` to every element in the list of numbers [1, 2, 3, 4]."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def number_times_two(number):\n",
" \"\"\"\n",
" Multiply a number by 2\n",
" \n",
" :param number: a value we'll use in our computation\n",
" :type number: (preferably an) int\n",
" \n",
" :returns: number*2\n",
" \"\"\"\n",
" return number*2"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"function"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(number_times_two)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The `map` function returns an map object that is an iterator."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"map(number_times_two, [1, 2, 3, 4])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We can call the built-in `list` function to output our result, the `map` object, as a list."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[2, 4, 6, 8]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(map(number_times_two, [1, 2, 3, 4]))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Parallelism"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"from requests import get\n",
"from multiprocessing.dummy import Pool as ThreadPool \n",
"from multiprocessing import Pool\n",
"from concurrent.futures import ThreadPoolExecutor\n",
"from concurrent.futures import ProcessPoolExecutor\n",
"import matplotlib.pyplot as plt\n",
"from time import time\n",
"from random import sample\n",
"import numpy as np\n",
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We use some functions for visualizing the different techniques"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def multithreading(function, iterable, number_of_threads):\n",
" \"\"\"\n",
" Maps a function across an iterable (such as a list of elements) with the optional use of multithreading.\n",
" \n",
" :param function: name of a function\n",
" :type function: function\n",
" \n",
" :param iterable: elements used as inputs to function parameter\n",
" :type iterable: list\n",
" \n",
" :param number_of_threads: number of threads to use in map operation\n",
" :type number_of_threads: int\n",
" \n",
" :returns list_objects: return objects from our function parameter calls\n",
" :return type: list\n",
" \"\"\" \n",
" with ThreadPoolExecutor(max_workers=number_of_threads) as executor:\n",
" responses = executor.map(function, iterable)\n",
" return list(responses)\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def do_multiprocessing(function, iterable, number_of_concurrent_processes):\n",
" \"\"\"\n",
" Maps a function across an iterable (such as a list of elements) with the optional use of multiprocessing.\n",
" \n",
" :param function: name of a function\n",
" :type function: function\n",
" \n",
" :param iterable: elements used as inputs to function parameter\n",
" :type iterable: list\n",
" \n",
" :param number_of_concurrent_processes: number of concurrent processes in multiprocessing\n",
" :type number_of_concurrent_processes: int\n",
" \n",
" :returns list_objects: return objects from our function parameter calls\n",
" :return type: list\n",
" \"\"\" \n",
" with ProcessPoolExecutor(max_workers=number_of_concurrent_processes) as executor:\n",
" responses = executor.map(function, iterable)\n",
" return list(responses)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def transform_timestamps_to_be_seconds_from_process_start_time(process_start_time, all_task_timestamps):\n",
" \"\"\"\n",
" Take list of start and end timestamps of # of seconds since epoch, and subtract the process start time from them all\n",
" \n",
" Therefore we'll know how far timestamps are from the 0th second, the start of the program.\n",
" \n",
" :param process_start_time: # of seconds since epoch for start of task\n",
" :type process_start_time: float\n",
" \n",
" :param all_task_timestamps: # of seconds since epoch for end of task\n",
" :type all_task_timestamps: list\n",
" \n",
" :return function_timestamps_starting_from_zero: same shape as all_task_timestamps but all values subtracted by process_start_time\n",
" :type function_timestamps_starting_from_zero: numpy array\n",
" \"\"\"\n",
" function_timestamps_starting_from_zero = np.array(all_task_timestamps) - process_start_time\n",
" return function_timestamps_starting_from_zero"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def separate_list_elements(list_of_lists):\n",
" \"\"\"\n",
" Given a list structure such as [[x, y], [x, y]] return a list of just the x's and another of just y's\n",
" \n",
" :param list_of_lists: list with nested lists\n",
" :type list_of_list: list\n",
" \n",
" :return start_values, end_values: two lists - one of all 0-th index values and another of 1st index values in each nested list\n",
" :return type: tuple storing two lists\n",
" \"\"\"\n",
" start_values = [inner_list[0] for inner_list in list_of_lists]\n",
" start_values = np.array(start_values)\n",
" \n",
" end_values = [inner_list[1] for inner_list in list_of_lists]\n",
" end_values = np.array(end_values)\n",
" return start_values, end_values"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def generate_bar_colors(number_of_threads_or_subprocesses):\n",
" \"\"\"\n",
" Make a list of colors the same length as the number of threads or number of concurrent subprocesses\n",
" \n",
" :param number_of_threads_or_subprocesses: number of threads used in multithreading or number of processes used in multiprocessing\n",
" :type number_of_threads_or_subprocesses: int\n",
" \n",
" :return colors: list of colors chosen from good_colors\n",
" :type colors: list\n",
" \"\"\"\n",
" good_colors = ['firebrick', 'darkgreen', 'royalblue', 'rebeccapurple', 'dimgrey', 'teal', 'chocolate', 'darkgoldenrod']\n",
" colors = sample(good_colors, number_of_threads_or_subprocesses)\n",
" return colors\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def visualize_task_times(start_times, end_times, plot_title, colors):\n",
" \"\"\"\n",
" Use Matplotlib module to create a horizontal bar chart of the time elapsed for each task.\n",
" \n",
" :param start_times: start times of tasks\n",
" :type start_times: list\n",
" \n",
" :param end_times: end times of tasks\n",
" :type end_times: list\n",
" \n",
" :param plot_title: title of plot\n",
" :type plot_title: string\n",
" \n",
" :param colors: colors of bars\n",
" :type colors: list\n",
" \n",
" :return: None\n",
" \"\"\"\n",
" plt.barh(range(len(start_times)), end_times-start_times, left=start_times, color=colors);\n",
" plt.grid(axis='x');\n",
" plt.ylabel(\"Tasks\");\n",
" plt.xlabel(\"Seconds\");\n",
" plt.title(plot_title);\n",
" plt.figure(figsize=(12, 10));\n",
" plt.show();\n",
" return None;\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def visualize_multiprocessing_effect(number_of_concurrent_processes, function_name, iterable, plot_title):\n",
" \"\"\"\n",
" Perform multithreading given a function_name and number_of_threads and visualize tasks as bar chart\n",
" \n",
" :param number_of_concurrent_processes: number of concurrent processes in multiprocessing\n",
" :type number_of_concurrent_processes: int\n",
" \n",
" :param function_name: name of function applied in multithreading operation\n",
" :type function_name: function\n",
" \n",
" :param iterable: elements used as inputs to function parameter\n",
" :type iterable: list\n",
" \n",
" :param plot_title: title of plot\n",
" :type plot_title: string\n",
" \n",
" :return: None\n",
" \"\"\"\n",
" process_start_time = time() # we track time here \n",
" time_logs_multiprocessing_op = do_multiprocessing(function_name, iterable, number_of_concurrent_processes)\n",
" multiprocessing_task_timestamps = transform_timestamps_to_be_seconds_from_process_start_time(process_start_time, time_logs_multiprocessing_op)\n",
" start_times, end_times = separate_list_elements(multiprocessing_task_timestamps)\n",
" colors = generate_bar_colors(number_of_concurrent_processes)\n",
" visualize_task_times(start_times, end_times, plot_title, colors)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def visualize_multithreading_effect(number_of_threads, function_name, iterable, plot_title):\n",
" \"\"\"\n",
" Perform multithreading given a function_name and number_of_threads and visualize tasks as bar chart\n",
" \n",
" :param number_of_threads: number of threads used in multithreading\n",
" :type number_of_threads: int\n",
" \n",
" :param function_name: name of function applied in multithreading operation\n",
" :type function_name: function\n",
" \n",
" :param iterable: elements used as inputs to function parameter\n",
" :type iterable: list\n",
" \n",
" :param plot_title: title of plot\n",
" :type plot_title: string\n",
" \n",
" :return: None\n",
" \"\"\"\n",
" process_start_time = time() # we track time here \n",
" time_logs_multithreading_op = multithreading(function_name, iterable, number_of_threads)\n",
" multithreading_task_timestamps = transform_timestamps_to_be_seconds_from_process_start_time(process_start_time, time_logs_multithreading_op)\n",
" start_times, end_times = separate_list_elements(multithreading_task_timestamps)\n",
" colors = generate_bar_colors(number_of_threads)\n",
" visualize_task_times(start_times, end_times, plot_title, colors)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"# Measure Server Response Times\n",
"\n",
"This is a popular example on the web. For a list of URLs, we'll use the requests module to get a `response object`.\n",
"\n",
"With this `response object`, we could later perform operations to see the status of the request, get the contents of the site and more!\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"['https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de',\n",
" 'https://tu-chemnitz.de']"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"twelve_urls = ['https://tu-chemnitz.de']*12\n",
"twelve_urls"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def get_response_time_measurements(url):\n",
" \"\"\"\n",
" mark start time, then call the get method and pass in a url to receive a server response object, then mark end time\n",
" \n",
" :param url: address of a worldwide web page \n",
" :type url: string\n",
" \n",
" :returns: start_time and stop_time of this task\n",
" :type returns: list\n",
" \"\"\"\n",
" start_time = time()\n",
" try:\n",
" response = get(url)\n",
" except Exception as exception_object:\n",
" print('Error with request for url: {0}'.format(url))\n",
" stop_time = time()\n",
" return [start_time, stop_time]"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[[1592224065.7284248, 1592224066.6915462],\n",
" [1592224066.6919787, 1592224067.7007406],\n",
" [1592224067.7023625, 1592224068.2537656],\n",
" [1592224068.255095, 1592224068.803767],\n",
" [1592224068.8046625, 1592224069.381228],\n",
" [1592224069.3824537, 1592224069.9402099],\n",
" [1592224069.9418857, 1592224070.5079436],\n",
" [1592224070.508834, 1592224071.0595255],\n",
" [1592224071.0602398, 1592224071.62011],\n",
" [1592224071.6212552, 1592224072.168365],\n",
" [1592224072.1691875, 1592224072.737708],\n",
" [1592224072.737865, 1592224073.2956245]]"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"multithreading(function=get_response_time_measurements, iterable=twelve_urls, number_of_threads=1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multithreading"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multithreading_effect(number_of_threads=1,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 1 Thread\")"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multithreading_effect(number_of_threads=2,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 2 Threads\")"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multithreading_effect(number_of_threads=4,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 4 Threads\")"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multithreading_effect(number_of_threads=5,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 6 Threads\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multiprocessing"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=1,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 1 Process\")"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=2,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 2 Processes\")\n"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=3,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 3 Process\")\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=6,\n",
" function_name=get_response_time_measurements,\n",
" iterable=twelve_urls,\n",
" plot_title=\"Tasks for URL Server Responses; 6 Processes\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Single Process and Thread\n",
"\n",
"Now, let's perform the same operation without the overhead of setting up multithreading.\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 518 ms, sys: 35.9 ms, total: 554 ms\n",
"Wall time: 11.2 s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"# traditional python program without multithreading\n",
"task_timestamps = list(map(get_response_time_measurements, twelve_urls));"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Conclusion:** both multithreading and multiprocessing complete much quicker than a single thread & program.\n",
"\n",
"The reason parallel programming is much faster here is because the processor isn't working very hard to retreive the contents on the sites; however, the bottleneck is waiting for the site's server response to our HTTP request - an external resource. While one task is performing an operation of getting/waiting for a server response for one URL, another task can start for a different URL."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Threads are also fairly quick to combine their results too. So if we were web crawling and constantly wanted to combine results from multiple crawlers, it'd be ideal to use multiple threads to spawn multiple web crawlers rather than multiple processes which take longer to combine results."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Example: Squares of Numbers\n",
"\n",
"Given this big list of numbers in `big_list`, we want to output a new list that has the square of all numbers in `big_list`.\n",
"\n",
"Think of this as a lot of small operations.\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"big_list = range(1, 12000000)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def square_value(x):\n",
" return x**2"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multithreading\n",
"\n",
"Below we utilize code from another module of the Python standard library, multiprocessing, to perform multithreading for this operation.\n",
"\n",
"By default, we will use all available threads on our computer."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 7.92 s, sys: 601 ms, total: 8.52 s\n",
"Wall time: 8.35 s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"pool = ThreadPool() \n",
"\n",
"squares_pool_results = pool.map(square_value, big_list)\n",
"\n",
"pool.close()\n",
"pool.join()"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multiprocessing\n",
"\n",
"Below we utilize code from the lower-level module of the Python standard library, multiprocessing, to perform multiprocessing for this operation.\n",
"\n",
"We'll use 2 concurrent processes.\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 1.65 s, sys: 654 ms, total: 2.31 s\n",
"Wall time: 3.53 s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"with Pool(processes=2) as multiprocessing_operation:\n",
" multiprocessing_operation.map(square_value, big_list)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Single Process & Thread"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 14 µs, sys: 2 µs, total: 16 µs\n",
"Wall time: 24.1 µs\n"
]
}
],
"source": [
"%%time\n",
" \n",
"squares_results = map(square_value, big_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Conclusion:** process completes much faster without parallel programming.\n",
"\n",
"This may come as a surprise that parallel programming hurts our performance here.\n",
"\n",
"Using parallel programming in Python or any other interpreted language with a global interpreter lock (GIL) can actually result in reduced performance if you're just doing a CPU bound task. This program must carry parallel programming's additional overhead of creating new threads or processes and synchronizing their results.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Example: CPU Heavy Computations\n",
"\n",
"In this example, we'll only perform 8 tasks - with each task requiring a large amount of operations.\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def sum_all_intgers_from_zero_to_end_range_number(end_range_number):\n",
" \"\"\"\n",
" Calculate the sum of all integer numbers from 0 to end_range_number. \n",
" \n",
" :param end_range_number: highest value to loop over\n",
" :type end_range_number: integer\n",
" \n",
" :returns [start_time, stop_time]: list of start_time of task and end time of task\n",
" :return type: list\n",
" \"\"\"\n",
" start_time = time()\n",
" the_sum = 0\n",
" for number in range(0, end_range_number):\n",
" the_sum += number\n",
" stop_time = time()\n",
" return [start_time, stop_time]"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"large_number = 11**7\n",
"iterations = 8"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171]"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"large_numbers = [large_number]*iterations\n",
"large_numbers"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171,\n",
" 19487171]"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"large_numbers"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multithreading\n",
"\n",
"Let's visualize the effect of multithreading with 2 concurrent threads.\n"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multithreading_effect(number_of_threads=2,\n",
" function_name=sum_all_intgers_from_zero_to_end_range_number,\n",
" iterable=large_numbers,\n",
" plot_title=\"Tasks for Heavy CPU Computations; 2 Threads\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multiprocessing\n",
"\n",
"Let's visualize the effect of multiprocessing with 2 concurrent subprocesses.\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=2,\n",
" function_name=sum_all_intgers_from_zero_to_end_range_number,\n",
" iterable=large_numbers,\n",
" plot_title=\"Tasks for Heavy CPU Computations; 2 Processes\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Let's visualize the effect of multiprocessing with 4 concurrent subprocesses."
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=4,\n",
" function_name=sum_all_intgers_from_zero_to_end_range_number,\n",
" iterable=large_numbers,\n",
" plot_title=\"Tasks for Heavy CPU Computations; 4 Processes\")"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_multiprocessing_effect(number_of_concurrent_processes=4,\n",
" function_name=sum_all_intgers_from_zero_to_end_range_number,\n",
" iterable=large_numbers,\n",
" plot_title=\"Tasks for Heavy CPU Computations; 4 Processes\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Single Program & Thread"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 7.81 s, sys: 0 ns, total: 7.81 s\n",
"Wall time: 7.82 s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"for i in range(iterations):\n",
" sum_all_intgers_from_zero_to_end_range_number(large_number)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Conclusion:** program completes much faster with multiprocessing at approximately 4 subprocesses running concurrently.\n",
"\n",
"Multiprocessing here was helpful for this CPU intensive task because we could benefit from using multiple cores and avoid the global interpreter lock.\n",
"\n",
"Interestingly, spinning up additional subprocesses past 4 has no major effect on improving runtime of our program. Notice how the total program runtime with 4 subprocesses is equivalent to the program with 5 subprocesses.\n",
"\n",
"Threads provide no benefit in Python for CPU intensive tasks like these because of the global interpreter lock.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Summary:**\n",
"\n",
"The `threading` module uses `threads`, the `multiprocessing` module uses `processes`. The difference is that threads run in the **same memory space**, while processes have **separate memory**. This makes it a bit harder to share objects between processes with multiprocessing. Since threads use the same memory, precautions have to be taken or two threads will write to the same memory at the same time. This is what the global interpreter lock is for."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": []
}
],
"metadata": {
"celltoolbar": "Slideshow",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}