local-rdd.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Benchmarking local computation in Spark*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An excellent feature of Spark is that it runs locally with minimal setup. This is incredibly useful for debugging, but can be surprisingly slow for *real* local computation, due to its enumlating certain aspects of the distributed codepath. Although local computation is not Spark's intended use case, real-world workflows often involve working with both large and medium sized data sets in the same notebook, and we want to maintain high performance without switching frameworks. This notebook serves to document these differences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notes*: I'm using RDDs, not Spark's DataFrames, it's possible that performance would be improved for DataFrames, this would be good to try. A related point is that some of this difference could be Python specific, so it would be worth trying the same thing in Scala. Finally, it's worth rerunning with different values of *n* and *k*. In my own testing, I've found that the difference may scale by their ratio, it's dramatic when *n/k=10* and less dramatic when *n/k=100*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Run using Spark 1.3.1 and the current `local-rdd` branch of Thunder.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import our packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import timeit\n",
    "from numpy import random, add, arange, fix, round, maximum, ceil, array, sum, percentile\n",
    "from pandas import DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setup plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style('darkgrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a class for storing an RDD and running some benchmarks (best of 3 loops each with 3 reps) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Benchmark(object):\n",
    "    \n",
    "    def __init__(self, rdd):\n",
    "        self.rdd = rdd\n",
    "        \n",
    "    def run(self, name):\n",
    "        t = timeit.Timer(lambda: funcs[name](self.rdd))\n",
    "        r = min([t.timeit(3)/3.0 * 1000 for _ in range(3)])\n",
    "        return r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a dictionary of RDD operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "funcs = {}\n",
    "funcs['sum'] = lambda rdd: rdd.values().reduce(add)\n",
    "funcs['max'] = lambda rdd: rdd.values().reduce(maximum)\n",
    "funcs['filter'] = lambda rdd: rdd.filter(lambda (k, v): k > 50).count()\n",
    "funcs['map'] = lambda rdd: rdd.mapValues(lambda x: x.sum()).count()\n",
    "funcs['collect'] = lambda rdd: rdd.values().collect()\n",
    "funcs['reduceByKey'] = lambda rdd: rdd.reduceByKey(add).count()\n",
    "funcs['groupByKey'] = lambda rdd: rdd.groupByKey().count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Distributed\" mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we compute times for an RDD defined through `sc.parallelize`. It's a collection of records, each a one-dimensional numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = 10000\n",
    "k = 1000\n",
    "vals = random.rand(n,k)\n",
    "keys = ceil(random.rand(n) * 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We force a cache, and use only 1 slice. For most operation, parallelizing in local mode does not seem to improve times, and may even make things worse, but it's worth experimenting with in different environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "rdd = sc.parallelize(zip(keys, vals), numSlices=1)\n",
    "rdd.cache()\n",
    "rdd.count()\n",
    "t = Benchmark(rdd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run a simple benchmark using the timit magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loops, best of 3: 444 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit rdd.values().reduce(add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use our `Benchmark` class to do the same thing (confirm a similar answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "346.8603293100993"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.run('sum')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now collect times for all functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "distributed = [t.run(k) for k in funcs.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"max-height:1000px;max-width:1500px;overflow:auto;\">\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>map</th>\n",
       "      <td>  361.647367</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>reduceByKey</th>\n",
       "      <td>  393.696626</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>  337.116003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sum</th>\n",
       "      <td>  368.278344</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>groupByKey</th>\n",
       "      <td> 1381.878694</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>filter</th>\n",
       "      <td>  328.457991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>collect</th>\n",
       "      <td> 1917.637348</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    time\n",
       "map           361.647367\n",
       "reduceByKey   393.696626\n",
       "max           337.116003\n",
       "sum           368.278344\n",
       "groupByKey   1381.878694\n",
       "filter        328.457991\n",
       "collect      1917.637348"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DataFrame(distributed, index=funcs.keys(), columns=[\"time\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Local\" mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll try a simple trick. In Thunder we've prototyped a `LocalRDD` (view on [GitHub](https://github.com/thunder-project/thunder/blob/local-rdd/python/thunder/rdds/local.py)) which is a rather dumb object that  replicates much of the RDD API but implemented through operations on locally stored lists, mainly using for comprehensions and Python's built-in functional methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from thunder.rdds.local import LocalRDD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We initialize a local RDD just by passing it values and keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rdd = LocalRDD(vals, keys)\n",
    "t = Benchmark(rdd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rerun the same benchmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "local = [t.run(k) for k in funcs.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"max-height:1000px;max-width:1500px;overflow:auto;\">\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>map</th>\n",
       "      <td>  33.987284</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>reduceByKey</th>\n",
       "      <td> 106.415669</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>  22.393306</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sum</th>\n",
       "      <td>  16.190052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>groupByKey</th>\n",
       "      <td>  87.693691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>filter</th>\n",
       "      <td>   3.379663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>collect</th>\n",
       "      <td>   1.320998</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   time\n",
       "map           33.987284\n",
       "reduceByKey  106.415669\n",
       "max           22.393306\n",
       "sum           16.190052\n",
       "groupByKey    87.693691\n",
       "filter         3.379663\n",
       "collect        1.320998"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DataFrame(local, index=funcs.keys(), columns=[\"time\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = len(funcs.keys())\n",
    "col1 = local + distributed\n",
    "col2 = funcs.keys() + funcs.keys()\n",
    "col3 = ['local' for _ in range(n)] + ['distributed' for _ in range(n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df = DataFrame({\"time\": col1, \"function\": col2, \"location\": col3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAFhCAYAAAD3Otx5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109f40390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.factorplot(\"function\", \"time\", \"location\", df, aspect=2.0);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}