notebooks/multiproc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LwHphyYT2lo5"
   },
   "source": [
    "# Multiprocessing in Python\n",
    "\n",
    "Here we will explore how to make use of multiple processes in python via the [multiprocessing library](https://docs.python.org/2/library/multiprocessing.html).\n",
    "\n",
    "The multiprocessing Python module contains two classes capable of handling tasks. The Process class sends each task to a different processor, and the Pool class sends sets of tasks to different processors. We will show how to multiprocess the example code using both classes. Although both classes provide a similar speed increase, the Process class is more efficient in this case because there are not many processes to execute. Pool is most useful for large amounts of processes where each process can execute quickly, while Process is most useful for a small number of processes where each process would take a longer time to execute.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic usage of multiprocessing library -- the Process class\n",
    "\n",
    "To use the Process class, place the functions and calculations that are done on each list item in its own function that will take a list item as one of its arguments. Next, import the multiprocessing module, create a new process for each list item, and trigger each process in one call. We keep track of these processes by making a list and adding each process to it. After creating all the processes, take the separate output of each CPU and join them into a single list.\n",
    "\n",
    "In the following example, we create two processes and try to operate on the same list inside of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 67,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 514,
     "status": "ok",
     "timestamp": 1520171574376,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "RynK6PXb2QPk",
    "outputId": "b5e19014-74a5-4916-e8fb-d08d3a78d0c8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 squared results in a/an zero number\n",
      "1 squared results in a/an odd number\n",
      "2 squared results in a/an even number\n",
      "3 squared results in a/an odd number\n",
      "4 squared results in a/an even number\n",
      "5 squared results in a/an odd number\n",
      "6 squared results in a/an even number\n",
      "7 squared results in a/an odd number\n",
      "8 squared results in a/an even number\n",
      "9 squared results in a/an odd number\n",
      "That took 2.1348626613616943 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import multiprocessing \n",
    "\n",
    "def basic_func(x):\n",
    "    if x == 0:\n",
    "        return 'zero'\n",
    "    elif x%2 == 0:\n",
    "        return 'even'\n",
    "    else:\n",
    "        return 'odd'\n",
    "\n",
    "def multiprocessing_func(x):\n",
    "    y = x*x\n",
    "    time.sleep(2)\n",
    "    print('{} squared results in a/an {} number'.format(x, basic_func(y)))\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    starttime = time.time()\n",
    "    processes = []\n",
    "    for i in range(0,10):\n",
    "        p = multiprocessing.Process(target=multiprocessing_func, args=(i,))\n",
    "        processes.append(p)\n",
    "        p.start()\n",
    "        \n",
    "    for process in processes:\n",
    "        process.join()\n",
    "        \n",
    "    print('That took {} seconds'.format(time.time() - starttime))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Usage of the Pool Class\n",
    "\n",
    "To use the Pool class, we also have to create a separate function that takes a list item as an argument like we did when using Process. Then, using the multiprocessing module, create a Pool object called pool. This object has a function called map, which takes the function we want to multiprocess and the list as arguments and then iterates through the list for that function. After calling the function map, close the object to allow for a clean shutdown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 squared results in a/an odd number\n",
      "0 squared results in a/an zero number\n",
      "2 squared results in a/an even number\n",
      "3 squared results in a/an odd number\n",
      "5 squared results in a/an odd number\n",
      "4 squared results in a/an even number\n",
      "6 squared results in a/an even number\n",
      "7 squared results in a/an odd number\n",
      "9 squared results in a/an odd number\n",
      "8 squared results in a/an even number\n",
      "That took 6.080142021179199 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import multiprocessing \n",
    "\n",
    "def basic_func(x):\n",
    "    if x == 0:\n",
    "        return 'zero'\n",
    "    elif x%2 == 0:\n",
    "        return 'even'\n",
    "    else:\n",
    "        return 'odd'\n",
    "\n",
    "def multiprocessing_func(x):\n",
    "    y = x*x\n",
    "    time.sleep(2)\n",
    "    print('{} squared results in a/an {} number'.format(x, basic_func(y)))\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    \n",
    "    starttime = time.time()\n",
    "    pool = multiprocessing.Pool()\n",
    "    pool.map(multiprocessing_func, range(0,10))\n",
    "    pool.close()\n",
    "    print('That took {} seconds'.format(time.time() - starttime))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another simple example using the Process Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing as mp\n",
    "\n",
    "def func(some_list):\n",
    "  some_list.append(\"hello\")\n",
    "  print(some_list)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "  some_list = []\n",
    "\n",
    "  p1 = mp.Process(target=func, args=(some_list, ))\n",
    "  p2 = mp.Process(target=func, args=(some_list, ))\n",
    "\n",
    "  p1.start()\n",
    "  p2.start()\n",
    "\n",
    "  p1.join()\n",
    "  p2.join()\n",
    "\n",
    "  print(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, changes made to the list in the subprocesses are not visible in the main process. This is a result of the fact, that memory is copied on creation of the new process. There are few techniques to actually share information between processes.\n",
    "\n",
    "Let's do something practical before we visit other functinalities of `multiprocessing`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NNqkHpd39NJw"
   },
   "source": [
    "## Multiprocessing -- the Pool class\n",
    "Allows for easy offloading of tasks to 'worker processes'.\n",
    "\n",
    "Map functions keep the order of returned results. If you don't need it, use `imap_unordered` for optimization. You can also run tasks asynchronously with help of apply_async."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 221,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 808,
     "status": "ok",
     "timestamp": 1520361018399,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "n0HnYbRP9Vzi",
    "outputId": "6f08970e-3994-4684-ba6f-aa48ae423bd8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "from time import sleep\n",
    "import multiprocessing as mp\n",
    "\n",
    "def f_sleep(x):\n",
    "    sleep(2)\n",
    "    return x*x\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return x*x\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "  \n",
    "  with mp.Pool(processes=3) as pool:  # default number of processes: os.cpu_count()\n",
    "    \n",
    "    print(pool.map(f, range(10)))\n",
    "\n",
    "    for i in pool.imap_unordered(f, range(10)):\n",
    "        print(i)\n",
    "        \n",
    "    \n",
    "    # run tasks asynchronously\n",
    "    tasks = []   \n",
    "    \n",
    "    for i in range(10):\n",
    "        tasks.append(pool.apply_async(f_sleep, args=(i, )))\n",
    "        \n",
    "    # timeout if fetching results takes too long\n",
    "    for i in tasks:\n",
    "        print(i.get(timeout=3))\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example - mandelbrot set\n",
    "\"Embarassingly parallel problem\"\n",
    "\n",
    "### Standard implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jhskone/anaconda/anaconda3/lib/python3.6/site-packages/matplotlib/font_manager.py:278: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment.\n",
      "  'Matplotlib is building the font cache using fc-list. '\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed in: 14.99233889579773 seconds\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from functools import partial\n",
    "import time\n",
    "\n",
    "\n",
    "def mandelbrotCalcRow(yPos, h, w, max_iteration = 1000):\n",
    "    y0 = yPos * (2/float(h)) - 1 #rescale to -1 to 1\n",
    "    row = []\n",
    "    for xPos in range(w):\n",
    "        x0 = xPos * (3.5/float(w)) - 2.5 #rescale to -2.5 to 1\n",
    "        iteration, z = 0, 0 + 0j\n",
    "        c = complex(x0, y0)\n",
    "        while abs(z) < 2 and iteration < max_iteration:\n",
    "            z = z**2 + c\n",
    "            iteration += 1\n",
    "        row.append(iteration)\n",
    "\n",
    "    return row\n",
    "\n",
    "\n",
    "def mandelbrotCalcSet(h, w, max_iteration = 1000):\n",
    "    partialCalcRow = partial(mandelbrotCalcRow, h=h, w=w, max_iteration = max_iteration)\n",
    "    mandelImg = list(map(partialCalcRow, range(h)))\n",
    "    return mandelImg\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    start_time = time.time()\n",
    "    mandelImg = mandelbrotCalcSet(500, 400, 1000)\n",
    "    print(\"Completed in: %s seconds\" % (time.time() - start_time))\n",
    "    \n",
    "    plt.figure(figsize=(10, 6), facecolor='w', edgecolor='k')\n",
    "    plt.imshow(mandelImg,  interpolation='nearest', aspect='auto')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parallel implmentation\n",
    "Let's use a pool of process to caluclate rows in parallel.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed in: 3.513144016265869 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import multiprocessing as mp\n",
    "\n",
    "\n",
    "def mandelbrotCalcSet(h, w, max_iteration = 1000):\n",
    "\n",
    "    partialCalcRow = partial(mandelbrotCalcRow, h=h, w=w, max_iteration = max_iteration)\n",
    " \n",
    "    pool = mp.Pool(processes=4)\n",
    "    mandelImg = pool.map(partialCalcRow, range(h)) \n",
    "    pool.close()\n",
    "    pool.join()\n",
    " \n",
    "    return mandelImg\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    start_time = time.time()\n",
    "    mandelImg = mandelbrotCalcSet(500, 400, 1000)\n",
    "    print(\"Completed in: %s seconds\" % (time.time() - start_time))\n",
    "    \n",
    "    plt.figure(figsize=(10, 6), facecolor='w', edgecolor='k')\n",
    "    plt.imshow(mandelImg,  interpolation='nearest', aspect='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We were able to achieve a significant speed-up."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k2nFMcTs8m0d"
   },
   "source": [
    "## Exchanging data between processes\n",
    "\n",
    "### Pipes\n",
    "- objects have to be picklable\n",
    "- pretty slow\n",
    "- objects > 32MB might cause errors\n",
    "- pipe is basically a buffer\n",
    "- data might become corrupted if to processes write to the same end of the pipe at the same time\n",
    "- implemented in os\n",
    "- can be uni- or bi- dirctional\n",
    "\n",
    "In this example we try to send data from the child process to the main process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 34,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 619,
     "status": "ok",
     "timestamp": 1520176537071,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "Hff-PPjn8ZCH",
    "outputId": "54a5ff87-24fc-4df8-f996-8e07d39461cd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there, bud!\n"
     ]
    }
   ],
   "source": [
    "def func(conn):\n",
    "    conn.send(\"Hi there, bud!\")\n",
    "    conn.close()\n",
    "    \n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "  one_end, second_end = mp.Pipe()\n",
    "\n",
    "  for i in range(100):\n",
    "      p = mp.Process(target=func, args=(second_end,))\n",
    "      p.start()\n",
    "\n",
    "  print(one_end.recv())\n",
    "  p.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fTdALuPnA69k"
   },
   "source": [
    "### Queue\n",
    "- higher level than pipes, safer\n",
    "- can store python objects\n",
    "- slow\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 34,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 673,
     "status": "ok",
     "timestamp": 1520176522330,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "YneOC88XBDQ1",
    "outputId": "2baa0bd1-c7e7-43b9-8c77-375bab711e5e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['An answer is 42']\n"
     ]
    }
   ],
   "source": [
    "def func(results):\n",
    "    results.put([\"An answer is 42\"])\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "\n",
    "  results = mp.Queue()\n",
    "\n",
    "  p1 = mp.Process(target=func, args=(results, ))\n",
    "  p1.start()\n",
    "\n",
    "  print(results.get())\n",
    "  p1.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p9tNVc8_8rHG"
   },
   "source": [
    "## Synchronization\n",
    "\n",
    "To ilustrate synchronization mechanisms, we use shared memory explained later in this notebook.\n",
    "\n",
    "### Trivial example\n",
    "Sometimes we want to ensure some resources are not used by multiple processes at the same time. In this example, process are waiting for lock to be released in order not to mix up their output.\n",
    "\n",
    "Other examples: database, files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 101,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 641,
     "status": "ok",
     "timestamp": 1520169728588,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "WeB51fVf8uXP",
    "outputId": "8a23e52b-b3b6-47eb-dcb1-c7861a3328bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 0\n",
      "hello world 1\n"
     ]
    }
   ],
   "source": [
    "import multiprocessing as mp\n",
    "\n",
    "def f(lock, i):\n",
    "    lock.acquire()\n",
    "    try:\n",
    "        print('hello world', i)\n",
    "    finally:\n",
    "        lock.release()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    lock = mp.Lock()\n",
    "\n",
    "    for num in range(2):\n",
    "        mp.Process(target=f, args=(lock, num)).start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why is it important?\n",
    "\n",
    "Unsupervised access to shared resources may cause unexpected behaviour, such as presented below. In theory, we should add 1 to `num` value 2000 times, resulting in `num` equaling to 2000 and change sign of `arr` array elements 2000 times, leaving them positive. When you run the cell below, you should notice `num` value beeing lower and `arr` elements having different signs. See `Sharing state` below for more information about Value and Array classes.\n",
    "\n",
    "**Warning:** This example might not run at your machine due to open processes limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1997.0\n",
      "[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n"
     ]
    }
   ],
   "source": [
    "import multiprocessing as mp\n",
    "\n",
    "\n",
    "def f(n, a):\n",
    "    n.value += 1;\n",
    "    for i in range(len(a)):\n",
    "        a[i] = -a[i]\n",
    "\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    num = mp.Value('d', 0.0)\n",
    "    arr = mp.Array('i', range(10))\n",
    "\n",
    "    processes = []\n",
    "    \n",
    "    for i in range(1, 2000):\n",
    "        p = mp.Process(target=f, args=(num, arr))\n",
    "        p.start()\n",
    "        processes.append(p)\n",
    "    \n",
    "    print(num.value)\n",
    "    print(arr[:])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6dNCQ0Yh8uq2"
   },
   "source": [
    "## Sharing state\n",
    "\n",
    "In general, you should design your software to avoid sharing memory between process. If the use case requires it, multiprocessing provides a way to share memory spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Dv2YLg5pLgcy"
   },
   "source": [
    "### Shared memory\n",
    "\n",
    "- uses c-like memory representation there are only Arrays and Values.\n",
    "- see multiprocessing.csharedtypes for more\n",
    "- see resources for use with numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 51,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 557,
     "status": "ok",
     "timestamp": 1520169822578,
     "user": {
      "displayName": "Karol Horosin",
      "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128",
      "userId": "100004662707027644040"
     },
     "user_tz": -60
    },
    "id": "YWg1kFav9XN6",
    "outputId": "226086ed-0c8c-46be-9e4f-0e128ce751ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415927\n",
      "[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def f(n, a, lock):\n",
    "    lock.acquire()\n",
    "    n.value = 3.1415927\n",
    "    lock.release()\n",
    "    for i in range(len(a)):\n",
    "        a[i] = -a[i]\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    num = mp.Value('d', 0.0)\n",
    "    arr = mp.Array('i', range(10))\n",
    "\n",
    "    p = mp.Process(target=f, args=(num, arr))\n",
    "    p.start()\n",
    "    p.join()\n",
    "\n",
    "    print(num.value)\n",
    "    print(arr[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Server process\n",
    "\n",
    "Less performance but can be used with any pickle'able object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: '1', '2': 2, 0.25: None}\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "from multiprocessing import Process, Manager\n",
    "\n",
    "def f(d, l):\n",
    "    d[1] = '1'\n",
    "    d['2'] = 2\n",
    "    d[0.25] = None\n",
    "    l.reverse()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    with Manager() as manager:\n",
    "        d = manager.dict()\n",
    "        l = manager.list(range(10))\n",
    "\n",
    "        p = Process(target=f, args=(d, l))\n",
    "        p.start()\n",
    "        p.join()\n",
    "\n",
    "        print(d)\n",
    "        print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "default_view": {},
   "name": "multiprocessing.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}