notebooks/03.1_Distributed_Computing.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "# 3.1 Distributed Computing\n",
      "\n",
      "<center>\n",
      "*[This tutorial](https://github.com/pyHPC/pyhpc-tutorial) has been collectively developed by the [PyHPC Community](https://github.com/pyHPC) and is available for reuse under a CC BY license.  \n",
      "All code samples are available for reuse under the terms of the [MIT license](http://opensource.org/licenses/MIT).*  \n",
      "[![Creative Commons License](../figures/creative_commons_logo.png)](http://creativecommons.org/licenses/by/3.0/deed.en_US)</center>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Acknowledgements\n",
      "\n",
      "* Much of this tutorial uses slide material from [William Gropp](http://www.cs.uiuc.edu/~wgropp/), University of Illinois and [Lisandro Dalcin](http://plus.google.com/107621373684536061961/about), CONICET\n",
      "* [mpi4py](http://code.google.com/p/mpi4py/) is a [Cythonized](http://www.cython.org/) wrapper around [MPI](http://www.mpi-forum.org/) originally developed by [Lisandro Dalcin](http://plus.google.com/107621373684536061961/about), CONICET\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Notebook Engine Setup\n",
      "\n",
      "Following the recommendations in PEP 8, we import all Python modules at the beginning of the notebook."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext parallelmagic\n",
      "%pylab inline --no-import-all"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The parallelmagic extension is already loaded. To reload it, use:\n",
        "  %reload_ext parallelmagic\n",
        "Populating the interactive namespace from numpy and matplotlib\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "from mpi4py import MPI\n",
      "import numpy as np\n",
      "from matplotlib import pyplot"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Connecting to MPI via IPython\n",
      "\n",
      "To run the examples in parallel, you must run the command:\n",
      "\n",
      "    ipcluster start --engines=MPI --n 4\n",
      "\n",
      "Or use notebook Appendix_Launch_MPI_Engines \n",
      "(if you are using the VMs or have this configured for your environment).\n",
      "\n",
      "Then execute the next cell:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.parallel import Client\n",
      "c = Client()\n",
      "view = c[:]\n",
      "\n",
      "view.activate()\n",
      "view.block = True"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are now 5 IPython Engines (also sometimes called kernels) running: 1 directly connected to the Notebook and 4 started by `ipcluster` and connected via the Client interface. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## `%autopx` and the `ipcluster` Engines"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "For interactive convenience, we will use the `autopx` magic from the `parallelmagic` extensions.  We can use the `autopx` magic to execute cells on the ipcluster Engines instead of the Notebook Engines.  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "os.getpid()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "22158"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%autopx"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "%autopx enabled\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "source": [
      "Recall that when we used `import` earlier it was on the Notebook Engine.  Before we can call `os.getpid` on the ipcluster Engines, we need to import `os` and any other modules we would like to use.  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "#We will use mpi4py, numpy, and math later\n",
      "from mpi4py import MPI\n",
      "import numpy as np\n",
      "import math"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "os.getpid()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "\u001b[0;31mOut[0:3]: \u001b[0m22398"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "\u001b[0;31mOut[1:3]: \u001b[0m22399"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "\u001b[0;31mOut[2:3]: \u001b[0m22400"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "\u001b[0;31mOut[3:3]: \u001b[0m22397"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "# A Quick Review of Concepts of Scalability"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "# The Multiple Forms of Parallelism\n",
      "\n",
      "* **instruction** - multiple program instructions are simultaneously dispatched in a pipeline or to multiple execution units (superscalar)\n",
      "* **data** - the same program instructions are carried out simultaneously on multiple data items (SIMD)\n",
      "* **task** - different program instructions on different data (MIMD)\n",
      "* **collective** - single program, multiple data, not necessarily synchronized at individual operation level (SPMD)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true,
       "slide_type": "fragment"
      }
     },
     "source": [
      "> *This part of the tutorial focuses on data and collective parallelism*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "# Parallel Programming Paradigms\n",
      "\n",
      "* a parallel programming paradigm is a specific approach to exploiting parallelism in hardware\n",
      "* many programming paradigms are very tightly coupled to the hardware beneath!\n",
      "  \n",
      " - CUDA assumes large register files, Same Instruction Multiple Thread parallelism, and a mostly flat, structured memory model, matching the underlying GPU hardware\n",
      "\n",
      " - OpenMP exposes loop level parallelism with a fork/join model, assumes the presence of shared memory and atomics\n",
      "\n",
      " - OpenCL tries to generalize CUDA, but still assumes a 'coprocessor' approach, where kernels are shipped from a master core to worker cores\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## The Message Passing Model\n",
      "\n",
      "* a process is (traditionally) a program counter for instructions and an address space for data\n",
      "* processes may have multiple threads (program counters and associated stacks) sharing a single address space\n",
      "* message passing is for communication among processes, which have separate address spaces\n",
      "* interprocess communication consists of\n",
      "  \n",
      "  - synchronization\n",
      "  - movement of data from one process's address space to another's\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Why MPI?\n",
      "\n",
      "* **communicators** encapsulate communication spaces for library safety\n",
      "* **datatypes** reduce copying costs and permit heterogeneity\n",
      "* multiple **communication modes** allow more control of memory buffer management\n",
      "* extensive **collective operations** for scalable global communication\n",
      "* **process topologies** permit efficient process placement, user views of process layout\n",
      "* **profiling interface** encourages portable tools\n",
      "\n",
      "It Scales!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## MPI - Quick Review\n",
      "\n",
      "* processes can be collected into **groups**\n",
      "* each message is sent in a **context**, and must be received in the same context\n",
      "* a  **communicator** encapsulates a context for a specific group\n",
      "* a given program may have many communicators with any level of overlap\n",
      "* two initial communicators\n",
      " \n",
      "  - `MPI_COMM_WORLD` (all processes)\n",
      "  - `MPI_COMM_SELF` (current process)\n",
      "  \n",
      "In Python, these communicators are `MPI.COMM_WORLD and MPI.COMM_SELF`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Communicator, Rank, and Size Setup\n",
      "\n",
      "We'll be using the `MPI.COMM_WORLD` communicator as `comm` for the remainder of this notebook.  It's also very common to use the communicator's associated rank and size attributes as `rank` and `size`.  We'll assign these variables now to simplify the readability of the code."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "comm = MPI.COMM_WORLD\n",
      "size = comm.Get_size()\n",
      "rank = comm.Get_rank()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## First Example: Hello World"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# set up basic variables\n",
      "name = MPI.Get_processor_name()\n",
      "pid = os.getpid()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Hello World! I am process %d of %d on %s with pid %d.\\n\" % (rank, size, name, pid))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] \n",
        "Hello World! I am process 1 of 4 on Arons-MacBook-Pro.local with pid 22398.\n",
        "\n",
        "[stdout:1] \n",
        "Hello World! I am process 2 of 4 on Arons-MacBook-Pro.local with pid 22399.\n",
        "\n",
        "[stdout:2] \n",
        "Hello World! I am process 3 of 4 on Arons-MacBook-Pro.local with pid 22400.\n",
        "\n",
        "[stdout:3] \n",
        "Hello World! I am process 0 of 4 on Arons-MacBook-Pro.local with pid 22397.\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note that the MPI rank is not necessarily synchronized with the IPython view rank."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Communicators\n",
      "\n",
      "* processes can be collected into **groups**\n",
      "* each message is sent in a **context**, and must be received in the same context\n",
      "* a  **communicator** encapsulates a context for a specific group\n",
      "* a given program may have many communicators with any level of overlap\n",
      "* two initial communicators\n",
      " \n",
      "  - ``MPI_COMM_WORLD`` (all processes)\n",
      "  - ``MPI_COMM_SELF`` (current process)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Datatypes\n",
      "\n",
      "* the data in a message to send or receive is described by address, count and datatype\n",
      "* a datatype is recursively defined as:\n",
      "\n",
      "  + predefined, corresponding to a data type from the language (e.g., ``MPI_INT``, ``MPI_DOUBLE``)\n",
      "  + a contiguous, strided block, or indexed array of blocks of MPI datatypes\n",
      "  + an arbitrary structure of datatypes\n",
      "\n",
      "* there are MPI functions to construct custom datatypes"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Tags\n",
      "\n",
      "* messages are sent with an accompanying user-defined integer tag to assist the receiving process in identifying the message\n",
      "* messages can be screened at the receiving end by specifying the expected tag, or not screened by using ``MPI_ANY_TAG`` "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_type": "slide"
      }
     },
     "source": [
      "## mpi4py Functionality\n",
      "\n",
      "* Implements up to MPI-3 with underlying MPI implementation support\n",
      "* Generic API with lowercase function names, e.g. `Comm.send`\n",
      "* Efficient API with titlecase function names, e.g. `Comm.Send`\n",
      "  + The efficient API can still handle default arguments and type discovery for NumPy arrays and PEP-3118 buffers"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Job Startup\n",
      "\n",
      "* To launch:\n",
      "        mpirun --np NP python script_name\n",
      "* IPython automatically handles calling `mpirun` for you with the `ipcluster` command\n",
      "\n",
      "## Initialization\n",
      "`mpi4py` automatically calls `MPI_Init()` and `MPI_Finalize()`\n",
      "\n",
      "* `MPI_Init()` is called when you import the `MPI` module from `mpi4py`\n",
      "* `MPI_Finalize()` is called before the Python process ends\n",
      "* If you need explicit control, use the `mpi4py.rc` module to configure before importing `MPI`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_step": false,
       "slide_type": "slide"
      }
     },
     "source": [
      "## MPI Basic (Blocking) Send\n",
      "\n",
      "#### C\n",
      "```\n",
      "   int MPI_Send(void* buf, int count, MPI_Datatype type, \n",
      "   int dest, int tag, MPI_Comm comm)\n",
      "```\n",
      "\n",
      "#### mpi4py\n",
      "```\n",
      "  Comm.Send(self, buf, dest=0, tag=0)\n",
      "  Comm.send(self, obj=None, dest=0, tag=0)\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## MPI Basic (Blocking) Recv\n",
      "\n",
      "#### C\n",
      "```\n",
      "   int MPI_Recv(void* buf, int count, MPI_Datatype type, \n",
      "   int source, int tag, MPI_Comm comm, MPI_Status status)\n",
      "```\n",
      "\n",
      "#### mpi4py\n",
      "```\n",
      "  comm.Recv(self, buf, source=0, tag=0, status=None)\n",
      "  comm.recv(self, obj=None, source=0, tag=0, status=None)\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Send/Receive Example "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Generic"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if rank == 0:\n",
      "   data = {'a': 7, 'b': 3.14}\n",
      "   comm.send(data, dest=1, tag=11)\n",
      "elif rank == 1:\n",
      "   data = comm.recv(source=0, tag=11)\n",
      "   print data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] {'a': 7, 'b': 3.14}\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "### Efficient"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "-"
      }
     },
     "source": [
      "#### Explicit MPI Datatypes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if rank == 0:\n",
      "    data = np.arange(10, dtype='i')\n",
      "    comm.Send([data, MPI.INT], dest=1, tag=77)\n",
      "elif rank == 1:\n",
      "    data = np.empty(10, dtype='i')\n",
      "    comm.Recv([data, MPI.INT], source=0, tag=77)\n",
      "    print data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_type": "-"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] [0 1 2 3 4 5 6 7 8 9]\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "-"
      }
     },
     "source": [
      "#### Automatic MPI Datatype Discovery (NumPy arrays)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if rank == 0:\n",
      "    data = np.arange(10, dtype=np.float64)\n",
      "    comm.Send(data, dest=1, tag=13)\n",
      "elif rank == 1:\n",
      "    data = np.empty(10, dtype=np.float64)\n",
      "    comm.Recv(data, source=0, tag=13)\n",
      "    print data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "-"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Synchronization\n",
      "\n",
      "#### C\n",
      "```\n",
      "   int MPI_Barrier(MPI_Comm comm)\n",
      "```\n",
      "\n",
      "#### mpi4py\n",
      "\n",
      "```\n",
      "   comm.Barrier(self)\n",
      "   comm.barrier(self)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for r_id in range(comm.Get_size()):\n",
      "    if rank == r_id:\n",
      "        print \"Hello from proc:\", rank\n",
      "    comm.Barrier()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] Hello from proc: 1\n",
        "[stdout:1] Hello from proc: 2\n",
        "[stdout:2] Hello from proc: 3\n",
        "[stdout:3] Hello from proc: 0\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Timing and Profiling\n",
      "\n",
      "The elapsed (wall-clock) time between two points in an MPI program can be computed using MPI_Wtime:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t1 = MPI.Wtime()\n",
      "t2 = MPI.Wtime()\n",
      "print(\"time elapsed is: %e\\n\" % (t2-t1))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] \n",
        "time elapsed is: 9.230500e-05\n",
        "\n",
        "[stdout:1] \n",
        "time elapsed is: 9.876500e-05\n",
        "\n",
        "[stdout:2] \n",
        "time elapsed is: 9.861000e-05\n",
        "\n",
        "[stdout:3] \n",
        "time elapsed is: 4.349900e-05\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Basic Collectives: Broadcast, Scatter, and Gather\n",
      "![](../figures/broadcast_scatter_gather.png)\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "#### C\n",
      "\n",
      "```\n",
      "   int MPI_Bcast(void *buf, int count, MPI_Datatype type, \n",
      "   int root, MPI_Comm comm)\n",
      "```\n",
      "\n",
      "#### mpi4py\n",
      "\n",
      "``` \n",
      "  comm.Bcast(self, buf, root=0)\n",
      "  comm.bcast(self, obj=None, root=0)\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Broadcast Example"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if rank == 0:\n",
      "   data = {'key1' : [7, 2.72, 2+3j],\n",
      "           'key2' : ( 'abc', 'xyz')}\n",
      "else:\n",
      "   data = None\n",
      "data = comm.bcast(data, root=0)\n",
      "print \"bcast finished and data \\\n",
      " on rank %d is: \"%comm.rank, data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] bcast finished and data  on rank 0 is:  {'key2': ('abc', 'xyz'), 'key1': [7, 2.72, (2+3j)]}\n",
        "[stdout:1] bcast finished and data  on rank 1 is:  {'key2': ('abc', 'xyz'), 'key1': [7, 2.72, (2+3j)]}\n",
        "[stdout:2] bcast finished and data  on rank 3 is:  {'key2': ('abc', 'xyz'), 'key1': [7, 2.72, (2+3j)]}\n",
        "[stdout:3] bcast finished and data  on rank 2 is:  {'key2': ('abc', 'xyz'), 'key1': [7, 2.72, (2+3j)]}\n"
       ]
      }
     ],
     "prompt_number": 54
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Scatter Example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if rank == 0:\n",
      "   data = [(i+1)**2 for i in range(size)]\n",
      "else:\n",
      "   data = None\n",
      "data = comm.scatter(data, root=0)\n",
      "assert data == (rank+1)**2\n",
      "print \"data on rank %d is: \"%comm.rank, data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] data on rank 0 is:  1\n",
        "[stdout:1] data on rank 1 is:  4\n",
        "[stdout:2] data on rank 3 is:  16\n",
        "[stdout:3] data on rank 2 is:  9\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Gather (and Barrier) Example:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data = (rank+1)**2\n",
      "print \"before gather, data on \\\n",
      "  rank %d is: \"%rank, data\n",
      "\n",
      "comm.Barrier()\n",
      "data = comm.gather(data, root=0)\n",
      "if rank == 0:\n",
      "   for i in range(size):\n",
      "       assert data[i] == (i+1)**2\n",
      "else:\n",
      "   assert data is None\n",
      "print \"data on rank: %d is: \"%rank, data"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] \n",
        "before gather, data on   rank 0 is:  1\n",
        "data on rank: 0 is:  [1, 4, 9, 16]\n",
        "[stdout:1] \n",
        "before gather, data on   rank 1 is:  4\n",
        "data on rank: 1 is:  None\n",
        "[stdout:2] \n",
        "before gather, data on   rank 3 is:  16\n",
        "data on rank: 3 is:  None\n",
        "[stdout:3] \n",
        "before gather, data on   rank 2 is:  9\n",
        "data on rank: 2 is:  None\n"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Reduce and Scan\n",
      "\n",
      "![](../figures/reduce_scan.png)\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Reduce Example\n",
      "\n",
      "The lower-case `reduce` implemented in `mpi4py` is not designed to be particularly scalable.  If you need to perform a reduce on thousands of processes or more, it is recommended that you either switch to the non-generic Reduce, or utilize the scalable reduce provided in `mpi4py/demo/reductions/reductions.py`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sendmsg = comm.rank\n",
      "recvmsg1 = comm.reduce(sendmsg, op=MPI.SUM, root=0)\n",
      "recvmsg2 = comm.allreduce(sendmsg)\n",
      "print recvmsg2"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:0] 6\n",
        "[stdout:1] 6\n",
        "[stdout:2] 6\n",
        "[stdout:3] 6\n"
       ]
      }
     ],
     "prompt_number": 57
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Compute Pi Example\n",
      "\n",
      "The following example is completely self-contained to simplify reuse in another script.  You can switch between running the code in parallel and serial by executing an %autopx cell."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from mpi4py import MPI\n",
      "import math\n",
      "\n",
      "def compute_pi(n, start=0, step=1):\n",
      "    h = 1.0 / n\n",
      "    s = 0.0\n",
      "    for i in range(start, n, step):\n",
      "        x = h * (i + 0.5)\n",
      "        s += 4.0 / (1.0 + x**2)\n",
      "    return s * h\n",
      "\n",
      "comm = MPI.COMM_WORLD\n",
      "nprocs = comm.Get_size()\n",
      "myrank = comm.Get_rank()\n",
      "if myrank == 0:\n",
      "    n = 10\n",
      "else:\n",
      "    n = None\n",
      "\n",
      "n = comm.bcast(n, root=0)\n",
      "\n",
      "mypi = compute_pi(n, myrank, nprocs)\n",
      "\n",
      "pi = comm.reduce(mypi, op=MPI.SUM, root=0)\n",
      "\n",
      "if myrank == 0:\n",
      "    error = abs(pi - math.pi)\n",
      "    print (\"pi is approximately %.16f\\nerror is %.16f\" % (pi, error))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true,
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[stdout:3] \n",
        "pi is approximately 3.1424259850010983\n",
        "error is 0.0008333314113051\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": true,
       "slide_type": "slide"
      }
     },
     "source": [
      "## Mandelbrot Set Example\n",
      "\n",
      "The following example is completely self-contained to simplify reuse in another script."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from mpi4py import MPI\n",
      "import numpy as np\n",
      "\n",
      "def mandelbrot (x, y, maxit):\n",
      "    c = x + y*1j\n",
      "    z = 0 + 0j\n",
      "    it = 0\n",
      "    while abs(z) < 2 and it < maxit:\n",
      "        z = z**2 + c\n",
      "        it += 1\n",
      "    return it\n",
      "\n",
      "x1, x2 = -2.0, 1.0\n",
      "y1, y2 = -1.0, 1.0\n",
      "w, h = 250, 200\n",
      "maxit = 127\n",
      "  \n",
      "comm = MPI.COMM_WORLD\n",
      "size = comm.Get_size()\n",
      "rank = comm.Get_rank()\n",
      "\n",
      "# number of rows to compute here\n",
      "N = h // size + (h % size > rank)\n",
      "\n",
      "# first row to compute here\n",
      "start = comm.scan(N)-N\n",
      "\n",
      "# array to store local result\n",
      "Cl = np.zeros([N, w], dtype='i')\n",
      "\n",
      "# compute owned rows\n",
      "\n",
      "dx = (x2 - x1) / w\n",
      "dy = (y2 - y1) / h\n",
      "\n",
      "for i in range(N):\n",
      "    y = y1 + (i + start) * dy\n",
      "    for j in range(w):\n",
      "        x = x1 + j * dx\n",
      "        Cl[i, j] = mandelbrot(x, y, maxit)\n",
      "\n",
      "# gather results at root (process 0)\n",
      "counts = comm.gather(N, root=0)\n",
      "C = None\n",
      "if rank == 0:\n",
      "    C = np.zeros([h, w], dtype='i')\n",
      "\n",
      "# here we create a custom datatype for sending/receiving rows of data.\n",
      "rowtype = MPI.INT.Create_contiguous(w)\n",
      "rowtype.Commit()\n",
      "\n",
      "comm.Gatherv(sendbuf=[Cl, MPI.INT], recvbuf=[C, (counts, None), rowtype],root=0)\n",
      "\n",
      "rowtype.Free()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_step": true,
       "slide_type": "slide"
      }
     },
     "outputs": [],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_start": false,
       "slide_type": "slide"
      }
     },
     "source": [
      "We can't inline plots from the `ipcluster` Engines where we just performed the computations.  Instead, we use the Notebook Engine to get a copy of the data on MPI rank 0, then plot as before.\n",
      "\n",
      "First, we switch off `%autopx` to enable computing on the Notebook Engine. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%autopx"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "%autopx disabled\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Then we collect the array and rank data from the `ipcluster` Engines using the `view` object."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# CC is a list of C from all ranks\n",
      "CC = view['C']\n",
      "# Similarly, ranks is a list of MPI ranks from all ipcluster processes\n",
      "ranks = view['rank']\n",
      "\n",
      "# Do the plotting\n",
      "# We use the IPython index of the ipcluster process with rank 0 as\n",
      "# the index into CC\n",
      "pyplot.imshow(CC[ranks.index(0)])\n",
      "pyplot.spectral()\n",
      "pyplot.show()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_start": false
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAToAAAD9CAYAAAAs2LvkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text": [
        "<matplotlib.figure.Figure at 0x111773c10>"
       ]
      }
     ],
     "prompt_number": 43
    }
   ],
   "metadata": {}
  }
 ]
}