{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Optimal complexity finite element assembly" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sum factorisation\n", "Suppose we are assemblying the 2-form of the Laplace operator on a hexahedral element, e.g. the Q3 element:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since each quadrature point $X$ can be represented as a 3-tuple $q=\\{q_1,q_2,q_3\\}$, and each basis function by a 3-tuple $i = \\{i_1,i_2,i_3\\}$, the naive local assembly kernel for the local tensor $A_{ij}$ contains the loop structure:\n", "```\n", "for q1, q2, q3\n", " for i1, i2, i3\n", " for j1, j2, j3\n", " A[i1,i2,i3,j1,j2,j3] += ...\n", "```\n", "This requires $O(N_{q}^3N_{i}^6)$ FLOPs. For polynomial degree $p$, both $N_q$ and $N_i$ are $O(p)$, so this local assembly requires $O(p^9)$ FLOPs." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For *tensor product elements* like this, we can rearrange the contraction over quadrature points and hoist invariant sub-expressions out of the innermost loop into temporary variables. This is known as *sum factorisation*:\n", "```\n", "for q1, i1, j1\n", " t1[i1,j1] += ...\n", "for q2, i2, j2\n", " t2[i2,j2] += ...\n", "for q3\n", " for i1, i2, i3\n", " for j1, j2, j3\n", " A[i1,i2,i3,j1,j2,j3] += t1*t2*...\n", "```\n", "This reduces the complexity to $O(p^7)$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC \\[1\\], the form compiler of Firedrake, is capable of exploiting this intrinsic structure of the finite element, provided by FInAT \\[2\\], and apply sum factorisation automatically to generate assembly kernels with optimal algorithmic complexity." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib widget\n", "%config InlineBackend.figure_format = 'svg'\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams['figure.figsize'] = (11, 6)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from firedrake import *\n", "set_log_level(ERROR)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can create a hexahedral mesh by extruding a quadrilateral mesh." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "mesh = ExtrudedMesh(UnitSquareMesh(10, 10, quadrilateral=True), 10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's choose the continuous Lagrange element of degree 5 as our function space." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "p = 5\n", "V = FunctionSpace(mesh, \"CG\", p)\n", "u = TrialFunction(V)\n", "v = TestFunction(V)\n", "a = dot(grad(u), grad(v)) *dx # Laplace operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Firedrake internalises the process of local assembly. In order to look at the kernel, we need to import the compilation interface from TSFC." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from tsfc import compile_form" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC organises the optimisation passes into *modes*. Let's first try the *vanilla* mode, which does as little optimisation as possible:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "kernel_vanilla, = compile_form(a, parameters={\"mode\": \"vanilla\"})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC also lets us estimate the number of FLOPs performed by the kernel:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with vanilla mode is 4.45e+08\n" ] } ], "source": [ "print(\"Local assembly FLOPs with vanilla mode is {0:.3g}\".format(kernel_vanilla.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The default optimisation mode in TSFC is *spectral*, which applies sum factorisation to determine the tensor contraction order, and at each level, apply *argument factorisation* \\[3\\] to rearrange the expression using associative and distributive laws. Since *spectral* is the default mode, we do not need to specify it in the parameters." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with spectral mode is 5.45e+06\n" ] } ], "source": [ "kernel_spectral, = compile_form(a)\n", "print(\"Local assembly FLOPs with spectral mode is {0:.3g}\".format(kernel_spectral.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is a 43x reduction in FLOPs. Not bad, but there's opportunity to do better. For spectral elements, if we use the Gauss–Lobatto–Legendre (GLL) quadrature scheme, which has quadrature points collated with the Lagrange basis function nodes, then we know that the basis function tabulation is an indentity matrix. TSFC and FInAT can further simplify the loop structure of the local assembly kernels. This reduces the complexity to $O(p^5)$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to specify the GLL quadrature scheme for hexahedra. We can do this with FIAT, which defines GLL on intervals, and FInAT, which makes the tensor product scheme from the interval scheme." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "import FIAT, finat\n", "\n", "def gauss_lobatto_legendre_line_rule(degree):\n", " fiat_make_rule = FIAT.quadrature.GaussLobattoLegendreQuadratureLineRule\n", " fiat_rule = fiat_make_rule(FIAT.ufc_simplex(1), degree + 1)\n", " finat_ps = finat.point_set.GaussLobattoLegendrePointSet\n", " points = finat_ps(fiat_rule.get_points())\n", " weights = fiat_rule.get_weights()\n", " return finat.quadrature.QuadratureRule(points, weights)\n", "\n", "def gauss_lobatto_legendre_cube_rule(dimension, degree):\n", " make_tensor_rule = finat.quadrature.TensorProductQuadratureRule\n", " result = gauss_lobatto_legendre_line_rule(degree)\n", " for _ in range(1, dimension):\n", " line_rule = gauss_lobatto_legendre_line_rule(degree)\n", " result = make_tensor_rule([result, line_rule])\n", " return result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start by creating the spectral finite element function space of the same polynomial degree." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "element = FiniteElement('CG', mesh.ufl_cell(), degree=p, variant='spectral')\n", "V = FunctionSpace(mesh, element)\n", "u = TrialFunction(V)\n", "v = TestFunction(V)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to tell Firedrake to use the GLL quadratures for numerical integration." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "gll_quadrature_rule = gauss_lobatto_legendre_cube_rule(dimension=3, degree=p)\n", "a_gll = dot(grad(u), grad(v)) *dx(scheme=gll_quadrature_rule)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with GLL quadrature is 2.14e+05\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n" ] } ], "source": [ "kernel_gll, = compile_form(a_gll)\n", "print(\"Local assembly FLOPs with GLL quadrature is {0:.3g}\".format(kernel_gll.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is a further 10x reduction in FLOPs.\n", "\n", "Now, let's verify that we achieve the expected asymptotic algorithmic complexity with respect to polynomial degrees." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "from collections import defaultdict\n", "import matplotlib.pyplot as plt\n", "import numpy" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n" ] } ], "source": [ "flops = defaultdict(list)\n", "ps = range(1, 33) # polynomial degrees\n", "modes = {\n", " 'gll': {'mode': 'spectral', 'variant': 'spectral', 'rule': gauss_lobatto_legendre_cube_rule},\n", " 'spectral': {'mode': 'spectral', 'variant': None, 'rule': lambda *args: None},\n", " 'vanilla': {'mode': 'vanilla', 'variant': None, 'rule': lambda *args: None}\n", "}\n", "\n", "for p in ps:\n", " for mode in modes:\n", " element = FiniteElement('CG', mesh.ufl_cell(), degree=p, variant=modes[mode]['variant'])\n", " V = FunctionSpace(mesh, element)\n", " u = TrialFunction(V)\n", " v = TestFunction(V)\n", " a = dot(grad(u), grad(v))*dx(scheme=modes[mode]['rule'](3, p))\n", " kernel, = compile_form(a, parameters={\"mode\": modes[mode]['mode']})\n", " flops[mode].append(kernel.flop_count)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b643618da54d41f791bdda429df36129", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "