02-cython-comparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How does Cython speed up Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reason 1: Interpreted -> Compiled\n",
    "\n",
    "## Cython version of trivial function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%cython -n cyfoo\n",
    "\n",
    "def cyfoo(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Profiling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfoo(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.modules['cyfoo']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Cython integer addition speedup: {:0.1f}%\".format((112. - 79.) / 112. * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfoo('a', 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Cython string addition speedup: {:0.1f}%\".format((159. - 133.) / 159. * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For simple addition, Cython version gives consistent speedup\n",
    "\n",
    "* With all the caveats for microbenchmarks..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We see the same `PyNumber_Add()` entry point as for interpreted Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat /home/jovyan/.cache/ipython/cython/cyfoo.c | nl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "```c\n",
    "static PyObject \n",
    "*__pyx_pf_5cyfoo_cyfoo(CYTHON_UNUSED PyObject *__pyx_self,\n",
    "                       PyObject *__pyx_v_a,\n",
    "                       PyObject *__pyx_v_b) {\n",
    "[...]\n",
    "  /* \"cyfoo.pyx\":3\n",
    " * \n",
    " * def cyfoo(a, b):\n",
    " *     return a + b             # <<<<<<<<<<<<<<\n",
    " */\n",
    "  __pyx_t_1 = PyNumber_Add(__pyx_v_a, __pyx_v_b);\n",
    " [...]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We conclude: converting from interpreted to compiled code gives some speedup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reason 2: Dynamic -> Static Typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def pyfac(n):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    return n * pyfac(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit pyfac(20.0)\n",
    "pyfac(20.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "def cyfac(n):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    return n * cyfac(n - 1)\n",
    "\n",
    "def cyfac_double(double n):\n",
    "    if n <= 1:\n",
    "        return 1.0\n",
    "    return n * cyfac_double(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfac(20.0)\n",
    "cyfac(20.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfac_double(20.0)\n",
    "cyfac_double(20.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimal Cython solution: up to 40x speedup\n",
    "\n",
    "* Optimal for *this* recursive implementation..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "cpdef double cyfac_double_fast(double n):\n",
    "    if n <= 1:\n",
    "        return 1.0\n",
    "    return n * cyfac_double_fast(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfac_double_fast(20.0)\n",
    "cyfac_double_fast(20.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For the record: what about a loop-based version?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def pyfac_loop(n):\n",
    "    r = 1.0\n",
    "    for i in range(1, n+1):\n",
    "        r *= i\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit pyfac_loop(20)\n",
    "pyfac_loop(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "cpdef double cyfac_loop(int n):\n",
    "    cdef double r = 1.0\n",
    "    cdef int i\n",
    "    for i in range(1, n+1):\n",
    "        r *= <double>i\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cyfac_loop(20)\n",
    "cyfac_loop(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Cython speedup factor--loop-based version: {:0.1f}\".format((1.81 / 0.062)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercises / questions\n",
    "\n",
    "* Why are we using `double` here instead of `long`?\n",
    "* Why are the `pyfac_loop()` and `cyfac_loop()` versions *better* from a robustness pov?\n",
    "* Write a trivial no-op function in Python and measure its performance w/ `timeit`.  Now, make a Cython no-op `def` function, and measure *it*.  How do they compare?  Conjecture why.  What does this imply for function call overhead between pure Python and Cython code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pynoop(): pass\n",
    "%timeit pynoop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "def cynoop(): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit cynoop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}