Speed without drag - Saul Diez-Guerra.ipynb

{
 "metadata": {
  "celltoolbar": "Slideshow",
  "name": "",
  "signature": "sha256:18a44af5b7f2db6ba4493c0777bea0caab65920f383073cb41966f38e6458ed4"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "# Speed without drag\n",
      "\n",
      "*Saul Diez-Guerra*"
     ]
    },
    {
     "cell_type": "raw",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "<div style=\"width: 100%; text-align: center\"><img src=\"files/saool1.png\"></div>"
     ]
    },
    {
     "cell_type": "raw",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "<div style=\"width: 100%; text-align: center\"><img src=\"files/saool2.png\"></div>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## *What's the story here?*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "## *How to speed up your numerical Python when there is no time to waste.*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Think first.."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "### TANSTAAFL!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "*there ain't no such thing as a free speed-up*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "## ..and then don't try."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## What if..."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* You thought it through and refactored"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* You threw money at the problem"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* You evaluated the cost of opportunity"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* ~~You blamed it on the GIL and on van Rossum, and switched to Java~~"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "## Ok, fine."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## But first\n",
      "* Rule out other problems"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "* IO, deserializing, any other bottleneck. I can't help you otherwise."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Calculating something over and over (e.g. re-compiling a reg ex)."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Are you discarding any computation?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Different types of randoms, different speeds\u2026 how much entropy do you need?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Many other things..."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "  * [https://www.youtube.com/watch?v=e08kOj2kISU](How to speed up a program 114kx)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "## But first\n",
      "* Rule out other problems\n",
      "* Capture low-hanging fruit"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "* Multiprocessing (overhead and Amdahl's)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Check your use of immutable objects, temporary storage: e.g. string concat"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Obscure language features like ``__ slots __``"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Fast append comprehensions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Generators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* But seriously, don't use his code"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "## But this is not the point of the talk"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "*Libraries and tools that help you circumvent The Safety of Python!*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## many tools, such speed"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "* Exhausting CPython\n",
      "* SciPy\n",
      "* NumPy\n",
      "* Numba\n",
      "* Parakeet\n",
      "* NumExpr\n",
      "* Theano\n",
      "* PyPy\n",
      "* NumPyPy\n",
      "* Jython\n",
      "* Blaze\n",
      "* Pyston\n",
      "* Pythran"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "### Driving example\n",
      "\n",
      "Polygon area based on its coordinates\n",
      "\n",
      "![http://upload.wikimedia.org/wikipedia/commons/e/e2/Polygon_area_formula.jpg](http://upload.wikimedia.org/wikipedia/commons/e/e2/Polygon_area_formula.jpg)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## DISCLAIMER\n",
      "*Time measurements are just for reference and are a biased,\n",
      " reductionistic tool that shouldn't be blindly trusted.*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "*Especially when you use a single piece of code to test many\n",
      "methods of optimization at once.*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "### Vanilla CPython"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\n",
      "XX\n",
      " XX\n",
      "  XX\n",
      "   XX\n",
      "\"\"\"\n",
      "\n",
      "def diag_gen(length):\n",
      "    points = [(0.25, 0.25)]\n",
      "    for _ in xrange(1, length + 1):\n",
      "        points.append((points[-1][0] + 1, points[-1][1]))\n",
      "        points.append((points[-1][0], points[-1][1] + 1))\n",
      "    points.append((points[-1][0], points[-1][1] + 1))\n",
      "    points.append((points[-1][0] - 1, points[-1][1]))\n",
      "    points.append((points[-1][0], points[-1][1] - 1))\n",
      "    for _ in xrange(1, length):\n",
      "        points.append((points[-1][0] - 1, points[-1][1]))\n",
      "        points.append((points[-1][0], points[-1][1] - 1))\n",
      "    points.append((0.25, 0.25))\n",
      "\n",
      "    return points"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 49
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def test_diag_gen(points):\n",
      "    res = 0\n",
      "    for point in points:\n",
      "        assert abs(point[0] + point[1] - res) <= 1\n",
      "        res = point[0] + point[1]\n",
      "    assert points[0] == points[-1]\n",
      "test_diag_gen(diag_gen(200))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 51
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def area(points):\n",
      "    acc = 0\n",
      "    for i in xrange(len(points) - 1):\n",
      "        acc += points[i][0] * points[i + 1][1] - points[i + 1][0] * points[i][1]\n",
      "    return abs(acc) / 2\n",
      "\n",
      "assert area(diag_gen(32)) == 64.0"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "polygon = diag_gen(2*10**5)\n",
      "%timeit area(polygon)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 252 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 54
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### SciPy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "SciPy, other than the \"stack\" and the \"ecosystem\" that contains amazing things as SciPy (hah), NumPy, IPython, pandas, PyTables, matplotlib... it is also the name of a package filled with algorithms and convenience functions.\n",
      "\n",
      "[http://github.com/scipy/scipy](http://github.com/scipy/scipy)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### NumPy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "N-dimesional arrays. C and fortran for speed, just like SciPy.\n",
      "\"Part\" of SciPy, but packaged on its own because of its standalone utility.\n",
      "\n",
      "[https://github.com/numpy/numpy](https://github.com/numpy/numpy)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "polygon_np = np.array(polygon, dtype=np.float64)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def area_np(arr):\n",
      "    return abs((arr[:-1,0] * arr[1:,1] - arr[:-1,1] * arr[1:,0]).sum()) / 2\n",
      "assert area_np(polygon_np) == 4.*10**5"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \" Python Area:\".ljust(21),\n",
      "%timeit area(polygon)\n",
      "\n",
      "print \"Numpy Area:\".ljust(20),\n",
      "%timeit area_np(polygon_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " Python Area:        1 loops, best of 3: 257 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        " Numpy Area:         100 loops, best of 3: 8.84 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 59
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Numba"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* JIT compiler that leverages the LLVM project\n",
      "* AST -> LLVM IR for a targeted subset of Python and NumPy\n",
      "* Experimental CUDA. Static compilation through pycc\n",
      "* NumbaPro: multicore and GPU\n",
      "    \n",
      "[https://github.com/numba/numba](https://github.com/numba/numba)\n",
      "\n",
      "[https://github.com/diezguerra/pycon-spain-numba-talk](https://github.com/diezguerra/pycon-spain-numba-talk)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numba as nb\n",
      "\n",
      "area_nb = nb.jit(area)\n",
      "area_np_nb = nb.jit(area_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 60
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \" Python Area:\".ljust(21),\n",
      "%timeit area(polygon)\n",
      "print \"Python Area Numba:\".ljust(20),\n",
      "%timeit area_nb(polygon)\n",
      "\n",
      "print \"Python NumPy:\".ljust(20),\n",
      "%timeit area_np(polygon_np)\n",
      "print \"Python NumPy Numba:\".ljust(20),\n",
      "%timeit area_np_nb(polygon_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " Python Area:        1 loops, best of 3: 257 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        " Python Area Numba:  1 loops, best of 3: 404 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        " Python NumPy:       100 loops, best of 3: 8.68 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        " Python NumPy Numba: 100 loops, best of 3: 8.56 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 62
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "### *(unrelated to the shoelace example)*"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@nb.vectorize([nb.i8(nb.i8), nb.i4(nb.i4)])\n",
      "def power(x):\n",
      "    return x * x + 1\n",
      "power_np = np.vectorize(lambda x: x * x + 1)\n",
      "\n",
      "\n",
      "arr = np.arange(1000000)\n",
      "%timeit -n 5 power_np(arr)\n",
      "%timeit -n100 np.square(arr) + 1\n",
      "%timeit -n100 power(arr)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5 loops, best of 3: 213 ms per loop\n",
        "100 loops, best of 3: 5.58 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "100 loops, best of 3: 5.06 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 63
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Parakeet"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "Similar to Numba originally, development is now focusing on manual optimization of functions and it has gone from translation\n",
      "into LLVM (deprecated) to C and OpenMP (gcc).\n",
      "\n",
      "Experimental support for CUDA.\n",
      "\n",
      "[https://github.com/iskandr/parakeet](https://github.com/iskandr/parakeet)\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import parakeet\n",
      "area_pk = parakeet.jit(area)\n",
      "area_np_pk = parakeet.jit(area_np)\n",
      "assert area_pk(polygon) == 4.*10**5\n",
      "assert area_np_pk(polygon_np) == 4.*10**5"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 65
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit area_pk(polygon)\n",
      "%timeit area_np_pk(polygon_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 491 ms per loop\n",
        "1000 loops, best of 3: 1.28 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 66
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### NumExpr"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Feeds the processor large arrays (larger than its cache) in a piecemeal fashion\n",
      "* Avoids temporary storage of intermediate values\n",
      "* Support for OpenMP and Intel's VML / MKL for transcendent expressions.\n",
      "* Reduced yet useful set of expressions, but highly performant (5-10x vs numpy)\n",
      "\n",
      "[https://github.com/pydata/numexpr](https://github.com/pydata/numexpr)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numexpr as ne\n",
      "def area_ne(arr):\n",
      "    arrX, arrx, arrY, arry = arr[:-1,0], arr[1:,0], arr[:-1,1], arr[1:,1]\n",
      "    return abs(ne.evaluate('sum(arrX * arry - arrY * arrX)'))\n",
      "assert area_ne(polygon_np) == 4.*10**5"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit area_np(polygon_np)\n",
      "%timeit area_ne(polygon_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 8.87 ms per loop\n",
        "100 loops, best of 3: 2.54 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 73
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Theano"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "Defines, optimizes and evaluates array expressions. Seamless GPU.\n",
      "CUDA. Native optimizations. Really specialized.\n",
      "\n",
      "Some tricky dependencies, depends on the platform. Anaconda will solve it.\n",
      "\n",
      "[https://github.com/Theano/Theano](https://github.com/Theano/Theano)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "os.environ['DYLD_FALLBACK_LIBRARY_PATH'] = '/Users/saul/anaconda/lib:' + os.environ.get('DYLD_FALLBACK_LIBRARY_PATH', '')"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "skip"
      }
     },
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from theano import tensor as T\n",
      "from theano import function\n",
      "\n",
      "def area_th(arr):\n",
      "    x, y, z, j = T.vectors('x', 'y', 'z', 'j')\n",
      "    expr = T.sum((x * y - z * j) * 0.5)\n",
      "    \n",
      "    return abs(function([x, y, z, j], expr)(arr[:-1,0], arr[1:,1], arr[:-1,1], arr[1:,0]))\n",
      "\n",
      "assert area_th(polygon_np) == 400000."
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit -n 10 area_np(polygon_np)\n",
      "%timeit -n 10 area_ne(polygon_np)\n",
      "%timeit -n 10 area_th(polygon_np)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 10.6 ms per loop\n",
        "10 loops, best of 3: 2.53 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10 loops, best of 3: 41.5 ms per loop"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 44
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### PyPy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "JIT compiler following the Python spec, but not (C)Python. \n",
      "Pretty mature, lots of support, not entirely there yet in some regards but highly compatible.\n",
      "\n",
      "[http://pypy.org/](http://pypy.org/)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "**pypy \u00bb** ./bin/pypy shoelace.py\n",
      "\n",
      "> ta:\t0.029669 s"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "** cpython \u00bb** python shoelace.py\n",
      "\n",
      "> pp: 2.539226 s"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### NumPyPy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "Fork of the original to make it work.\n",
      "http://buildbot.pypy.org/numpy-status/latest.html\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "**pypy \u00bb** ./bin/pypy shoelace.py\n",
      "\n",
      "> pp: 0.030495 s\n",
      "\n",
      "**pypy \u00bb** ./bin/pypy shoelace_np.py\n",
      "\n",
      "> np: 0.213656 s"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "** cpython \u00bb** python shoelace.py\n",
      "\n",
      "> pp: 2.539226 s\n",
      "\n",
      "**cpython \u00bb** python shoelace_np.py\n",
      "\n",
      "> np: 0.077828 s"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from timeit import Timer\n",
      "\n",
      "polygon_3 = diag_gen(2*10**5)\n",
      "polygon_3_np = np.array(diag_gen(2*10**5))\n",
      "ta = Timer('area(polygon_3)', 'from __main__ import area, polygon_3')\n",
      "tanp = Timer('area_np(polygon_3_np)', 'from __main__ import area_np, polygon_3_np')\n",
      "print \"ta:\\t\", round(min(ta.repeat(3, 10)), 6), \"s\"\n",
      "print \"tanp:\\t\", round(min(tanp.repeat(3, 10)), 6), \"s\""
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "ta:\t2.590854"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " s\n",
        "tanp:\t0.085523"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " s\n"
       ]
      }
     ],
     "prompt_number": 74
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Jython"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Python on the JVM\n",
      "* Needs JDK\n",
      "\n",
      "[http://www.jython.org/](http://www.jython.org/)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "**pypy \u00bb** ~/jython2.7b1/bin/jython shoelace.py\n",
      "\n",
      "> ta:\t1.944 s\n",
      "\n",
      "> No numpy :("
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\"\n",
      "\n",
      "python: 2.162128 s\n",
      "\n",
      "jython: 1.967000 s\n",
      "\n",
      "npypy : 0.213656 s\n",
      "\n",
      "numpy : 0.077828 s\n",
      "\n",
      "pypy  : 0.030495 s\n",
      "\n",
      "\"\"\";"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 141
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Pyston"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* New JIT compiler of Python 2.7 by Dropbox\n",
      "* No tracing\n",
      "* Conservative garbage collection\n",
      "* Built on top of LLVM\n",
      "* AST, LLVM IR, LLVM optimizer/JIT.\n",
      "  * AST to IR branching with type prediction + fall back.\n",
      "* Really early stage, lots of parts missing. OS X doesn't work yet.\n",
      "\n",
      "[https://github.com/dropbox/pyston](https://github.com/dropbox/pyston)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### Blaze"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "Cloud, big data infrastructure and analytics library\n",
      "\n",
      "* Computing large, distributed, heterogeneous datasets\n",
      "* Adapters and helpers to deal with Big Data and The Cloud.\n",
      "* LLVM"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "[https://github.com/ContinuumIO/blaze/](https://github.com/ContinuumIO/blaze/)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "### Pythran"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "source": [
      "* ~2 year old project\n",
      "* Subset of Python to modern C++ transpiler through comment annotations, including types\n",
      "* Multi-core, SIMD instructions\n",
      "* AST parsing, optimization\n",
      "\n",
      "[https://github.com/serge-sans-paille/pythran](https://github.com/serge-sans-paille/pythran)\n",
      "\n",
      "[http://www.youtube.com/watch?v=KKoVeiQOmik](http://www.youtube.com/watch?v=KKoVeiQOmik)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#pythran export dprod(int list, int list)\n",
      "def dprod(l0,l1):\n",
      "    return sum(x*y for x,y in zip(l0,l1))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "### And when all else fails..."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "C extensions, Cython, Ctypes, CFFI."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* [http://github.com/samyvilar/poly_area.git](http://github.com/samyvilar/poly_area.git)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "## Recap"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* TANSTAAFL"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Think first"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "* Use the best tool for the job, while using the second best tool for any job"
     ]
    },
    {
     "cell_type": "raw",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<div style=\"width: 100%; text-align: center\"><img src=\"files/saool3.png\"></div>"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}