LoweredTypedCode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "89171417",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lowered & typed code\n",
    "\n",
    "## An introduction to code transformations in Julia\n",
    "\n",
    "Tim Holy\n",
    "\n",
    "JuliaCon 2021"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "053367a3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Multiple ways to write the same code\n",
    "\n",
    "```julia\n",
    "if isempty(list)\n",
    "    idx = nothing\n",
    "else\n",
    "    idx = firstindex(list)\n",
    "end\n",
    "```\n",
    "\n",
    "is the same as\n",
    "\n",
    "```julia\n",
    "idx = isempty(list) ? nothing : firstindex(list)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a651a9f",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```julia\n",
    "function f(x, y)\n",
    "    return x + y\n",
    "end\n",
    "```\n",
    "\n",
    "is the same as\n",
    "\n",
    "```julia\n",
    "f(x, y) = x + y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c77bbcb9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Other examples: `do`-block syntax, `for` vs `while` loops, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc074f24",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Some higher-level constructs add complexity\n",
    "\n",
    "```julia\n",
    "function myfunc(a, b)\n",
    "    f(z) = z^2 + a      # an inner function\n",
    "    \n",
    "    ...\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c44c068",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Scoping rules make the naive parsing of code less straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f3e815a",
   "metadata": {},
   "outputs": [],
   "source": [
    "function f()\n",
    "    for i = 1:5\n",
    "        x = rand()\n",
    "    end\n",
    "    println(\"The last random number was \", x)\n",
    "end\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ac445f0",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Expressing these with uniform syntax is the main purpose of *lowering*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef22686",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# @code_lowered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ea3812b",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(a, b) = a*a + b\n",
    "@code_lowered f(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee5898d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "%n: [Single Static Assignment](https://en.wikipedia.org/wiki/Static_single_assignment_form) value\n",
    "\n",
    "Left column: [basic block](https://en.wikipedia.org/wiki/Basic_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8978ac8",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "g(cond, val1, val2) = cond ? val1 + val2 : val2\n",
    "@code_lowered g(true, 1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61fe5b98",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "function blastoff()\n",
    "    counter = 5\n",
    "    while counter > 0\n",
    "        println(counter)\n",
    "        counter -= 1\n",
    "    end\n",
    "    println(\"blast off!\")\n",
    "end\n",
    "@code_lowered blastoff()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc18dc52",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "function mysum(list)\n",
    "    ss = 0.0\n",
    "    for item in list\n",
    "        ss += item\n",
    "    end\n",
    "    return ss\n",
    "end\n",
    "@code_lowered mysum([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "432aa9cd",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# We can see scoping in action:\n",
    "function f()\n",
    "    for i = 1:5\n",
    "        x = rand()\n",
    "    end\n",
    "    println(\"The last random number was \", x)\n",
    "end\n",
    "@code_lowered f()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29dc8922",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lowered representation of more complex constructs\n",
    "\n",
    "An example using inner functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0f3edcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "function myfunc(a, b)\n",
    "    f(z) = z^2 + a      # an inner function\n",
    "\n",
    "    return f(b)\n",
    "end\n",
    "@code_lowered myfunc(1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47d8b96b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What is `#f#1`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dfba846",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Conceptually, Julia expands it like this:\n",
    "\n",
    "```julia\n",
    "struct FClosure{A}\n",
    "    a::A\n",
    "end\n",
    "(f::FClosure)(z) = z^2 + f.a\n",
    "\n",
    "function myfunc(a, b)\n",
    "    fc = FClosure{typeof(a)}(a)\n",
    "    return fc(b)\n",
    "end\n",
    "```\n",
    "\n",
    "`#f#1` is the automatically-generated name given to `FClosure`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41726e9f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can see this with `Meta.lower(mod, expr)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f25b078",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Meta.lower(Main, quote\n",
    "    function myfunc(a, b)\n",
    "        f(z) = z^2 + a      # an inner function\n",
    "\n",
    "        return f(b)\n",
    "    end\n",
    "end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25cb202c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# @code_typed\n",
    "\n",
    "This allows you to see the results of type-inference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf498bdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(a, b) = a*a + b\n",
    "@code_lowered f(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "945fcc2b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@code_typed optimize=false f(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec9b3f3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "@code_typed optimize=true f(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d844c82",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@code_typed f(1.0, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c68cbf0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Summary\n",
    "\n",
    "- Each `Method` has a single lowered-code representation\n",
    "- See it with `@code_lowered` or, in complex cases, `Meta.lower`\n",
    "- Lowering expands macros, resolves and flattens scope, and reduces control-flow to \"goto\"s\n",
    "- `@code_typed` also shows type inference (corresponding to a particular `MethodInstance`)\n",
    "- `@code_typed` by default applies optimization transformations like inlining and linearization\n",
    "\n",
    "With practice, these code representations become quite readable"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 1.7.0-pre3-ns 1.7.0-beta3",
   "language": "julia",
   "name": "julia-1.7.0-pre3-ns-1.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.7.0"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}