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.5.3\n",
      "Commit 788b2c77c1 (2020-11-09 13:37 UTC)\n",
      "Platform Info:\n",
      "  OS: macOS (x86_64-apple-darwin18.7.0)\n",
      "  CPU: Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\n",
      "  WORD_SIZE: 64\n",
      "  LIBM: libopenlibm\n",
      "  LLVM: libLLVM-9.0.1 (ORCJIT, skylake)\n",
      "Environment:\n",
      "  JULIA_EDITOR = code\n",
      "  JULIA_CXX_RTTI = 1\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, 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",
    "    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": [
       "8.599750569898517e-16"
      ]
     },
     "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": [
    "### Naive algorithm + SIMD\n",
    "\n",
    "All modern CPUs have special [SIMD instrucions](https://en.wikipedia.org/wiki/SIMD) that perform multiple floating-point operations simultaneously.   This gives almost a factor of 8 speedup to matrix multiplication on typical modern Intel processors thanks to hand-coded support for [AVX-512](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions) SIMD instructions.\n",
    "\n",
    "Not only that, but there are also \"[fused-multiply add](https://en.wikipedia.org/wiki/FMA_instruction_set)\" that perform `x + αy` in a single instruction, which can give another factor of 2 in computing dot products and matrix multiplications.\n",
    "\n",
    "If we don't use these instructions, we lose up to a factor of 16 right off the bat, and it will be hard to compare to optimized BLAS libraries.   Fortunately, for a problem as simple as matrix multiplication, the use of SIMD can be **automated**.   You typically have to tell the compiler to do this explicitly, however, because changing the code to use SIMD **changes the floating-point result** because it requires doing operations in a different order.  (Compilers don't like to change your answers unless you give them permission!)\n",
    "\n",
    "In particular, there is a nice Julia package called [LoopVectorization.jl](https://github.com/chriselrod/LoopVectorization.jl) that provides an `@avx` macro to rewrite simple loops to use AVX and FMA instructions.   We'll use this in a `matmul2` variant of the code above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "using LoopVectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matmul2 (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "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 matmul2!(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",
    "    @avx for i = 1:m, 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",
    "    return C\n",
    "end\n",
    "\n",
    "# a wrapper that allocates C of an appropriate type\n",
    "matmul2(A, B) = matmul2!(Array{promote_type(eltype(A), eltype(B))}(undef,\n",
    "                             size(A,1), size(B,2)),\n",
    "                         A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  183.287 μs (0 allocations: 0 bytes)\n",
      "  10.739 μs (0 allocations: 0 bytes)\n"
     ]
    }
   ],
   "source": [
    "A = rand(50,60); B = rand(60,70); C = zeros(50,70);\n",
    "@btime matmul!($C, $A, $B);\n",
    "@btime matmul2!($C, $A, $B);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Benchmarking naive `matmul`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we will benchmark our two naive `matmul` implementations 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": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: slowdown of 2.2571504835754426\n",
      "finished n = 11: slowdown of 2.4950691233198357\n",
      "finished n = 12: slowdown of 3.5707673377490377\n",
      "finished n = 13: slowdown of 3.4865546942291124\n",
      "finished n = 15: slowdown of 3.599620732978466\n",
      "finished n = 16: slowdown of 5.630373700477662\n",
      "finished n = 18: slowdown of 5.243865125760819\n",
      "finished n = 20: slowdown of 6.874664698176374\n",
      "finished n = 22: slowdown of 6.387227592987055\n",
      "finished n = 24: slowdown of 7.530390738060781\n",
      "finished n = 26: slowdown of 7.139406668416908\n",
      "finished n = 29: slowdown of 8.86996197718631\n",
      "finished n = 32: slowdown of 8.063699530516432\n",
      "finished n = 35: slowdown of 8.306155473952822\n",
      "finished n = 39: slowdown of 7.8994731502994195\n",
      "finished n = 43: slowdown of 8.78684030157642\n",
      "finished n = 47: slowdown of 8.872432655588812\n",
      "finished n = 52: slowdown of 11.35894960417069\n",
      "finished n = 57: slowdown of 11.229594409624667\n",
      "finished n = 63: slowdown of 10.679177119919718\n",
      "finished n = 69: slowdown of 12.7211454513707\n",
      "finished n = 76: slowdown of 15.040056012086819\n",
      "finished n = 84: slowdown of 15.753567049381342\n",
      "finished n = 92: slowdown of 17.092524771384277\n",
      "finished n = 102: slowdown of 16.621883914175864\n",
      "finished n = 112: slowdown of 18.920114327477748\n",
      "finished n = 123: slowdown of 18.19056822213508\n",
      "finished n = 136: slowdown of 20.336674367002036\n",
      "finished n = 150: slowdown of 20.31741376511874\n",
      "finished n = 165: slowdown of 20.2904499894427\n",
      "finished n = 182: slowdown of 21.965074406415226\n",
      "finished n = 200: slowdown of 24.728083316259607\n",
      "finished n = 221: slowdown of 23.298093092435405\n",
      "finished n = 243: slowdown of 23.615522898556552\n",
      "finished n = 268: slowdown of 25.363386568368117\n",
      "finished n = 295: slowdown of 24.449838923997785\n",
      "finished n = 325: slowdown of 25.827970639495494\n",
      "finished n = 358: slowdown of 25.60151899390615\n",
      "finished n = 394: slowdown of 26.386463599559594\n",
      "finished n = 434: slowdown of 27.653257847554208\n",
      "finished n = 478: slowdown of 27.73446719730181\n",
      "finished n = 526: slowdown of 27.442908250601207\n",
      "finished n = 580: slowdown of 28.24196057903414\n",
      "finished n = 639: slowdown of 27.894851485757723\n",
      "finished n = 704: slowdown of 32.19274609232377\n",
      "finished n = 775: slowdown of 28.101950897993888\n",
      "finished n = 854: slowdown of 28.704945212934334\n",
      "finished n = 940: slowdown of 33.59099217844437\n",
      "finished n = 1036: slowdown of 31.388923438146342\n",
      "finished n = 1141: slowdown of 38.542516868347455\n",
      "finished n = 1257: slowdown of 32.326363845664744\n",
      "finished n = 1384: slowdown of 48.44881463157586\n",
      "finished n = 1525: slowdown of 56.25239043644647\n",
      "finished n = 1680: slowdown of 87.92004480586539\n",
      "finished n = 1850: slowdown of 102.2170752969168\n",
      "finished n = 2038: slowdown of 114.34477319737667\n",
      "finished n = 2245: slowdown of 115.49633126747378\n",
      "finished n = 2473: slowdown of 128.1797712118958\n",
      "finished n = 2724: slowdown of 126.06789160710578\n",
      "finished n = 3000: slowdown of 142.05141996766926\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",
    "tv = 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!(tv, @belapsed matmul2!($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": 9,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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 0x7f8d184ff510>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(N, 2N.^3 ./ t * 1e-9, \"m.--\")\n",
    "plot(N, 2N.^3 ./ tv * 1e-9, \"rs-\")\n",
    "plot(N, 2N.^3 ./ t0 * 1e-9, \"b.-\")\n",
    "ylabel(L\"gigaflops $2n^3/t$\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "legend([\"naive matmul\", \"naive + SIMD\", \"BLAS matmul\"], 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": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cmatmul (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0175362097255202e-15"
      ]
     },
     "execution_count": 12,
     "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: speedup of 0.8096392132348016\n",
      "finished n = 11: speedup of 0.787933800068331\n",
      "finished n = 12: speedup of 0.8429995468962392\n",
      "finished n = 13: speedup of 0.8449945527175886\n",
      "finished n = 15: speedup of 0.9459532739843644\n",
      "finished n = 16: speedup of 0.9247698181001573\n",
      "finished n = 18: speedup of 0.9302127439843024\n",
      "finished n = 20: speedup of 0.8912962271199104\n",
      "finished n = 22: speedup of 0.8948917748917748\n",
      "finished n = 24: speedup of 0.8670125876813682\n",
      "finished n = 26: speedup of 1.005001103184526\n",
      "finished n = 29: speedup of 0.8989197530864198\n",
      "finished n = 32: speedup of 0.9371017624920818\n",
      "finished n = 35: speedup of 0.8755310778914239\n",
      "finished n = 39: speedup of 0.9625932062966033\n",
      "finished n = 43: speedup of 0.9251170046801873\n",
      "finished n = 47: speedup of 0.9471063805036934\n",
      "finished n = 52: speedup of 0.9394676004623648\n",
      "finished n = 57: speedup of 0.9359114179037452\n",
      "finished n = 63: speedup of 0.9298708865041629\n",
      "finished n = 69: speedup of 0.9078362203859774\n",
      "finished n = 76: speedup of 0.8845695860754345\n",
      "finished n = 84: speedup of 0.8774865071882058\n",
      "finished n = 92: speedup of 0.8900395274582411\n",
      "finished n = 102: speedup of 0.8975104879973288\n",
      "finished n = 112: speedup of 0.9356617279334923\n",
      "finished n = 123: speedup of 0.9556412476601625\n",
      "finished n = 136: speedup of 0.9537445468897421\n",
      "finished n = 150: speedup of 0.9844177502939319\n",
      "finished n = 165: speedup of 0.9551775324504405\n",
      "finished n = 182: speedup of 0.9860263536709534\n",
      "finished n = 200: speedup of 0.9441919276969843\n",
      "finished n = 221: speedup of 0.9907513876310845\n",
      "finished n = 243: speedup of 0.9990125898590008\n",
      "finished n = 268: speedup of 0.9916502820202407\n",
      "finished n = 295: speedup of 0.9939553564949799\n",
      "finished n = 325: speedup of 0.9905882483291066\n",
      "finished n = 358: speedup of 0.981835574410494\n",
      "finished n = 394: speedup of 0.9852785395384825\n",
      "finished n = 434: speedup of 0.9908817162394533\n",
      "finished n = 478: speedup of 0.9917092456362243\n",
      "finished n = 526: speedup of 0.9934823924981853\n",
      "finished n = 580: speedup of 0.991162753360323\n",
      "finished n = 639: speedup of 0.9951056952239036\n",
      "finished n = 704: speedup of 0.9786153629846499\n",
      "finished n = 775: speedup of 0.984708599313264\n",
      "finished n = 854: speedup of 0.9972466098521331\n",
      "finished n = 940: speedup of "
     ]
    },
    {
     "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": [
      "0.9930787512487544\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1-element Array{PyCall.PyObject,1}:\n",
       " PyObject <matplotlib.lines.Line2D object at 0x7f8d18834210>"
      ]
     },
     "execution_count": 13,
     "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",
    "(The \"last factor of 2\" in performance takes a lot more effort.  Our code still doesn't match the OpenBLAS performance because the cache-oblivious algorithm is only optimal up to constant factors, and moreover one really needs to unroll and optimize the base cases to optimize register utilization.  And then there is the effort required to parallelize the whole thing, which is not considered here.)\n",
    "\n",
    "In contrast, OpenBLAS requires ≈1000× as much code (≈30000 lines for matrix multiplications).  A recent pure-Julia library called [Octavian.jl](https://github.com/JuliaLinearAlgebra/Octavian.jl) can match and even sometimes exceed the multi-threaded OpenBLAS performance, with \"only\" 100× as much code (a few thousand lines).  High-level languages + fast compilation is a convenient combination for writing high-performance code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matmul_rec (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function add_matmul_rec!(m,n,p, i0,j0,k0, C,A,B)\n",
    "    if m+n+p <= 256   # base case: naive matmult for sufficiently large matrices\n",
    "        @avx for i = 1:m, 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",
    "    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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: slowdown of 0.42001787059144474\n",
      "finished n = 11: slowdown of 0.3744457778506396\n",
      "finished n = 12: slowdown of 0.5041604323980581\n",
      "finished n = 13: slowdown of 0.5199141574397629\n",
      "finished n = 15: slowdown of 0.4199135366588606\n",
      "finished n = 16: slowdown of 0.5527778677231711\n",
      "finished n = 18: slowdown of 0.5997538447503661\n",
      "finished n = 20: slowdown of 0.6598303216818115\n",
      "finished n = 22: slowdown of 0.6105471661213682\n",
      "finished n = 24: slowdown of 0.6054457506492477\n",
      "finished n = 26: slowdown of 0.6547650301916514\n",
      "finished n = 29: slowdown of 0.667514258555133\n",
      "finished n = 32: slowdown of 0.5813784037558685\n",
      "finished n = 35: slowdown of 0.587218107508143\n",
      "finished n = 39: slowdown of 0.5800459766353611\n",
      "finished n = 43: slowdown of 0.6574409521633646\n",
      "finished n = 47: slowdown of 0.6198369284755909\n",
      "finished n = 52: slowdown of 0.7644332882795906\n",
      "finished n = 57: slowdown of 0.8070023773503351\n",
      "finished n = 63: slowdown of 0.7167586552935273\n",
      "finished n = 69: slowdown of 0.859088528025144\n",
      "finished n = 76: slowdown of 0.8939823856726978\n",
      "finished n = 84: slowdown of 0.9027979043584885\n",
      "finished n = 92: slowdown of 1.0306243961624015\n",
      "finished n = 102: slowdown of 1.0338273595435943\n",
      "finished n = 112: slowdown of 1.013494818720472\n",
      "finished n = 123: slowdown of 1.0922077194554927\n",
      "finished n = 136: slowdown of 1.0610428888416061\n",
      "finished n = 150: slowdown of 1.1496622245605002\n",
      "finished n = 165: slowdown of 1.108019822885745\n",
      "finished n = 182: slowdown of 1.2082268595068328\n",
      "finished n = 200: slowdown of 1.3487085607243876\n",
      "finished n = 221: slowdown of 1.2927168814548335\n",
      "finished n = 243: slowdown of 1.281230228017142\n",
      "finished n = 268: slowdown of 1.34465028457611\n",
      "finished n = 295: slowdown of 1.2720082744576946\n",
      "finished n = 325: slowdown of 1.44003504602943\n",
      "finished n = 358: slowdown of 1.3618780961782526\n",
      "finished n = 394: slowdown of 1.4870545074866357\n",
      "finished n = 434: slowdown of 1.4920417112593873\n",
      "finished n = 478: slowdown of 1.575467493331027\n",
      "finished n = 526: slowdown of 1.5873598921013061\n",
      "finished n = 580: slowdown of 1.7110408616573909\n",
      "finished n = 639: slowdown of 1.59850854225871\n",
      "finished n = 704: slowdown of 1.441796289755857\n",
      "finished n = 775: slowdown of 1.502407218795922\n",
      "finished n = 854: slowdown of 1.7202498542978835\n",
      "finished n = 940: slowdown of 1.6664969962115703\n",
      "finished n = 1036: slowdown of 1.754418686970654\n",
      "finished n = 1141: slowdown of 1.7199930651660251\n",
      "finished n = 1257: slowdown of 1.827259833448249\n",
      "finished n = 1384: slowdown of 1.7536936660976454\n",
      "finished n = 1525: slowdown of 1.5631772405220175\n",
      "finished n = 1680: slowdown of 1.7056254048980006\n",
      "finished n = 1850: slowdown of 1.871265472364321\n",
      "finished n = 2038: slowdown of 1.7970598957555743\n",
      "finished n = 2245: slowdown of 2.1909956398756925\n",
      "finished n = 2473: slowdown of 2.0075170584159063\n",
      "finished n = 2724: slowdown of 1.9658048765581884\n",
      "finished n = 3000: slowdown of 1.6747624520873492\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": 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 0x7f8d18a02dd0>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(N, 2N.^3 ./ tv * 1e-9, \"rs-\")\n",
    "plot(N, 2N.^3 ./ tco * 1e-9, \"ko-\")\n",
    "plot(N, 2N.^3 ./ t0 * 1e-9, \"b.-\")\n",
    "ylim(0,50)\n",
    "ylabel(L\"gigaflops $2n^3/t$\")\n",
    "xlabel(L\"matrix size $n$\")\n",
    "legend([\"naive+SIMD\", \"cache-oblivious+SIMD\", \"BLAS matmul (single-threaded)\"], loc=\"upper right\")"
   ]
  },
  {
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished n = 10: ratio t1/t2 of 1.0230625080301594\n",
      "finished n = 11: ratio t1/t2 of 1.0686913725305058\n",
      "finished n = 12: ratio t1/t2 of 1.0949888352129231\n",
      "finished n = 13: ratio t1/t2 of 1.0825560142269264\n",
      "finished n = 15: ratio t1/t2 of 1.0440187828083989\n",
      "finished n = 16: ratio t1/t2 of 2.0463619261597166\n",
      "finished n = 18: ratio t1/t2 of 1.8997204570255033\n",
      "finished n = 20: ratio t1/t2 of 1.7882358742287783\n",
      "finished n = 22: ratio t1/t2 of 1.749614054182348\n",
      "finished n = 24: ratio t1/t2 of 1.7210357565446446\n",
      "finished n = 26: ratio t1/t2 of 1.6955612908163085\n",
      "finished n = 29: ratio t1/t2 of 1.6268502571988732\n",
      "finished n = 32: ratio t1/t2 of 3.7985615003507647\n",
      "finished n = 35: ratio t1/t2 of 2.184259278495316\n",
      "finished n = 39: ratio t1/t2 of 2.636343399866439\n",
      "finished n = 43: ratio t1/t2 of 2.5014325977133742\n",
      "finished n = 47: ratio t1/t2 of 2.3754143845488613\n",
      "finished n = 52: ratio t1/t2 of 3.9109653916211293\n",
      "finished n = 57: ratio t1/t2 of 5.485032635606571\n",
      "finished n = 63: ratio t1/t2 of 2.548234882908074\n",
      "finished n = 69: ratio t1/t2 of 2.9762531493250104\n",
      "finished n = 76: ratio t1/t2 of 3.5468661336084604\n",
      "finished n = 84: ratio t1/t2 of 4.781761983884512\n",
      "finished n = 92: ratio t1/t2 of 4.397587419417854\n",
      "finished n = 102: ratio t1/t2 of 5.6833489769100805\n",
      "finished n = 112: ratio t1/t2 of 5.605194971370078\n",
      "finished n = 123: ratio t1/t2 of 4.057858711093892\n",
      "finished n = 136: ratio t1/t2 of 3.060295964949906\n",
      "finished n = 150: ratio t1/t2 of 3.9087834375320285\n",
      "finished n = 165: ratio t1/t2 of 4.787215753692272\n",
      "finished n = 182: ratio t1/t2 of 4.675062801276393\n",
      "finished n = 200: ratio t1/t2 of 3.746411757951544\n",
      "finished n = 221: ratio t1/t2 of 4.444597701149425\n",
      "finished n = 243: ratio t1/t2 of 4.264818796068796\n",
      "finished n = 268: ratio t1/t2 of 4.108974948640112\n",
      "finished n = 295: ratio t1/t2 of 4.2012526096033405\n",
      "finished n = 325: ratio t1/t2 of 4.356924508240298\n",
      "finished n = 358: ratio t1/t2 of 4.330135862782156\n",
      "finished n = 394: ratio t1/t2 of 4.577073299659345\n",
      "finished n = 434: ratio t1/t2 of 4.616964397251718\n",
      "finished n = 478: ratio t1/t2 of 3.883952142030104\n",
      "finished n = 526: ratio t1/t2 of 10.140144336101446\n",
      "finished n = 580: ratio t1/t2 of 14.569555318807371\n",
      "finished n = 639: ratio t1/t2 of 17.416578748647154\n",
      "finished n = 704: ratio t1/t2 of 16.68947246927238\n",
      "finished n = 775: ratio t1/t2 of 17.026629484555645\n",
      "finished n = 854: ratio t1/t2 of 16.683473218211113\n",
      "finished n = 940: ratio t1/t2 of 14.982423636374792\n",
      "finished n = 1036: ratio t1/t2 of 15.476104697294462\n",
      "finished n = 1141: ratio t1/t2 of 17.092937001283893\n",
      "finished n = 1257: ratio t1/t2 of 15.49919176720316\n",
      "finished n = 1384: ratio t1/t2 of 14.013528372534543\n",
      "finished n = 1525: ratio t1/t2 of 16.4677420528883\n",
      "finished n = 1680: ratio t1/t2 of 15.175868218928526\n",
      "finished n = 1850: ratio t1/t2 of 13.771946491596166\n",
      "finished n = 2038: ratio t1/t2 of 16.69229308028548\n",
      "finished n = 2245: ratio t1/t2 of 14.411234783257054\n",
      "finished n = 2473: ratio t1/t2 of 14.735477683088696\n",
      "finished n = 2724: ratio t1/t2 of 17.709709652956878\n",
      "finished n = 3000: ratio t1/t2 of 16.002173288119597\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": 20,
   "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 0x7f8ced4db7d0>"
      ]
     },
     "execution_count": 20,
     "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": 21,
   "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.0, 'ratio of matrix-addition algorithms')"
      ]
     },
     "execution_count": 21,
     "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": 22,
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  6.198 ms (10 allocations: 38.15 MiB)\n"
     ]
    }
   ],
   "source": [
    "@btime f_vec($X);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.020 ms (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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f_vec_really (generic function with 1 method)"
      ]
     },
     "execution_count": 25,
     "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.5.3",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}