notes/Memory-and-Matrices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiments with Memory Access and Matrices\n",
    "\n",
    "In many problems, especially problems accessing lots of data and doing relatively simple computations on each datum, the performance bottleneck is memory rather than computational speed.  Because memory is arranged into a **memory hierarchy** of larger/slower and smaller/faster memories, it turns out that *changing the order* of memory access can have a huge impact on performance.\n",
    "\n",
    "In this notebook, we'll explore these performance issues with a few typical matrix algorithms, implemented in Julia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Julia Version 1.3.1\n",
      "Commit 2d5741174c (2019-12-30 21:36 UTC)\n",
      "Platform Info:\n",
      "  OS: macOS (x86_64-apple-darwin18.6.0)\n",
      "  CPU: Intel(R) Core(TM) i5-8500B CPU @ 3.00GHz\n",
      "  WORD_SIZE: 64\n",
      "  LIBM: libopenlibm\n",
      "  LLVM: libLLVM-6.0.1 (ORCJIT, skylake)\n"
     ]
    }
   ],
   "source": [
    "using BenchmarkTools # a useful package of benchmarking utilities\n",
    "versioninfo() # a useful function to print out information about the machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmarking Matrix Multiplication\n",
    "\n",
    "One of the most basic building blocks of numerical linear algebra is the computation of matrix multiplication: given an $m \\times n$ matrix $A$ and an $n \\times p$ matrix $B$, compute the $m \\times p$ matrix $C = AB$.   The entries of $C$ are given by the exact formula:\n",
    "$$\n",
    "C_{ik} = \\sum_{j=1}^n A_{ij} B_{jk}\n",
    "$$\n",
    "but there are many ways to implement this computation.   $\\approx 2mnp$ flops (floating-point additions and multiplications) are required, but they can re-ordered arbitrarily, leading to $\\sim (mnp)!$ possible orderings.\n",
    "\n",
    "It turns out that the ordering of the operations in the matrix multiplication has a *huge* impact on performance, along with low-level details of the inner loops.  Basically, three factors make the implementation of efficient matrix multiplication highly nontrivial:\n",
    "\n",
    "* [Caches](https://en.wikipedia.org/wiki/CPU_cache): the matrix accesses must be reordered to obtain [temporal locality](https://en.wikipedia.org/wiki/Locality_of_reference) and hence efficient memory (cache) usage.\n",
    "* [Registers](https://en.wikipedia.org/wiki/Processor_register): at the lowest level, the CPU registers form a kind of ideal cache.  The innermost loops of the matrix multiplication need to be unrolled in order to load many values into registers and perform as much work with them as possible (essentially a small submatrix multiplication).  It turns out that a [lot of tricks](http://cscads.rice.edu/workshops/july2007/autotune-slides-07/Frigo.pdf) are required to do this well.\n",
    "* [SIMD instructions](https://en.wikipedia.org/wiki/SIMD): modern CPUs include special instructions that can perform several arithmetic operations at once (e.g. 2, 4, or even 8 `Float64` operations), and to get the full benefit of these operations typically requires hand coding. \n",
    "\n",
    "As a consequence, there is a huge performance gap between the most obvious three-loop matrix-multiplication code and highly optimized code.  This gap has become the central factor in the design of dense linear-algebra libraries for several decades, especially the industry-standard free/open-source the [LAPACK](https://en.wikipedia.org/wiki/LAPACK) library: nearly all dense linear algebra is now organized around highly optimized [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) libraries.\n",
    "\n",
    "Because Julia benefits from fast compilers, we can illustrate this performance gap fairly with simple Julia code.  (In contrast, similar implementation in Matlab or Python would be orders of magnitude slower, and would demonstrate mostly language rather than the algorithmic effects.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naive algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is the simplest, most obvious, matrix-multiplication algorithm: just three nested loops, implementing a dot product for each output $C_{ik}$.\n",
    "\n",
    "The only concessions we have made to performance concerns here are (1) we implement an in-place `matmul!` variant that operates on a pre-existing `C` array, to avoid benchmarking the memory allocation/deallocation and (2) we use the `@inbounds` macro to turn off array bounds-checking in Julia for the inner loop.   Together, these make less than a factor of two difference in speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matmul (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compute C = A * B, using naive matrix-multiplication algorithm,\n",
    "# with a pre-allocated output array C.  (\"!\" is a Julia convention\n",
    "# for functions that modify their arguments.)\n",
    "function matmul!(C, A, B)\n",
    "    m,n = size(A)\n",
    "    n,p = size(B)\n",
    "    size(C) == (m,p) || error(\"incorrect dimensions \", size(C), \" ≠ $m × $p\")\n",
    "    for i = 1:m\n",
    "        for k = 1:p\n",
    "            c = zero(eltype(C))\n",
    "            for j = 1:n\n",
    "                @inbounds c += A[i,j] * B[j,k]\n",
    "            end\n",
    "            @inbounds C[i,k] = c\n",
    "        end\n",
    "    end\n",
    "    return C\n",
    "end\n",
    "\n",
    "# a wrapper that allocates C of an appropriate type\n",
    "matmul(A, B) = matmul!(Array{promote_type(eltype(A), eltype(B))}(undef,\n",
    "                             size(A,1), size(B,2)),\n",
    "                       A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.1957467920563633e-15"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# correctness check:\n",
    "A = rand(5,6)\n",
    "B = rand(6,7)\n",
    "using LinearAlgebra\n",
    "norm(matmul(A,B) - A * B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Benchmarking naive `matmul`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we will benchmark our naive `matmul` implementation against the highly optimized [OpenBLAS library](http://www.openblas.net/) that Julia uses for its built-in matrix multiplication.   Like `matmul!`, we will call OpenBLAS with pre-allocated output via `mul!(C, A, B)` instead of the simpler `A * B`.  By default, OpenBLAS uses multiple CPU cores, which gives it an \"unfair\" parallel speedup, but we can disable this for benchmarking purposes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for benchmarking, use only single-threaded BLAS:\n",
    "BLAS.set_num_threads(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will benchmark $n \\times n$ matrix multiplications for various $n$ from 10 to 1000.  Julia's `@elapsed ...code...` macro is useful for benchmarking: it times the code and returns the time in seconds.   As we go, we will print the ratio of the naive time to the optimized time, to see the slowdown of our naive code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: slowdown of 1.6603248761057487\n",
      "finished n = 11: slowdown of 2.0185509202329146\n",
      "finished n = 12: slowdown of 2.7422470482269286\n",
      "finished n = 13: slowdown of 2.8553713779577374\n",
      "finished n = 15: slowdown of 3.2077467819554757\n",
      "finished n = 16: slowdown of 4.877335706114147\n",
      "finished n = 18: slowdown of 5.053280894563905\n",
      "finished n = 20: slowdown of 5.889070740913707\n",
      "finished n = 22: slowdown of 5.695035460992908\n",
      "finished n = 24: slowdown of 7.439816680096696\n",
      "finished n = 26: slowdown of 6.741635817559545\n",
      "finished n = 29: slowdown of 7.232224132699505\n",
      "finished n = 32: slowdown of 9.059210526315791\n",
      "finished n = 35: slowdown of 8.385440221752134\n",
      "finished n = 39: slowdown of 8.099125918419052\n",
      "finished n = 43: slowdown of 8.763080749755707\n",
      "finished n = 47: slowdown of 8.908666712413368\n",
      "finished n = 52: slowdown of 11.48585454075701\n",
      "finished n = 57: slowdown of 11.546802868087616\n",
      "finished n = 63: slowdown of 10.673677884615383\n",
      "finished n = 69: slowdown of 12.013292433537833\n",
      "finished n = 76: slowdown of 14.445438621407943\n",
      "finished n = 84: slowdown of 15.24437102739972\n",
      "finished n = 92: slowdown of 15.900979636135151\n",
      "finished n = 102: slowdown of 16.208724912392483\n",
      "finished n = 112: slowdown of 18.95872259457977\n",
      "finished n = 123: slowdown of 17.817670338053688\n",
      "finished n = 136: slowdown of 20.56045717471601\n",
      "finished n = 150: slowdown of 19.99051057099696\n",
      "finished n = 165: slowdown of 20.60679367108492\n",
      "finished n = 182: slowdown of 21.671416544927823\n",
      "finished n = 200: slowdown of 23.762203116205548\n",
      "finished n = 221: slowdown of 23.16466442183521\n",
      "finished n = 243: slowdown of 23.424120074528012\n",
      "finished n = 268: slowdown of 24.709796940068546\n",
      "finished n = 295: slowdown of 23.85455892106333\n",
      "finished n = 325: slowdown of 25.07804386042119\n",
      "finished n = 358: slowdown of 25.646376965332514\n",
      "finished n = 394: slowdown of 26.57290960407436\n",
      "finished n = 434: slowdown of 27.615483383918423\n",
      "finished n = 478: slowdown of 27.138588466052575\n",
      "finished n = 526: slowdown of 26.582361096005933\n",
      "finished n = 580: slowdown of 27.508482101408557\n",
      "finished n = 639: slowdown of 26.933233028669466\n",
      "finished n = 704: slowdown of 31.99107458933126\n",
      "finished n = 775: slowdown of 27.297947520081085\n",
      "finished n = 854: slowdown of 28.129332761032053\n",
      "finished n = 940: slowdown of 29.297855715787218\n",
      "finished n = 1036: slowdown of 29.489638335541887\n",
      "finished n = 1141: slowdown of 31.795954626321784\n",
      "finished n = 1257: slowdown of 30.34074257482406\n",
      "finished n = 1384: slowdown of 47.875180434912096\n",
      "finished n = 1525: slowdown of 49.65823274290976\n",
      "finished n = 1680: slowdown of 89.3067114495764\n",
      "finished n = 1850: slowdown of 103.73099250765196\n",
      "finished n = 2038: slowdown of 116.75087328719093\n",
      "finished n = 2245: slowdown of 115.15792563584536\n",
      "finished n = 2473: slowdown of 125.87703143851445\n",
      "finished n = 2724: slowdown of 131.46774058263676\n",
      "finished n = 3000: slowdown of 140.89276775598034\n"
     ]
    }
   ],
   "source": [
    "N = round.(Int, 10 .^ range(1, log10(3000), length=60))  # 60 sizes from 10 to 3000\n",
    "# alternatively, use N = 10:1000 to see some interesting patterns due to cache associativity etc.\n",
    "t = Float64[]\n",
    "t0 = Float64[]\n",
    "for n in N\n",
    "    A = zeros(n,n)\n",
    "    B = zeros(n,n)\n",
    "    # preallocate output C so that allocation is not included in timing\n",
    "    C = zeros(n,n)\n",
    "    push!(t, @belapsed matmul!($C,$A,$B))\n",
    "    push!(t0, @belapsed mul!($C,$A,$B))\n",
    "    println(\"finished n = $n: slowdown of \", t[end]/t0[end])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot # a plotting library based on Python's Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will plot the results.  Since the number of flops is $2n^3$, we will plot $2n^3 / t$ for time $t$ in microseconds in order to plot the **gigaflops rate** (billions of flops per second).  If you naively think of a CPU as a box that performs floating-point instructions at a fixed rate, with all other instructions being negligible (a picture that *may* have been true circa 1985), this would be a flat horizontal line independent of $n$, but we will see that reality is quite different.\n",
    "\n",
    "The OpenBLAS library gets an \"unfair\" factor of 8 speedup on typical modern Intel processors thanks to hand-coded support for [AVX-512](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions) SIMD instructions, which perform 8 double-precision floating-point operations simultaneously, so we will divide the BLAS performance by 8 for comparison purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.legend.Legend object at 0x1af8fd898>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(N, 2N.^3 ./ t * 1e-9, \"rs-\")\n",
    "plot(N, 2N.^3 ./ t0 * 1e-9 / 8, \"b.-\")\n",
    "ylabel(L\"gigaflops $2n^3/t$\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "legend([\"naive matmul\", \"BLAS matmul / 8\"], loc=\"center right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Naive matmul in C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may be suspicious that the problem is simply that Julia is slow.   We can check this hypothesis by implementing the same algorithm in C, compiling it, and then calling it by Julia's built-in `ccall` instruction that makes it [easy to call C from Julia](http://docs.julialang.org/en/latest/manual/calling-c-and-fortran-code/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cmatmul (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# C implementation:\n",
    "Cmatmul = \"\"\"\n",
    "void Cmatmul(int m, int n, int p, double *C, double *A, double *B)\n",
    "{\n",
    "    int i, j, k;\n",
    "    for (i = 0; i < m; ++i)\n",
    "        for (j = 0; j < p; ++j) {\n",
    "            double c = 0.0;\n",
    "            for (k = 0; k < n; ++k)\n",
    "                c += A[i + m*k] * B[k + n*j];\n",
    "            C[i + m*j] = c;\n",
    "    }\n",
    "}\n",
    "\"\"\"\n",
    "# compile to a shared library by piping Cmatmul to gcc:\n",
    "# (only works if you have gcc installed)\n",
    "const Clib = tempname()\n",
    "import Libdl\n",
    "open(`gcc -fPIC -O3 -xc -shared -o $(Clib * \".\" * Libdl.dlext) -`, \"w\") do f\n",
    "    print(f, Cmatmul)\n",
    "end\n",
    "\n",
    "# define a Julia cmatmul! function that simply calls the C code in the shared library we compiled\n",
    "function cmatmul!(C, A, B)\n",
    "    m,n = size(A)\n",
    "    n,p = size(B)\n",
    "    size(C) == (m,p) || error(\"incorrect dimensions \", size(C), \" ≠ $m × $p\")\n",
    "    ccall((\"Cmatmul\", Clib), Cvoid, (Cint, Cint, Cint, Ptr{Float64}, Ptr{Float64}, Ptr{Float64}),\n",
    "          m, n, p, C, A, B)\n",
    "    return C\n",
    "end\n",
    "cmatmul(A, B) = cmatmul!(Array{promote_type(eltype(A), eltype(B))}(undef,\n",
    "                               size(A,1), size(B,2)),\n",
    "                         A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.996003610813204e-16"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# correctness check:\n",
    "A = rand(5,6)\n",
    "B = rand(6,7)\n",
    "norm(cmatmul(A,B) - A * B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's benchmark it and print out the \"speedup\" compared to pure Julia.  We see that it is **about the same speed**.  Julia's main claim to fame is that it is a dynamic language (like Python or Matlab) that stays within a factor of 2 (usually better) of C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: speedup of 0.9921205232541567\n",
      "finished n = 11: speedup of 0.9290750345812165\n",
      "finished n = 12: speedup of 0.89956365963089\n",
      "finished n = 13: speedup of 0.987857839227156\n",
      "finished n = 15: speedup of 1.0312428342123365\n",
      "finished n = 16: speedup of 0.9849361480323171\n",
      "finished n = 18: speedup of 0.9526663830774585\n",
      "finished n = 20: speedup of 0.9880663361258334\n",
      "finished n = 22: speedup of 0.912770293218612\n",
      "finished n = 24: speedup of 0.9567101032323575\n",
      "finished n = 26: speedup of 0.9436731592761431\n",
      "finished n = 29: speedup of 0.995874414376617\n",
      "finished n = 32: speedup of 0.9438196847366397\n",
      "finished n = 35: speedup of 0.9073384599324958\n",
      "finished n = 39: speedup of 0.9919800733563257\n",
      "finished n = 43: speedup of 1.012489102447134\n",
      "finished n = 47: speedup of 0.9836550459846256\n",
      "finished n = 52: speedup of 0.9690930358106892\n",
      "finished n = 57: speedup of 0.9705592133244867\n",
      "finished n = 63: speedup of 0.9675881613272527\n",
      "finished n = 69: speedup of 1.0207393537038614\n",
      "finished n = 76: speedup of 0.9764887867833816\n",
      "finished n = 84: speedup of 0.9738545617299945\n",
      "finished n = 92: speedup of 0.9612476896797613\n",
      "finished n = 102: speedup of 0.9339526107801938\n",
      "finished n = 112: speedup of 0.9432655663000284\n",
      "finished n = 123: speedup of 0.9595299579865664\n",
      "finished n = 136: speedup of 0.9540896223719877\n",
      "finished n = 150: speedup of 0.9673630067245149\n",
      "finished n = 165: speedup of 0.9805934470683298\n",
      "finished n = 182: speedup of 0.97692280300663\n",
      "finished n = 200: speedup of 1.0077681985109523\n",
      "finished n = 221: speedup of 1.0115095980701014\n",
      "finished n = 243: speedup of 1.0068100032399365\n",
      "finished n = 268: speedup of 1.0085825028638362\n",
      "finished n = 295: speedup of 1.0034280664457311\n",
      "finished n = 325: speedup of 1.0063724969882393\n",
      "finished n = 358: speedup of 1.0054269515554781\n",
      "finished n = 394: speedup of 1.004166839951953\n",
      "finished n = 434: speedup of 0.9593919204281547\n",
      "finished n = 478: speedup of 1.0049153221462235\n",
      "finished n = 526: speedup of 1.006333771932871\n",
      "finished n = 580: speedup of 1.0024619288008463\n",
      "finished n = 639: speedup of 1.0019028046520642\n",
      "finished n = 704: speedup of 1.0224390857025696\n",
      "finished n = 775: speedup of 1.0062020187828786\n",
      "finished n = 854: speedup of 1.0003650039132648\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 940: speedup of 1.0003202651121077\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1-element Array{PyCall.PyObject,1}:\n",
       " PyObject <matplotlib.lines.Line2D object at 0x1afb5ea20>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tc = Float64[]\n",
    "for n in N[N .<= 1000]\n",
    "    A = zeros(n,n)\n",
    "    B = zeros(n,n)\n",
    "    # preallocate output C so that allocation is not included in timing\n",
    "    C = zeros(n,n)\n",
    "    push!(tc, @belapsed cmatmul!($C,$A,$B))\n",
    "    println(\"finished n = $n: speedup of \", tc[end]/t[length(tc)])\n",
    "end\n",
    "\n",
    "title(\"C vs. Julia\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "ylabel(\"C time / Julia time\")\n",
    "plot(N[N .<= 1000], tc ./ t[N .<= 1000], \"k*-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cache-oblivious matrix-multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a first step in the right direction, we'll implement a [cache-oblivious algorithm](https://en.wikipedia.org/wiki/Cache-oblivious_algorithm) for matrix multiplication: divide the matrices into four submatrices which are multiplied *recursively* until a sufficiently large base case is reached (large enough to amortize the recursion overhead).   This strategy erases the steep performance drop-off that occurs for large $n$ where the matrix goes out-of-cache, at the cost of ~25 lines of code rather than ~10 for the naive loops.\n",
    "\n",
    "(It still doesn't match the OpenBLAS performance because it fails to address the other two problems: unrolling and optimizing the base cases to optimize register utilization, and coding for SIMD instructions.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matmul_rec (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function add_matmul_rec!(m,n,p, i0,j0,k0, C,A,B)\n",
    "    if m+n+p <= 64   # base case: naive matmult for sufficiently large matrices\n",
    "        for i = 1:m\n",
    "            for k = 1:p\n",
    "                c = zero(eltype(C))\n",
    "                for j = 1:n\n",
    "                    @inbounds c += A[i0+i,j0+j] * B[j0+j,k0+k]\n",
    "                end\n",
    "                @inbounds C[i0+i,k0+k] += c\n",
    "            end\n",
    "        end\n",
    "    else\n",
    "        m2 = m ÷ 2; n2 = n ÷ 2; p2 = p ÷ 2\n",
    "        add_matmul_rec!(m2, n2, p2, i0, j0, k0, C, A, B)\n",
    "        \n",
    "        add_matmul_rec!(m-m2, n2, p2, i0+m2, j0, k0, C, A, B)\n",
    "        add_matmul_rec!(m2, n-n2, p2, i0, j0+n2, k0, C, A, B)\n",
    "        add_matmul_rec!(m2, n2, p-p2, i0, j0, k0+p2, C, A, B)\n",
    "        \n",
    "        add_matmul_rec!(m-m2, n-n2, p2, i0+m2, j0+n2, k0, C, A, B)\n",
    "        add_matmul_rec!(m2, n-n2, p-p2, i0, j0+n2, k0+p2, C, A, B)\n",
    "        add_matmul_rec!(m-m2, n2, p-p2, i0+m2, j0, k0+p2, C, A, B)\n",
    "        \n",
    "        add_matmul_rec!(m-m2, n-n2, p-p2, i0+m2, j0+n2, k0+p2, C, A, B)\n",
    "    end\n",
    "    return C\n",
    "end\n",
    "\n",
    "function matmul_rec!(C, A, B)\n",
    "    m,n = size(A)\n",
    "    n,p = size(B)\n",
    "    size(C) == (m,p) || error(\"incorrect dimensions \", size(C), \" ≠ $m × $p\")\n",
    "    fill!(C, 0)\n",
    "    return add_matmul_rec!(m,n,p, 0,0,0, C,A,B)\n",
    "end\n",
    "\n",
    "\n",
    "matmul_rec(A, B) = matmul_rec!(Array{promote_type(eltype(A), eltype(B))}(undef,\n",
    "                                     size(A,1), size(B,2)),\n",
    "                               A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0695128959796112e-13"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# correctness check:\n",
    "A = rand(50,60)\n",
    "B = rand(60,70)\n",
    "norm(matmul_rec(A,B) - A * B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: slowdown of 1.7630598933611796\n",
      "finished n = 11: slowdown of 2.1362724534796174\n",
      "finished n = 12: slowdown of 2.9082073664040875\n",
      "finished n = 13: slowdown of 2.9376186258382893\n",
      "finished n = 15: slowdown of 3.4690519973394887\n",
      "finished n = 16: slowdown of 5.407906444642176\n",
      "finished n = 18: slowdown of 5.055625895172388\n",
      "finished n = 20: slowdown of 6.136554684855677\n",
      "finished n = 22: slowdown of 5.736137975499678\n",
      "finished n = 24: slowdown of 7.497481869460112\n",
      "finished n = 26: slowdown of 6.469930851435356\n",
      "finished n = 29: slowdown of 6.493375139071508\n",
      "finished n = 32: slowdown of 7.858020510835914\n",
      "finished n = 35: slowdown of 6.780655044131592\n",
      "finished n = 39: slowdown of 7.1341208512794525\n",
      "finished n = 43: slowdown of 7.70525006662521\n",
      "finished n = 47: slowdown of 7.7341659232827835\n",
      "finished n = 52: slowdown of 9.526159410928821\n",
      "finished n = 57: slowdown of 9.56595619290836\n",
      "finished n = 63: slowdown of 8.978966346153845\n",
      "finished n = 69: slowdown of 10.083333333333334\n",
      "finished n = 76: slowdown of 11.31264498414051\n",
      "finished n = 84: slowdown of 11.628613495170036\n",
      "finished n = 92: slowdown of 11.954959586439323\n",
      "finished n = 102: slowdown of 11.179913985345653\n",
      "finished n = 112: slowdown of 12.68373416528104\n",
      "finished n = 123: slowdown of 11.944857674152482\n",
      "finished n = 136: slowdown of 13.526846071901476\n",
      "finished n = 150: slowdown of 13.074894148185448\n",
      "finished n = 165: slowdown of 13.312356117933192\n",
      "finished n = 182: slowdown of 13.495712316669556\n",
      "finished n = 200: slowdown of 14.365350328775527\n",
      "finished n = 221: slowdown of 13.69896327407461\n",
      "finished n = 243: slowdown of 14.01656319597083\n",
      "finished n = 268: slowdown of 14.820131933675974\n",
      "finished n = 295: slowdown of 14.329727504918198\n",
      "finished n = 325: slowdown of 14.942019780563093\n",
      "finished n = 358: slowdown of 15.121226495268013\n",
      "finished n = 394: slowdown of 15.279951342893478\n",
      "finished n = 434: slowdown of 14.874662019842313\n",
      "finished n = 478: slowdown of 15.607693842309843\n",
      "finished n = 526: slowdown of 15.682785746410483\n",
      "finished n = 580: slowdown of 16.371801015191497\n",
      "finished n = 639: slowdown of 16.07967854878843\n",
      "finished n = 704: slowdown of 16.838525366644287\n",
      "finished n = 775: slowdown of 15.350534721800004\n",
      "finished n = 854: slowdown of 15.338087432635747\n",
      "finished n = 940: slowdown of 16.260012114946058\n",
      "finished n = 1036: slowdown of 16.382497684558587\n",
      "finished n = 1141: slowdown of 16.35038063457649\n",
      "finished n = 1257: slowdown of 16.452139331012226\n",
      "finished n = 1384: slowdown of 17.157642318897928\n",
      "finished n = 1525: slowdown of 16.041399354442163\n",
      "finished n = 1680: slowdown of 16.699855545258412\n",
      "finished n = 1850: slowdown of 16.088873942739987\n",
      "finished n = 2038: slowdown of 17.154819273495608\n",
      "finished n = 2245: slowdown of 16.425747626536367\n",
      "finished n = 2473: slowdown of 16.713279025346427\n",
      "finished n = 2724: slowdown of 18.13471434004001\n",
      "finished n = 3000: slowdown of 16.394833240450538\n"
     ]
    }
   ],
   "source": [
    "tco = Float64[]\n",
    "for n in N\n",
    "    A = zeros(n,n)\n",
    "    B = zeros(n,n)\n",
    "    # preallocate output C so that allocation is not included in timing\n",
    "    C = zeros(n,n)\n",
    "    push!(tco, @belapsed matmul_rec!($C,$A,$B))\n",
    "    println(\"finished n = $n: slowdown of \", tco[end]/t0[length(tco)])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.legend.Legend object at 0x1aff72cf8>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(N, 2N.^3 ./ t * 1e-9, \"rs-\")\n",
    "plot(N, 2N.^3 ./ tco * 1e-9, \"ko-\")\n",
    "plot(N, 2N.^3 ./ t0 * 1e-9 / 8, \"b.-\")\n",
    "ylabel(L\"gigaflops $2n^3/t$\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "legend([\"naive matmul\", \"cache-oblivious\", \"BLAS matmul / 8\"], loc=\"upper left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix addition\n",
    "\n",
    "Matrix addition is an interesting case because it has no data re-use, so there is no possible temporal locality, but depending on *what order* you use for the loops and *how matrices are stored* in memory, you may or may not get **spatial locality** that takes advantage of **cache lines**.\n",
    "\n",
    "Here let's implement matrix addition in two different ways.  As above, we'll use a pre-allocated output array so that our benchmark does not include the time for memory allocation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function matadd1!(C, A, B)\n",
    "    size(C) == size(A) == size(B) || throw(DimensionMismatchmatch())\n",
    "    m,n = size(A)\n",
    "    for i = 1:m\n",
    "        @simd for j = 1:n\n",
    "            @inbounds C[i,j] = A[i,j] + B[i,j]\n",
    "        end\n",
    "    end\n",
    "    return C\n",
    "end\n",
    "matadd1(A, B) = matadd1!(similar(A, promote_type(eltype(A), eltype(B))), A, B)\n",
    "\n",
    "function matadd2!(C, A, B)\n",
    "    size(C) == size(A) == size(B) || throw(DimensionMismatch())\n",
    "    m,n = size(A)\n",
    "    for j = 1:n\n",
    "        @simd for i = 1:m\n",
    "            @inbounds C[i,j] = A[i,j] + B[i,j]\n",
    "        end\n",
    "    end\n",
    "    return C\n",
    "end\n",
    "matadd2(A, B) = matadd2!(similar(A, promote_type(eltype(A), eltype(B))), A, B)\n",
    "\n",
    "A = rand(5,6)\n",
    "B = rand(5,6)\n",
    "A + B ≈ matadd1(A,B) ≈ matadd2(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: ratio t1/t2 of 1.2705540970628382\n",
      "finished n = 11: ratio t1/t2 of 1.2316157570486317\n",
      "finished n = 12: ratio t1/t2 of 1.2424465753625902\n",
      "finished n = 13: ratio t1/t2 of 1.2450082559368891\n",
      "finished n = 15: ratio t1/t2 of 1.1803471539714419\n",
      "finished n = 16: ratio t1/t2 of 1.9507481879513617\n",
      "finished n = 18: ratio t1/t2 of 1.8624197808351186\n",
      "finished n = 20: ratio t1/t2 of 1.750152141202608\n",
      "finished n = 22: ratio t1/t2 of 1.7200359561920178\n",
      "finished n = 24: ratio t1/t2 of 1.6499167477537782\n",
      "finished n = 26: ratio t1/t2 of 1.6007208110087499\n",
      "finished n = 29: ratio t1/t2 of 1.5211709253225827\n",
      "finished n = 32: ratio t1/t2 of 2.9862414080130497\n",
      "finished n = 35: ratio t1/t2 of 2.5410900249191677\n",
      "finished n = 39: ratio t1/t2 of 2.5183077113811057\n",
      "finished n = 43: ratio t1/t2 of 2.241819625060024\n",
      "finished n = 47: ratio t1/t2 of 2.268923938145866\n",
      "finished n = 52: ratio t1/t2 of 3.595132196295553\n",
      "finished n = 57: ratio t1/t2 of 3.028465146369077\n",
      "finished n = 63: ratio t1/t2 of 2.528690896752689\n",
      "finished n = 69: ratio t1/t2 of 3.036986245292287\n",
      "finished n = 76: ratio t1/t2 of 3.3292873601053325\n",
      "finished n = 84: ratio t1/t2 of 3.9217796046666265\n",
      "finished n = 92: ratio t1/t2 of 3.213932346723044\n",
      "finished n = 102: ratio t1/t2 of 5.0317040005725335\n",
      "finished n = 112: ratio t1/t2 of 5.985283075536867\n",
      "finished n = 123: ratio t1/t2 of 2.8940843297671486\n",
      "finished n = 136: ratio t1/t2 of 2.444454716341561\n",
      "finished n = 150: ratio t1/t2 of 3.1896902554827045\n",
      "finished n = 165: ratio t1/t2 of 3.5071934945788152\n",
      "finished n = 182: ratio t1/t2 of 3.5736330090573634\n",
      "finished n = 200: ratio t1/t2 of 4.126110994471271\n",
      "finished n = 221: ratio t1/t2 of 4.352765909601979\n",
      "finished n = 243: ratio t1/t2 of 0.8777746881322455\n",
      "finished n = 268: ratio t1/t2 of 4.377638761604973\n",
      "finished n = 295: ratio t1/t2 of 4.375291102350936\n",
      "finished n = 325: ratio t1/t2 of 4.320448022756712\n",
      "finished n = 358: ratio t1/t2 of 4.201110869091702\n",
      "finished n = 394: ratio t1/t2 of 4.690272249075917\n",
      "finished n = 434: ratio t1/t2 of 4.620232995114618\n",
      "finished n = 478: ratio t1/t2 of 4.93866657113173\n",
      "finished n = 526: ratio t1/t2 of 10.316716337036032\n",
      "finished n = 580: ratio t1/t2 of 18.253596723492503\n",
      "finished n = 639: ratio t1/t2 of 19.158030050691202\n",
      "finished n = 704: ratio t1/t2 of 17.88576687478879\n",
      "finished n = 775: ratio t1/t2 of 16.97274825265371\n",
      "finished n = 854: ratio t1/t2 of 16.20700167021604\n",
      "finished n = 940: ratio t1/t2 of 15.430325902372184\n",
      "finished n = 1036: ratio t1/t2 of 15.144798082113855\n",
      "finished n = 1141: ratio t1/t2 of 14.062616116967632\n",
      "finished n = 1257: ratio t1/t2 of 14.102169976085044\n",
      "finished n = 1384: ratio t1/t2 of 14.007334794706683\n",
      "finished n = 1525: ratio t1/t2 of 13.752899474405464\n",
      "finished n = 1680: ratio t1/t2 of 14.386781554887987\n",
      "finished n = 1850: ratio t1/t2 of 13.880508975547198\n",
      "finished n = 2038: ratio t1/t2 of 13.985519321908729\n",
      "finished n = 2245: ratio t1/t2 of 14.094679538791402\n",
      "finished n = 2473: ratio t1/t2 of 14.220649500728292\n",
      "finished n = 2724: ratio t1/t2 of 14.677971958163587\n",
      "finished n = 3000: ratio t1/t2 of 14.979503641290975\n"
     ]
    }
   ],
   "source": [
    "Na = round.(Int, 10 .^ range(1, log10(3000), length=60))  # 60 sizes from 10 to 3000\n",
    "# alternatively, use N = 10:1000 to see some interesting patterns due to cache associativity etc.\n",
    "t1 = Float64[]\n",
    "t2 = Float64[]\n",
    "for n in Na\n",
    "    A = zeros(n,n)\n",
    "    B = zeros(n,n)\n",
    "    # preallocate output C so that allocation is not included in timing\n",
    "    C = zeros(n,n)\n",
    "    matadd1!(C,A,B) # add once just to make sure we are in cache if A and B are small\n",
    "    push!(t1, @belapsed matadd1!($C,$A,$B))\n",
    "    push!(t2, @belapsed matadd2!($C,$A,$B))\n",
    "    println(\"finished n = $n: ratio t1/t2 of \", t1[end]/t2[end])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.legend.Legend object at 0x1af4dc160>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Na, Na.^2 ./ t1 * 1e-9, \"rs-\")\n",
    "plot(Na, Na.^2 ./ t2 * 1e-9, \"bo-\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "ylabel(L\"gigaflops $n^2/t$\")\n",
    "legend([\"by row\", \"by column\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject Text(0.5, 1, 'ratio of matrix-addition algorithms')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Na, t1 ./ t2, \"rs-\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "ylabel(\"by row time / by column time\")\n",
    "title(\"ratio of matrix-addition algorithms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that addition is almost ***20 times slower*** if we add by rows rather than by columns.\n",
    "\n",
    "The reason for this is that **Julia stores matrices with consecutive columns**, which is known as **column-major storage** format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other examples: vectorized vs. devectorized operations\n",
    "\n",
    "Another example of the importance of spatial locality can be seen in vectorized operations.  For more information on this subject, see the blog post:\n",
    "\n",
    "* [More Dots: Syntactic Loop Fusion in Julia](https://julialang.org/blog/2017/01/moredots)\n",
    "\n",
    "Consider the following function, which computes $f(x) = 2x^2 - 3x + 4$ *element-wise* for an array of $x$ values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_vec(x) = 2 * x.^2 - 3 * x .+ 4\n",
    "f_devec(X) = f_vec.(X)\n",
    "\n",
    "X = rand(10^6);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  4.356 ms (8 allocations: 30.52 MiB)\n"
     ]
    }
   ],
   "source": [
    "@btime f_vec($X);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  991.469 μs (2 allocations: 7.63 MiB)\n"
     ]
    }
   ],
   "source": [
    "@btime f_devec($X);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `f_devec` function is more than **4 times faster** than the vectorized version, and allocates about **1/4 the memory**.   That is because `f_vec` is effectively equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f_vec_really (generic function with 1 method)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f_vec_really(x)\n",
    "    tmp1 = x.^2\n",
    "    tmp2 = 2 * tmp1\n",
    "    tmp3 = 3 * x\n",
    "    tmp4 = tmp2 .- tmp3\n",
    "    tmp5 = tmp4 .+ 4\n",
    "    return tmp5\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is, each \"vectorized\" operation, like `x.^2`, while it is *individually fast*, does a *separate loop* over its data and *allocates a temporary array for the result*.  This is slow for three reasons:\n",
    "\n",
    "* It has poor temporal locality.\n",
    "* It is expensive to allocate all those temporary arrays.\n",
    "* The overhead of looping (incrementing/testing a counter, fetching elements `x[i]`, etcetera), is incurred multiple times rather than once.\n",
    "\n",
    "In Julia, there is a  syntax `2 .* x.^2 .- 3 .* x .+ 4`, or equivalently `@. 2x^2 - 3x + 4` in which the compiler is guaranteed to \"fuse\" the operations into a single loop, allocating no temporary arrays."
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.3.0",
   "language": "julia",
   "name": "julia-1.3"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.3.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}