From fc2465636a3715fec27aece526438a2b1b9d2669 Mon Sep 17 00:00:00 2001 From: Edmund Miller Date: Thu, 10 Aug 2023 19:54:39 -0500 Subject: [PATCH 01/16] Add initial automa1 markdown --- .../posts/automa1/automa_tutorial_13_0.svg | 103 ++ .../posts/automa1/automa_tutorial_25_0.svg | 129 +++ _assets/posts/automa1/automa_tutorial_2_0.svg | 66 ++ .../posts/automa1/automa_tutorial_37_0.svg | 136 +++ .../posts/automa1/automa_tutorial_47_0.svg | 390 ++++++++ _assets/posts/automa1/automa_tutorial_4_0.svg | 84 ++ _assets/posts/automa1/automa_tutorial_6_0.svg | 124 +++ posts/automa1.md | 889 ++++++++++++++++++ 8 files changed, 1921 insertions(+) create mode 100644 _assets/posts/automa1/automa_tutorial_13_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_25_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_2_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_37_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_47_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_4_0.svg create mode 100644 _assets/posts/automa1/automa_tutorial_6_0.svg create mode 100644 posts/automa1.md diff --git a/_assets/posts/automa1/automa_tutorial_13_0.svg b/_assets/posts/automa1/automa_tutorial_13_0.svg new file mode 100644 index 0000000..3deaebe --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_13_0.svg @@ -0,0 +1,103 @@ + + + + + + + + + +start + + + + +1 + + +1 + + + +start->1 + + + + + +2 + +2 + + + +1->2 + + +'>' + + + +3 + +3 + + + +2->3 + + +[a-z] + + + +3->3 + + +[a-z] + + + +4 + +4 + + + +3->4 + + +'\n' + + + +5 + +5 + + + +4->5 + + +[ACGT] + + + +5->1 + + +'\n' + + + +5->5 + + +[ACGT] + + + diff --git a/_assets/posts/automa1/automa_tutorial_25_0.svg b/_assets/posts/automa1/automa_tutorial_25_0.svg new file mode 100644 index 0000000..3a67d61 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_25_0.svg @@ -0,0 +1,129 @@ + + + + + + + + + +start + + + + +1 + + +1 + + + +start->1 + + + + + +2 + +2 + + + +1->2 + + +'>'/enter + + + +3 + +3 + + + +2->3 + + +[a-z] + + + +3->3 + + +[a-z] + + + +4 + +4 + + + +3->4 + + +'\n'/exit_header + + + +5 + +5 + + + +4->5 + + +[ACGT]/enter + + + +5->5 + + +[ACGT] + + + +6 + + +6 + + + +5->6 + + +'\n'/exit_sequence + + + +6->2 + + +'>'/enter,exit_record + + + +eof6 + + + + +6->eof6 + + +EOF/exit_record + + + diff --git a/_assets/posts/automa1/automa_tutorial_2_0.svg b/_assets/posts/automa1/automa_tutorial_2_0.svg new file mode 100644 index 0000000..5cea272 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_2_0.svg @@ -0,0 +1,66 @@ + + + + + + + + + +begin + +begin + + + +header + +header + + + +begin->header + + + + + +end + +end + + + +begin->end + + + + + +sequence + +sequence + + + +header->sequence + + + + + +sequence->header + + + + + +sequence->end + + + + + diff --git a/_assets/posts/automa1/automa_tutorial_37_0.svg b/_assets/posts/automa1/automa_tutorial_37_0.svg new file mode 100644 index 0000000..753e516 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_37_0.svg @@ -0,0 +1,136 @@ + + + + + + + + + +start + + + + +1 + + +1 + + + +start->1 + + + + + +2 + +2 + + + +1->2 + + +'>'/enter + + + +3 + +3 + + + +2->3 + + +[a-z] + + + +3->3 + + +[a-z] + + + +4 + +4 + + + +3->4 + + +'\n'/exit_header + + + +5 + +5 + + + +4->5 + + +[ACGT]/enter + + + +5->5 + + +[ACGT] + + + +6 + + +6 + + + +5->6 + + +'\n'/exit_seqline + + + +6->2 + + +'>'/enter,exit_record + + + +6->5 + + +[ACGT]/enter + + + +eof6 + + + + +6->eof6 + + +EOF/exit_record + + + diff --git a/_assets/posts/automa1/automa_tutorial_47_0.svg b/_assets/posts/automa1/automa_tutorial_47_0.svg new file mode 100644 index 0000000..50529e8 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_47_0.svg @@ -0,0 +1,390 @@ + + + + + + + + + +start + + + + +1 + + +1 + + + +start->1 + + + + + +1->1 + + +'\n' + + + +2 + +2 + + + +1->2 + + +'>'/enter + + + +3 + +3 + + + +1->3 + + +'\r' + + + +4 + +4 + + + +2->4 + + +[\0-\b\x0e-\x1f!-\xff] + + + +3->1 + + +'\n' + + + +4->4 + + +[\0-\b\x0e-\x1f!-\xff] + + + +5 + +5 + + + +4->5 + + +'\n'/exit_header + + + +6 + +6 + + + +4->6 + + +'\r'/exit_header + + + +7 + +7 + + + +4->7 + + +[\t\v\f ] + + + +8 + + +8 + + + +5->8 + + +[*\-A-DGHKMNR-WYa-dghkmnr-wy]/enter + + + +6->5 + + +'\n' + + + +7->5 + + +'\n'/exit_header + + + +7->6 + + +'\r'/exit_header + + + +8->8 + + +[*\-A-DGHKMNR-WYa-dghkmnr-wy] + + + +9 + + +9 + + + +8->9 + + +'\n'/exit_seqline + + + +10 + +10 + + + +8->10 + + +'\r'/exit_seqline + + + +11 + + +11 + + + +8->11 + + +[\t\v\f ] + + + +eof8 + + + + +8->eof8 + + +EOF/exit_seqline,exit_record + + + +9->2 + + +'>'/enter,exit_record + + + +9->8 + + +[*\-A-DGHKMNR-WYa-dghkmnr-wy]/enter + + + +12 + + +12 + + + +9->12 + + +'\n' + + + +13 + +13 + + + +9->13 + + +'\r' + + + +14 + + +14 + + + +9->14 + + +[\t\v\f ] + + + +eof9 + + + + +9->eof9 + + +EOF/exit_record + + + +10->9 + + +'\n' + + + +11->9 + + +'\n'/exit_seqline + + + +11->10 + + +'\r'/exit_seqline + + + +eof11 + + + + +11->eof11 + + +EOF/exit_seqline,exit_record + + + +12->12 + + +'\n' + + + +12->13 + + +'\r' + + + +12->14 + + +[\t\v\f ] + + + +eof12 + + + + +12->eof12 + + +EOF/exit_record + + + +13->12 + + +'\n' + + + +14->12 + + +'\n' + + + +14->13 + + +'\r' + + + +eof14 + + + + +14->eof14 + + +EOF/exit_record + + + diff --git a/_assets/posts/automa1/automa_tutorial_4_0.svg b/_assets/posts/automa1/automa_tutorial_4_0.svg new file mode 100644 index 0000000..418caf4 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_4_0.svg @@ -0,0 +1,84 @@ + + + + + + + + + +begin + +begin + + + +header + +header + + + +begin->header + + +>[a-z] + + + +end + +end + + + +begin->end + + + + + +header->header + + +[a-z] + + + +sequence + +sequence + + + +header->sequence + + +\n[ACGT] + + + +sequence->header + + +\n> + + + +sequence->sequence + + +[ACGT] + + + +sequence->end + + +\nEOF + + + diff --git a/_assets/posts/automa1/automa_tutorial_6_0.svg b/_assets/posts/automa1/automa_tutorial_6_0.svg new file mode 100644 index 0000000..785fe65 --- /dev/null +++ b/_assets/posts/automa1/automa_tutorial_6_0.svg @@ -0,0 +1,124 @@ + + + + + + + + + +begin + +begin + + + +1 + +1 + + + +begin->1 + + +> + + + +end + +end + + + +begin->end + + +EOF + + + +2 + +2 + + + +sequence + +sequence + + + +2->sequence + + +[ACGT] + + + +header + +header + + + +1->header + + +[a-z] + + + +3 + +3 + + + +3->1 + + +> + + + +3->end + + +EOF + + + +header->2 + + +\n + + + +header->header + + +[a-z] + + + +sequence->3 + + +\n + + + +sequence->sequence + + +[ACGT] + + + diff --git a/posts/automa1.md b/posts/automa1.md new file mode 100644 index 0000000..df0d350 --- /dev/null +++ b/posts/automa1.md @@ -0,0 +1,889 @@ ++++ +using Dates +date = Date("2020-08-30") +title = "Tutorial to Automa: Part 1" +author = "Jakob Nybo Nissen" ++++ + +# Tutorial to Automa: Part 1 + +**Find this notebook at [https://github.com/jakobnissen/automa_tutorial](https://github.com/jakobnissen/automa_tutorial)** + +In bioinformatics, we have a saying: + +> The first step of any bioinformatics project is to define a new file format, incompatible with all previous ones. + +The situation might not be _quite_ as bad as the saying implies, but it _is_ true that we have a _lot_ of different file formats, representing the various kinds of data we work with. + +For that reason, creating file parsers is a central task in bioinformatics, and has almost become [a craft in itself.](http://biopython.org/DIST/docs/tutorial/Tutorial.html#sec14) An awful, awful craft. For anything but the simplest formats, designing robust parsers is hard, and it is difficult to know if a parser you've built is solid. Insignificant details like trailing whitespace can break a seemingly well-built parser. + +At its core, a parser is a program that checks whether some input data comforms to some format. For bioinformatics, we typically also want to load the data in the file into some data structure to work on it. The format itself is typically specified in some kind of higher-level, but unambiguous language, like [this description of the Newick format.](https://en.wikipedia.org/wiki/Newick_format#Grammar) A parser then, can be viewed as a program that: + +- Is given a format specified in a high-level “language”, e.g. “a leaf in the Newick format consist of only a _name_, which is formed from the alphabet “a-z, A-Z and \_"", and +- Checks whether some input follows that format using relatively low-level instructions, e.g. checking whether the following bytes until the next `(`, `)`, `,` or `;` match the pattern `[A-Za-z_]` + +The central job of a parser is then to act as a _translator_ between different abstraction levels: The format is specified in a high-level language, but the actual data processing must happen at a lower level language. + +When described like that, parser generation seems quite analogous to code compilation, and begins too look like a _machine's_ job, not a human's. Machines are fast and accurate, and do not make oversights or mistakes - exactly the characteristics you want when making a parser. Let's leave the machine tasks to the machines; we humans ought to put our effort into what we do best: Specifying the formats themselves. + +In this tutorial, I will introduce Automa, a Julia package for creating parsers. Actually, when reading this you might be able to tell that Automa solves a problem slightly more general than just creating parsers, but creating parsers is what we will use it for in this tutorial. Automa is not an easy package to use; it is complex and a little opaque, but it's worth all the effort and more. Parsers generated by Automa have several advantages over human-made parsers: + +- They are failsafe: Any deviation of the input from the specified format, no matter how trivial, will cause it to fail. Therefore, they are much more reliant than human-written parsers. +- They are easy to change. You can often easily change details in the input format, such as allowing whitespace, with minimal changes to your code, +- They are quite fast, with Automa-code often being faster than even optimized human-crafted parsers. + +In this first part of the tutorial I will show how to create parsers from data loaded into memory in order to highlight Automa itself. In the second part, which I will release at a later date, I will show how to create a proper BioJulia reader and writer for a file format. + +## Our format + +For our example, let us begin with a simlified version of the FASTA format - we can call it “SimpleFasta”. Our format will be defined as something that looks like this: + +``` +>first +TGATAGTAGTCGTGTGATA +>second +AGGACCCAATTATCGGGGTAA +``` + +I.e. + +- A SimpleFasta file is a sequence of zero or more _records_ +- A _record_ consists of _header_ \* newline \* _sequence_ \* newline, where “\*” signifies concatenation +- A _header_ consists of `>` followed by one or more characters from the alphabet a-z +- A _sequence_ consists of one or more chatacters from the alphabet A, C, G or T. + +We can visualize a hypothetical SimpleFasta parser using a simple flowchart - note: You need to have `graphviz` installed to be able to run the code below. + +```julia +s = """digraph { +graph [ rankdir = LR ]; +begin [ shape = circle ]; +begin -> header; +header [ shape = circle ]; +header -> sequence; +sequence [ shape = circle ]; +sequence -> end; +end [ shape = circle ]; +sequence -> header; +begin -> end; +} +""" +function display_machine() + write("/tmp/fasta_machine.dot", s) + run(`dot -Tsvg -o /tmp/fasta_machine.svg /tmp/fasta_machine.dot`) + open("/tmp/fasta_machine.svg") do file + display("image/svg+xml", String(read(file))) + end +end; +``` + +```julia +display_machine() +``` + +![svg](automa_tutorial_2_0.svg) + +After the beginning of the file, we expect to see a header. Next, we move to the sequence. From there, we can either reach the end of the file, or loop back to another header. Alternatively, in the case of an empty file, we may move from the beginning of the file to the end immediately without any headers or sequences. We consider an empty file to also be specification-compliant. + +Note that this simple flowchart describes any _valid_ SimpleFasta format. But if, for example, a file had two consecutive header lines, there is no path we can take through the flowchart from “begin” to “end” which describes the file, and we can tell that the input did not conform to the format. + +The circles marked “begin”, “header”, “sequence” or “end” are what we call the four _states_. Because the parser shown in the diagram has a fixed list of possible states that it changes between, we call the parser a _finite state machine_ (FSM), or _finite state automaton_ (FSA). + +The flowchart above doesn't do a very good job of describing the FSM that our parser is, because it doesn't tell you _how_ the machine transitions between states. The state _transitions_ are what actually defines the format. For example, we know we are transitioning to a header when we see a `>` symbol - that is, in a way, what _defines_ the header state. + +In the flowchart below, the arrows signifying transitions between states are marked with the input character(s) that causes the FSM (our parser) to transition, written in a [regex-like](http://regexr.com) notation. For example, the transition from a header to a sequence is defined by a `\n` followed by one of the characters in `[ACGT]`. “EOF” signifies end of file. Note also that some states have transitions leading to itself. For example, when in the “header” state, the FSM may continue to read characters in `a-z` and stay in the “header” state. + +```julia +s = """digraph { + graph [ rankdir = LR ]; +begin [ shape = circle ]; +header [ shape = circle ]; +sequence [ shape = circle ]; +end [ shape = circle ]; + +begin -> header [ label = ">[a-z]" ]; +header -> header [ label = "[a-z]"]; +header -> sequence [ label = "\\\\n[ACGT]" ]; +sequence -> sequence [ label = "[ACGT]" ]; +sequence -> header [ label = "\\\\n>" ]; +sequence -> end [ label = "\\\\nEOF" ]; +begin -> end; +} +""" +display_machine() +``` + +![svg](automa_tutorial_4_0.svg) + +How does the machine know when it's supposed to transition between states? Suppose a machine is at the beginning of a file and it begins by observing the input `>`. Is this part of a transition to the header state, or the beginning of a malformed input? + +It is certainly possible for the machine to have a _memory_ of the pattern, such that it only transitions to the “header” state once it sees the two specific inputs `>` and `[a-z]` in that order. However, we can make things much simpler by requiring the machine to make a state transition for _every single input byte_, then we don't need any memory other than what state the machine is in, which is a single integer. To still represent the same format at the flowchart above, we need to insert some extra states: + +```julia +s = """digraph { + graph [ rankdir = LR ]; + begin [ shape = circle ]; + 2 [ shape = circle ]; +1 [ shape = circle ]; +3 [ shape = circle ]; + begin -> 1 [ label = ">" ]; + header [ shape = circle ]; +1 -> header [label = "[a-z]" ]; +header -> header [ label = "[a-z]" ]; +2 -> sequence [ label = "[ACGT]" ]; +header -> 2 [ label = "\\\\n" ]; + + +sequence [ shape = circle ]; +sequence -> sequence [ label = "[ACGT]" ]; +sequence -> 3 [ label = "\\\\n" ]; +3 -> 1 [ label = ">" ]; +end [ shape = circle ]; +3 -> end [ label = "EOF" ]; +"begin" -> end [ label = "EOF" ]; +} +""" +display_machine() +``` + +![svg](automa_tutorial_6_0.svg) + +The diagram above is exactly equivalent to the previous one, but this diagram makes a state transition for _every single_ input byte. All bytes cause a transition, and no transition consumes multiple bytes. For simplicity, Automa's parsers work like that. + +Note that it is always possible, given a FSM with multi-byte transitions to convert it to a FSM with single-byte transitions by just putting in more nodes. E.g. the transition from header to sequence requires two bytes, a newline and an A, C, G or T. Therefore, an intermediate note (on the illustration marked “2”) is needed. Unfortunately, the requirement of single-byte transitions limits what you can do with Automa - I'll come back to the limitations later. + +Now let's create this same FSM using Automa. + +## Introducing Automa + +```julia +# First imports +import Automa +import Automa.RegExp: @re_str +const re = Automa.RegExp; +``` + +We define the elements that make up the SimpleFasta (the header and the sequence) using `Automa.RegExp`, a subset of regular expressions. Automa's regular expressions can be manipulated with the following operations: + +Function + +Alias + +Meaning + +`cat(re...)` + +`*` + +concatenation + +`alt(re1, re2...)` + +`\|` + +alternation + +`rep(re)` + +zero or more repetition + +`rep1(re)` + +one or more repetition + +`opt(re)` + +zero or one repetition + +`isec(re1, re2)` + +`&` + +intersection + +`diff(re1, re2)` + +`\` | difference (subtraction) | + +`neg(re)` + +`!` + +negation + +Furthermore inside the re-strings themselves, you can use + +- groups of characters, like `[ACGT]` representing the set `{A, C, G, T}` +- ranges `A-Z` representing `'A':'Z'` (or more accurately, the _bytes_ `UInt8('A'):UInt8('Z')` +- `*`, representing zero or more repetitions of the last element, such as `[a-z]*` +- `+`, representing one or more repetitions of the last element, such as `[a-z]+` +- `?`, representing zero or one repetition of the last element, such as `[a-z]?` + +We can specify our FSM like below. We use a `let` statement only so we don't pollute global namespace with `header`, `sequence` etc. + +```julia +machine = let + # Define SimpleFasta syntax + header = re">[a-z]+" + sequence = re"[ACGT]+" + record = header * re"\n" * sequence * re"\n" + fasta = re.rep(record) + + # Compile the regex to a FSM + Automa.compile(fasta) +end; +``` + +If you have `dot` installed on your computer, you can visualize the compiled FSM. You might want to modify the paths in the function below to make it work on your computer. + +```julia +function display_machine(machine) + write("/tmp/fasta_machine.dot", Automa.machine2dot(machine)) + run(`dot -Tsvg -o /tmp/fasta_machine.svg /tmp/fasta_machine.dot`) + open("/tmp/fasta_machine.svg") do file + display("image/svg+xml", String(read(file))) + end +end; +``` + +```julia +display_machine(machine) +``` + +![svg](automa_tutorial_13_0.svg) + +Yes, that looks correct! The start node here is the small point on the left. You can see one of the states are represented by a double circle. This represents an _accept state_, where the machine may stop at a valid end of input - here after each SimpleFasta record. If the machine stops at any other state, it did not complete correctly. In other words, state “1” here doubles as the “end” state. + +With this parser we can read a SimpleFasta file and determine if it conforms to the specification. In Automa, we do this by having our machine create Julia code in the form of a Julia expression (of type `Expr`), which we can then use to create a function using metaprogramming. + +First, we need an `Automa.CodeGenContext`, an object which contains the options for code generation. For now, we don't worry about the settings and just make a default context object: + +```julia +context = Automa.CodeGenContext(); +``` + +Then, we use two functions to generate code: + +- `Automa.generate_init_code(::CodeGenContext, ::Machine)` creates the Julia code needed to initialize the parsing of the given FSM. +- `Automa.generate_exec_code(::CodeGenContext, ::Machine, ::Dict{Symbol, Expr})` creates the Julia code needed for the main loop of the running parser. Here, the `Dict` is an _action dict_, which may contain arbitrary Julia code that the parser executes while parsing. We need that action dict later to make our parser do something useful - but for now, we simply want to create _a_ parser, not necessarily a _useful_ one, so we just use an empty dict. We will come back to the action dict later. + +Let's have a look at these functions: + +```julia +Automa.generate_init_code(context, machine) +``` + +``` +quote + #= /home/jakob/.julia/packages/Automa/sfHZ6/src/codegen.jl:94 =# + p::Int = 1 + #= /home/jakob/.julia/packages/Automa/sfHZ6/src/codegen.jl:95 =# + p_end::Int = 0 + #= /home/jakob/.julia/packages/Automa/sfHZ6/src/codegen.jl:96 =# + p_eof::Int = -1 + #= /home/jakob/.julia/packages/Automa/sfHZ6/src/codegen.jl:97 =# + cs::Int = 1 +end +``` + +Besides the comments, the init code seems to define four integers. What to they mean? + +Automa works by reading the data byte by byte. When doing this, the data is represented in the function as an `AbstractVector{UInt8}` - let us call that `data`. `p` represents the index of `data` that the parser is currently reading from. `p_end` represents the last position of the data in `data`. Because `data` may just be a small, buffered part of a much larger file being parsed, `p_eof` represents the index of actual end of input. Last, `cs` is short for “current state”, and is an integer representing the state of the FSM. You can see that sensibly, it is initialized at state 1, and so, by looking at the FSM diagram, we can see it next expects a ‘>’. The zero state is special, and represents the “accept state”, that is, the state of a correctly exited FSM. + +The code generated by `Automa.generate_exec_code` is a little more complicated, and also depends on the `CodeGenContext`. But it will increment `p` by one, read a byte from `data`, and execute a state transition (i.e. change `cs`) depending on the byte. If `cs` goes negative, it knows the input is malformed. If `cs` is zero, the parser has finished. If `cs` is positive, it will continue until end of file. + +Alright, let's create a parser using these functions! + +```julia +@eval function parse_fasta(data::Union{String,Vector{UInt8}}) + $(Automa.generate_init_code(context, machine)) + + # p_end and p_eof were set to 0 and -1 in the init code, + # we need to set them to the end of input, i.e. the length of `data`. + p_end = p_eof = lastindex(data) + + # We just use an empty dict here because we don't want our parser + # to do anything just yet - only parse the input + $(Automa.generate_exec_code(context, machine, Dict{Symbol, Expr}())) + + # We need to make sure that we reached the accept state, else the + # input did not parse correctly + iszero(cs) || error("failed to parse on byte ", p) + return nothing +end; +``` + +Does it work? + +```julia +for (inputno, data) in enumerate([ + "", + ">hi\nACGT\n", + ">hi\nACGT", + ">hi\nAA\n>x\nGTGATCGTAGTA\n", + ">hi\nthere!" + ]) + try + parse_fasta(data) + println("Input $inputno: parsed successfully!") + catch e + println("Input $inputno: ", e) + end +end +``` + +``` +Input 1: parsed successfully! +Input 2: parsed successfully! +Input 3: ErrorException("failed to parse on byte 9") +Input 4: parsed successfully! +Input 5: ErrorException("failed to parse on byte 5") +``` + +Excellent. It correctly parsed the empty data, input 2 and 4. Input 3 lacked a trailing newline, and input 5 didn't have a proper sequence. + +But just parsing a file is not too useful. Normally, we parse a file in order to load it into some kind of datastructure to manipulate it. That's where the action dict comes into the picture. We can make Automa execute arbitrary Julia code during parsing. Here is how it works: + +- When defining our machine, we add _action names_, in the form of Julia `Symbol`s to certain regexes. For example, we may define that exiting the regex `sequence` should execute the action `:exit_sequence`. Like other Julia identifiers, the name can be chosen arbitrarily. +- Using the action dict, which was of type `Dict{Symbol, Expr}`, we can map action names to Julia code. This tells Automa what each action name _means_. +- The actions expressions are put into the function we create at parse time, so there is no runtime cost to this. + +First, we redefine our machine. This time, we add actions: + +```julia +machine = let + # Define SimpleFasta syntax + newline = re"\n" + header = re">[a-z]+" + sequence = re"[ACGT]+" + record = header * newline * sequence * newline + fasta = re.rep(record) + + # Define SimpleFasta actions using arbitrary names + header.actions[:enter] = [:enter] + header.actions[:exit] = [:exit_header] + sequence.actions[:enter] = [:enter] + sequence.actions[:exit] = [:exit_sequence] + record.actions[:exit] = [:exit_record] + + Automa.compile(fasta) +end; +``` + +If we visualize the machine now, the actions will be printed on the relevant edges in the FSM diagram. For example, the newline after a header is labeled `'\n'/exit_header`, meaning the transition will happen at the input byte `'\n'`, and it will execute the action `exit_header`. + +Also note that the diagram structure itself changed, because the entering state and exit state are now distinct. The exit state 6 will execute `:exit_record` at the end of file (EOF), whereas if the FSM ends at state 1, `:exit_record` is not executed. + +```julia +display_machine(machine) +``` + +![svg](automa_tutorial_25_0.svg) + +Let's also define a simple data structure to parse the SimpleFasta records into. Like our SimpleFasta format, let's not overcomplicate things: + +```julia +using BioSequences +``` + +```julia +struct FastaRecord{A} + header::String + sequence::LongSequence{A} +end + +FastaRecord(h, sequence::LongSequence{A}) where A = FastaRecord{A}(h, sequence); +``` + +And now our action dict. I can use the variables `data`, `p`, `p_end` etc. in the code: + +```julia +actions = Dict( + # Record which byte position marks the beginning of header or sequence + :enter => quote + mark = p + end, + :exit_header => quote + header = String(data[mark+1:p-1]) + end, + :exit_sequence => quote + sequence = LongSequence{A}(data[mark:p-1]) + end, + :exit_record => quote + record = FastaRecord(header, sequence) + push!(records, record) + end, +); +``` + +```julia +@eval function parse_fasta(::Type{A}, data::Union{String,Vector{UInt8}}) where {A <: Alphabet} + # We can't control the order that the code from out action dict is executed, so + # we define variables beforehand so we can be sure they are not used before + # they are defined. + mark = 0 + records = FastaRecord{A}[] + header = "" + sequence = LongSequence{A}() + + # The rest is just like in our previous example, except now we use the + # action dict we just created. + $(Automa.generate_init_code(context, machine)) + p_end = p_eof = lastindex(data) + $(Automa.generate_exec_code(context, machine, actions)) + + iszero(cs) || error("failed to parse on byte ", p) + return records +end; +``` + +We can verify that it works: + +```julia +parse_fasta(DNAAlphabet{4}, ">hello\nTAG\n>there\nTAA\n") +``` + +``` +2-element Array{FastaRecord{DNAAlphabet{4}},1}: + FastaRecord{DNAAlphabet{4}}("hello", TAG) + FastaRecord{DNAAlphabet{4}}("there", TAA) +``` + +## Redesign the format + +With the basics now covered, let's step up the game a tad and make it parse SimpleFasta records with multiple lines per sequence. We first define a `seqline` pattern that looks like the old `sequence` pattern, and build a new `sequence` pattern from multiple `seqline` patterns. + +```julia +machine = let + # Define SimpleFasta syntax + header = re">[a-z]+" + seqline = re"[ACGT]+" + sequence = seqline * re.rep(re"\n" * seqline) + record = header * re"\n" * sequence * re"\n" + fasta = re.rep(record) + + # Define SimpleFasta actions + header.actions[:enter] = [:enter] + header.actions[:exit] = [:exit_header] + seqline.actions[:enter] = [:enter] + seqline.actions[:exit] = [:exit_seqline] + record.actions[:exit] = [:exit_record] + + Automa.compile(fasta) +end; +``` + +The machine now has a subtle change with a small loop between node 5 and 6 representing the parser seeing multiple sequence lines. + +```julia +display_machine(machine) +``` + +![svg](automa_tutorial_37_0.svg) + +We also need to update the `actions`. Here, I use `:(this syntax)`, which is equivalent to + +``` +quote + this syntax +end +``` + +but more readable for one-liners. I keep a buffer containing the sequence, and append every sequence line to the buffer at the end of each `seqline`. When the record is done, I create the sequence and empty the buffer for the next record. + +```julia +actions = Dict( + :enter => :(mark= p), + :exit_header => :(header = String(data[mark+1:p-1])), + :exit_seqline => quote + doff = length(seqbuffer) + 1 + resize!(seqbuffer, length(seqbuffer) + p - mark) + copyto!(seqbuffer, doff, data, mark, p-mark) + end, + :exit_record => quote + sequence = LongSequence{A}(seqbuffer) + empty!(seqbuffer) + record = FastaRecord(header, sequence) + push!(records, record) + end, +); +``` + +We need to redefine `parse_fasta`, now also containing the `seqbuffer`: + +```julia +@eval function parse_fasta(::Type{A}, data::Union{String,Vector{UInt8}}) where {A <: Alphabet} + mark = 0 + records = FastaRecord{A}[] + header = "" + sequence = LongSequence{A}() + seqbuffer = UInt8[] + + $(Automa.generate_init_code(context, machine)) + p_end = p_eof = lastindex(data) + $(Automa.generate_exec_code(context, machine, actions)) + + iszero(cs) || error("failed to parse on byte ", p) + return records +end; +``` + +And we can confirm it now works for multiple sequences! + +```julia +parse_fasta(DNAAlphabet{2}, ">hello\nTAG\nGGG\n>there\nTAA\nTAG\n") +``` + +``` +2-element Array{FastaRecord{DNAAlphabet{2}},1}: + FastaRecord{DNAAlphabet{2}}("hello", TAGGGG) + FastaRecord{DNAAlphabet{2}}("there", TAATAG) +``` + +## Even more complexity + +One of the greatest things about Automa is how we can parse quite complicated formats without needing to manually construct much code. For example, here, I change _only_ the regular expressions: + +- I allow optional Windows-style newlines (`\r\n`) +- I allow trailing whitespace on each line (`re.space() \ (re"\r" | re"\n")` means all space characters except \\r or \\n), but not whitespace inside headers +- Sequences can only contain all UIPAC ambiguous RNA or DNA nucleotides +- The trailing record no longer needs a trailing newline to be valid. It has the same actions as a regular record. + +```julia +machine = let + # Define FASTA syntax + newline = re.opt("\r") * re"\n" + hspace = re.space() \ (re"\r" | re"\n") + header = re">" * re.rep1((re.any() \ re.space())) * re.opt(hspace) + seqline = re"[acgturmkyswbdhvnACGTURMKYSWBDHVN\-*]+" * re.opt(hspace) + sequence = seqline * re.rep(newline * seqline) + record = header * newline * sequence * newline + trailing_record = header * newline * sequence * re.rep(newline * re.opt(hspace)) + fasta = re.rep(newline) * re.rep(record) * re.opt(trailing_record) + + # Define FASTA actions + header.actions[:enter] = [:enter] + header.actions[:exit] = [:exit_header] + seqline.actions[:enter] = [:enter] + seqline.actions[:exit] = [:exit_seqline] + record.actions[:exit] = [:exit_record] + trailing_record.actions[:exit] = [:exit_record] + + Automa.compile(fasta) +end; +``` + +The machine is now a bit more complicated. But who cares, it's automatically generated. Look how easy it was to generate! + +```julia +display_machine(machine) +``` + +![svg](automa_tutorial_47_0.svg) + +## Pitfall 1: Ambiguous parsers + +Besides its complexity, building parsers with Automa has some pitfalls - notably those caused by Automa transitioning state for every input byte. + +Unfortunately, it's very easy to accidentally create a machine that can't possibly figure out what action to take when looking only at one byte at a time. The following simple machine will not compile (on the master branch of Automa). + +```julia +bad_machine = let + left = re"Turn left!" + right = re"Turn right!" + left_or_right = left | right + + left.actions[:enter] = [:turn_left] + right.actions[:enter] = [:turn_right] + + Automa.compile(left_or_right) +end +``` + +``` +Ambiguous DFA: Input 0x54 can lead to actions [:turn_right] or [:turn_left] + + + +Stacktrace: + + [1] error(::String) at ./error.jl:33 + + [2] validate_paths(::Array{Tuple{Union{Nothing, Automa.Edge},Array{Symbol,1}},1}) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:176 + + [3] validate_nfanodes(::Automa.StableSet{Automa.NFANode}) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:195 + + [4] nfa2dfa(::Automa.NFA, ::Bool) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:104 + + [5] compile(::Automa.RegExp.RE; optimize::Bool, unambiguous::Bool) at /home/jakob/.julia/packages/Automa/sfHZ6/src/machine.jl:55 + + [6] compile(::Automa.RegExp.RE) at /home/jakob/.julia/packages/Automa/sfHZ6/src/machine.jl:55 + + [7] top-level scope at In[27]:9 + + [8] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091 +``` + +Automa refuse to create this FSM. Why? Well, the first byte it expects is a `T` (or `0x54`) - but there is no way of knowing whether it's entering `left` or `right` when it sees that byte, and these two patters have conflicting actions! If they had the same actions, there would be no problem. + +This situation is highly artificial, but the situation happens often in real life. Here's a very subtle change to one of the previous parsers: + +```julia +bad_machine = let + # Define SimpleFasta syntax + header = re">[a-z]+" + seqline = re"[ACGT]+" + sequence = seqline * re.rep(re"\n" * seqline) + record = header * re"\n" * sequence + fasta = re.rep(record * re"\n") + + # Define SimpleFasta actions + header.actions[:enter] = [:enter] + header.actions[:exit] = [:exit_header] + seqline.actions[:enter] = [:enter] + seqline.actions[:exit] = [:exit_seqline] + record.actions[:exit] = [:exit_record] + + Automa.compile(fasta) +end; +``` + +``` +Ambiguous DFA: Input 0x0a can lead to actions [:exit_seqline, :exit_record] or [:exit_seqline] + + + +Stacktrace: + + [1] error(::String) at ./error.jl:33 + + [2] validate_paths(::Array{Tuple{Union{Nothing, Automa.Edge},Array{Symbol,1}},1}) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:176 + + [3] validate_nfanodes(::Automa.StableSet{Automa.NFANode}) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:195 + + [4] nfa2dfa(::Automa.NFA, ::Bool) at /home/jakob/.julia/packages/Automa/sfHZ6/src/dfa.jl:104 + + [5] compile(::Automa.RegExp.RE; optimize::Bool, unambiguous::Bool) at /home/jakob/.julia/packages/Automa/sfHZ6/src/machine.jl:55 + + [6] compile(::Automa.RegExp.RE) at /home/jakob/.julia/packages/Automa/sfHZ6/src/machine.jl:55 + + [7] top-level scope at In[28]:16 + + [8] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091 +``` + +After a `seqline`, when encountering a newline, there is no way of knowing whether this marks the end of a record or whether it continues at the next line. Automa can't look ahead, it has to make a decision at every byte. + +Here, the solution is to move the newline from the definition of `fasta` to that of `sequence`. That way, the newline functions as a kind of one-byte lookahead - if the byte after the newline is a `>`, it knows the record is complete. + +In general, encountering situations like this is usually a sign that the parser is badly built - or that the format is. You can usually resolve it by using single-byte lookahead like above. If not, it is possible to optionally disable the check for ambiguous actions by passing a keyword to the `Automa.parse` function. But beware that this may lead to absurd results. + +## Pitfall 2: No recursively defined patterns + +Some formats are naturally recursive. The [Newick format](https://en.wikipedia.org/wiki/Newick_format), for example, defines “subtree” in terms of “internal”, which is defined in terms of “branchset”, defined in terms of “branch” which is defined in terms of… “subtree”. + +Something like that will not work Automa: + +```julia +simple_newick = let + name = re"[a-z_]" + clade = name | (re"\(" * cladeset * ")") + cladeset = clade * re.rep(re"," * clade) + Automa.compile(cladeset * re";") +end + +``` + +``` +UndefVarError: cladeset not defined + + + +Stacktrace: + + [1] top-level scope at In[29]:3 + + [2] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091 +``` + +Because, in general, you can't refer to objects in Julia that have not yet been defined. Worse, even if the syntactical challenge was solved, recursive patterns usually only make sense if you have lookahead. Newick files, for example, simply _can't_ be parsed by FSMs, because every time you see an open parenthesis, you need to make sure there is a closing one further in the file, and this requires lookahead that can't be resolved by parsing one byte at a time. + +Luckily, because Automa can execute arbitrary Julia code, we can have the FSM manipulate a stack and turn the FSM into a _pushdown automaton_, which can handle formats like Newick. It does require a little more manual fiddling, and is less elegant: + +```julia +simple_newick = let + name = re"[a-z_]+" + cladestart = re"\(" + cladestop = re"\)" + cladesep = re"," + nodechange = cladestart | cladestop | cladesep + newick_element = nodechange * re.opt(name) + tree = re.opt(name) * re.rep(newick_element) * re";" + + cladestart.actions[:enter] = [:push] + cladestop.actions[:enter] = [:pop] + cladesep.actions[:enter] = [:pop, :push] + + Automa.compile(tree) +end + +actions = Dict( + :push => quote + level -= 1 + end, + :pop => quote + iszero(level) && error("Too many closing parentheses") + level += 1 + end +); +``` + +```julia +@eval function parse_newick(data::Union{String,Vector{UInt8}}) + level = 0 + $(Automa.generate_init_code(context, simple_newick)) + p_end = p_eof = lastindex(data) + $(Automa.generate_exec_code(context, simple_newick, actions)) + + iszero(cs) || error("failed to parse on byte ", p) + iszero(level) || error("Too many opening parentheses") +end; +``` + +And it sort of works: + +```julia +println("Does this parse? ", parse_newick("(hello,hi);")) +println("Does this parse? ", parse_newick("(hello,hi)(;")) +``` + +``` +Does this parse? true + + + +Too many opening parentheses + + + +Stacktrace: + + [1] error(::String) at ./error.jl:33 + + [2] parse_newick(::String) at ./In[31]:8 + + [3] top-level scope at In[32]:2 + + [4] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091 +``` + +Here, I needed to manually keep track of the level of nesting. In fact, I would have to keep track of more stuff to disallow inputs like `();`, removing some of the point of Automa - namely, that it is automatic. + +In the next part of this tutorial, I will show how to use Automa to create honest-to-God parsers which integrate with the BioJulia ecosystem and can work on streamed data. + +## Optimizing + +Automa's parsers are pretty fast. To create hand-written parsers of comparable speeds, you need to microoptimize every operation, which is annoying. That being said, for actually loading parsed files to be fast, you need to optimize the user-defined actions in the actions dictionary, too. + +How fast is our un-optimized Fasta parser already? Let's test it on some data and find out. I'll make 50k sequences with 2k base pairs each, for a total of 100 MB data. + +Remember to re-run the block of code where the `parse_fasta` function is defined since we changed the machine. + +```julia +# Create 50k records with 2kbp each +function generate_data() + open("/tmp/fasta.fna", "w") do file + for seq in 1:50000 + println(file, '>', join(rand('a':'z', 16))) + for line in 1:20 + println(file, join(rand("ACGT", 100))) + end + end + end +end +generate_data() +``` + +```julia +function parsedata() + open("/tmp/fasta.fna") do file + parse_fasta(DNAAlphabet{2}, read(file)) + end +end; +``` + +```julia +parsedata(); +@time parsedata(); +``` + +``` + 0.330489 seconds (200.04 k allocations: 138.861 MiB, 4.15% gc time) +``` + +Alright! It does about 300 MB/s on my laptop. Not bad! I'd say for most applications, this speed is more than sufficient. + +But this is Julia. We want to be able to optimize the crap out of it. So let's optimize the actions: + +```julia +actions = Dict( + :enter => :(mark = p), + + # Create string with only one copy of the data. + :exit_header => :(header = unsafe_string(pointer(data, mark + 1), p - mark - 1)), + + # Only resize buffer if it's too small, else just keep track of how many bytes are used. + :exit_seqline => quote + N = p - mark + length(seqbuffer) < filled + N && resize!(seqbuffer, filled + N) + copyto!(seqbuffer, filled+1, data, mark, N) + filled += N + end, + + # Use `copyto!` to only encode data directly from data vector into sequence + # note this requires the latest versions of BioSequences. + :exit_record => quote + sequence = copyto!(LongSequence{A}(filled), 1, seqbuffer, 1, filled) + record = FastaRecord(header, sequence) + push!(records, record) + filled = 0 + end, +); +``` + +If we want to optimize, we also need to use the fastest `CodeGenContext`. We use the `:goto`\-generator. This creates machine code using `@goto`\-statements, which creates very long and completely unreadable code - but it's fast. Also, who cares if it's hard to read. It's machine-generated code. We disable the FSM's boundschecks when accessing the `data` vector - since we don't manipulate the position `p` manually, we are confident it will not go out of bounds. And we allow the code generator to unroll loops: + +```julia +context = Automa.CodeGenContext(generator=:goto, checkbounds=false, loopunroll=4); +``` + +We also need to modify the `parse` function because we use a new variable called `filled` and need to initialize it. + +```julia +@eval function parse_fasta(::Type{A}, data::Union{String,Vector{UInt8}}) where {A <: Alphabet} + mark = 0 + records = FastaRecord{A}[] + header = "" + sequence = LongSequence{A}() + seqbuffer = UInt8[] + filled = 0 + + $(Automa.generate_init_code(context, machine)) + p_end = p_eof = lastindex(data) + $(Automa.generate_exec_code(context, machine, actions)) + + iszero(cs) || error("failed to parse on byte ", p) + return records +end; +``` + +```julia +parsedata(); +@time parsedata(); +``` + +``` +0.162113 seconds (150.04 k allocations: 133.520 MiB, 7.90% gc time) +``` + +Okay, we're at slightly above 600 MB/s. Profiling confirms nearly all time is spent encoding the DNA sequences to `LongSequence`. We can make it faster still by not storing the data as a `LongSequence`, and instead make it a “lazy” object that only constructs the sequence upon demand. Even further, we could avoid heap-allocating each sequence individually. But these optimizations do not pertain directly to Automa, and I will leave them here. From 87c2fb69697c4c90a0babcad5dc69c181442d912 Mon Sep 17 00:00:00 2001 From: Edmund Miller Date: Thu, 10 Aug 2023 20:39:15 -0500 Subject: [PATCH 02/16] fix: Trying to fix automa post --- posts/automa1.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/posts/automa1.md b/posts/automa1.md index df0d350..5d4724b 100644 --- a/posts/automa1.md +++ b/posts/automa1.md @@ -38,7 +38,7 @@ In this first part of the tutorial I will show how to create parsers from data l For our example, let us begin with a simlified version of the FASTA format - we can call it “SimpleFasta”. Our format will be defined as something that looks like this: -``` +```fasta >first TGATAGTAGTCGTGTGATA >second @@ -882,8 +882,8 @@ parsedata(); @time parsedata(); ``` -``` +```! 0.162113 seconds (150.04 k allocations: 133.520 MiB, 7.90% gc time) ``` -Okay, we're at slightly above 600 MB/s. Profiling confirms nearly all time is spent encoding the DNA sequences to `LongSequence`. We can make it faster still by not storing the data as a `LongSequence`, and instead make it a “lazy” object that only constructs the sequence upon demand. Even further, we could avoid heap-allocating each sequence individually. But these optimizations do not pertain directly to Automa, and I will leave them here. +Okay, we're at slightly above 600 MB/s. Profiling confirms nearly all time is spent encoding the DNA sequences to `LongSequence`. We can make it faster still by not storing the data as a `LongSequence`, and instead make it a "lazy" object that only constructs the sequence upon demand. Even further, we could avoid heap-allocating each sequence individually. But these optimizations do not pertain directly to Automa, and I will leave them here. From 5c7ac57b36839ae5acb3dd39a68dbd756756b1c8 Mon Sep 17 00:00:00 2001 From: Edmund Miller Date: Thu, 10 Aug 2023 20:49:12 -0500 Subject: [PATCH 03/16] Add hardware that was in 0.1 --- _assets/scripts/hardware.jl | 1751 +++++++++++++++++++++++++++++++++++ posts/hardware.html | 14 + 2 files changed, 1765 insertions(+) create mode 100644 _assets/scripts/hardware.jl create mode 100644 posts/hardware.html diff --git a/_assets/scripts/hardware.jl b/_assets/scripts/hardware.jl new file mode 100644 index 0000000..c23ba12 --- /dev/null +++ b/_assets/scripts/hardware.jl @@ -0,0 +1,1751 @@ +### A Pluto.jl notebook ### +# v0.19.11 + +using Markdown +using InteractiveUtils + +# ╔═╡ 675e66aa-8aef-11eb-27be-5fe273e33297 +# Load packages +begin + using BenchmarkTools + using PlutoUI +end + +# ╔═╡ 15f5c31a-8aef-11eb-3f19-cf0a4e456e7a +md""" +# What scientists must know about hardware to write fast code + +**Find this notebook at https://github.com/jakobnissen/hardware_introduction** + +Programming is used in many fields of science today, where individual scientists often have to write custom code for their own projects. For most scientists, however, computer science is not their field of expertise; They have learned programming by necessity. I count myself as one of them. While we may be reasonably familiar with the *software* side of programming, we rarely have even a basic understanding of how computer *hardware* impacts code performance. + +The aim of this tutorial is to give non-professional programmers a *brief* overview of the features of modern hardware that you must understand in order to write fast code. It will be a distillation of what have learned the last few years. This tutorial will use Julia because it allows these relatively low-level considerations to be demonstrated easily in a high-level, interactive language. + +## What this notebook is not +#### This is not a guide to the Julia programming language +To write fast code, you must first understand your programming language and its idiosyncrasies. But this is *not* a guide to the Julia programming language. I recommend reading the [performance tips section](https://docs.julialang.org/en/v1/manual/performance-tips/) of the Julia documentation. + +#### This is not an explanation of specific data structures or algorithms +Besides knowing your language, you must also know your own code to make it fast. You must understand the idea behind big-O notation, why some algorithms are faster than others, and how different data structures work internally. Without knowing *what an `Array` is*, how could you possibly optimize code making use of arrays? + +This too, is outside the scope of this paper. However, I would say that as a minimum, a programmer should have an understanding of: + +* How a binary integer is represented in memory +* How a floating point number is represented in memory (learning this is also necessary to understand computational inaccuracies from floating point operations, which is a must when doing scientific programming) +* The memory layout of a `String` including ASCII and UTF-8 encoding +* The basics of how an `Array` is structured, and what the difference between a dense array of e.g. integers and an array of references to objects are +* The principles behind how a `Dict` (i.e. hash table) and a `Set` works + +Furthermore, I would also recommend familiarizing yourself with: + +* Heaps +* Deques +* Tuples + +#### This is not a tutorial on benchmarking your code +To write fast code *in practice*, it is necessary to profile your code to find bottlenecks where your machine spends the majority of the time. One must benchmark different functions and approaches to find the fastest in practice. Julia (and other languages) have tools for exactly this purpose, but I will not cover them here. +""" + +# ╔═╡ 5dd2329a-8aef-11eb-23a9-7f3c325bcf74 +md"""## Setting up this notebook + +If you don't already have these packages installed, uncomment these lines and run them: +""" + +# ╔═╡ 7490def0-8aef-11eb-19ce-4b11ce5a9328 +# begin +# using Pkg +# Pkg.add(["BenchmarkTools", "PlutoUI"]) +# end + +# ╔═╡ 800d827e-8c20-11eb-136a-97a622a7c1e6 +TableOfContents() + +# ╔═╡ 9a24985a-8aef-11eb-104a-bd9abf0adc6d +md""" +## The basic structure of computer hardware + +For now, we will work with a simplified mental model of a computer. Through this document, I will add more details to our model as they become relevant. + +$$[CPU] ↔ [RAM] ↔ [DISK]$$ + +In this simple, uh, "diagram", the arrows represent data flow in either direction. The diagram shows three important parts of a computer: + +* The central processing unit (CPU) is a chip the size of a stamp. This is where all the computation actually occurs, the brain of the computer. +* Random access memory (RAM, or just "memory") is the short-term memory of the computer. This memory requires electrical power to maintain, and is lost when the computer is shut down. RAM serves as a temporary storage of data between the disk and the CPU. Much of time spent "loading" various applications and operating systems is actually spent moving data from disk to RAM and unpacking it there. A typical consumer laptop has around $10^{11}$ bits of RAM memory. +* The disk is a mass storage unit. This data on disk persists after power is shut down, so the disk contains the long-term memory of the computer. It is also much cheaper per gigabyte than RAM, with consumer PCs having around $10^{13}$ bits of disk space. +""" + +# ╔═╡ a2fad250-8aef-11eb-200f-e5f8caa57a67 +md""" +## Avoid accessing disk too often +When discussing software performance, it's useful to distinguish between *throughput* and *latency*. Latency is the time it takes from something begins until it is finished. Throughput is a measure of how much stuff gets done in a set amount of time. + +On the surface, the relationship between latency and throughput seems obvious: If an operation takes $N$ seconds to compute, then $1/N$ operations can be done per second. So you would think: + +Naive equation: $$throughput = \frac{1}{latency}$$ + +In reality, it's not so simple. For example, imagine an operation that has a 1 second "warmup" before it begins, but afterwards completes in 0.1 seconds. The latency is thus 1.1 seconds, but it's throughput after the initial warmup is 10 ops/second. + +Or, imagine a situation with an operation with a latency of 1 second, but where 8 operations can be run concurrently. In bulk, these operations can be run with a throughput of 8 ops/second. + +One place where it's useful to distinguish between latency and throughput is when programs read from the disk. Most modern computers use a type of disk called a *solid state drive (SSD)*. In round numbers, current (2021) SSD's have latencies around 100 µs, and read/write throughputs of well over 1 GB/s. Older, or cheaper mass-storage disks are of the *hard disk drive (HDD)* type. These have latencies 100 times larger, at near 10 ms, and 10 times lower throughput of 100 MB/s. + +Even the latest, fastest SSDs has latencies thousands of times slower than RAM, whose latency is below 100 nanoseconds. Disk latency is incurred whenever a read or write happen. To write fast code, you must therefore at all costs avoid repeatedly reading from, or writing to disk. + +The following example serves to illustrate the difference in latency: The first function opens a file, accesses one byte from the file, and closes it again. The second function randomly accesses 1,000,000 integers from RAM. +""" + +# ╔═╡ cdde6fe8-8aef-11eb-0a3c-77e28f7a2c09 +md""" +Benchmarking this is a little tricky, because the *first* invocation will include the compilation times of both functions. And in the *second* invocation, your operating system will have stored a copy of the file (or *cached* the file) in RAM, making the file seek almost instant. To time it properly, run it once, then *change the file* to another not-recently-opened file, and run it again. So in fact, we should update our computer diagram: + +$$[CPU] ↔ [RAM] ↔ [DISK CACHE] ↔ [DISK]$$ + +On my computer, finding a single byte in a file (including opening and closing the file) takes about 500 µs, and accessing 1,000,000 integers from memory takes 200 milliseconds. So RAM latency is on the order of 2,500 times lower than disk's. Therefore, repeated access to files *must* be avoided in high performance computing. + +Only a few years back, SSDs were uncommon and HDD throughput was lower than today. Therefore, old texts will often warn people not to have your program depend on the disk at all for high throughput. That advice is mostly outdated today, as most programs are incapable of bottlenecking at the throughput of even cheap, modern SSDs of 1 GB/s. The advice today still stands only for programs that need *frequent* individual reads/writes to disk, where the high *latency* accumulates. In these situations, you should indeed keep your data in RAM. + +The worst case for performance is if you need to read/write a large file in tiny chunks, for example one single byte at a time. In these situations, great speed improvements can be found by *buffering* the file. When buffering, you read in larger chunks, the *buffer*, to memory, and when you want to read from the file, you check if it's in the buffer. If not, read another large chunk into your buffer from the file. This approach minimizes disk latency. Both your operating system and your programming language will make use of caches, however, sometimes [it is necessary to manually buffer your files](https://github.com/JuliaLang/julia/issues/34195). + +""" + +# ╔═╡ f58d428c-8aef-11eb-3127-89d729e23823 +md""" +## Avoid cache misses +The RAM is faster than the disk, and the CPU in turn is faster than RAM. A CPU ticks like a clock, with a speed of about 3 GHz, i.e. 3 billion ticks per second. One "tick" of this clock is called a *clock cycle*. While this is a simplification, you may imagine that every cycle, the CPU executes a single, simple command called a *CPU instruction* which does one operation on a small piece of data. The clock speed then can serve as a reference for other timings in a computer. It is worth realizing just how quick a clock cycle is: In one cycle, a photon will travel only around 10 cm. In fact, modern CPUs are so fast that a significant constraint on their physical layout is that one must take into account the time needed for electricity to move through the wires inside them, so called wire delays. + +On this scale, reading from RAM takes around 500 clock cycles. Similarly to how the high latency of disks can be mitigated by copying data to the faster RAM, data from RAM is copied to a smaller memory chip physically on the CPU, called a *cache*. The cache is faster because it is physically on the CPU chip (reducing wire delays), and because it uses a faster type of storage, static RAM, instead of the slower (but cheaper to manufacture) dynamic RAM which is what the main RAM is made of. Because the cache must be placed on the CPU, limiting its size, and because it is more expensive to produce, a typical CPU cache only contains around $10^8$ bits, around 1000 times less than RAM. There are actually multiple layers of CPU cache, but here we simplify it and just refer to "the cache" as one single thing: + +$$[CPU] ↔ [CPU CACHE] ↔ [RAM] ↔ [DISK CACHE] ↔ [DISK]$$ + +When the CPU requests a piece of data from the RAM, say a single byte, it will first check if the memory is already in cache. If so, it will read it from there. This is much faster, usually just one or a few clock cycles, than access to RAM. If not, we have a *cache miss*, where your program will stall for around 100 nanoseconds while your computer copies data from RAM into the cache. + +It is not possible, except in very low-level languages, to manually manage the CPU cache. Instead, you must make sure to use your cache effectively. + +First, you strive to use as little memory as possible. With less memory, it is more likely that your data will be in cache when the CPU needs it. Remember, a CPU can do approximately 500 small operations in the time wasted by a single cache miss. + +Effective use of the cache comes down to *locality*, temporal and spacial locality: +* By *temporal locality*, I mean that data you recently accessed likely resides in cache already. Therefore, if you must access a piece of memory multiple times, make sure you do it close together in time. +* By *spacial locality*, I mean that you should access data from memory addresses close to each other. Your CPU does not copy *just* the requested bytes to cache. Instead, your CPU will always copy data in larger chunks called *cache lines* (usually 512 consecutive bits, depending on the CPU model). + +To illustrate this, let's compare the performance of the `random_access` function above when it's run on a short (8 KiB) vector, compared to a long (16 MiB) one. The first one is small enough that after just a few accessions, all the data has been copied to cache. The second is so large that new indexing causes cache misses most of the time. + +Notice the large discrepancy in time spent - a difference of around 70x. +""" + +# ╔═╡ c6da4248-8c19-11eb-1c16-093695add9a9 +md""" +We can play around with the function `random_access` from before. What happens if, instead of accessing the array randomly, we access it *in the worst possible order*? + +For example, we could use the following function: +""" + +# ╔═╡ d4c67b82-8c1a-11eb-302f-b79c86412ce5 +md""" +`linear_access` does nearly the same computation as `random_access`, but accesses every 15th element. An `UInt` in Julia is 8 bytes (64 bits), so a step size of 15 means there are $15 * 64 = 960$ bits between each element; larger than the 64 byte cache line. That means *every single* access will cause a cache miss - in contrast to `random_access` with a large vector, where only *most* accesses forces cache misses. +""" + +# ╔═╡ 0f2ac53c-8c1b-11eb-3841-27f4ea1e9617 +md""" +Surprise! The linear access pattern is more than 20 times faster! How can that be? + +Next to the cache of the CPU lies a small circuit called the *prefetcher*. This electronic circuit collects data on which memory is being accessed by the CPU, and looks for patterns. When it detects a pattern, it will *prefetch* whatever data it predicts will soon be accessed, so that it already resides in cache when the CPU requests the data. + +Our function `linear_access`, depite having worse *cache usage* than *random_access*, fetched the data in a completely predictable pattern, which allowed the prefetcher to do its job. + +In summary, we have seen that +* A *cache miss* incurs a penalty equivalent to roughly 500 CPU operations, so is absolutely critical for performance to avoid these +* To reduce cache misses: + - Use smaller data so it more easily fits in cache + - Access data in a predicatable, regular pattern to allow the prefetcher to do its job + - Access data close together in memory instead of far apart + - When accessing data close together in memory, do so close together in time, so when it's accessed the second time, it's still in cache. + +Cache usage has implications for your data structures. Hash tables such as `Dict`s and `Set`s are inherently cache inefficient and almost always cause cache misses, whereas arrays don't. Hence, while many operations of hash tables are $O(1)$ (i.e. they complete in constant time), their cost per operation is high. + +Many of the optimizations in this document indirectly impact cache use, so this is important to have in mind. +""" + +# ╔═╡ 12f1228a-8af0-11eb-0449-230ae20bfa7a +md""" +## Keep your data aligned to memory +As just mentioned, your CPU will move entire cache lines of usually 512 consecutive bits (64 bytes) to and from main RAM to cache at a time. Your entire main memory is segmented into cache lines. For example, memory addresses 0 to 63 is one cache line, addresses 64 to 127 is the next, 128 to 191 the next, et cetera. Your CPU may only request one of these cache lines from memory, and not e.g. the 64 bytes from address 30 to 93. + +This means that some data structures can straddle the boundaries between cache lines. If I request a 64-bit (8 byte) integer at adress 60, the CPU must first generate two memory requests from the single requested memory address (namely to get cache lines 0-63 and 64-127), and then retrieve the integer from both cache lines, wasting time. + +The time wasted can be significant. In a situation where in-cache memory access proves the bottleneck, the slowdown can approach 2x. In the following example, I use a pointer to repeatedly access an array at a given offset from a cache line boundary. If the offset is in the range `0:56`, the integers all fit within one single cache line, and the function is fast. If the offset is in `57:63` all integers will straddle cache lines. +""" + +# ╔═╡ 3a1efd5a-8af0-11eb-21a2-d1011f16555c +md"The consequences of unaligned memory access are very CPU-dependent. On my current CPU, I see a ~15% performance decrease. On my old computer where I originally wrote this notebook, the penalty was around 100%. Old processors can do [even worse things](https://www.kernel.org/doc/Documentation/unaligned-memory-access.txt) - incredibly, the CPU inside the Game Boy Advance from 2001 would _silently perform a different read!_ 😱 + +Fortunately, the compiler does a few tricks to make it less likely that you will access misaligned data. First, Julia (and other compiled languages) always places new objects in memory at the boundaries of cache lines. When an object is placed right at the boundary, we say that it is *aligned*. Julia also aligns the beginning of larger arrays:" + +# ╔═╡ 5b10a2b6-8af0-11eb-3fe7-4b78b4c22550 +md"Note that if the beginning of an array is aligned, then it's not possible for 1-, 2-, 4-, or 8-byte objects to straddle cache line boundaries, and everything will be aligned. + +It would still be possible for an e.g. 7-byte object to be misaligned in an array. In an array of 7-byte objects, the 10th object would be placed at byte offset $7 \times (10-1) = 63$, and the object would straddle the cache line. However, the compiler usually does not allow struct with a nonstandard size for this reason. If we define a 7-byte struct:" + +# ╔═╡ 6061dc94-8af0-11eb-215a-4f3af731774e +struct AlignmentTest + a::UInt32 # 4 bytes + + b::UInt16 # 2 bytes + + c::UInt8 # 1 byte = 7 bytes? +end; + +# ╔═╡ 624eae74-8af0-11eb-025b-8b68dc55f31e +md"Then we can use Julia's introspection to get the relative position of each of the three integers in an `AlignmentTest` object in memory:" + +# ╔═╡ d4c8c38c-8ee6-11eb-0b49-33fbfbd214f3 +let + T = AlignmentTest + println("Size of $T: ", sizeof(T), "bytes") + for fieldno in 1:fieldcount(T) + print("Name: ", fieldname(T, fieldno), '\t') + print("Size: ", sizeof(fieldtype(T, fieldno)), '\t') + print("Offset: ", fieldoffset(T, fieldno), '\n') + end +end + +# ╔═╡ 7b979410-8af0-11eb-299c-af0a5d740c24 +md""" +We can see that, despite an `AlignmentTest` only having 4 + 2 + 1 = 7 bytes of actual data, it takes up 8 bytes of memory, and accessing an `AlignmentTest` object from an array will always be aligned. + +As a coder, there are only a few situations where you can face alignment issues. I can come up with two: + +1. If you manually create an object with a strange size, e.g. by accessing a dense integer array with pointers. This can save memory, but will waste time. [My implementation of a Cuckoo filter](https://github.com/jakobnissen/Probably.jl) does this to save space. +2. During matrix operations. If you have a matrix the columns are sometimes unaligned because it is stored densely in memory. E.g. in a 15x15 matrix of `Float32`s, only the first column is aligned, all the others are not. This can have serious effects when doing matrix operations: [I've seen benchmarks](https://juliasimd.github.io/LoopVectorization.jl/latest/examples/matrix_vector_ops/) where an 80x80 matrix/vector multiplication is 2x faster than a 79x79 one due to alignment issues. +""" + +# ╔═╡ 8802ff60-8af0-11eb-21ac-b9fdbeac7c24 +md""" +## Digression: Assembly code +To run, any program must be translated, or *compiled* to CPU instructions. The CPU instructions are what is actually running on your computer, as opposed to the code written in your programming language, which is merely a *description* of the program. CPU instructions are usually presented to human beings in *assembly*. Assembly is a programming language which has a one-to-one correspondance with CPU instructions. + +Viewing assembly code will be useful to understand some of the following sections which pertain to CPU instructions. + +In Julia, we can easily inspect the compiled assembly code using the `code_native` function or the equivalent `@code_native` macro. We can do this for a simple function: +""" + +# ╔═╡ a36582d4-8af0-11eb-2b5a-e577c5ed07e2 +# View assembly code generated from this function call +function foo(x) + s = zero(eltype(x)) + @inbounds for i in eachindex(x) + s = x[i ⊻ s] + end + return s +end; + +# ╔═╡ a74a9966-8af0-11eb-350f-6787d2759eba + @code_native foo([UInt(1)]) + +# ╔═╡ ae9ee028-8af0-11eb-10c0-6f2db3ab8025 +md""" +Let's break it down: + +The lines beginning with `;` are comments, and explain which section of the code the following instructions come from. They show the nested series of function calls, and where in the source code they are. You can see that `eachindex`, calls `axes1`, which calls `axes`, which calls `size`. Under the comment line containing the `size` call, we see the first CPU instruction. The instruction name is on the far left, `movq`. The name is composed of two parts, `mov`, the kind of instruction (to move content to or from a register), and a suffix `q`, short for "quad", which means 64-bit integer. There are the following suffixes: `b` (byte, 8 bit), `w` (word, 16 bit), `l`, (long, 32 bit) and `q` (quad, 64 bit). + +The next two columns in the instruction, `24(%rdi)` and `%rax` are the arguments to `movq`. These are the names of the registers (we will return to registers later) where the data to operate on are stored. + +You can also see (in the larger display of assembly code) that the code is segmented into sections beginning with a name starting with "L", for example, when I ran it, there's a section `L32`. These sections are jumped between using if-statements, or *branches*. Here, section `L32` marks the actual loop. You can see the following two instructions in the `L32` section: + +``` +; ││┌ @ promotion.jl:401 within `==' + cmpq $1, %rdi +; │└└ + jne L32 +``` + +The first instruction `cmpq` (compare quad) compares the data in registry `rdi`, which hold the data for the number of iterations left (plus one), with the number 1, and sets certain flags (wires) in the CPU based on the result. The next instruction `jne` (jump if not equal) makes a jump if the "equal" flag is not set in the CPU, which happens if there is one or more iterations left. You can see it jumps to `L32`, meaning this section repeat. +""" + +# ╔═╡ b73b5eaa-8af0-11eb-191f-cd15de19bc38 +md""" +#### Fast instruction, slow instruction +Not all CPU instructions are equally fast. Below is a table of selected CPU instructions with *very rough* estimates of how many clock cycles they take to execute. You can find much more detailed tables [in this document](https://www.agner.org/optimize/instruction_tables.pdf). Here, I'll summarize the speed of instructions on modern Intel CPUs. It's very similar for all modern CPUs. + +You will see that the time is given both as latency, and reciprocal throughput (that is, $1/throughput$). The reason is that CPUs contain multiple circuits for some operations that can operate in parallel. So while float multiplication has a latency of 5 clock cycles, if 10 floating point ops can be computed in parallel in 10 different circuits, it has a throughput of 2 ops/second, and so a reciprocal throughput of 0.5. + +The following table measures time in clock cycles: + +|Instruction |Latency|Rec. throughp.| +|------------------------|-------|--------------| +|move data | 1 | 0.25 +|and/or/xor | 1 | 0.25 +|test/compare | 1 | 0.25 +|do nothing | 1 | 0.25 +|int add/subtract | 1 | 0.25 +|bitshift | 1 | 0.5 +|float multiplication | 5 | 0.5 +|vector int and/or/xor | 1 | 0.5 +|vector int add/sub | 1 | 0.5 +|vector float add/sub | 4 | 0.5 +|vector float multiplic. | 5 | 0.5 +|lea | 3 | 1 +|int multiplic | 3 | 1 +|float add/sub | 3 | 1 +|float multiplic. | 5 | 1 +|float division | 15 | 5 +|vector float division | 13 | 8 +|integer division | 50 | 40 + + +The `lea` instruction takes three inputs, A, B and C, where A must be 1, 2, 4, or 8, and calculates AB + C. We'll come back to what the "vector" instructions do later. + +For comparison, we may also add some *very rough* estimates of other sources of delays: + +|Delay |Cycles| +|-----------------------|----| +|move memory from cache | 1 +|misaligned memory read | 10 +|cache miss | 500 +|read from disk | 5000000 +""" + +# ╔═╡ c0c757b2-8af0-11eb-38f1-3bc3ec4c43bc +md"If you have an inner loop executing millions of times, it may pay off to inspect the generated assembly code for the loop and check if you can express the computation in terms of fast CPU instructions. For example, if you have an integer you know to be 0 or above, and you want to divide it by 8 (discarding any remainder), you can instead do a bitshift, since bitshifts are way faster than integer division: +" + +# ╔═╡ c5472fb0-8af0-11eb-04f1-95a1f7b6b9e0 +begin + divide_slow(x) = div(x, 8) + divide_fast(x) = x >>> 3; +end; + +# ╔═╡ ce0e65d4-8af0-11eb-0c86-2105c26b62eb +md"However, modern compilers are pretty clever, and will often figure out the optimal instructions to use in your functions to obtain the same result, by for example replacing an integer divide `idivq` instruction with a bitshift right (`shrq`) where applicable to be faster. You need to check the assembly code yourself to see:" + +# ╔═╡ d376016a-8af0-11eb-3a15-4322759143d1 +# Calling it with these keywords removes comments in the assembly code +@code_native debuginfo=:none dump_module=false divide_slow(UInt(1)) + +# ╔═╡ d70c56bc-8af0-11eb-1220-09e78dba26f7 +md"## Allocations and immutability +As already mentioned, main RAM is much slower than the CPU cache. However, working in main RAM comes with an additional disadvantage: Programs are handed a bunch of RAM by the operating system (OS) to work with. Within that chunk of memory, the program itself needs to keep track of what RAM is in use by which objects. If the program didn't keep track, the creation of one object in memory could overwrite another object, causing data loss. Therefore, every creation and destruction of data in RAM requires book-keeping, that takes time. + +The creation of new objects in RAM is termed *allocation*, and the destruction is called *deallocation*. Really, the (de)allocation is not really *creation* or *destruction* per se, but rather the act of starting and stopping keeping track of the memory. Memory that is not kept track of will eventually be overwritten by other data. Allocation and deallocation take a significant amount of time depending on the size of objects, from a few tens of nanoseconds to a few microseconds per allocation. + +In programming languages such as Julia, Python, R and Java, deallocation is automatically done using a program called the *garbage collector* (GC). This program keeps track of which objects are rendered unreachable by the programmer, and deallocates them. For example, if you do:" + +# ╔═╡ dc24f5a0-8af0-11eb-0332-2bc0834d426c +begin + thing = [1,2,3] + thing = nothing +end + +# ╔═╡ e3c136de-8af0-11eb-06f1-9393c0f95fbb +md"Then there is no way to get the original array `[1,2,3]` back, it is unreachable. Hence it is simply wasting RAM, and doing nothing. It is *garbage*. Allocating and deallocating objects sometimes cause the GC to start its scan of all objects in memory and deallocate the unreachable ones, which causes significant lag. You can also start the garbage collector manually:" + +# ╔═╡ e836dac8-8af0-11eb-1865-e3feeb011fc4 +GC.gc() + +# ╔═╡ ecfd04e4-8af0-11eb-0962-f548d2eabad3 +md"The following example illustrates the difference in time spent in a function that allocates a vector with the new result relative to one which simply modifies the vector, allocating nothing:" + +# ╔═╡ f0e24b50-8af0-11eb-1a0e-5d925f3743e0 +begin + function increment(x::Vector{<:Integer}) + y = similar(x) + @inbounds for i in eachindex(x) + y[i] = x[i] + 1 + end + return y + end + + function increment!(x::Vector{<:Integer}) + @inbounds for i in eachindex(x) + x[i] = x[i] + 1 + end + return x + end +end; + +# ╔═╡ 22512ab2-8af1-11eb-260b-8d6c16762547 +md""" +On my computer, the allocating function is more than 15x slower on average. Also note the high maximum time spend on the allocating function. This is due to a few properties of the code: +* First, the allocation itself takes time +* Second, the allocated objects eventually have to be deallocated, also taking time +* Third, repeated allocations triggers the GC to run, causing overhead +* Fourth, more allocations sometimes means less efficient cache use because you are using more memory + +Note that I used the mean time instead of the median, since for this function the GC only triggers approximately every 30'th call, but it consumes 30-40 µs when it does. All this means performant code should keep allocations to a minimum. + +The `@btime` macro, and other benchmarking tools, tell you the number of allocations. This information is given because it is assumed that any programmer who cares to benchmark their code will be interested in reducing allocations. + +#### Not all objects need to be allocated +Inside RAM, data is kept on either the *stack* or the *heap*. The stack is a simple data structure with a beginning and end, similar to a `Vector` in Julia. The stack can only be modified by adding or subtracting elements from the end, analogous to a `Vector` with only the two mutating operations `push!` and `pop!`. These operations on the stack are very fast. When we talk about "allocations", however, we talk about data on the heap. Unlike the stack, the heap has an unlimited size (well, it has the size of your computer's RAM), and can be modified arbitrarily, deleting and accessing any objects. You can think of the stack like a `Vector`, and the heap like a `Dict`. + +Intuitively, it may seem obvious that all objects need to be placed in RAM, must be able to be retrieved and deleted at any time by the program, and therefore need to be allocated on the heap. And for some languages, like Python, this is true. However, this is not true in Julia and other efficient, compiled languages. Integers, for example, can often be placed on the stack. + +Why do some objects need to be heap allocated, while others can be stack allocated? To be stack-allocated, the compiler needs to know for certain that: + +* The object is a reasonably small size, so it fits on the stack. For technical reasons, the stack can't just be hundreds of megabytes in size. +* The compiler can predict exactly *when* it needs to create and destroy the object so it can destroy it timely by simply popping the stack (similar to calling `pop!` on a `Vector`). This is usually the case for local variables in compiled languages. + +Julia has even more constrains on stack-allocated objects. +* The object should have a fixed size known at compile time. +* The compiler must know that object never changes. The CPU is free to copy stack-allocated objects, and for immutable objects, there is no way to distinguish a copy from the original. This bears repeating: *With immutable objects, there is no way to distinguish a copy from the original*. This gives the compiler and the CPU certain freedoms when operating on it. The latter point is also why objects are immutable by default in Julia, and leads to one other performance tip: Use immutable objects wherever possible. + +What does this mean in practice? In Julia, it means if you want fast stack-allocated objects: +* Your object must be created, used and destroyed in a fully compiled function so the compiler knows for certain when it needs to create, use and destroy the object. If the object is returned for later use (and not immediately returned to another, fully compiled function), we say that the object *escapes*, and must be allocated. +* Your type must be limited in size. I don't know exactly how large it has to be, but 100 bytes is fine. +* The exact memory layout of your type must be known by the compiler (it nearly always is). +""" + +# ╔═╡ 2a7c1fc6-8af1-11eb-2909-554597aa2949 +begin + abstract type AllocatedInteger end + + struct StackAllocated <: AllocatedInteger + x::Int + end + + mutable struct HeapAllocated <: AllocatedInteger + x::Int + end +end + +# ╔═╡ 2e3304fe-8af1-11eb-0f6a-0f84d58326bf +md"We can inspect the code needed to instantiate a `HeapAllocated` object with the code needed to instantiate a `StackAllocated` one:" + +# ╔═╡ 33350038-8af1-11eb-1ff5-6d42d86491a3 +@code_native debuginfo=:none dump_module=false HeapAllocated(1) + +# ╔═╡ 3713a8da-8af1-11eb-2cb2-1957455227d0 +md"Notice the `callq` instruction in the `HeapAllocated` one. This instruction calls out to other functions, meaning that in fact, much more code is really needed to create a `HeapAllocated` object that what is displayed. In constrast, the `StackAllocated` really only needs a few instructions:" + +# ╔═╡ 59f58f1c-8af1-11eb-2e88-997e9d4bcc48 +@code_native debuginfo=:none dump_module=false StackAllocated(1) + +# ╔═╡ 5c86e276-8af1-11eb-2b2e-3386e6795f37 +md" +Because immutable objects dont need to be stored on the heap and can be copied freely, immutables are stored *inline* in arrays. This means that immutable objects can be stored directly inside the array's memory. Mutable objects have a unique identity and location on the heap. They are distinguishable from copies, so cannot be freely copied, and so arrays contain reference to the memory location on the heap where they are stored. Accessing such an object from an array then means first accessing the array to get the memory location, and then accessing the object itself using that memory location. Beside the double memory access, objects are stored less efficiently on the heap, meaning that more memory needs to be copied to CPU caches, meaning more cache misses. Hence, even when stored on the heap in an array, immutables can be stored more effectively. +" + +# ╔═╡ 6849d9ec-8af1-11eb-06d6-db49af4796bc +md"We can verify that, indeed, the array in the `data_stack` stores the actual data of a `StackAllocated` object, whereas the `data_heap` contains pointers (i.e. memory addresses):" + +# ╔═╡ 74a3ddb4-8af1-11eb-186e-4d80402adfcf +md"## Registers and SIMD +It is time yet again to update our simplified computer schematic. A CPU operates only on data present in *registers*. These are small, fixed size slots (e.g. 8 bytes in size) inside the CPU itself. A register is meant to hold one single piece of data, like an integer or a floating point number. As hinted in the section on assembly code, each instruction usually refers to one or two registers which contain the data the operation works on: + +$$[CPU] ↔ [REGISTERS] ↔ [CACHE] ↔ [RAM] ↔ [DISK CACHE] ↔ [DISK]$$ + +To operate on data structures larger than one register, the data must be broken up into smaller pieces that fits inside the register. For example, when adding two 128-bit integers on my computer:" + +# ╔═╡ 7a88c4ba-8af1-11eb-242c-a1813a9e6741 +@code_native debuginfo=:none dump_module=false UInt128(5) + UInt128(11) + +# ╔═╡ 7d3fcbd6-8af1-11eb-0441-2f88a9d59966 +md"""There is no register that can do 128-bit additions. First the lower 64 bits must be added using a `addq` instruction, fitting in a register. Then the upper bits are added with a `adcq` instruction, which adds the digits, but also uses the carry bit from the previous instruction. Finally, the results are moved 64 bits at a time using `movq` instructions. + +The small size of the registers serves as a bottleneck for CPU throughput: It can only operate on one integer/float at a time. In order to sidestep this, modern CPUs contain specialized 256-bit registers (or 128-bit in older CPUs, or 512-bit in the brand new ones) than can hold 4 64-bit integers/floats at once, or 8 32-bit integers, etc. Confusingly, the data in such wide registers are termed "vectors." The CPU have access to instructions that can perform various CPU operations on vectors, operating on 4 64-bit integers in one instruction. This is called "single instruction, multiple data," *SIMD*, or *vectorization*. Notably, a 4x64 bit operation is *not* the same as a 256-bit operation, e.g. there is no carry-over with between the 4 64-bit integers when you add two vectors. Instead, a 256-bit vector operation is equivalent to 4 individual 64-bit operations. + +We can illustrate this with the following example:""" + +# ╔═╡ 8c2ed15a-8af1-11eb-2e96-1df34510e773 +md""" +Here, two 8×32 bit vectors are added together in one single instruction. You can see the CPU makes use of a single `vpaddd` (vector packed add double) instruction to add 8 32-bit integers, as well as the corresponding move instruction `vmovdqu`. Note that vector CPU instructions begin with `v`. + +It's worth mentioning the interaction between SIMD and alignment: If a series of 256-bit (32-byte) SIMD loads are misaligned, then up to half the loads could cross cache line boundaries, as opposed to just 1/8th of 8-byte loads. Thus, alignment is a much more serious issue when using SIMD. Since array beginnings are always aligned, this is usually not an issue, but in cases where you are not guaranteed to start from an aligned starting point, such as with matrix operations, this may make a significant difference. In brand new CPUs with 512-bit registers, the issues is even worse as the SIMD size is the same as the cache line size, so *all* loads would be misaligned if the initial load is. + +SIMD vectorization of e.g. 64-bit integers may increase throughput by almost 4x, so it is of huge importance in high-performance programming. Compilers will automatically vectorize operations if they can. What can prevent this automatic vectorization? + +#### SIMD needs uninterrupted iteration of fixed length +Because vectorized operations operate on multiple data at once, it is not possible to interrupt the loop at an arbitrary point. For example, if 4 64-bit integers are processed in one clock cycle, it is not possible to stop a SIMD loop after 3 integers have been processed. Suppose you had a loop like this: + +```julia +for i in 1:8 + if foo() + break + end + # do stuff with my_vector[i] +end +``` + +Here, the loop could end on any iteration due to the break statement. Therefore, any SIMD instruction which loaded in multiple integers could operate on data *after* the loop is supposed to break, i.e. data which is never supposed to be read. This would be wrong behaviour, and so, the compiler cannot use SIMD instructions. + +A good rule of thumb is that SIMD needs: +* A loop with a predetermined length, so it knows when to stop, and +* A loop with no branches (i.e. if-statements) in the loop + +In fact, even boundschecking, i.e. checking that you are not indexing outside the bounds of a vector, causes a branch. After all, if the code is supposed to raise a bounds error after 3 iterations, even a single SIMD operation would be wrong! To achieve SIMD vectorization then, all boundschecks must be disabled. + +Fortunately, in the latest versions of Julia, the compiler has been pretty smart at figuring out when it can SIMD even when boundschecking. + +To demonstrate the significant impact of SIMDd, we can use a function that uses an input function to break a loop. We can then compare the speed of the function when given a function that the compiler knows will never break the loop and so can SIMDd, with a function that might break the loop.""" + +# ╔═╡ 94182f88-8af1-11eb-207a-37083c1ead68 +begin + # The loop in the function breaks if pred(x[i]) + # returns `true`, and therefore cannot be SIMDd + function sum_predicate(pred, x::Vector) + n = zero(eltype(x)) + for i in eachindex(x) + y = x[i] + pred(y) && break + n += y + end + return n + end +end; + +# ╔═╡ aa3931fc-8af1-11eb-2f42-f582b8e639ad +md""" +On my computer, the SIMD code is 10x faster than the non-SIMD code. SIMD alone accounts for only about 4x improvements (since we moved from 64-bits per iteration to 256 bits per iteration). The rest of the gain comes from not spending time checking the bounds and from automatic loop unrolling (explained later), which is also made possible by the `@inbounds` annotation. + +#### SIMD needs a loop where loop order doesn't matter +SIMD can change the order in which elements in an array is processed. If the result of any iteration depends on any previous iteration such that the elements can't be re-ordered, the compiler will usually not SIMD-vectorize. Often when a loop won't auto-vectorize, it's due to subtleties in which data moves around in registers means that there will be some hidden memory dependency between elements in an array. + +Imagine we want to sum some 64-bit integers in an array using SIMD. For simplicity, let's say the array has 8 elements, `A`, `B`, `C` ... `H`. In an ordinary non-SIMD loop, the additions would be done like so: + +$$(((((((A + B) + C) + D) + E) + F) + G) + H)$$ + +Whereas when loading the integers using SIMD, four 64-bit integers would be loaded into one vector ``, and the other four into another ``. The two vectors would be added: ``. After the loop, the four integers in the resulting vector would be added. So the overall order would be: + +$$((((A + E) + (B + F)) + (C + G)) + (D + H))$$ + +Perhaps surprisingly, addition of floating point numbers can give different results depending on the order (i.e. float addition is not associative): +""" + +# ╔═╡ c01bf4b6-8af1-11eb-2f17-bfe0c93d48f9 +begin + x = eps(1.0) * 0.4 + 1.0 + (x + x) == (1.0 + x) + x +end + +# ╔═╡ c80e05ba-8af1-11eb-20fc-235b45f2eb4b +md"for this reason, float addition will not auto-vectorize:" + +# ╔═╡ e3931226-8af1-11eb-0da5-fb3c1c22d12e +md"However, high-performance programming languages usually provide a command to tell the compiler it's alright to re-order the loop, even for non-associative loops. In Julia, this command is the `@simd` macro:" + +# ╔═╡ e793e300-8af1-11eb-2c89-e7bc1be249f0 +function sum_simd(x::Vector) + n = zero(eltype(x)) + # Here we add the `@simd` macro to allow SIMD of floats + @inbounds @simd for i in eachindex(x) + n += x[i] + end + return n +end; + +# ╔═╡ f0a4cb58-8af1-11eb-054c-03192285b5e2 +md""" +Julia also provides the macro `@simd ivdep` which further tells the compiler that there are no memory-dependencies in the loop order. However, I *strongly discourage* the use of this macro, unless you *really* know what you're doing. In general, the compiler knows best when a loop has memory dependencies, and misuse of `@simd ivdep` can very easily lead to bugs that are hard to detect. +""" + +# ╔═╡ f5c28c92-8af1-11eb-318f-5fa059d8fd80 +md""" +## Struct of arrays +If we create an array containing four `AlignmentTest` objects `A`, `B`, `C` and `D`, the objects will lie end to end in the array, like this: + + Objects: | A | B | C | D | + Fields: | a | b |c| | a | b |c| | a | b |c| | a | b |c| | + Byte: 1 9 17 25 33 + +Note again that byte no. 8, 16, 24 and 32 are empty to preserve alignment, wasting memory. +Now suppose you want to do an operation on all the `.a` fields of the structs. Because the `.a` fields are scattered 8 bytes apart, SIMD operations are much less efficient (loading up to 4 fields at a time) than if all the `.a` fields were stored together (where 8 fields could fit in a 256-bit register). When working with the `.a` fields only, the entire 64-byte cache lines would be read in, of which only half, or 32 bytes would be useful. Not only does this cause more cache misses, we also need instructions to pick out the half of the data from the SIMD registers we need. + +The memory structure we have above is termed an "array of structs," because, well, it is an array filled with structs. Instead we can strucure our 4 objects `A` to `D` as a "struct of arrays." Conceptually, it could look like: +""" + +# ╔═╡ fc2d2f1a-8af1-11eb-11a4-8700f94e866e +struct AlignmentTestVector + a::Vector{UInt32} + b::Vector{UInt16} + c::Vector{UInt8} +end + +# ╔═╡ 007cd39a-8af2-11eb-053d-f584d68f7d2f +md""" +With the following memory layout for each field: + + Object: AlignmentTestVector + .a | A | B | C | D | + .b | A | B | C | D | + .c |A|B|C|D| + +Alignment is no longer a problem, no space is wasted on padding. When running through all the `a` fields, all cache lines contain full 64 bytes of relevant data, so SIMD operations do not need extra operations to pick out the relevant data: +""" + +# ╔═╡ 72fbb3ec-8ee8-11eb-3836-11092ef74e86 +function Base.rand(::Type{AlignmentTest}) + AlignmentTest(rand(UInt32), rand(UInt16), rand(UInt8)) +end; + +# ╔═╡ abb45d6a-8aef-11eb-37a4-7b10847b39b4 +begin + # Open a file + function test_file(path) + open(path) do file + # Go to 1000'th byte of file and read it + seek(file, 1000) + read(file, UInt8) + end + end + + # Randomly access data N times + function random_access(data::Vector{UInt}, N::Integer) + n = rand(UInt) + mask = length(data) - 1 + @inbounds for i in 1:N + n = (n >>> 7) ⊻ data[n & mask + 1] + end + return n + end +end; + +# ╔═╡ bff99828-8aef-11eb-107b-a5c67101c735 +let + data = rand(UInt, 2^24) + @time test_file("../alen/src/main.rs") + @time random_access(data, 1000000) + nothing +end + +# ╔═╡ b73605ca-8ee4-11eb-1a0d-bb6678de91c6 +begin + @btime random_access($(rand(UInt, 1024)), 2^20) seconds=1 + @btime random_access($(rand(UInt, 2^24)), 2^20) seconds=1 + nothing +end + +# ╔═╡ ffca4c72-8aef-11eb-07ac-6d5c58715a71 +function linear_access(data::Vector{UInt}, N::Integer) + n = rand(UInt) + mask = length(data) - 1 + for i in 1:N + n = (n >>> 7) ⊻ data[(15 * i) & mask + 1] + end + return n +end; + +# ╔═╡ e71e4798-8ee4-11eb-3ea2-fdbbcdcf7410 +let + data = rand(UInt, 2^24) + @btime random_access($data, 2^20) seconds=1 + @btime linear_access($data, 2^20) seconds=1 + nothing +end + +# ╔═╡ 18e8e4b6-8af0-11eb-2f17-2726f162e9b0 +function alignment_test(data::Vector{UInt}, offset::Integer) + # Jump randomly around the memory. + n = rand(UInt) + mask = (length(data) - 9) ⊻ 7 + GC.@preserve data begin # protect the array from moving in memory + ptr = pointer(data) + iszero(UInt(ptr) & 63) || error("Array not aligned") + ptr += (offset & 63) + for i in 1:4096 + n = (n >>> 7) ⊻ unsafe_load(ptr, (n & mask + 1) % Int) + end + end + return n +end; + +# ╔═╡ 1f38f8c6-8ee5-11eb-1c01-f3706534a9cf +let + data = rand(UInt, 256 + 8) + @btime alignment_test($data, 0) seconds=1 + @btime alignment_test($data, 60) seconds=1 + nothing +end + +# ╔═╡ 3fae31a0-8af0-11eb-1ea8-7980e7875039 +let + memory_address = reinterpret(UInt, pointer(rand(1024))) + @assert iszero(memory_address % 64) # should not error! +end + +# ╔═╡ 11c500e8-8ee2-11eb-3291-4382b60c5a2b +let + data = rand(UInt, 2^10) + show(stdout, MIME"text/plain"(), @benchmark increment($data) seconds=1) + println('\n') + show(stdout, MIME"text/plain"(), @benchmark increment!($data) seconds=1) +end + +# ╔═╡ 61ee9ace-8af1-11eb-34bd-c5af962c8d82 +let + Base.:+(x::Int, y::AllocatedInteger) = x + y.x + Base.:+(x::AllocatedInteger, y::AllocatedInteger) = x.x + y.x + + data_stack = [StackAllocated(i) for i in rand(UInt16, 1000000)] + data_heap = [HeapAllocated(i.x) for i in data_stack] + + @btime sum($data_stack) seconds=1 + @btime sum($data_heap) seconds=1 + nothing +end + +# ╔═╡ 6ba266f4-8af1-11eb-10a3-3daf6e473142 +let + data_stack = [StackAllocated(i) for i in rand(UInt16, 1)] + data_heap = [HeapAllocated(i.x) for i in data_stack] + + println(rpad("First object of data_stack:", 36), data_stack[1]) + println( + rpad("First data in data_stack array:", 36), + unsafe_load(pointer(data_stack)), + '\n' + ) + + println(rpad("First object of data_heap:", 36), data_heap[1]) + first_data = unsafe_load(Ptr{UInt}(pointer(data_heap))) + println(rpad("First data in data_heap array:", 36), repr(first_data)) + println( + "Data at address ", + repr(first_data), ": ", + unsafe_load(Ptr{HeapAllocated}(first_data)) + ) +end + +# ╔═╡ 84c0d56a-8af1-11eb-30f3-d137b377c31f +let + add_tuple(a, b) = a .+ b + + # Create a tuple of 8 32-bit integers. + # could also have created 4 64-bit numbers etc. + numbers = ntuple(i -> rand(UInt32), 8) + @code_native debuginfo=:none dump_module=false add_tuple(numbers, numbers) + nothing +end + +# ╔═╡ a0286cdc-8af1-11eb-050e-072acdd4f0a0 +let + # Make sure the vector is small so we don't time cache misses + data = rand(UInt64, 4096) + + # For a function that always returns false, the compiler + # knows it can never break, and so will SIMD + @btime sum_predicate(Returns(false), $data) seconds=1 + + # This function has a 1/2^64 risk of returning true; + # while practically impossible, the compiler cannot + # guarantee it won't break the loop, and so will not SIMD + @btime sum_predicate(iszero, $data) seconds=1 + nothing +end + +# ╔═╡ cc99d9ce-8af1-11eb-12ec-fbd6df3becc8 +let + data = rand(Float64, 4096) + @btime sum_predicate(Returns(false), $data) seconds=1 + @btime sum_predicate(iszero, $data) seconds=1 + nothing +end + +# ╔═╡ e8d2ec8e-8af1-11eb-2018-1fa4df5b47ad +let + data = rand(Float64, 4096) + @btime sum_predicate(Returns(false), $data) seconds=1 + @btime sum_simd($data) seconds=1 + nothing +end + +# ╔═╡ 054d848a-8af2-11eb-1f98-67f5d0b9f4ec +let + N = 1_000_000 + array_of_structs = [rand(AlignmentTest) for i in 1:N] + struct_of_arrays = AlignmentTestVector( + rand(UInt32, N), + rand(UInt16, N), + rand(UInt8, N) + ) + + @btime sum(x -> x.a, $array_of_structs) seconds=1 + @btime sum($struct_of_arrays.a) seconds=1 + nothing +end + +# ╔═╡ 0dfc5054-8af2-11eb-098d-35f4e69ae544 +md""" +## Specialized CPU instructions + +Most code makes use of only a score of simple CPU instructions like move, add, multiply, bitshift, and, or, xor, jumps, and so on. However, CPUs in the typical modern laptop support a *lot* of CPU instructions. Usually, if an operation is used heavily in consumer laptops, CPU manufacturers will add specialized instructions to speed up these operations. Depending on the hardware implementation of the instructions, the speed gain from using these instructions can be significant. + +Julia only exposes a few specialized instructions, including: + +* The number of set bits in an integer is effectively counted with the `popcnt` instruction, exposed via the `count_ones` function. +* The `tzcnt` instructions counts the number of trailing zeros in the bits an integer, exposed via the `trailing_zeros` function +* The order of individual bytes in a multi-byte integer can be reversed using the `bswap` instruction, exposed via the `bswap` function. This can be useful when having to deal with [endianness](https://en.wikipedia.org/wiki/Endianness). + +The following example illustrates the performance difference between a manual implementation of the `count_ones` function, and the built-in version, which uses the `popcnt` instruction: +""" + +# ╔═╡ 126300a2-8af2-11eb-00ea-e76a979aef45 +function manual_count_ones(x) + n = 0 + while x != 0 + n += x & 1 + x >>>= 1 + end + return n +end; + +# ╔═╡ 14e46866-8af2-11eb-0894-bba824f266f0 +let + data = rand(UInt, 10000) + @btime sum(manual_count_ones, $data) seconds=1 + @btime sum(count_ones, $data) seconds=1 + nothing +end + +# ╔═╡ 1e7edfdc-8af2-11eb-1429-4d4220bad0f0 +md""" +The timings you observe here will depend on whether your compiler is clever enough to realize that the computation in the first function can be expressed as a `popcnt` instruction, and thus will be compiled to that. On my computer, the compiler is not able to make that inference, and the second function achieves the same result more than 100x faster. + +#### Call any CPU instruction +Julia makes it possible to call CPU instructions direcly. This is not generally advised, since not all your users will have access to the same CPU with the same instructions, and so your code will crash on users working on computers of different brands. + +The latest CPUs contain specialized instructions for AES encryption and SHA256 hashing. If you wish to call these instructions, you can call Julia's backend compiler, LLVM, directly. In the example below, I create a function which calls the `vaesenc` (one round of AES encryption) instruction directly: +""" + +# ╔═╡ 25a47c54-8af2-11eb-270a-5b58c3aafe6e +begin + # This is a 128-bit CPU "vector" in Julia + const __m128i = NTuple{2, VecElement{Int64}} + + # Define the function in terms of LLVM instructions + aesenc(a, roundkey) = ccall( + "llvm.x86.aesni.aesenc", llvmcall, __m128i, + (__m128i, __m128i), a, roundkey + ) +end; + +# ╔═╡ 2dc4f936-8af2-11eb-1117-9bc10e619ec6 +md"(Thanks to Kristoffer Carlsson for [the example](http://kristofferc.github.io/post/intrinsics/)). We can verify it works by checking the assembly of the function, which should contain only a single `vaesenc` instruction, as well as the `retq` (return) and the `nopw` (do nothing, used as a filler to align the CPU instructions in memory) instruction:" + +# ╔═╡ 76a4e83c-8af2-11eb-16d7-75eaabcb21b6 +@code_native debuginfo=:none dump_module=false aesenc( + __m128i((1, 1)), __m128i((1, 1)) +) + +# ╔═╡ 797264de-8af2-11eb-0cb0-adf3fbc95c90 +md"""Algorithms which makes use of specialized instructions can be extremely fast. [In a blog post](https://mollyrocket.com/meowhash), the video game company Molly Rocket unveiled a new non-cryptographic hash function using AES instructions which reached unprecedented speeds.""" + +# ╔═╡ 80179748-8af2-11eb-0910-2b825104159d +md"## Inlining +Consider the assembly of this function:" + +# ╔═╡ 36b723fc-8ee9-11eb-1b92-451b992acc0c +f() = error(); + +# ╔═╡ 8af63980-8af2-11eb-3028-83a935bac0db +md""" +This code contains the `callq` instruction, which calls another function. A function call comes with some overhead depending on the arguments of the function and other things. While the time spent on a function call is measured in nanoseconds, it can add up if the function called is in a tight loop. + +However, if we show the assembly of this function: +""" + +# ╔═╡ 50ab0cf6-8ee9-11eb-3e04-af5fef7f2850 +call_plus(x) = x + 1; + +# ╔═╡ 93af6754-8af2-11eb-0fe6-216d76e683de +@code_native debuginfo=:none dump_module=false call_plus(1) + +# ╔═╡ a105bd68-8af2-11eb-31f6-3335b4fb0f08 +md""" +The function `call_plus` calls `+`, and is compiled to a single `leaq` instruction (as well as some filler `retq` and `nopw`). But `+` is a normal Julia function, so `call_plus` is an example of one regular Julia function calling another. Why is there no `callq` instruction to call `+`? + +The compiler has chosen to *inline* the function `+` into `call_plus`. That means that instead of calling `+`, it has copied the *content* of `+` directly into `call_plus`. The advantages of this is: +* There is no overhead from the function call +* There is no need to construct a `Tuple` to hold the arguments of the `+` function +* Whatever computations happens in `+` is compiled together with `call_plus`, allowing the compiler to use information from one in the other and possibly simplify some calculations. + +So why aren't *all* functions inlined then? Inlining copies code, increases the size of it and consuming RAM. Furthermore, the *CPU instructions themselves* also needs to fit into the CPU cache (although CPU instructions have their own cache) in order to be efficiently retrieved. If everything was inlined, programs would be enormous and grind to a halt. Inlining is only an improvement if the inlined function is small. + +Instead, the compiler uses heuristics (rules of thumb) to determine when a function is small enough for inlining to increase performance. These heuristics are not bulletproof, so Julia provides the macros `@noinline`, which prevents inlining of small functions (useful for e.g. functions that raises errors, which must be assumed to be called rarely), and `@inline`, which does not *force* the compiler to inline, but *strongly suggests* to the compiler that it ought to inline the function. + +If code contains a time-sensitive section, for example an inner loop, it is important to look at the assembly code to verify that small functions in the loop is inlined. For example, in [this line in my kmer hashing code](https://github.com/jakobnissen/Kash.jl/blob/b9a6e71acf9651d3614f92d5d4b29ffd136bcb5c/src/kmersketch.jl#L41), overall minhashing performance drops by a factor of two if this `@inline` annotation is removed. + +An extreme difference between inlining and no inlining can be demonstrated thus: +""" + +# ╔═╡ a843a0c2-8af2-11eb-2435-17e2c36ec253 +begin + @noinline noninline_poly(x) = x^3 - 4x^2 + 9x - 11 + inline_poly(x) = x^3 - 4x^2 + 9x - 11 + + function time_function(F, x::AbstractVector) + n = 0 + for i in x + n += F(i) + end + return n + end +end; + +# ╔═╡ b4d9cbb8-8af2-11eb-247c-d5b16e0de13f +let + data = rand(UInt, 1024) + @btime time_function(noninline_poly, $data) seconds=1 + @btime time_function(inline_poly, $data) seconds=1 + nothing +end + +# ╔═╡ bc0a2f22-8af2-11eb-3803-f54f84ddfc46 +md""" +## Unrolling +Consider a function that sums a vector of 64-bit integers. If the vector's data's memory offset is stored in register `%r9`, the length of the vector is stored in register `%r8`, the current index of the vector in `%rcx` and the running total in `%rax`, the assembly of the inner loop could look like this: + +``` +L1: + ; add the integer at location %r9 + %rcx * 8 to %rax + addq (%r9,%rcx,8), %rax + + ; increment index by 1 + addq $1, %rcx + + ; compare index to length of vector + cmpq %r8, %rcx + + ; repeat loop if index is smaller + jb L1 +``` + +For a total of 4 instructions per element of the vector. The actual code generated by Julia will be similar to this, but also incluce extra instructions related to bounds checking that are not relevant here (and of course will include different comments). + +However, if the function is written like this: + +```julia +function sum_vector(v::Vector{Int}) + n = 0 + i = 1 + for chunk in 1:div(length(v), 4) + n += v[i + 0] + n += v[i + 1] + n += v[i + 2] + n += v[i + 3] + i += 4 + end + return n +end +``` + +The result is obviously the same if we assume the length of the vector is divisible by four. If the length is not divisible by four, we could simply use the function above to sum the first $N - rem(N, 4)$ elements and add the last few elements in another loop. Despite the functionally identical result, the assembly of the loop is different and may look something like: + +``` +L1: + addq (%r9,%rcx,8), %rax + addq 8(%r9,%rcx,8), %rax + addq 16(%r9,%rcx,8), %rax + addq 24(%r9,%rcx,8), %rax + addq $4, %rcx + cmpq %r8, %rcx + jb L1 +``` + +For a total of 7 instructions per 4 additions, or 1.75 instructions per addition. This is less than half the number of instructions per integer! The speed gain comes from simply checking less often when we're at the end of the loop. We call this process *unrolling* the loop, here by a factor of four. Naturally, unrolling can only be done if we know the number of iterations beforehand, so we don't "overshoot" the number of iterations. Often, the compiler will unroll loops automatically for extra performance, but it can be worth looking at the assembly. For example, this is the assembly for the innermost loop generated on my computer for `sum([1])`: + + L144: + vpaddq 16(%rcx,%rax,8), %ymm0, %ymm0 + vpaddq 48(%rcx,%rax,8), %ymm1, %ymm1 + vpaddq 80(%rcx,%rax,8), %ymm2, %ymm2 + vpaddq 112(%rcx,%rax,8), %ymm3, %ymm3 + addq $16, %rax + cmpq %rax, %rdi + jne L144 + +Where you can see it is both unrolled by a factor of four, and uses 256-bit SIMD instructions, for a total of 128 bytes, 16 integers added per iteration, or 0.44 instructions per integer. + +Notice also that the compiler chooses to use 4 different `ymm` SIMD registers, `ymm0` to `ymm3`, whereas in my example assembly code, I just used one register `rax`. This is because, if you use 4 independent registers, then you don't need to wait for one `vpaddq` to complete (remember, it had a ~3 clock cycle latency) before the CPU can begin the next. + +The story for unrolling is similar to that for SIMD: The compiler will only unroll a loop if it can tell _for sure_ that it will not overshoot the number of iterations. For example, compare the two following functions: +""" + +# ╔═╡ f0bc1fdc-8ee9-11eb-2916-d71e1cf36375 +let + data = fill(false, 2^20) + + # any: Stops as soon as it finds a `true` + @btime any($data) seconds=1 + + # foldl: Loops over all values in the array + @btime foldl(|, $data) seconds=1 + + data[1] = true + @btime any($data) seconds=1 + @btime foldl(|, $data) seconds=1 + nothing +end + +# ╔═╡ 36a2872e-8eeb-11eb-0999-4153ced71678 +md""" +The _first_ function stops and returns as soon as it finds a `true` value - but this break in the loop disables SIMD and unrolling. The _second_ function continues throughout the entire array, even if the very first value is `true`. While this enables SIMD and unrolling, it's obviously wasteful if it sees a `true` right in the beginning. Hence, the first is better when we expect to see the first `true` before around 1/4th of the way though the array, the latter better otherwise. + +We can create a compromise by manually unrolling. In the functions below, `check128` checks 128 entries using `inbounds`, without stopping underway to check if it's found a `true`, and is thus unrolled and SIMDd. `unroll_compromise` then uses `check128`, but breaks out of the loop as soon as it finds a `true.` +""" + +# ╔═╡ 9ca70cfc-8eeb-11eb-361b-b929089ca109 +begin + @inline function check128(data, i) + n = false + @inbounds for j in 0:127 + n |= data[i+j] + end + n + end + + function unroll_compromise(data) + found = false + i = 1 + while !found & (i ≤ length(data)) + check128(data, i) && return true + i += 128 + end + return false + end +end; + +# ╔═╡ d4a43094-8eeb-11eb-106f-3b54253aa663 +let + data = fill(false, 2^20) + @btime foldl(|, $data) seconds=1 + @btime unroll_compromise($data) seconds=1 + + data[1] = true + @btime any($data) seconds=1 + @btime unroll_compromise($data) seconds=1 + nothing +end + +# ╔═╡ 270950ac-8eed-11eb-365d-df9d36d090bc +md""" +We see excellent performance for both arrays with no `trues`, and for the one with a `true` right in the beginning. + +Unfortunately, I'm not aware of any way to automatically generate this kind of unrolling, where you want a compromise between unrolling smaller chunks, and including branches in between each chunk. Perhaps in the future, this desire can be communicated to the compiler, such that the optimal code is automatically generated. +""" + +# ╔═╡ c36dc5f8-8af2-11eb-3f35-fb86143a54d2 +md""" +## Avoid unpredicable branches +As mentioned previously, CPU instructions take multiple cycles to complete, but may be queued into the CPU before the previous instruction has finished computing. So what happens when the CPU encounters a branch (i.e. a jump instruction)? It can't know which instruction to queue next, because that depends on the instruction that it just put into the queue and which has yet to be executed. + +Modern CPUs make use of *branch prediction*. The CPU has a *branch predictor* circuit, which guesses the correct branch based on which branches were recently taken. In essense, the branch predictor attempts to learn simple patterns in which branches are taken in code, while the code is running. After queueing a branch, the CPU immediately queues instructions from whatever branch predicted by the branch predictor. The correctness of the guess is verified later, when the queued branch is being executed. If the guess was correct, great, the CPU saved time by guessing. If not, the CPU has to empty the pipeline and discard all computations since the initial guess, and then start over. This process causes a delay of a few nanoseconds. + +For the programmer, this means that the speed of an if-statement depends on how easy it is to guess. If it is trivially easy to guess, the branch predictor will be correct almost all the time, and the if statement will take no longer than a simple instruction, typically 1 clock cycle. In a situation where the branching is random, it will be wrong about 50% of the time, and each misprediction may cost many clock cycles. + +Branches caused by loops are among the easiest to guess. If you have a loop with 1000 elements, the code will loop back 999 times and break out of the loop just once. Hence the branch predictor can simply always predict "loop back", and get a 99.9% accuracy. + +We can demonstrate the performance of branch misprediction with a simple function: +""" + +# ╔═╡ c96f7f50-8af2-11eb-0513-d538cf6bc619 +# Copy all odd numbers from src to dst. +function copy_odds_branches!(dst::Vector{T}, src::Vector{T}) where {T <: Integer} + write_index = 1 + @inbounds for i in eachindex(src) # <--- this branch is trivially easy to predict + v = src[i] + if isodd(v) # <--- this is the branch we want to predict + dst[write_index] = v + write_index += 1 + end + end + return dst +end; + +# ╔═╡ cf90c600-8af2-11eb-262a-2763ae29b428 +let + dst = rand(UInt32, 2^18) + src_random = rand(UInt32, 2^18) + src_all_odd = [(2*i+1) % UInt32 for i in src_random] + @btime copy_odds_branches!($dst, $src_random) seconds=1 + @btime copy_odds_branches!($dst, $src_all_odd) seconds=1 + nothing +end + +# ╔═╡ d53422a0-8af2-11eb-0417-b9740c4a571c +md""" +In the first case, the integers are random, and about half the branches will be mispredicted causing delays. In the second case, the branch is always taken, the branch predictor is quickly able to pick up the pattern and will reach near 100% correct prediction. As a result, on my computer, the latter is around 8x faster. + +Note that if you use smaller vectors and repeat the computation many times, as the `@btime` macro does, the branch predictor is able to learn the pattern of the small random vectors by heart, and will reach much better than random prediction. This is especially pronounced in the most modern CPUs (and in particular the CPUs sold by AMD, I hear) where the branch predictors have gotten much better. This "learning by heart" is an artifact of the loop in the benchmarking process. You would not expect to run the exact same computation repeatedly on real-life data: +""" + +# ╔═╡ dc5b9bbc-8af2-11eb-0197-9b5da5087f0d +let + src_random = rand(UInt32, 128) + dst = similar(src_random) + src_all_odd = [(2i+1) % UInt32 for i in src_random] + + @btime copy_odds_branches!($dst, $src_random) seconds=1 + @btime copy_odds_branches!($dst, $src_all_odd) seconds=1 + nothing +end + +# ╔═╡ e735a302-8af2-11eb-2ce7-01435b60fdd9 +md""" +Because branches are very fast if they are predicted correctly, highly predictable branches caused by error checks are not of much performance concern, assuming that the code essensially never errors. Hence a branch like bounds checking is very fast. You should only remove bounds checks if absolutely maximal performance is critical, or if the bounds check happens in a loop which would otherwise SIMD-vectorize. + +If branches cannot be easily predicted, it is often possible to re-phrase the function to avoid branches all together. For example, in the `copy_odds!` example above, we could instead write it like so: +""" + +# ╔═╡ eb158e60-8af2-11eb-2227-59d6404e3335 +function copy_odds_branchless!(dst::Vector{T}, src::Vector{T}) where {T <: Integer} + write_index = 1 + @inbounds for i in eachindex(src) + v = src[i] + dst[write_index] = v + write_index += isodd(v) + end + return dst +end; + +# ╔═╡ ee579dca-8af2-11eb-140f-a96778b7b39f +let + dst = rand(UInt32, 2^18) + src_random = rand(UInt32, 2^18) + src_all_odd = [(2*i+1) % UInt32 for i in src_random] + @btime copy_odds_branchless!($dst, $src_random) seconds=1 + @btime copy_odds_branchless!($dst, $src_all_odd) seconds=1 + nothing +end + +# ╔═╡ f969eed2-8af2-11eb-1e78-5b322a7f4ebd +md""" +Which contains no other branches than the one caused by the loop itself (which is easily predictable), and results in speeds slightly worse than the perfectly predicted one, but much better for random data. + +The compiler will often remove branches in your code when the same computation can be done using other instructions. When the compiler fails to do so, Julia offers the `ifelse` function, which sometimes can help elide branching. +""" + +# ╔═╡ 72e1b146-8c1c-11eb-2c56-b1342271c2f6 +md""" +## Be aware of memory dependencies + +Thinking about it more deeply, why *is* the perfectly predicted example above faster than the solution that avoids having that extra branch there at all? + +Let's look at the assembly code. Here, I've just cut out the assembly for the loop (since almost all time is spent there) + +For the branch-ful version, we have: +```julia +1 L48: +2 incq %rsi +3 cmpq %rsi, %r9 +4 je L75 +5 L56: +6 movq (%rdx,%rsi,8), %rcx +7 testb $1, %cl +8 je L48 +9 movq %rcx, -8(%r8,%rdi,8) +10 incq %rdi +11 jmp L48 +``` + +And for the branch-less, we have: +```julia +1 L48: +2 movq (%r9,%rcx,8), %rdx +3 incq %rcx +4 movq %rdx, -8(%rsi,%rdi,8) +5 andl $1, %edx +6 addq %rdx, %rdi +7 cmpq %rcx, %r8 +8 jne L48 +``` + +The branch-ful executes 9 instructions per iteration (remember, all iterations had uneven numbers), whereas the branch-less executes only 7. Looking at the table for how long instructions take, you will find all these instructions are fast. So what gives? + +To understand what is happening, we need to go a little deeper into the CPU. In fact, the CPU does not execute CPU instructions in a linear fashion as the assembly code would have you believe. Instead, a more accurate (but still simplified) picture is the following: + +1. The CPU reads in CPU instructions. It then on-the-fly translates these CPU instructions to a set of even lower-level instructions called _micro-operations_ or _µops_. The important difference between µops and CPU instructions is that while only a few different registers can be referred to by the instructions, the actual processor has many more registers, which can be addressed by µops. Code written with µops is called _microcode_. + +2. This microcode is loaded into an internal array called the *reorder buffer* for storage. A CPU may hold more than 200 instructions in the reorder buffer at a time. The purpose of this storage is to allow execution of microcode in a highly parallel way. The code is then sent to execution in bulk. + +3. Finally, results from the reorder buffer is then shipped out to memory in the correct order. + +The existance of a re-order buffer has two important implications (that I know about) for how you should think about your code: + +First, your code is executed in large chunks often in parallel, not necessarily in the same order as it was loaded in. Therefore, _a program with more, slower CPU instructions can be faster than a program with fewer, faster instructions_, if the former program manages to execute more of them in parallel. + +Second, branch prediction (as discussed in the previous section) does not happen just for the upcoming branch, but instead for a large amount of future branches, simultaneously. + +When visualizing how the code of the small `copy_odds_branches!` loop above is executed, you may imagine that the branch predictor predicts all branches, say, 6 iterations of the loop into the future, loads the microcode of all 6 future iterations into the reorder buffer, executes them all in parallel, and _then_ verifies - still in parallel - that its branches were guessed correctly. + + Indicentally, this bulk processing is why a branch mispredict is so bad for performance - if a branch turns out to be mispredicted, all the work in the reorder buffer must be scrapped, the and the CPU must start over with fetching new instructions, compile them to microcode, fill the buffer et cetera. + +Let's think about the implications re-order buffer for a moment. Other than creating hard-to-predict branches, what kind of code can re write that messes up that workflow for the CPU? + +What if we do this? +""" + +# ╔═╡ 7732b6d8-8dab-11eb-0bc2-19690386ec27 +function read_indices(dst::Vector{T}, src::Vector{T}) where {T <: Integer} + i = 1 + while i ≤ lastindex(src) - 1 + i = src[i] + 1 + dst[i] = i + end + return dst +end; + +# ╔═╡ 29463b02-8dab-11eb-0bf5-23a3f4075b32 +let + dst = rand(UInt32, 2^18) + src = UInt32.(eachindex(dst)) + @btime read_indices($dst, $src) seconds=1 + nothing +end + +# ╔═╡ a5d93434-8dac-11eb-34bf-91061089f0ef +md""" +If you think about it, `read_indices` does strictly less work than any of the `copy_odds` functions. It doesn't even check if the numbers it copies are odd. Yet it's more than three times slower than `copy_odds_branches`! + +The difference is *memory dependencies*. We humans, seeing that the input data is simply a range of numbers, can tell _precisely_ what the function should do at every iteration: Simply copy the next number over. But the compiler _can't_ predict what the next number it loads will be, and therefore where it needs to store the loaded number. We say that the code has a memory dependency on the number it loads from `src`. + +In that case, the reorder buffer is of no use. All the instructions get loaded in, but are simply kept idle in the reorder buffer, because they simply *cannot* be executed until it's "their turn". + +Going back to the original example, that is why the perfectly predicted `copy_odds_branches!` performs better than `code_odds_branchless!`. Even though the latter has fewer instructions, it has a memory dependency: The index of `dst` where the odd number gets stored to depends on the last loop iteration. So fewer instructions can be executed at a time compared to the former function, where the branch predictor predicts several iterations ahead and allow for the parallel computation of multiple iterations. +""" + +# ╔═╡ 0b6d234e-8af3-11eb-1ba9-a1dcf1497785 +md""" +## Variable clock speed + +A modern laptop CPU optimized for low power consumption consumes roughly 25 watts of power on a chip as small as a stamp (and thinner than a human hair). Without proper cooling, this will cause the temperature of the CPU to skyrocket and melting the plastic of the chip, destroying it. Typically, CPUs have a maximal operating temperature of about 100 degrees C. Power consumption, and therefore heat generation, depends among many factors on clock speed, higher clock speeds generate more heat. + +Modern CPUs are able to adjust their clock speeds according to the CPU temperature to prevent the chip from destroying itself. Often, CPU temperature will be the limiting factor in how quick a CPU is able to run. In these situations, better physical cooling for your computer translates directly to a faster CPU. Old computers can often be revitalized simply by removing dust from the interior, and replacing the cooling fans and [CPU thermal paste](https://en.wikipedia.org/wiki/Thermal_grease)! + +As a programmer, there is not much you can do to take CPU temperature into account, but it is good to know. In particular, variations in CPU temperature often explain observed difference in performance: + +* CPUs usually work fastest at the beginning of a workload, and then drop in performance as it reaches maximal temperature +* SIMD instructions usually require more power than ordinary instructions, generating more heat, and lowering the clock frequency. This can offset some performance gains of SIMD, but SIMD will nearly always be more efficient when applicable. One exception is the relatively recent 512-bit SIMD instructions. In current (2021) CPUs, these instructions draw so much power that the resulting clock frequency lowering actually leads to overall performance decrease for some workloads. This problem will probably be solved in the near future, either by the power draw begin reduced, by consumer chips abandoning 512-bit SIMD, or by compilers refusing to compile to these instructions. +""" + +# ╔═╡ 119d269c-8af3-11eb-1fdc-b7ac75b89cf2 +md""" +## Multithreading +In the bad old days, CPU clock speed would increase every year as new processors were brought onto the market. Partially because of heat generation, this acceleration slowed down once CPUs hit the 3 GHz mark. Now we see only minor clock speed increments every processor generation. Instead of raw speed of execution, the focus has shifted on getting more computation done per clock cycle. CPU caches, CPU pipelining (i.e. the entire re-order buffer "workflow"), branch prediction and SIMD instructions are all important contibutions in this area, and have all been covered here. + +Another important area where CPUs have improved is simply in numbers: Almost all CPU chips contain multiple smaller CPUs, or *cores* inside them. Each core has their own small CPU cache, and does computations in parallel. Furthermore, many CPUs have a feature called *hyper-threading*, where two *threads* (i.e. streams of instructions) are able to run on each core. The idea is that whenever one process is stalled (e.g. because it experiences a cache miss or a branch misprediction), the other process can continue on the same core. The CPU "pretends" to have twice the amount of processors. + +Hyperthreading only really matters when your threads are sometimes prevented from doing work. Besides CPU-internal causes like cache misses, a thread can also be paused because it is waiting for an external resource like a webserver or data from a disk. If you are writing a program where some threads spend a significant time idling, the core can be used by the other thread, and hyperthreading can show its value. + +Let's see our first parallel program in action. First, we need to make sure that Julia actually was started with the correct number of threads. To do this, start Julia with the `-t` option - e.g. `-t 8` for 8 threads. I have set Julia to have 4 threads: +""" + +# ╔═╡ 1886f60e-8af3-11eb-2117-eb0014d2fca1 +Threads.nthreads() + +# ╔═╡ 1a0e2998-8af3-11eb-031b-a3448fd65041 +# Spend about half the time waiting, half time computing +function half_asleep(start::Bool) + a, b = 1, 0 + for iteration in 1:5 + start && sleep(0.1) + t1 = time() + while time() - t1 < 0.1 + for i in 1:100000 + a, b = a + b, a + end + end + start || sleep(0.1) + end + return a +end; + +# ╔═╡ 1ecf434a-8af3-11eb-3c49-cb21c6a80bfc +function parallel_sleep(n_jobs) + jobs = [] + for job in 1:n_jobs + push!(jobs, Threads.@spawn half_asleep(isodd(job))) + end + return sum(fetch, jobs) +end; + +# ╔═╡ 2192c228-8af3-11eb-19d8-81db4f3c0d81 +let + parallel_sleep(1); # run once to compile it + for njobs in (1, 4, 8, 16, 32) + @time parallel_sleep(njobs); + end +end + +# ╔═╡ 2d0bb0a6-8af3-11eb-384d-29fbb0f66f24 +md""" +You can see that with this task, my computer can run 8 jobs in parallel almost as fast as it can run 1. But 16 jobs takes much longer. This is because 4 can run at the same time, and 4 more can sleep for a total of 8 concurrent jobs. + +For CPU-constrained programs, the core is kept busy with only one thread, and there is not much to do as a programmer to leverage hyperthreading. Actually, for the most optimized programs, it usually leads to better performance to *disable* hyperthreading. Most workloads are not that optimized and can really benefit from hyperthreading, however. + +#### Parallelizability +Multithreading is more difficult that any of the other optimizations, and should be one of the last tools a programmer reaches for. However, it is also an impactful optimization. Scientific compute clusters usually contain many (e.g. hundreds, or thousands) of CPUs with tens of CPU cores each, offering a massive potential speed boost ripe for picking. + +A prerequisite for efficient use of multithreading is that your computation is able to be broken up into multiple chunks that can be worked on independently. Luckily the majority of compute-heavy tasks (at least in my field of work, bioinformatics), contain sub-problems that are *embarassingly parallel*. This means that there is a natural and easy way to break it into sub-problems that can be processed independently. For example, if a certain __independent__ computation is required for 100 genes, it is natural to use one thread for each gene. The size of the problem is also important. There is a small overhead involved with spawning (creating) a thread, and fetching the result from the computation of a thread. Therefore, for it to pay off, each thread should have a task that takes at least a few microseconds to complete. + +Let's have an example of a small embarrasingly parallel problem. We want to construct a [Julia set](https://en.wikipedia.org/wiki/Julia_set). Julia sets are named after Gaston Julia, and have nothing to do with the Julia language. Julia sets are (often) fractal sets of complex numbers. By mapping the real and complex component of the set's members to the X and Y pixel value of a screen, one can generate the LSD-trippy images associated with fractals. + +The Julia set I create below is defined thus: We define a function $f(z) = z^2 + C$, where $C$ is some constant. We then record the number of times $f$ can be applied to any given complex number $z$ before $|z| > 2$. The number of iterations correspond to the brightness of one pixel in the image. We simply repeat this for a range of real and imaginary values in a grid to create an image. + +First, let's see a non-parallel solution: +""" + +# ╔═╡ 316e5074-8af3-11eb-256b-c5b212f7e0d3 +begin + const SHIFT = Complex{Float32}(-0.221, -0.713) + + f(z::Complex) = z^2 + SHIFT + + "Set the brightness of a particular pixel represented by a complex number" + function mandel(z) + n = 0 + while ((abs2(z) < 4) & (n < 255)) + n += 1 + z = f(z) + end + return n + end + + "Set brightness of pixels in one column of pixels" + function fill_column!(M::Matrix, x, real) + for (y, im) in enumerate(range(-1.0f0, 1.0f0, length=size(M, 1))) + M[y, x] = mandel(Complex{Float32}(real, im)) + end + end + + "Create a Julia fractal image" + function julia_single_threaded() + M = Matrix{UInt8}(undef, 5000, 5000) + for (x, real) in enumerate(range(-1.0f0, 1.0f0, length=size(M, 2))) + fill_column!(M, x, real) + end + return M + end +end; + +# ╔═╡ 37cd1f1c-8ee9-11eb-015c-ade9efc27708 +@code_native debuginfo=:none dump_module=false f() + +# ╔═╡ 39a85a58-8af3-11eb-1334-6f50ed9acd31 +@time julia_single_threaded(); + +# ╔═╡ 3e83981a-8af3-11eb-3c87-77797adb7e1f +md"That took around 2 seconds on my computer. Now for a parallel one:" + +# ╔═╡ 3e1c4090-8af3-11eb-33d0-b9c299fef20d +begin + function recursive_fill_columns!(M::Matrix, cols::UnitRange) + F, L = first(cols), last(cols) + # If only one column, fill it using fill_column! + if F == L + r = range(-1.0f0,1.0f0,length=size(M, 1))[F] + fill_column!(M, F, r) + # Else divide the range of columns in two, spawning a new task for each half + else + mid = div(L+F,2) + p = Threads.@spawn recursive_fill_columns!(M, F:mid) + recursive_fill_columns!(M, mid+1:L) + wait(p) + end + end + + function julia_multi_threaded() + M = Matrix{UInt8}(undef, 5000, 5000) + recursive_fill_columns!(M, 1:size(M, 2)) + return M + end +end; + +# ╔═╡ 4be905b4-8af3-11eb-0344-dbdc7e94ddf3 +@time julia_multi_threaded(); + +# ╔═╡ 4e8f6cb8-8af3-11eb-1746-9384995d7022 +md""" +This is almost exactly 4 times as fast! With 4 threads, this is close to the best case scenario, only possible for near-perfect embarrasingly parallel tasks. + +Despite the potential for great gains, in my opinion, multithreading should be one of the last resorts for performance improvements, for three reasons: + +1. Implementing multithreading is harder than other optimization methods in many cases. In the example shown, it was very easy. In a complicated workflow, it can get messy quickly. +2. Multithreading can cause hard-to-diagnose and erratic bugs. These are almost always related to multiple threads reading from, and writing to the same memory. For example, if two threads both increment an integer with value `N` at the same time, the two threads will both read `N` from memory and write `N+1` back to memory, where the correct result of two increments should be `N+2`! Infuriatingly, these bugs appear and disappear unpredictably, since they are causing by unlucky timing. These bugs of course have solutions, but it is tricky subject outside the scope of this document. +3. Finally, achieving performance by using multiple threads is really achieving performance by consuming more resources, instead of gaining something from nothing. Often, you pay for using more threads, either literally when buying cloud compute time, or when paying the bill of increased electricity consumption from multiple CPU cores, or metaphorically by laying claim to more of your users' CPU resources they could use somewhere else. In contrast, more *efficent* computation costs nothing. +""" + +# ╔═╡ 54d2a5b8-8af3-11eb-3273-85d551fceb7b +md""" +## GPUs +So far, we've covered only the most important kind of computing chip, the CPU. But there are many other kind of chips out there. The most common kind of alternative chip is the *graphical processing unit* or GPU. + +As shown in the above example with the Julia set, the task of creating computer images are often embarassingly parallel with an extremely high degree of parallelizability. In the limit, the value of each pixel is an independent task. This calls for a chip with a high number of cores to do effectively. Because generating graphics is a fundamental part of what computers do, nearly all commercial computers contain a GPU. Often, it's a smaller chip integrated into the motherboard (*integrated graphics*, popular in small laptops). Other times, it's a large, bulky card. + +GPUs have sacrificed many of the bells and whistles of CPUs covered in this document such as specialized instructions, SIMD and branch prediction. They also usually run at lower frequencies than CPUs. This means that their raw compute power is many times slower than a CPU. To make up for this, they have a high number of cores. For example, the high-end gaming GPU NVIDIA RTX 2080Ti has 4,352 cores. Hence, some tasks can experience 10s or even 100s of times speedup using a GPU. Most notably for scientific applications, matrix and vector operations are highly parallelizable. + +Unfortunately, the laptop I'm writing this document on has only integrated graphics, and there is not yet a stable way to interface with integrated graphics using Julia, so I cannot show examples. + +There are also more esoteric chips like TPUs (explicitly designed for low-precision tensor operations common in deep learning) and ASICs (an umbrella term for highly specialized chips intended for one single application). At the time of writing, these chips are uncommon, expensive, poorly supported and have limited uses, and are therefore not of any interest for non-computer science researchers. +""" + +# ╔═╡ 00000000-0000-0000-0000-000000000001 +PLUTO_PROJECT_TOML_CONTENTS = """ +[deps] +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8" + +[compat] +BenchmarkTools = "~1.1.3" +PlutoUI = "~0.7.39" +""" + +# ╔═╡ 00000000-0000-0000-0000-000000000002 +PLUTO_MANIFEST_TOML_CONTENTS = """ +# This file is machine-generated - editing it directly is not advised + +[[AbstractPlutoDingetjes]] +deps = ["Pkg"] +git-tree-sha1 = "8eaf9f1b4921132a4cff3f36a1d9ba923b14a481" +uuid = "6e696c72-6542-2067-7265-42206c756150" +version = "1.1.4" + +[[ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[BenchmarkTools]] +deps = ["JSON", "Logging", "Printf", "Statistics", "UUIDs"] +git-tree-sha1 = "42ac5e523869a84eac9669eaceed9e4aa0e1587b" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.1.4" + +[[ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "eb7f0f8307f71fac7c606984ea5fb2817275d6e4" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.11.4" + +[[CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "0.5.2+0" + +[[Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.4" + +[[Hyperscript]] +deps = ["Test"] +git-tree-sha1 = "8d511d5b81240fc8e6802386302675bdf47737b9" +uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91" +version = "0.0.4" + +[[HypertextLiteral]] +deps = ["Tricks"] +git-tree-sha1 = "c47c5fa4c5308f27ccaac35504858d8914e102f9" +uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2" +version = "0.9.4" + +[[IOCapture]] +deps = ["Logging", "Random"] +git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a" +uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" +version = "0.2.2" + +[[InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.3" + +[[LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.3" + +[[LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "7.84.0+0" + +[[LibGit2]] +deps = ["Base64", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.10.2+0" + +[[Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[LinearAlgebra]] +deps = ["Libdl", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.0+0" + +[[Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2022.2.1" + +[[NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.20+0" + +[[Parsers]] +deps = ["Dates"] +git-tree-sha1 = "3d5bf43e3e8b412656404ed9466f1dcbf7c50269" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.4.0" + +[[Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.8.0" + +[[PlutoUI]] +deps = ["AbstractPlutoDingetjes", "Base64", "ColorTypes", "Dates", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "UUIDs"] +git-tree-sha1 = "8d1f54886b9037091edf146b517989fc4a09efec" +uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8" +version = "0.7.39" + +[[Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[Random]] +deps = ["SHA", "Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[SparseArrays]] +deps = ["LinearAlgebra", "Random"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.0" + +[[Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[Tricks]] +git-tree-sha1 = "6bac775f2d42a611cdfcd1fb217ee719630c4175" +uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775" +version = "0.1.6" + +[[UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.12+3" + +[[libblastrampoline_jll]] +deps = ["Artifacts", "Libdl", "OpenBLAS_jll"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.1.1+0" + +[[nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.48.0+0" + +[[p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+0" +""" + +# ╔═╡ Cell order: +# ╟─15f5c31a-8aef-11eb-3f19-cf0a4e456e7a +# ╟─5dd2329a-8aef-11eb-23a9-7f3c325bcf74 +# ╠═7490def0-8aef-11eb-19ce-4b11ce5a9328 +# ╠═675e66aa-8aef-11eb-27be-5fe273e33297 +# ╟─800d827e-8c20-11eb-136a-97a622a7c1e6 +# ╟─9a24985a-8aef-11eb-104a-bd9abf0adc6d +# ╟─a2fad250-8aef-11eb-200f-e5f8caa57a67 +# ╠═abb45d6a-8aef-11eb-37a4-7b10847b39b4 +# ╠═bff99828-8aef-11eb-107b-a5c67101c735 +# ╟─cdde6fe8-8aef-11eb-0a3c-77e28f7a2c09 +# ╟─f58d428c-8aef-11eb-3127-89d729e23823 +# ╠═b73605ca-8ee4-11eb-1a0d-bb6678de91c6 +# ╟─c6da4248-8c19-11eb-1c16-093695add9a9 +# ╠═ffca4c72-8aef-11eb-07ac-6d5c58715a71 +# ╟─d4c67b82-8c1a-11eb-302f-b79c86412ce5 +# ╠═e71e4798-8ee4-11eb-3ea2-fdbbcdcf7410 +# ╟─0f2ac53c-8c1b-11eb-3841-27f4ea1e9617 +# ╟─12f1228a-8af0-11eb-0449-230ae20bfa7a +# ╠═18e8e4b6-8af0-11eb-2f17-2726f162e9b0 +# ╠═1f38f8c6-8ee5-11eb-1c01-f3706534a9cf +# ╟─3a1efd5a-8af0-11eb-21a2-d1011f16555c +# ╠═3fae31a0-8af0-11eb-1ea8-7980e7875039 +# ╟─5b10a2b6-8af0-11eb-3fe7-4b78b4c22550 +# ╠═6061dc94-8af0-11eb-215a-4f3af731774e +# ╟─624eae74-8af0-11eb-025b-8b68dc55f31e +# ╠═d4c8c38c-8ee6-11eb-0b49-33fbfbd214f3 +# ╟─7b979410-8af0-11eb-299c-af0a5d740c24 +# ╟─8802ff60-8af0-11eb-21ac-b9fdbeac7c24 +# ╠═a36582d4-8af0-11eb-2b5a-e577c5ed07e2 +# ╠═a74a9966-8af0-11eb-350f-6787d2759eba +# ╟─ae9ee028-8af0-11eb-10c0-6f2db3ab8025 +# ╟─b73b5eaa-8af0-11eb-191f-cd15de19bc38 +# ╟─c0c757b2-8af0-11eb-38f1-3bc3ec4c43bc +# ╠═c5472fb0-8af0-11eb-04f1-95a1f7b6b9e0 +# ╟─ce0e65d4-8af0-11eb-0c86-2105c26b62eb +# ╠═d376016a-8af0-11eb-3a15-4322759143d1 +# ╟─d70c56bc-8af0-11eb-1220-09e78dba26f7 +# ╠═dc24f5a0-8af0-11eb-0332-2bc0834d426c +# ╟─e3c136de-8af0-11eb-06f1-9393c0f95fbb +# ╠═e836dac8-8af0-11eb-1865-e3feeb011fc4 +# ╟─ecfd04e4-8af0-11eb-0962-f548d2eabad3 +# ╠═f0e24b50-8af0-11eb-1a0e-5d925f3743e0 +# ╠═11c500e8-8ee2-11eb-3291-4382b60c5a2b +# ╟─22512ab2-8af1-11eb-260b-8d6c16762547 +# ╠═2a7c1fc6-8af1-11eb-2909-554597aa2949 +# ╟─2e3304fe-8af1-11eb-0f6a-0f84d58326bf +# ╠═33350038-8af1-11eb-1ff5-6d42d86491a3 +# ╟─3713a8da-8af1-11eb-2cb2-1957455227d0 +# ╠═59f58f1c-8af1-11eb-2e88-997e9d4bcc48 +# ╟─5c86e276-8af1-11eb-2b2e-3386e6795f37 +# ╠═61ee9ace-8af1-11eb-34bd-c5af962c8d82 +# ╟─6849d9ec-8af1-11eb-06d6-db49af4796bc +# ╠═6ba266f4-8af1-11eb-10a3-3daf6e473142 +# ╟─74a3ddb4-8af1-11eb-186e-4d80402adfcf +# ╠═7a88c4ba-8af1-11eb-242c-a1813a9e6741 +# ╟─7d3fcbd6-8af1-11eb-0441-2f88a9d59966 +# ╠═84c0d56a-8af1-11eb-30f3-d137b377c31f +# ╟─8c2ed15a-8af1-11eb-2e96-1df34510e773 +# ╠═94182f88-8af1-11eb-207a-37083c1ead68 +# ╠═a0286cdc-8af1-11eb-050e-072acdd4f0a0 +# ╟─aa3931fc-8af1-11eb-2f42-f582b8e639ad +# ╠═c01bf4b6-8af1-11eb-2f17-bfe0c93d48f9 +# ╟─c80e05ba-8af1-11eb-20fc-235b45f2eb4b +# ╠═cc99d9ce-8af1-11eb-12ec-fbd6df3becc8 +# ╟─e3931226-8af1-11eb-0da5-fb3c1c22d12e +# ╠═e793e300-8af1-11eb-2c89-e7bc1be249f0 +# ╠═e8d2ec8e-8af1-11eb-2018-1fa4df5b47ad +# ╟─f0a4cb58-8af1-11eb-054c-03192285b5e2 +# ╟─f5c28c92-8af1-11eb-318f-5fa059d8fd80 +# ╠═fc2d2f1a-8af1-11eb-11a4-8700f94e866e +# ╟─007cd39a-8af2-11eb-053d-f584d68f7d2f +# ╠═72fbb3ec-8ee8-11eb-3836-11092ef74e86 +# ╠═054d848a-8af2-11eb-1f98-67f5d0b9f4ec +# ╟─0dfc5054-8af2-11eb-098d-35f4e69ae544 +# ╠═126300a2-8af2-11eb-00ea-e76a979aef45 +# ╠═14e46866-8af2-11eb-0894-bba824f266f0 +# ╟─1e7edfdc-8af2-11eb-1429-4d4220bad0f0 +# ╠═25a47c54-8af2-11eb-270a-5b58c3aafe6e +# ╟─2dc4f936-8af2-11eb-1117-9bc10e619ec6 +# ╠═76a4e83c-8af2-11eb-16d7-75eaabcb21b6 +# ╟─797264de-8af2-11eb-0cb0-adf3fbc95c90 +# ╟─80179748-8af2-11eb-0910-2b825104159d +# ╠═36b723fc-8ee9-11eb-1b92-451b992acc0c +# ╠═37cd1f1c-8ee9-11eb-015c-ade9efc27708 +# ╟─8af63980-8af2-11eb-3028-83a935bac0db +# ╠═50ab0cf6-8ee9-11eb-3e04-af5fef7f2850 +# ╠═93af6754-8af2-11eb-0fe6-216d76e683de +# ╟─a105bd68-8af2-11eb-31f6-3335b4fb0f08 +# ╠═a843a0c2-8af2-11eb-2435-17e2c36ec253 +# ╠═b4d9cbb8-8af2-11eb-247c-d5b16e0de13f +# ╟─bc0a2f22-8af2-11eb-3803-f54f84ddfc46 +# ╠═f0bc1fdc-8ee9-11eb-2916-d71e1cf36375 +# ╟─36a2872e-8eeb-11eb-0999-4153ced71678 +# ╠═9ca70cfc-8eeb-11eb-361b-b929089ca109 +# ╠═d4a43094-8eeb-11eb-106f-3b54253aa663 +# ╟─270950ac-8eed-11eb-365d-df9d36d090bc +# ╟─c36dc5f8-8af2-11eb-3f35-fb86143a54d2 +# ╠═c96f7f50-8af2-11eb-0513-d538cf6bc619 +# ╠═cf90c600-8af2-11eb-262a-2763ae29b428 +# ╟─d53422a0-8af2-11eb-0417-b9740c4a571c +# ╠═dc5b9bbc-8af2-11eb-0197-9b5da5087f0d +# ╟─e735a302-8af2-11eb-2ce7-01435b60fdd9 +# ╠═eb158e60-8af2-11eb-2227-59d6404e3335 +# ╠═ee579dca-8af2-11eb-140f-a96778b7b39f +# ╟─f969eed2-8af2-11eb-1e78-5b322a7f4ebd +# ╟─72e1b146-8c1c-11eb-2c56-b1342271c2f6 +# ╠═7732b6d8-8dab-11eb-0bc2-19690386ec27 +# ╠═29463b02-8dab-11eb-0bf5-23a3f4075b32 +# ╟─a5d93434-8dac-11eb-34bf-91061089f0ef +# ╟─0b6d234e-8af3-11eb-1ba9-a1dcf1497785 +# ╟─119d269c-8af3-11eb-1fdc-b7ac75b89cf2 +# ╠═1886f60e-8af3-11eb-2117-eb0014d2fca1 +# ╠═1a0e2998-8af3-11eb-031b-a3448fd65041 +# ╠═1ecf434a-8af3-11eb-3c49-cb21c6a80bfc +# ╠═2192c228-8af3-11eb-19d8-81db4f3c0d81 +# ╟─2d0bb0a6-8af3-11eb-384d-29fbb0f66f24 +# ╠═316e5074-8af3-11eb-256b-c5b212f7e0d3 +# ╠═39a85a58-8af3-11eb-1334-6f50ed9acd31 +# ╟─3e83981a-8af3-11eb-3c87-77797adb7e1f +# ╠═3e1c4090-8af3-11eb-33d0-b9c299fef20d +# ╠═4be905b4-8af3-11eb-0344-dbdc7e94ddf3 +# ╟─4e8f6cb8-8af3-11eb-1746-9384995d7022 +# ╟─54d2a5b8-8af3-11eb-3273-85d551fceb7b +# ╟─00000000-0000-0000-0000-000000000001 +# ╟─00000000-0000-0000-0000-000000000002 diff --git a/posts/hardware.html b/posts/hardware.html new file mode 100644 index 0000000..3652c7c --- /dev/null +++ b/posts/hardware.html @@ -0,0 +1,14 @@ + + + + +
\ No newline at end of file From 55dccbdd2582979f1803aa37bb16cc96d8d836d8 Mon Sep 17 00:00:00 2001 From: Edmund Miller Date: Thu, 10 Aug 2023 21:02:44 -0500 Subject: [PATCH 04/16] Add seq-lang blog post --- _assets/posts/seq-lang/featured.png | Bin 0 -> 100218 bytes ...6402b2ac_100218_150x0_resize_lanczos_2.png | Bin 0 -> 5257 bytes ...6402b2ac_100218_720x0_resize_lanczos_2.png | Bin 0 -> 27227 bytes _assets/posts/seq-lang/fig1.png | Bin 0 -> 22463 bytes _assets/posts/seq-lang/fig2.png | Bin 0 -> 24283 bytes _assets/posts/seq-lang/fig3-a.png | Bin 0 -> 10397 bytes _assets/posts/seq-lang/fig3-b.png | Bin 0 -> 10209 bytes _assets/posts/seq-lang/fig3-c.png | Bin 0 -> 9776 bytes _assets/posts/seq-lang/fig3.png | Bin 0 -> 159469 bytes _assets/posts/seq-lang/fig4.png | Bin 0 -> 23891 bytes _assets/posts/seq-lang/fig5.png | Bin 0 -> 24527 bytes posts/seq-lang.md | 113 ++++++++++++++++++ 12 files changed, 113 insertions(+) create mode 100644 _assets/posts/seq-lang/featured.png create mode 100644 _assets/posts/seq-lang/featured_hu673fdf9bf6c03bbd2130cc0e6402b2ac_100218_150x0_resize_lanczos_2.png create mode 100644 _assets/posts/seq-lang/featured_hu673fdf9bf6c03bbd2130cc0e6402b2ac_100218_720x0_resize_lanczos_2.png create mode 100644 _assets/posts/seq-lang/fig1.png create mode 100644 _assets/posts/seq-lang/fig2.png create mode 100644 _assets/posts/seq-lang/fig3-a.png create mode 100644 _assets/posts/seq-lang/fig3-b.png create mode 100644 _assets/posts/seq-lang/fig3-c.png create mode 100644 _assets/posts/seq-lang/fig3.png create mode 100644 _assets/posts/seq-lang/fig4.png create mode 100644 _assets/posts/seq-lang/fig5.png create mode 100644 posts/seq-lang.md diff --git a/_assets/posts/seq-lang/featured.png b/_assets/posts/seq-lang/featured.png new file mode 100644 index 0000000000000000000000000000000000000000..2d0a35b667b60de636890fe8c01a9617aeee3cf0 GIT binary patch literal 100218 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

lOQfbZ;`adlqpgt}nxL(i(6p)~s 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 literal 0 HcmV?d00001 diff --git a/_assets/posts/seq-lang/fig3-a.png b/_assets/posts/seq-lang/fig3-a.png new file mode 100644 index 0000000000000000000000000000000000000000..5894e199134b5f6c985d8b65ed1a75958639d031 GIT binary patch literal 10397 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 ^Vb|LTm^0fMqFMdO{u$=k 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 z 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