From 692ac4df9fa1774320e0a34cd3139937179af421 Mon Sep 17 00:00:00 2001 From: Mark Mansi Date: Tue, 12 Nov 2019 11:21:50 -0600 Subject: [PATCH] add oli note --- src/appendix/glossary.md | 1 + src/mir/optimizations.md | 6 +++++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/appendix/glossary.md b/src/appendix/glossary.md index 5b0f7cfa..d737e037 100644 --- a/src/appendix/glossary.md +++ b/src/appendix/glossary.md @@ -45,6 +45,7 @@ LTO | Link-Time Optimizations. A set of optimizations offer memoize | memoization is the process of storing the results of (pure) computations (such as pure function calls) to avoid having to repeat them in the future. This is typically a trade-off between execution speed and memory usage. MIR | the Mid-level IR that is created after type-checking for use by borrowck and codegen ([see more](../mir/index.html)) miri | an interpreter for MIR used for constant evaluation ([see more](../miri.html)) +monomorphize | Monomorphization is the process of taking generic implementations of types and functions and producing instantiating them with concrete types. For example, in the code we might have `Vec`, but in the final executable, we will have a copy of the `Vec` code for every concrete type used in the program (e.g. a copy for `Vec`, a copy for `Vec`, etc). normalize | a general term for converting to a more canonical form, but in the case of rustc typically refers to [associated type normalization](../traits/associated-types.html#normalize) newtype | a "newtype" is a wrapper around some other type (e.g., `struct Foo(T)` is a "newtype" for `T`). This is commonly used in Rust to give a stronger type for indices. NLL | [non-lexical lifetimes](../borrow_check/region_inference.html), an extension to Rust's borrowing system to make it be based on the control-flow graph. diff --git a/src/mir/optimizations.md b/src/mir/optimizations.md index fb550af4..cb60af1a 100644 --- a/src/mir/optimizations.md +++ b/src/mir/optimizations.md @@ -3,9 +3,13 @@ MIR optimizations are optimizations run on the [MIR][mir] to produce better MIR before codegen. This is important for two reasons: first, it make the final generated executable code better, and second, it means that LLVM has less work -to do, so compilation is faster. +to do, so compilation is faster. Note that since MIR is generic (not +[monomorphized][monomorph] yet), these optimizations are particularly +effective; we can optimize the generic version, so all of the monomorphizations +are cheaper! [mir]: https://rust-lang.github.io/rustc-guide/mir/index.html +[monomorph]: https://rust-lang.github.io/rustc-guide/appendix/glossary.html?highlight=monomorphize#appendix-c-glossary MIR optimizations run after borrow checking. We run a series of optimization passes over the MIR to improve it. Some passes are required to run on all code,