From 570d4a0af82d547264a2bc46f6f0abeba59f3d66 Mon Sep 17 00:00:00 2001 From: Scott Main Date: Wed, 19 Apr 2023 16:47:35 -0700 Subject: [PATCH] [Docs][Mojo] Move some of the Mojo notebooks into new "public" dir. (#12881) This is to hopefully avoid committing notebooks that are meant for internal eyes only. The Mojo Playground can simply fetch all notebooks from this dir, and so can the docs website to render them as static web pages (for people without Playground access to read). modular-orig-commit: e00f2cb1c44c408eeb54918c1a722df0f9b7fa7d --- examples/BoolMLIR.ipynb | 485 +++++++++++++++ examples/HelloMojo.ipynb | 45 ++ examples/Matmul.ipynb | 1240 ++++++++++++++++++++++++++++++++++++++ examples/Memset.ipynb | 674 +++++++++++++++++++++ examples/index.md | 3 + 5 files changed, 2447 insertions(+) create mode 100644 examples/BoolMLIR.ipynb create mode 100644 examples/HelloMojo.ipynb create mode 100644 examples/Matmul.ipynb create mode 100644 examples/Memset.ipynb create mode 100644 examples/index.md diff --git a/examples/BoolMLIR.ipynb b/examples/BoolMLIR.ipynb new file mode 100644 index 000000000..e73ef4544 --- /dev/null +++ b/examples/BoolMLIR.ipynb @@ -0,0 +1,485 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "---\n", + "title: \"Low-Level IR in Mojo\"\n", + "subtitle: \"A Boolean Case Study\"\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "Mojo is a high-level programming language with an extensive set of modern features. But Mojo also provides you, the programmer, access to all of the low-level primitives that you need to write powerful -- yet zero-cost -- abstractions.\n", + "\n", + "These primitives are implemented in [MLIR](https://mlir.llvm.org), an extensible intermediate representation (IR) format for compiler design. Many different programming languages and compilers translate their source programs into MLIR, and because Mojo provides direct access to MLIR features, this means Mojo programs can enjoy the benefits of each of these tools.\n", + "\n", + "Going one step further, Mojo's unique combination of zero-cost abstractions with MLIR interoperability means that Mojo programs can take full advantage of *anything* that interfaces with MLIR. While this isn't something normal Mojo programmers may ever need to do, it's an extremely powerful capability when extending a system to interface with a new datatype, or an esoteric new accelerator feature.\n", + "\n", + "To illustrate these ideas, we'll implement a boolean type in Mojo below, which we'll call `OurBool`. We'll make extensive use of MLIR, so let's begin with a short primer.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## What is MLIR?\n", + "\n", + "MLIR is an intermediate representation of a program, not unlike an assembly language, in which a sequential set of instructions operate on in-memory values.\n", + "\n", + "More importantly, MLIR is modular and extensible. MLIR is composed of an ever-growing number of \"dialects.\" Each dialect defines operations and optimizations: for example, the ['math' dialect](https://mlir.llvm.org/docs/Dialects/MathOps/) provides mathematical operations such as sine and cosine, the ['amdgpu' dialect](https://mlir.llvm.org/docs/Dialects/AMDGPU/) provides operations specific to AMD processors, and so on.\n", + "\n", + "Each of MLIR's dialects can interoperate with the others. This is why MLIR is said to unlock heterogeneous compute: as newer, faster processors and architectures are developed, new MLIR dialects are implemented to generate optimal code for those environments. Any new MLIR dialect can be translated seamlessly into other dialects, so as more get added, all existing MLIR becomes more powerful.\n", + "\n", + "This means that our own custom types, such as the `OurBool` type we'll create below, can be used to provide programmers with a high-level, Python-like interface. But \"under the covers,\" Mojo and MLIR will optimize our convenient, high-level types for each new processor that appears in the future.\n", + "\n", + "There's much more to write about why MLIR is such a revolutionary technology, but let's get back to Mojo and defining the `OurBool` type. There will be opportunities to learn more about MLIR along the way." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#|echo: false\n", + "\n", + "from IO import print\n", + "\n", + "\n", + "alias OurTrue = OurBool(__mlir_attr.`true`)\n", + "alias OurFalse: OurBool = __mlir_attr.`false`\n", + "\n", + "\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + " \n", + " fn __init__() -> Self:\n", + " return OurFalse\n", + "\n", + " fn __init__(value: __mlir_type.i1) -> Self:\n", + " return Self {value: value}\n", + " \n", + " fn __bool__(self) -> Bool:\n", + " return Bool(self.value)\n", + "\n", + " fn __mlir_i1__(self) -> __mlir_type.i1:\n", + " return self.value\n", + "\n", + " fn __eq__(self, rhs: OurBool) -> Self:\n", + " let lhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](\n", + " self.value\n", + " )\n", + " let rhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](\n", + " rhs.value\n", + " )\n", + " return Self(\n", + " __mlir_op.`index.cmp`[\n", + " pred : __mlir_attr.`#index`\n", + " ](lhsIndex, rhsIndex)\n", + " )\n", + "\n", + " fn __invert__(self) -> Self:\n", + " return OurFalse if self == OurTrue else OurTrue" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Defining the `OurBool` type\n", + "\n", + "We can use Mojo's `struct` keyword to define a new type `OurBool`:\n", + "\n", + "```\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + "```\n", + "\n", + "A boolean can represent 0 or 1, \"true\" or \"false.\" To store this information, `OurBool` has a single member, called `value`. Its type is represented *directly in MLIR*, using the MLIR builtin type [`i1`](https://mlir.llvm.org/docs/Dialects/Builtin/#integertype). In fact, you can use any MLIR type in Mojo, by prefixing the type name with `__mlir_type`.\n", + "\n", + "As we'll see below, representing our boolean value with `i1` will allow us to utilize all of the MLIR operations and optimizations that interface with the `i1` type -- and there are many of them!\n", + "\n", + "Having defined `OurBool`, we can now declare a variable of this type:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "var a: OurBool" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Leveraging MLIR\n", + "\n", + "Naturally, we might next try to create an instance of `OurBool`. Attempting to do so at this point, however, results in an error:\n", + "\n", + "```\n", + "let a = OurBool() # error: 'OurBool' does not implement an '__init__' method\n", + "```\n", + "\n", + "As in Python, `__init__` is a [special method](https://docs.python.org/3/reference/datamodel.html#specialnames) that can be defined to customize the behavior of a type. We can implement an `__init__` method that takes no arguments, and returns an `OurBool` with a \"false\" value.\n", + "\n", + "```\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + "\n", + " fn __init__(self&):\n", + " self.value = __mlir_op.`index.bool.constant`[\n", + " value : __mlir_attr.`false`,\n", + " ]()\n", + "```\n", + "\n", + "To initialize the underlying `i1` value, we use an MLIR operation from its ['index' dialect](https://mlir.llvm.org/docs/Dialects/IndexOps/), called [`index.bool.constant`](https://mlir.llvm.org/docs/Dialects/IndexOps/#indexboolconstant-mlirindexboolconstantop).\n", + "\n", + "MLIR's 'index' dialect provides us with operations for manipulating builtin MLIR types, such as the `i1` we use to store the value of `OurBool`. The `index.bool.constant` operation takes a `true` or `false` compile-time constant as input, and produces a runtime output of type `i1` with the given value.\n", + "\n", + "So, as shown above, in addition to any MLIR type, Mojo also provides direct access to any MLIR operation via the `__mlir_op` prefix, and to any attribute via the `__mlir_attr` prefix. MLIR attributes are used to represent compile-time constants.\n", + "\n", + "As you can see above, the syntax for interacting with MLIR isn't always pretty: MLIR attributes are passed in between square brackets `[...]`, and the operation is executed via a parentheses suffix `(...)`, which can take runtime argument values. However, most Mojo programmers will not need to access MLIR directly, and for the few that do, this \"ugly\" syntax gives them superpowers: they can define high-level types that are easy to use, but that internally plug into MLIR and its powerful system of dialects.\n", + "\n", + "We think this is very exciting, but let's bring things back down to earth: having defined an `__init__` method, we can now create an instance of our `OurBool` type:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "let b = OurBool()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Value semantics in Mojo\n", + "\n", + "We can now instantiate `OurBool`, but using it is another story:\n", + "\n", + "```\n", + "let a = OurBool()\n", + "let b = a # error: 'OurBool' does not implement the '__copyinit__' method\n", + "```\n", + "\n", + "Mojo uses \"value semantics\" by default, meaning that it expects to create a copy of `a` when assigning to `b`. However, Mojo doesn't make any assumptions about *how* to copy `OurBool`, or its underlying `i1` value. The error indicates that we should implement a `__copyinit__` method, which would implement the copying logic.\n", + "\n", + "In our case, however, `OurBool` is a very simple type, with only one \"trivially copyable\" member. We can use a decorator to tell the Mojo compiler that, saving us the trouble of defining our own `__copyinit__` boilerplate. Trivially copyable types must implement an `__init__` method that returns an instance of themselves, so we must also rewrite our initializer slightly.\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + "\n", + " fn __init__() -> Self:\n", + " return Self {\n", + " value: __mlir_op.`index.bool.constant`[\n", + " value : __mlir_attr.`false`,\n", + " ]()\n", + " }\n", + "```\n", + "\n", + "We can now copy `OurBool` as we please:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "let c = OurBool()\n", + "let d = c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compile-time constants\n", + "\n", + "It's not very useful to have a boolean type that can only represent \"false.\" Let's define compile-time constants that represent true and false `OurBool` values.\n", + "\n", + "First, let's define another `__init__` constructor for `OurBool` that takes its `i1` value as an argument:\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + " # ...\n", + "\n", + " fn __init__(value: __mlir_type.i1) -> Self:\n", + " return Self {value: value}\n", + "```\n", + "\n", + "This allows us to define compile-time constant `OurBool` values, using the `alias` keyword. First, let's define `OurTrue`:\n", + "\n", + "```\n", + "alias OurTrue = OurBool(__mlir_attr.`true`)\n", + "```\n", + "\n", + "Here we're passing in an MLIR compile-time constant value of `true`, which has the `i1` type that our new `__init__` constructor expects. We can use a slightly different syntax for `OurFalse`:\n", + "\n", + "```\n", + "alias OurFalse: OurBool = __mlir_attr.`false`\n", + "```\n", + "\n", + "`OurFalse` is declared to be of type `OurBool`, and then assigned an `i1` type -- in this case, the `OurBool` constructor we added is called implicitly.\n", + "\n", + "With true and false constants, we can also simplify our original `__init__` constructor for `OurBool`. Instead of constructing an MLIR value, we can simply return our `OurFalse` constant:\n", + "\n", + "```\n", + "alias OurTrue = OurBool(__mlir_attr.`true`)\n", + "alias OurFalse: OurBool = __mlir_attr.`false`\n", + "\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " # ...\n", + " fn __init__() -> Self:\n", + " return OurFalse\n", + "```\n", + "\n", + "Note also that we can define `OurTrue` before we define `OurBool`. The Mojo compiler is smart enough to figure this out.\n", + "\n", + "With these constants, we can now define variables with both true and false values of `OurBool`:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "let e = OurTrue\n", + "let f = OurFalse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementing `__bool__`\n", + "\n", + "Of course, the reason booleans are ubiquitous in programming is because they can be used for program control flow. However, if we attempt to use `OurBool` in this way, we get an error:\n", + "\n", + "```\n", + "let a = OurTrue\n", + "if a: print(\"It's true!\") # error: 'OurBool' does not implement the '__bool__' method\n", + "```\n", + "\n", + "When Mojo attempts to execute our program, it needs to be able to determine whether to print \"It's true!\" or not. It doesn't yet know that `OurBool` represents a boolean value -- Mojo just sees a struct that is 1 bit in size. However, Mojo also provides interfaces that convey boolean qualities, which are the same as those used by Mojo's standard library types, like `Bool`. In practice, this means Mojo gives you full control: any type that's packaged with the language's standard library is one for which you could define your own version.\n", + "\n", + "In the case of our error message, Mojo is telling us that implementing a `__bool__` method on `OurBool` would signify that it has boolean qualities.\n", + "\n", + "Thankfully, `__bool__` is simple to implement: Mojo's standard library and builtin types are all implemented on top of MLIR, and so the builtin `Bool` type also defines a constructor that takes an `i1`, just like `OurBool`:\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + " # ...\n", + "\n", + " fn __bool__(self) -> Bool:\n", + " return Bool(self.value)\n", + "```\n", + "\n", + "Now we can use `OurBool` anywhere we can use the builtin `Bool` type:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "It's true!\n" + ] + } + ], + "source": [ + "#| CHECK: It's true!\n", + "let g = OurTrue\n", + "if g: print(\"It's true!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Avoiding type conversion with `__mlir_i1__`\n", + "\n", + "Our `OurBool` type is looking great, and by providing a conversion to `Bool`, it can be used anywhere the builtin `Bool` type can. But in the last section we promised you \"full control,\" the ability to define your own version of any type built into Mojo or its standard library. Surely `Bool` doesn't implement `__bool__` to convert itself into `Bool`?\n", + "\n", + "Indeed it doesn't: when Mojo evaluates a conditional expression, it actually attempts to convert it to an MLIR `i1` value, by searching for the special interface method `__mlir_i1__`. (The automatic conversion to `Bool` occurs becasue `Bool` is known to implement the `__mlir_i1__` method.)\n", + "\n", + "Again, Mojo is designed to be extensible and modular. By implementing all the special methods `Bool` does, we can create a type that can replace it entirely. Let's do so by implementing `__mlir_i1__` on `OurBool`:\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + " # ...\n", + "\n", + " fn __mlir_i1__(self) -> __mlir_type.i1:\n", + " return self.value\n", + "```\n", + "\n", + "We can still use `OurBool` in conditionals just as we did before:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No more Bool conversion!\n" + ] + } + ], + "source": [ + "#| CHECK: No more Bool conversion!\n", + "let h = OurTrue\n", + "if h: print(\"No more Bool conversion!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But this time, no conversion to `Bool` occurs. You can try adding `print` statements to the `__bool__` and `__mlir_i1__` methods, or even removing the `__bool__` method entirely, to see for yourself." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding functionality with MLIR\n", + "\n", + "There are many more ways we can improve `OurBool`. Many of those involve implementing special methods, some of which you may recognize from Python, and some which are specific to Mojo. For example, we can implement inversion of a `OurBool` value by adding a `__invert__` method. We can also add an `__eq__` method, which allows two `OurBool` to be compared with the `==` operator.\n", + "\n", + "What sets Mojo apart is the fact that we can implement each of these using MLIR. To implement `__eq__`, for example, we use the [`index.casts`](https://mlir.llvm.org/docs/Dialects/IndexOps/#indexcasts-mlirindexcastsop) operation to cast our `i1` values to the MLIR index dialect's `index` type, and then the [`index.cmp`](https://mlir.llvm.org/docs/Dialects/IndexOps/#indexcmp-mlirindexcmpop) operation to compare them for equality:\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " var value: __mlir_type.i1\n", + " # ...\n", + "\n", + " fn __eq__(self, rhs: OurBool) -> Self:\n", + " let lhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](\n", + " self.value\n", + " )\n", + " let rhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](\n", + " rhs.value\n", + " )\n", + " return Self(\n", + " __mlir_op.`index.cmp`[\n", + " pred : __mlir_attr.`#index`\n", + " ](lhsIndex, rhsIndex)\n", + " )\n", + "```\n", + "\n", + "We can then implement `__invert__` in terms of `__eq__`:\n", + "\n", + "```\n", + "@register_passable(\"trivial\")\n", + "struct OurBool:\n", + " # ...\n", + " fn __invert__(self) -> Self:\n", + " return OurFalse if self == OurTrue else OurTrue\n", + "```\n", + "\n", + "This allows us to use the `~` operator with `OurBool`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "It's false!\n" + ] + } + ], + "source": [ + "#| CHECK: It's false!\n", + "let i = OurFalse\n", + "if ~i: print(\"It's false!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This extensible design is what allows even \"built in\" Mojo types like `Bool`, `Int`, and even `Tuple` (!!) to be implemented in the Mojo standard library in terms of MLIR, rather than hard-coded into the Mojo language. This also means that there's almost nothing that those types can achieve that user-defined types cannot.\n", + "\n", + "By extension, this means that the incredible performance that Mojo unlocks for machine learning workflows isn't due to some magic being performed behind a curtain -- you can define your own high-level types that, in their implementation, use low-level MLIR to achieve unprecedented speed and control." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The promise of modularity\n", + "\n", + "As we've seen, Mojo's integration with MLIR allows Mojo programmers to implement zero-cost abstractons on par with Mojo's own builtin and standard library types.\n", + "\n", + "MLIR is open-source and extensible: new dialects are being added all the time, and those dialects then become available to use in Mojo. All the while, Mojo code gets more powerful and more optimized for new hardware -- with no additional work necessary by Mojo programmers.\n", + "\n", + "What this means is that your own custom types, whether those be `OurBool` or `OurTensor`, can be used to provide programmers with an easy-to-use and unchanging interface. But behind the scenes, MLIR will optimize those convenient, high-level types for the computing environments of tomorrow.\n", + "\n", + "In other words: Mojo isn't magic, it's modular." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Mojo", + "language": "mojo", + "name": "mojo-jupyter-kernel" + }, + "language_info": { + "file_extension": ".mojo", + "mimetype": "text/x-mojo", + "name": "mojo" + }, + "vscode": { + "interpreter": { + "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/HelloMojo.ipynb b/examples/HelloMojo.ipynb new file mode 100644 index 000000000..7687f7f02 --- /dev/null +++ b/examples/HelloMojo.ipynb @@ -0,0 +1,45 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hello Mojo" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mojo is designed to be a super set of Python, and so many of the functions that you are already familiar with are present in Mojo. This document describes how to write a hello world program in Mojo." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IO import print \n", + "\n", + "#| CHECK: Hello Mojo!\n", + "print(\"Hello Mojo!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Matmul.ipynb b/examples/Matmul.ipynb new file mode 100644 index 000000000..fdd948cac --- /dev/null +++ b/examples/Matmul.ipynb @@ -0,0 +1,1240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matrix Multiplication" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook describes how to write a matrix multiplication (matmul) algorithm in Mojo. We will start with a pure Python implementation, transition to a naive implementation that is essentially a copy of the Python one, then add types, then continue the optimizations by vectorizing, tiling, and parallelizing the implementation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's define matrix multiplication. Given two dense matrices $A$ and $B$ of dimensions $M\\times K$ and $K\\times N$ respectively, we want to compute their dot product $C = A . B$ (also known as matmul). The dot product $C += A . B$ is defined by" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$C_{i,j} += \\sum_{k \\in [0 \\cdots K)} A_{i,k} B_{k,j}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The format of this demo is to start with an implementation which is identical to that of Python (effectively renaming the file extension), then look at how adding types to the implementation helps performance before extending the implementation by leveraging the vectorization and parallelization capabilities available on modern hardware. Throughout the execution, we report the GFlops achieved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Python Implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first implement matmul in Python directly from the definition." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%python\n", + "def matmul_python(C, A, B):\n", + " for m in range(C.rows):\n", + " for n in range(C.cols):\n", + " for k in range(A.cols):\n", + " C[m, n] += A[m, k] * B[k, n]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's benchmark our implementation using 128 by 128 square matrices and report the achieved GFLops." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%python\n", + "import numpy as np\n", + "from timeit import timeit\n", + "\n", + "class Matrix:\n", + " def __init__(self, value, rows, cols):\n", + " self.value = value\n", + " self.rows = rows\n", + " self.cols = cols\n", + " \n", + " def __getitem__(self, idxs):\n", + " return self.value[idxs[0]][idxs[1]]\n", + " \n", + " def __setitem__(self, idxs, value):\n", + " self.value[idxs[0]][idxs[1]] = value\n", + "\n", + "def benchmark_matmul_python(M, N, K):\n", + " A = Matrix(list(np.random.rand(M, K)), M, K)\n", + " B = Matrix(list(np.random.rand(K, N)), K, N)\n", + " C = Matrix(list(np.zeros((M, N))), M, N)\n", + " secs = timeit(lambda: matmul_python(C, A, B), number=2)/2\n", + " print(((2*M*N*K)/secs) / 1e9, \"GFLOP/s\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.005480328057626661 GFLOP/s\n" + ] + } + ], + "source": [ + "# %python # TODO: delete this once we switch to REPL in notebook testing (#12719).\n", + "benchmark_matmul_python(128, 128, 128)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing the Python implementation to Mojo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using Mojo is as simple as Python. First, let's include that modules from the Mojo stdlib that we are going to use:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from Benchmark import Benchmark\n", + "from DType import DType\n", + "from IO import print, _printf, _put_kgen_scalar\n", + "from Intrinsics import strided_load\n", + "from List import VariadicList, VariadicListMem\n", + "from Math import div_ceil\n", + "from Memory import memset_zero\n", + "from Object import object, Attr\n", + "from Pointer import DTypePointer\n", + "from Random import rand, random_f64\n", + "from Range import range\n", + "from SIMD import SIMD, F64, F32\n", + "from TargetInfo import dtype_sizeof\n", + "from Complex import ComplexSIMD as ComplexGenericSIMD\n", + "\n", + "alias python_gflops = F64(0.005480328057626661)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we can copy and paste our Python code. Mojo is a superset of Python, so the same Python code will run as Mojo code" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# This exactly the same Python implementation, \n", + "# but is infact Mojo code!\n", + "def matmul_untyped(C, A, B):\n", + " for m in range(C.rows):\n", + " for n in range(C.cols):\n", + " for k in range(A.cols):\n", + " C[m, n] += A[m, k] * B[k, n]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then benchmark the implementation. As before we use a 128 by 128 matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def matrix_getitem(self, i) -> object:\n", + " return self.value[i]\n", + "\n", + "\n", + "def matrix_setitem(self, i, value) -> object:\n", + " self.value[i] = value\n", + " return None\n", + "\n", + "\n", + "def matrix_append(self, value) -> object:\n", + " self.value.append(value)\n", + " return None\n", + "\n", + "\n", + "def matrix_init(rows: Int, cols: Int) -> object:\n", + " value = object([])\n", + " let getitem: object = __mlir_op.`kgen.addressof`[ _type : object.binary_function, callee:matrix_getitem, paramDecls : __mlir_attr.`#kgen`, ]()\n", + " let setitem: object = __mlir_op.`kgen.addressof`[ _type : object.ternary_function, callee:matrix_setitem, paramDecls : __mlir_attr.`#kgen`, ]()\n", + " let append: object = __mlir_op.`kgen.addressof`[ _type : object.binary_function, callee:matrix_append, paramDecls : __mlir_attr.`#kgen`, ]()\n", + " return object(\n", + " Attr(\"value\", value), Attr(\"__getitem__\", getitem), Attr(\"__setitem__\", setitem), \n", + " Attr(\"rows\", rows), Attr(\"cols\", cols), Attr(\"append\", append),\n", + " )\n", + "\n", + "def benchmark_matmul_untyped(M: Int, N: Int, K: Int):\n", + " C = matrix_init(M, N)\n", + " A = matrix_init(M, K)\n", + " B = matrix_init(K, N)\n", + " for i in range(M):\n", + " c = object([])\n", + " b = object([])\n", + " a = object([])\n", + " for j in range(N):\n", + " c.append(0.0)\n", + " b.append(random_f64(-5, 5))\n", + " a.append(random_f64(-5, 5))\n", + " C.append(c)\n", + " B.append(b)\n", + " A.append(a)\n", + "\n", + " fn test_fn():\n", + " try:\n", + " matmul_untyped(C, A, B)\n", + " except:\n", + " pass\n", + "\n", + " let secs = F64(Benchmark().run[test_fn]()) / 1_000_000_000\n", + " let gflops = ((2*M*N*K)/secs) / 1e9\n", + " _put_kgen_scalar[DType.f64](gflops.value)\n", + " _printf(\" GFLOP/s, a \")\n", + " let speedup : F64 = gflops / python_gflops\n", + " _printf(\"%0.2f\", speedup.value)\n", + " print(\"x speedup over Python\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.047082 GFLOP/s, a 8.59x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark_matmul_untyped(128, 128, 128)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note the huge speedup with no effort that we have gotten." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding types to the Python implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above program, while achieving better performance than Python is still not the best we can get from Mojo. If we tell Mojo the types of the inputs, it can optimize much of the code away and reduce cost due to dispatching (this is unlike Python which only uses types only for type checking), here Mojo is using the types for performance optimizations also." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To do that, let's first define a Matrix struct. The Matrix struct contains a data pointer along with a size field. While the Matrix struct can be parametrized on any data type, here we set the data type to be f32 for conciseness. The implementation is:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "struct Matrix:\n", + " var data: DTypePointer[DType.f32]\n", + " var rows: Int\n", + " var cols: Int\n", + "\n", + " fn __init__(self&, rows: Int, cols: Int):\n", + " self.data = DTypePointer[DType.f32].alloc(rows * cols)\n", + " rand(self.data, rows*cols)\n", + " self.rows = rows\n", + " self.cols = cols\n", + "\n", + " fn __del___(owned self):\n", + " self.data.free()\n", + "\n", + " fn zero(self&):\n", + " memset_zero(self.data, self.rows * self.cols * dtype_sizeof[DType.f32]())\n", + "\n", + " @always_inline\n", + " fn __getitem__(self, y: Int, x: Int) -> F32:\n", + " return self.load[1](y, x)\n", + "\n", + " @always_inline\n", + " fn load[nelts:Int](self, y: Int, x: Int) -> SIMD[DType.f32, nelts]:\n", + " return self.data.simd_load[nelts](y * self.cols + x)\n", + "\n", + " @always_inline\n", + " fn load_tr[nelts:Int](self, y: Int, x: Int) -> SIMD[DType.f32, nelts]:\n", + " # Perform a transposed simd load. \n", + " # return strided_load[nelts,DType.f32](self.data + x* dtype_sizeof[DType.f32](), self.cols)\n", + " var res = SIMD[DType.f32, nelts]()\n", + " res[0] = self[y + 0, x]\n", + " res[1] = self[y + 1, x]\n", + " res[2] = self[y + 2, x]\n", + " res[3] = self[y + 3, x]\n", + " res[4] = self[y + 4, x]\n", + " res[5] = self[y + 5, x]\n", + " res[6] = self[y + 6, x]\n", + " res[7] = self[y + 7, x]\n", + " return res\n", + "\n", + " @always_inline\n", + " fn __setitem__(self, y: Int, x: Int, val: F32):\n", + " return self.store[1](y, x, val)\n", + "\n", + " @always_inline\n", + " fn store[nelts:Int](self, y: Int, x: Int, val: SIMD[DType.f32, nelts]):\n", + " var data = self.data\n", + " data.simd_store[nelts](y * self.cols + x, val)\n", + "\n", + " def to_numpy(self) -> PythonObject:\n", + " let np = Python.import_module(\"numpy\")\n", + " var numpy_array = np.zeros((self.cols, self.rows), np.uint32)\n", + " for x in range(self.cols):\n", + " for y in range(self.rows):\n", + " numpy_array.itemset((y, x), self[x, y])\n", + " return numpy_array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Note that we implement `getitem` and `setitem` in terms of `load` and `store` while not important for the naive matmul, we will utilize it in the vectorized version of matmul. We are also defining a `load_tr` which loads a vector from the columns specified at the offset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the above Matrix type, we can effectively copy and paste the Python implementation and just add type annotations" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Note that C, A, and B have types.\n", + "def matmul_naive(C: Matrix, A: Matrix, B: Matrix):\n", + " for m in range(C.rows):\n", + " for n in range(C.cols):\n", + " for k in range(A.cols):\n", + " C[m, n] += A[m, k] * B[k, n]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are going to benchmark the implementations as we improve, so let's write a helper function that will do that for us: " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "@always_inline\n", + "def benchmark[func : __mlir_type[\n", + " `!kgen.signature<<>(`,\n", + " `!pop.pointer<`, Matrix,`>`, # C\n", + " ` borrow_in_mem,`,\n", + " `!pop.pointer<`, Matrix,`>`, # A\n", + " ` borrow_in_mem,`,\n", + " `!pop.pointer<`, Matrix,`>`, # B\n", + " ` borrow_in_mem) throws -> `,\n", + " `!pop.variant<`, Error, `,`, NoneType, `>`,\n", + " `>`,\n", + " ]](M : Int, N : Int, K : Int):\n", + " var C = Matrix(M, N)\n", + " C.zero()\n", + " var A = Matrix(M, K)\n", + " var B = Matrix(K, N)\n", + "\n", + " # func(C, A, B)\n", + " # print(C[10,4])\n", + "\n", + " @always_inline\n", + " fn test_fn():\n", + " try:\n", + " func(C, A, B)\n", + " except:\n", + " pass\n", + "\n", + " let secs = F64(Benchmark().run[test_fn]()) / 1_000_000_000\n", + " let gflops = ((2*M*N*K)/secs) / 1e9\n", + " _put_kgen_scalar[DType.f64](gflops.value)\n", + " _printf(\" GFLOP/s, a \")\n", + " let speedup : F64 = gflops / python_gflops\n", + " _printf(\"%0.2f\", speedup.value)\n", + " print(\"x speedup over Python\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Benchmarking the results shows significant speedups. We increase the size of the matrix to 512 by 512, since Mojo is much faster than Python." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.702316 GFLOP/s, a 310.62x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_naive](512, 512, 512)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adding types gives around a huge improvement over the untyped version" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vectorizing the inner most loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can do better than the above implementation by utilizing the vector instructions. Assuming a vector width of 8, we can modify the code to the following to leverage the simd instructions:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Mojo has SIMD vector types, we can vectorize the \n", + "# Matmul code as follows.\n", + "alias nelts = 8 # The SIMD vector width.\n", + "def matmul_vectorized_0(C: Matrix, A: Matrix, B: Matrix):\n", + " for m in range(C.rows):\n", + " for n in range(C.cols):\n", + " var tmp = SIMD[DType.f32, nelts]()\n", + " for kv in range(0, A.cols, nelts):\n", + " tmp += A.load[nelts](m,kv) * B.load_tr[nelts](kv,n)\n", + " C[m,n] += tmp.reduce_add()\n", + " \n", + " # Handle remaining elements with scalars.\n", + " for k in range(nelts*(A.cols//nelts), A.cols):\n", + " C[m,n] += A[m,k] * B[k,n]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can benchmark the above implementation. Note that many compilers can detect the naive loop and perform optimizations. Mojo allows you to be explicit however. In this case the compiler heuristics were better than what we wrote." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.136114 GFLOP/s, a 572.25x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_vectorized_0](512, 512, 512)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since vectorization is a common optimization, Mojo provides a higher-order function that performs vectorization for you. The vectorization function takes a vector width and a function which is parameteric on the vector width and is going to be evaluated in a vectorized manner." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Simplify the code by using the builtin vectorize function\n", + "from Functional import vectorize\n", + "def matmul_vectorized_1(C: Matrix, A: Matrix, B: Matrix):\n", + " for m in range(C.rows):\n", + " for n in range(C.cols):\n", + " fn dot[nelts : Int](k : Int):\n", + " C[m,n] += (A.load[nelts](m,k) * B.load_tr[nelts](k,n)).reduce_add()\n", + " vectorize[nelts, dot](A.cols)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is only a slight difference in terms of performance between the two implementations:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.125112 GFLOP/s, a 570.27x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_vectorized_1](512, 512, 512)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parallelizing Matmul" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the best performance from modern processors, one has to utilizing the multiple cores they provide you. We can parallelize the matmul algorithm above using the `parallelize` function. We can adjust the program above to be multi-threaded and run across cores using the `parallelize` function. For simplicity, we only `parallelize` on the M dimension:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Parallelize the code by using the builtin parallelize function\n", + "from Functional import parallelize\n", + "def matmul_parallelized(C: Matrix, A: Matrix, B: Matrix):\n", + " fn calc_row(m: Int):\n", + " for n in range(C.cols):\n", + " fn dot[nelts : Int](k : Int):\n", + " C[m,n] += (A.load[nelts](m,k) * B.load_tr[nelts](k,n)).reduce_add()\n", + " vectorize[nelts, dot](A.cols)\n", + " \n", + " parallelize[calc_row](C.rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can benchmark the parallel matmul implementation. Again, we increase the size of the matrix to 1024 by 1024, since this implementation is much faster than the unvectorized version." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11.388119 GFLOP/s, a 2078.00x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_parallelized](1024, 1024, 1024)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tiling Matmul" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tiling is an optimization performed for matmul to increase cache locality. The idea is to keep sub-matrices resident in the cache and increase the reuse. The tile function itself can be written in Mojo as:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from Functional import Static2DTileUnitFunc as Tile2DFunc" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Perform 2D tiling on the iteration space defined by end_x and end_y.\n", + "fn tile[tiled_fn: Tile2DFunc, tile_x: Int, tile_y: Int](end_x: Int, end_y: Int):\n", + " # Note: this assumes that ends are multiples of the tiles.\n", + " for y in range(0, end_y, tile_y):\n", + " for x in range(0, end_x, tile_x):\n", + " tiled_fn[tile_x, tile_y](x, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above will perform 2 dimensional tiling over a 2D iteration space defined to be between $([0, end_x], [0, end_y])$. Once we define it above, we can use it within our matmul kernel. For simplicity we We choose 2 as the tile height and since we also want to vectorize we use `2 * nelts` as the tile width (since we vectorize on the columns)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Use the above tile function to perform tiled matmul.\n", + "def matmul_tiled_parallelized(C: Matrix, A: Matrix, B: Matrix):\n", + " fn calc_row(m: Int):\n", + " fn calc_tile[tile_x: Int, tile_y: Int](x: Int, y: Int):\n", + " for n in range(y, y + tile_y):\n", + " fn dot[nelts: Int](k: Int):\n", + " C[m,n] += (A.load[nelts](m,k+x) * B.load_tr[nelts](k+x,n)).reduce_add()\n", + " vectorize[nelts, dot](tile_x)\n", + " \n", + " # We hardcode the tile factor to be 16.\n", + " alias tile_size = 16\n", + " tile[calc_tile, nelts * tile_size, tile_size](C.cols, A.cols)\n", + "\n", + " parallelize[calc_row](C.rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can benchmark the parallel matmul implementation:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11.896004 GFLOP/s, a 2170.67x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_tiled_parallelized](1024, 1024, 1024)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One source of overhead in the above implementation is the fact that the we are not unrolling the loops introduced by vectorize of the dot function. We can do that via the `vectorize_unroll` higher-order function in Mojo:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Unroll the vectorized loop by a constant factor.\n", + "from Functional import vectorize_unroll\n", + "def matmul_tiled_unrolled_parallelized(C: Matrix, A: Matrix, B: Matrix):\n", + " fn calc_row(m: Int):\n", + " fn calc_tile[tile_x: Int, tile_y: Int](x: Int, y: Int):\n", + " for n in range(y, y + tile_y):\n", + " fn dot[nelts : Int](k : Int):\n", + " C[m,n] += (A.load[nelts](m,k+x) * B.load_tr[nelts](k+x,y)).reduce_add()\n", + " \n", + " # Vectorize by nelts and unroll by tile_x/nelts\n", + " # Here unroll factor is 16/8 = 2\n", + " vectorize_unroll[nelts, tile_x//nelts, dot](tile_x)\n", + "\n", + " alias tile_size = 16\n", + " tile[calc_tile, nelts*tile_size, tile_size](A.cols, C.cols)\n", + " \n", + " parallelize[calc_row](C.rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can benchmark the parallel matmul implementation:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.243320 GFLOP/s, a 2234.05x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_tiled_unrolled_parallelized](1024, 1024, 1024)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Searching for the `tile_factor`" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from Autotune import autotune, search\n", + "from Time import now\n", + "from Pointer import Pointer\n", + "\n", + "alias matmul_fn_type = __mlir_type[\n", + " `( `,\n", + " Pointer[Matrix].pointer_type,\n", + " `, `,\n", + " Pointer[Matrix].pointer_type,\n", + " `, `,\n", + " Pointer[Matrix].pointer_type,\n", + " `) -> `, NoneType\n", + "]\n", + "alias matmul_fn_sig_type = __mlir_type[\n", + " `!kgen.signature<<>(`,\n", + " `!pop.pointer<`, Matrix,`>`, # C\n", + " ` borrow_in_mem,`,\n", + " `!pop.pointer<`, Matrix,`>`, # A\n", + " ` borrow_in_mem,`,\n", + " `!pop.pointer<`, Matrix,`>`, # B\n", + " ` borrow_in_mem) -> `, NoneType,\n", + " `>`,\n", + " ]\n", + "\n", + "alias matmul_fn_ptr_type = __mlir_type[`!pop.pointer<`, matmul_fn_sig_type, `>`]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The choice of the tile factor can greatly impact the performace of the full matmul,\n", + "but the optimal tile factor is highly hardware-dependant, and is influenced by the\n", + "cache configuration and other hard-to-model effects. We want write to write portable code\n", + "without knowing everything about the hardware, so we can ask Mojo to automatically\n", + "select the best tile factor using autotuning." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Autotune the tile size used in the matmul.\n", + "@adaptive\n", + "fn matmul_autotune_impl(C: Matrix, A: Matrix, B: Matrix):\n", + " fn calc_row(m: Int):\n", + " fn calc_tile[tile_x: Int, tile_y: Int](x: Int, y: Int):\n", + " for n in range(y, y + tile_y):\n", + " fn dot[nelts : Int](k : Int):\n", + " C[m,n] += (A.load[nelts](m,k+x) * B.load_tr[nelts](k+x,y)).reduce_add()\n", + " vectorize_unroll[nelts, tile_x // nelts, dot](tile_x)\n", + "\n", + " # Instead of hardcoding to tile_size = 16, search for the fastest \n", + " # tile size by evaluting this function as tile size varies.\n", + " alias tile_size = autotune(1, 2, 4, 8, 16, 32, 64)\n", + " tile[calc_tile, nelts * tile_size, tile_size](A.cols, C.cols)\n", + " \n", + " parallelize[calc_row](C.rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will generate multiple candidates for the matmul function. To teach Mojo how\n", + "to find the best tile factor, we provide an evaluator function Mojo can use to\n", + "measure each candidate." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "fn matmul_evaluator(funcs: matmul_fn_ptr_type, size: Int) -> Int:\n", + " print(\"matmul_evaluator, number of candidates: \")\n", + " print(size)\n", + "\n", + " let eval_begin: Int = now()\n", + "\n", + " # This size is picked at random, in real code we could use a real size\n", + " # distribution here.\n", + " print(\"Optimizing for size: \")\n", + " let M = 1024\n", + " let N = 1024\n", + " let K = 1024\n", + " print(M)\n", + " print(N)\n", + " print(K)\n", + "\n", + " var best_idx: Int = -1\n", + " var best_time: Int = -1\n", + " var funcs_ptr = Pointer[matmul_fn_sig_type](funcs).bitcast[matmul_fn_type]()\n", + "\n", + " alias eval_iterations = 10\n", + " alias eval_samples = 10\n", + "\n", + " var C = Matrix(M, N)\n", + " var A = Matrix(M, K)\n", + " var B = Matrix(K, N)\n", + " let Cptr = Pointer[Matrix].address_of(C).address\n", + " let Aptr = Pointer[Matrix].address_of(A).address\n", + " let Bptr = Pointer[Matrix].address_of(B).address\n", + "\n", + " # Find the function that's the fastest on the size we're optimizing for\n", + " for f_idx in range(size):\n", + " let func = funcs_ptr.load(f_idx)\n", + "\n", + " @always_inline\n", + " fn wrapper():\n", + " __mlir_op.`pop.call_indirect`[_type:NoneType](\n", + " func, Cptr, Aptr, Bptr\n", + " )\n", + " let cur_time = Benchmark(1, 100_000, 500_000_000, 1000_000_000).run[wrapper]()\n", + "\n", + " if best_idx < 0:\n", + " best_idx = f_idx\n", + " best_time = cur_time\n", + " if best_time > cur_time:\n", + " best_idx = f_idx\n", + " best_time = cur_time\n", + "\n", + " let eval_end: Int = now()\n", + " print(\"Time spent in matmul_evaluator, ms: \")\n", + " print((eval_end - eval_begin) // 1000000)\n", + "\n", + " print(\"Best candidate idx:\")\n", + " print(best_idx)\n", + " return best_idx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we need to define an entry function that would simply call the best candidate." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def matmul_autotune(C: Matrix, A: Matrix, B: Matrix):\n", + " alias best_impl: matmul_fn_sig_type\n", + " search[\n", + " matmul_fn_sig_type,\n", + " VariadicList(matmul_autotune_impl.__adaptive_set),\n", + " matmul_evaluator -> best_impl\n", + " ]()\n", + " # Run the best candidate\n", + " return best_impl(C, A, B)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's benchmark our new implementation:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22.824017 GFLOP/s, a 4164.72x speedup over Python\n" + ] + } + ], + "source": [ + "benchmark[matmul_autotune](1024, 1024, 1024)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mandelbrot in Mojo, Plotting in Python\n", + "\n", + "Mojo is great at compute and writing high-performance code, but Python has a huge ecosystem of libraries and tools. With seamless Python interoperability, Mojo can leverage Python for what it's good at, especially GUIs, with out sacrificing performance in critical code. Let's take the classic mandelbrot set algorithm and implement it in Mojo.\n", + "\n", + "We'll introduce a `Complex` type and use it in our implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "@register_passable(\"trivial\")\n", + "struct Complex:\n", + " var real: F32\n", + " var imag: F32\n", + "\n", + " fn __init__(real: F32, imag: F32) -> Self:\n", + " return Self {real: real, imag: imag}\n", + "\n", + " fn __add__(lhs, rhs: Self) -> Self:\n", + " return Self(lhs.real + rhs.real, lhs.imag + rhs.imag)\n", + "\n", + " fn __mul__(lhs, rhs: Self) -> Self:\n", + " return Self(\n", + " lhs.real * rhs.real - lhs.imag * rhs.imag,\n", + " lhs.real * rhs.imag + lhs.imag * rhs.real,\n", + " )\n", + "\n", + " fn norm(self) -> F32:\n", + " return self.real * self.real + self.imag * self.imag" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can write the core mandelbrot algorithm, which involves computing an iterative complex function for each pixel until it \"escapes\" the complex circle of radius 2, counting the number of iterations to escape.\n", + "\n", + "$$z_{i+1} = (z_i)^2 + c$$" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "alias xmin: F32 = -2.25\n", + "alias xmax: F32 = 0.75\n", + "alias xn = 1500\n", + "alias ymin: F32 = -1.25\n", + "alias ymax: F32 = 1.25\n", + "alias yn = 1250\n", + "\n", + "# Compute the number of steps to escape.\n", + "def mandlebrot_kernel(c: Complex) -> Int:\n", + " max_iter = 200\n", + " z = c\n", + " for i in range(max_iter):\n", + " z = z * z + c\n", + " if z.norm() > 4:\n", + " return i\n", + " return max_iter\n", + "\n", + "\n", + "def compute_mandlebrot() -> Matrix:\n", + " # create a matrix. Each element of the matrix corresponds to a pixel\n", + " result = Matrix(xn, yn)\n", + "\n", + " cnt = 0\n", + " x = xmin\n", + " dx = (xmax - xmin) / xn\n", + " dy = (ymax - ymin) / yn\n", + " for i in range(xn):\n", + " y = ymin\n", + " for j in range(yn):\n", + " result[i, j] = mandlebrot_kernel(Complex(x, y))\n", + " y += dy\n", + " x += dx\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting the number of iterations to escape with some color gives us the canonical mandelbrot set plot. We can directly leverage Python's `matplotlib` from Mojo to do our plotting!" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def to_numpy(m: Matrix) -> PythonObject:\n", + " let np = Python.import_module(\"numpy\")\n", + " var numpy_array = np.zeros((yn, xn), np.uint32)\n", + " for x in range(xn):\n", + " for y in range(yn):\n", + " numpy_array.itemset((y, x), m[x, y])\n", + " return numpy_array" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "np = Python.import_module(\"numpy\")\n", + "plt = Python.import_module(\"matplotlib.pyplot\")\n", + "colors = Python.import_module(\"matplotlib.colors\")\n", + "\n", + "result = compute_mandlebrot()\n", + "dpi = 72\n", + "width = 10\n", + "height = 10 * yn // xn\n", + "\n", + "fig = plt.figure(1, [width, height], dpi)\n", + "ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], False, 1)\n", + "\n", + "light = colors.LightSource(315, 10, 0, 1, 1, 0)\n", + "image = light.shade(\n", + " result.to_numpy(), plt.cm.hot, colors.PowerNorm(0.3), \"hsv\", 0, 0, 1.5\n", + " )\n", + "plt.imshow(image)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "We showed a naive implementation of the mandelbrot algorithm, but there are two things we can do to speed it up. We can early-stop the loop iteration when a pixel is known to have escaped, and we can leverage Mojo's access to hardware by vectorizing the loop, computing multiple pixels simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Some aliases to make the code easier to read\n", + "alias ComplexSIMD = ComplexGenericSIMD[DType.f32, 8]\n", + "alias NumStepsSIMD = SIMD[DType.si64, 8]\n", + "\n", + "# Multi-element mandlebrot with early-stop optimization.\n", + "def mandlebrot_kernel_simd(c: ComplexSIMD, iter: Int) -> NumStepsSIMD:\n", + " z = c\n", + " nv = NumStepsSIMD(0)\n", + " done_mask = SIMD[DType.bool, 8](0)\n", + "\n", + " i = 100\n", + " while i != 0 and done_mask:\n", + " done_mask = z.norm() > 4 \n", + " z = z*z + c\n", + " nv = done_mask.select(nv, nv + 1)\n", + " i -= 1\n", + " return nv" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Mojo", + "language": "mojo", + "name": "mojo-jupyter-kernel" + }, + "language_info": { + "codemirror_mode": { + "name": "mojo" + }, + "file_extension": ".mojo", + "mimetype": "text/x-mojo", + "name": "mojo" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/Memset.ipynb b/examples/Memset.ipynb new file mode 100644 index 000000000..aa148b82b --- /dev/null +++ b/examples/Memset.ipynb @@ -0,0 +1,674 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fast Memset in Mojo" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial we will implement a memset version optimized for small sizes\n", + "using Mojo's autotuning feature.\n", + "\n", + "The idea behind the implementation is based on Nadav Rotem's work [[1](https://github.com/nadavrot/memset_benchmark)], and is also well-described in [[2](https://storage.googleapis.com/pub-tools-public-publication-data/pdf/4f7c3da72d557ed418828823a8e59942859d677f.pdf)].\n", + "\n", + "Below we try to briefly summarize the approach." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## High-level overview\n", + "\n", + "For the best memset performance we want to use the widest possible register\n", + "width for the memory access. For instance, if we want to store 19 bytes, we\n", + "want to use vector width 16 and use two overlapping stores. To store 9 bytes,\n", + "we would want to use two 8-byte stores.\n", + "\n", + "However, before we get to actually doing stores, we need to perform size\n", + "checks to make sure that we're in the right range. I.e. we want to use 8\n", + "bytes stores for sizes 8-16, 16 bytes stores for sizes 16-32, etc.\n", + "\n", + "The order in which we do the size checks significantly affects performance\n", + "and ideally we would like to run as few checks as possible for the sizes\n", + "that occur most often. I.e. if most of the sizes we see are 16-32, then we\n", + "want to first check if it's within that range before we check if it's in\n", + "8-16 or some other range.\n", + "\n", + "This results in a number of different comparison \"trees\" that can be used to\n", + "perform the size checks, and in this tutorial we use Mojo's autotuning to pick\n", + "the most optimal one given the distribution of input data." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementation\n", + "\n", + "We will start as we always start - with imports and type aliases." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from Assert import assert_param\n", + "from Autotune import autotune_fork, search\n", + "from DType import DType\n", + "from IO import print, _printf, put\n", + "from List import VariadicList\n", + "from Math import min, max\n", + "from Memory import _malloc, _free\n", + "from OS import getenv\n", + "from Pointer import DTypePointer, Pointer\n", + "from Range import range\n", + "from SIMD import SIMD\n", + "from Sort import sort\n", + "from String import StringRef\n", + "from TargetInfo import sizeof\n", + "from Time import now\n", + "from Vector import DynamicVector\n", + "\n", + "alias UI8 = DType.ui8\n", + "alias BufferPtrType = DTypePointer[UI8]\n", + "alias ValueType = SIMD[UI8, 1]\n", + "alias NoneType = __mlir_type.`!lit.none`\n", + "\n", + "alias memset_fn_type = __mlir_type[\n", + " `(`, BufferPtrType, `, `, ValueType, `, `, Int, `) -> `, NoneType\n", + "]\n", + "alias memset_fn_sig_type = __mlir_type[\n", + " `!kgen.signature<(`,\n", + " BufferPtrType,\n", + " ` borrow, `,\n", + " ValueType,\n", + " ` borrow, `,\n", + " Int,\n", + " ` borrow) -> `,\n", + " NoneType, `>`\n", + "]\n", + "alias memset_fn_ptr_type = __mlir_type[\n", + " `!pop.pointer<`,\n", + " memset_fn_sig_type,\n", + " `>`\n", + "]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's add some auxiliary function. We will use them to benchmark various\n", + "memset implementations and visualize results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fn optimization_barrier(ptr: BufferPtrType):\n", + " __mlir_op.`pop.inline_asm`[\n", + " _type:None,\n", + " assembly:(\"\").value,\n", + " constraints:(\"r,~{memory}\").value,\n", + " hasSideEffects : __mlir_attr.unit,\n", + " ](ptr.address)\n", + "\n", + "\n", + "fn alloc_buffer(size: Int) -> BufferPtrType:\n", + " let data_mem = _malloc[ValueType](sizeof[ValueType]() * size)\n", + " return DTypePointer[UI8.value](data_mem.address)\n", + "\n", + "\n", + "fn free_buffer(ptr: BufferPtrType):\n", + " _free[ValueType](ptr.as_scalar_pointer())\n", + "\n", + "\n", + "fn measure_time(\n", + " func: memset_fn_type, size: Int, ITERS: Int, SAMPLES: Int\n", + ") -> Int:\n", + " alias alloc_size = 1024 * 1024\n", + " var ptr = alloc_buffer(alloc_size)\n", + "\n", + " var samples = DynamicVector[Int](SAMPLES)\n", + "\n", + " for sample in range(SAMPLES):\n", + " let tic = now()\n", + " for iter in range(ITERS):\n", + " # Offset pointer to shake up cache a bit\n", + " var offset_ptr = ptr.offset((iter * 128) & 1024)\n", + "\n", + " # Just in case compiler will try to outsmart us and avoid repeating\n", + " # memset, change the value we're filling with\n", + " var v = ValueType(iter&255)\n", + "\n", + " # Actually call the memset function\n", + " __mlir_op.`pop.call_indirect`[_type:NoneType](\n", + " func, offset_ptr, v.value, size\n", + " )\n", + "\n", + " # Insert optimization barriers to prevent compiler from optimizing\n", + " # this loop away\n", + " optimization_barrier(ptr)\n", + " optimization_barrier(offset_ptr)\n", + "\n", + " let toc = now()\n", + " samples.push_back(toc - tic)\n", + "\n", + " # Find median across the samples\n", + " sort(samples)\n", + " let result = samples[SAMPLES // 2]\n", + "\n", + " samples.__del__()\n", + " free_buffer(ptr)\n", + " return result\n", + "\n", + "\n", + "fn visualize_result(size: Int, result: Int):\n", + " _printf(\"Size: \")\n", + " if size < 10:\n", + " _printf(\" \")\n", + " put(size)\n", + " _printf(\" |\")\n", + " for _ in range(result // 10000):\n", + " _printf(\"*\")\n", + " print(\"\")\n", + "\n", + "\n", + "fn benchmark(func: memset_fn_type, title: StringRef):\n", + " print(\"\\n================\")\n", + " print(title)\n", + " print(\"----------------\\n\")\n", + "\n", + " alias warmup_iterations = 100\n", + " alias benchmark_iterations = 100000\n", + " alias benchmark_samples = 5\n", + "\n", + " for size in range(35):\n", + " # Warmup\n", + " let _ = measure_time(func, size, warmup_iterations, 1)\n", + "\n", + " # Actual run\n", + " let result = measure_time(\n", + " func, size, benchmark_iterations, benchmark_samples\n", + " )\n", + "\n", + " visualize_result(size, result)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reproducing results from the paper\n", + "\n", + "Let's implement a memset version from the paper in Mojo and compare it against\n", + "the system memset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@always_inline\n", + "fn overlapped_store[\n", + " width: Int\n", + "](ptr: BufferPtrType, value: ValueType, count: Int):\n", + " let v = SIMD.splat[UI8, width](value)\n", + " ptr.simd_store[width](v)\n", + " ptr.simd_store[width](count - width, v)\n", + "\n", + "\n", + "fn memset_manual(ptr: BufferPtrType, value: ValueType, count: Int):\n", + " if count < 32:\n", + " if count < 5:\n", + " if count == 0:\n", + " return\n", + " # 0 < count <= 4\n", + " ptr.store(0, value)\n", + " ptr.store(count - 1, value)\n", + " if count <= 2:\n", + " return\n", + " ptr.store(1, value)\n", + " ptr.store(count - 2, value)\n", + " return\n", + "\n", + " if count <= 16:\n", + " if count >= 8:\n", + " # 8 <= count < 16\n", + " overlapped_store[8](ptr, value, count)\n", + " return\n", + " # 4 < count < 8\n", + " overlapped_store[4](ptr, value, count)\n", + " return\n", + "\n", + " # 16 <= count < 32\n", + " overlapped_store[16](ptr, value, count)\n", + " else:\n", + " # 32 < count\n", + " memset_system(ptr, value, count)\n", + "\n", + "\n", + "fn memset_system(ptr: BufferPtrType, value: ValueType, count: Int):\n", + " __mlir_op.`pop.memset`(ptr.address, value.value, count.__as_mlir_index())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| CHECK: Manual memset\n", + "#| CHECK: System memset\n", + "let fptr_manual = __mlir_op.`kgen.addressof`[\n", + " _type:memset_fn_type,\n", + " callee:memset_manual,\n", + " paramDecls : __mlir_attr.`#kgen`,\n", + "]()\n", + "let fptr_system = __mlir_op.`kgen.addressof`[\n", + " _type:memset_fn_type,\n", + " callee:memset_system,\n", + " paramDecls : __mlir_attr.`#kgen`,\n", + "]()\n", + "benchmark(fptr_manual, \"Manual memset\")\n", + "benchmark(fptr_system, \"System memset\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tweaking the implementation for different sizes\n", + "\n", + "We can see that it's already much faster for small sizes.\n", + "That version was specifically optimized for a certain input size distribution,\n", + "e.g. we can see that sizes 8-16 and 0-4 work fastest.\n", + "\n", + "But what if in **our use case** the distribution is different? Let's imagine that\n", + "in our case the most common sizes are 16-32 - is this version the most optimal\n", + "version we can use then? The answer is obviously \"no\", and we can easily tweak\n", + "the implementation to work better for these sizes - we just need to move the\n", + "corresponding check closer to the beginning of the function. E.g. like so:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fn memset_manual_2(ptr: BufferPtrType, value: ValueType, count: Int):\n", + " if count < 32:\n", + " if count >= 16:\n", + " # 16 <= count < 32\n", + " overlapped_store[16](ptr, value, count)\n", + " return\n", + "\n", + " if count < 5:\n", + " if count == 0:\n", + " return\n", + " # 0 < count <= 4\n", + " ptr.store(0, value)\n", + " ptr.store(count - 1, value)\n", + " if count <= 2:\n", + " return\n", + " ptr.store(1, value)\n", + " ptr.store(count - 2, value)\n", + " return\n", + "\n", + " if count >= 8:\n", + " # 8 <= count < 16\n", + " overlapped_store[8](ptr, value, count)\n", + " return\n", + " # 4 < count < 8\n", + " overlapped_store[4](ptr, value, count)\n", + "\n", + " else:\n", + " # 32 < count\n", + " memset_system(ptr, value, count)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the performance of this version." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| CHECK: Manual memset v2\n", + "let fptr_manual_2 = __mlir_op.`kgen.addressof`[\n", + " _type:memset_fn_type,\n", + " callee:memset_manual_2,\n", + " paramDecls : __mlir_attr.`#kgen`,\n", + "]()\n", + "benchmark(fptr_manual_2, \"Manual memset v2\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The performance is now much better on the 16-32 sizes!\n", + "\n", + "The problem is that we had to manually re-write the code. Wouldn't it be nice\n", + "if it was done automatically?\n", + "\n", + "In Mojo this is possible (and quite easy) - we can generate multiple\n", + "implementations and let the compiler pick the fastest one for us evaluating\n", + "them on sizes we want!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mojo implementation\n", + "\n", + "Let's dive into that.\n", + "\n", + "The first thing we need to do is to generate all possible candidates. To do\n", + "that we will need to iteratively generate size checks to understand what size\n", + "for the overlapping store we can use. Once we localize the size interval, we\n", + "just call the overlapping store of the corresponding size.\n", + "\n", + "To express this we will implement an adaptive function `memset_impl_layer` two\n", + "parameters designating the current interval of possible size values. When we\n", + "generate a new size check, we split that interval into two parts and\n", + "recursively call the same functions on those two parts. Once we reach the\n", + "minimal intervals, we will call the corresponding overlapped_store function.\n", + "\n", + "This first implementation covers minimal interval cases:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@adaptive\n", + "@always_inline\n", + "fn memset_impl_layer[\n", + " lower: Int, upper: Int\n", + "](ptr: BufferPtrType, value: ValueType, count: Int):\n", + " @parameter\n", + " if (lower == -100) & (upper == 0):\n", + " pass\n", + " elif (lower == 0) & (upper == 4):\n", + " ptr.store(0, value)\n", + " ptr.store(count - 1, value)\n", + " if count <= 2:\n", + " return\n", + " ptr.store(1, value)\n", + " ptr.store(count - 2, value)\n", + " elif (lower == 4) & (upper == 8):\n", + " overlapped_store[4](ptr, value, count)\n", + " elif (lower == 8) & (upper == 16):\n", + " overlapped_store[8](ptr, value, count)\n", + " elif (lower == 16) & (upper == 32):\n", + " overlapped_store[16](ptr, value, count)\n", + " elif (lower == 32) & (upper == 100):\n", + " memset_system(ptr, value, count)\n", + " else:\n", + " assert_param[False]()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now add an implementation for the other case, where we need to generate a\n", + "size check." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@adaptive\n", + "@always_inline\n", + "fn memset_impl_layer[\n", + " lower: Int, upper: Int\n", + "](ptr: BufferPtrType, value: ValueType, count: Int):\n", + " alias cur: Int\n", + " autotune_fork[Int, 0, 4, 8, 16, 32 -> cur]()\n", + "\n", + " assert_param[cur > lower]()\n", + " assert_param[cur < upper]()\n", + "\n", + " if count > cur:\n", + " memset_impl_layer[max(cur, lower), upper](ptr, value, count)\n", + " else:\n", + " memset_impl_layer[lower, min(cur, upper)](ptr, value, count)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we use 'autotune_fork' to generate all possible at that point checks.\n", + "\n", + "We will discard values beyond the current interval, and for the values within\n", + "we will recursively call this function on the interval splits.\n", + "\n", + "This is sufficient to generate multiple correct versions of memset, but to\n", + "achieve the best performance we need to take into account one more factor: when\n", + "we're dealing with such small sizes, even the code location matters a lot. E.g.\n", + "if we swap Then and Else branches and invert the condition, we might get a\n", + "different performance of the final function.\n", + "\n", + "To account for that, let's add one more implementation of our function, but now\n", + "with branches swapped:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@adaptive\n", + "@always_inline\n", + "fn memset_impl_layer[\n", + " lower: Int, upper: Int\n", + "](ptr: BufferPtrType, value: ValueType, count: Int):\n", + " alias cur: Int\n", + " autotune_fork[Int, 0, 4, 8, 16, 32 -> cur]()\n", + "\n", + " assert_param[cur > lower]()\n", + " assert_param[cur < upper]()\n", + "\n", + " if count <= cur:\n", + " memset_impl_layer[lower, min(cur, upper)](ptr, value, count)\n", + " else:\n", + " memset_impl_layer[max(cur, lower), upper](ptr, value, count)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We defined building blocks for our implementation, now we need to add a top\n", + "level entry-point that will kick off the recursion we've just defined.\n", + "\n", + "We will simply call our function with [-100,100] interval - -100 and 100 simply\n", + "designate that no checks have been performed yet. This interval will be refined\n", + "as we generate more and more check until we have enough to emit actual stores." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@adaptive\n", + "fn memset_autotune_impl(ptr: BufferPtrType, value: ValueType, count: Int):\n", + " memset_impl_layer[-100, 100](ptr, value, count)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ok, we're done with our memset implementation, now we just need to plug it to\n", + "autotuning infrastructure to let the Mojo compiler do the search and pick the\n", + "best implementation.\n", + "\n", + "To do that, we need to define an evaluator - this is a function that will take\n", + "an array of function pointers to all implementations of our function and will\n", + "need to return an index of the best candidate.\n", + "\n", + "There are no limitations in how this function can be implemented - it can\n", + "return the first or a random candidate, or it can actually benchmark all of\n", + "them and pick the fastest - this is what we're going to do for this example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fn memset_evaluator(funcs: memset_fn_ptr_type, size: Int) -> Int:\n", + "\n", + " print(\"memset_evaluator, number of candidates: \")\n", + " print(size)\n", + " let eval_begin: Int = now()\n", + "\n", + " # This size is picked at random, in real code we could use a real size\n", + " # distribution here.\n", + " print(\"Optimizing for size: \")\n", + " let size_to_optimize_for = 17\n", + " print(size_to_optimize_for)\n", + "\n", + " var best_idx: Int = -1\n", + " var best_time: Int = -1\n", + " var funcs_ptr = Pointer[memset_fn_sig_type](funcs).bitcast[memset_fn_type]()\n", + "\n", + " alias eval_iterations = 10000\n", + " alias eval_samples = 10\n", + "\n", + " # Find the function that's the fastest on the size we're optimizing for\n", + " for f_idx in range(size):\n", + " let func = funcs_ptr.load(f_idx)\n", + " let cur_time = measure_time(\n", + " func, size_to_optimize_for, eval_iterations, eval_samples\n", + " )\n", + " if best_idx < 0:\n", + " best_idx = f_idx\n", + " best_time = cur_time\n", + " if best_time > cur_time:\n", + " best_idx = f_idx\n", + " best_time = cur_time\n", + "\n", + " let eval_end: Int = now()\n", + " print(\"Time spent in memset_evaluator, ms: \")\n", + " print((eval_end - eval_begin) // 1000000)\n", + "\n", + " return best_idx" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The evaluator is ready, the last brush stroke is to add a function that will\n", + "call the best candidate.\n", + "\n", + "The search will be performed at compile time, and at runtime we will go\n", + "directly to the best implementation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fn memset_autotune(ptr: BufferPtrType, value: ValueType, count: Int):\n", + " # Get the set of all candidates\n", + " alias candidates = memset_autotune_impl.__adaptive_set\n", + "\n", + " # Use the evaluator to select the best candidate.\n", + " alias best_impl: memset_fn_sig_type\n", + " search[memset_fn_sig_type, VariadicList(candidates), memset_evaluator -> best_impl]()\n", + "\n", + " # Run the best candidate\n", + " return best_impl(ptr, value, count)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now ready to benchmark our function, let's see how its performance looks!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| CHECK: Mojo autotune memset\n", + "let fptr_autotune = __mlir_op.`kgen.addressof`[\n", + " _type:memset_fn_type,\n", + " callee:memset_autotune,\n", + " paramDecls : __mlir_attr.`#kgen`,\n", + "]()\n", + "benchmark(fptr_autotune, \"Mojo autotune memset\")" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/index.md b/examples/index.md new file mode 100644 index 000000000..50d115f48 --- /dev/null +++ b/examples/index.md @@ -0,0 +1,3 @@ +# Public Mojo notebooks + +All files in here will be publicly visible.