speice.io/_drafts/understanding-allocations-in-rust.md

313 lines
13 KiB
Markdown
Raw Normal View History

2018-12-19 22:50:57 -05:00
---
layout: post
2019-01-08 00:16:10 -05:00
title: "Allocations in Rust"
description: "An introduction to the memory model"
2018-12-19 22:50:57 -05:00
category:
tags: [rust]
---
There's an alchemy of distilling complex technical topics into articles and videos
that change the way programmers see the tools they interact with on a regular basis.
2019-01-04 00:08:36 -05:00
I knew what a linker was, but there's a staggering amount of complexity in between
[`main()` and your executable](https://www.youtube.com/watch?v=dOfucXtyEsU).
2018-12-26 10:19:34 -05:00
Rust programmers use the [`Box`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html)
type all the time, but there's a rich history of the Rust language itself wrapped up in
2018-12-19 22:50:57 -05:00
[how special it is](https://manishearth.github.io/blog/2017/01/10/rust-tidbits-box-is-special/).
2019-01-04 00:08:36 -05:00
In a similar vein, I want you to look at code and understand how memory is used;
the complex choreography of operating system, compiler, and program that frees you
2019-01-01 14:31:15 -05:00
to focus on functionality far-flung from frivolous book-keeping. The Rust compiler relieves
2019-01-04 00:08:36 -05:00
a great deal of the cognitive burden associated with memory management, but we're going
to step into its world for a while.
2018-12-19 22:50:57 -05:00
2019-01-01 14:31:15 -05:00
Let's learn a bit about memory in Rust.
2018-12-19 22:50:57 -05:00
# Table of Contents
This post is intended as both guide and reference material; we'll work to establish
2018-12-26 10:19:34 -05:00
an understanding of the different memory types Rust makes use of, then summarize each
2018-12-19 22:50:57 -05:00
section for easy citation in the future. To that end, a table of contents is provided
to assist in easy navigation:
2018-12-26 10:19:34 -05:00
- [Foreword](#foreword)
2019-01-04 00:08:36 -05:00
- [Stacking Up: Non-Heap Memory Types](#non-heap-memory-types)
- [Piling On: Rust and the Heap](#piling-on-rust-and-the-heap)
2019-01-01 14:31:15 -05:00
- [Compiler Optimizations Make Everything Complicated](#compiler-optimizations-make-everything-complicated)
2018-12-26 10:19:34 -05:00
- Summary: When Does Rust Allocate?
2019-01-01 14:31:15 -05:00
- [Appendix and Further Reading](#appendix-and-further-reading)
2018-12-26 10:19:34 -05:00
# Foreword
2019-01-04 00:08:36 -05:00
There's a simple checklist to see if you can skip over reading this article. You must:
2018-12-26 10:19:34 -05:00
1. Only write `#![no_std]` crates
2. Never use `unsafe`
3. Never use `#![feature(alloc)]`
For some uses of Rust, typically embedded devices, these constraints make sense.
They're working with very limited memory, and the program binary size itself may
2019-01-04 00:08:36 -05:00
significantly affect what's available! There's no operating system able to manage
this "virtual memory" junk, but that's not an issue because there's only one
running application. The [embedonomicon] is ever in mind, and interacting with the
"real world" through extra peripherals is accomplished by reading and writing to
exact memory addresses.
2018-12-26 10:19:34 -05:00
Most Rust programs find these requirements overly burdensome though. C++ developers
2019-01-04 00:08:36 -05:00
would struggle without access to [`std::vector`](https://en.cppreference.com/w/cpp/container/vector)
(except those hardcore no-STL guys), and Rust developers would struggle without
[`std::vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html). But in this scenario,
`std::vec` is actually part of the [`alloc` crate](https://doc.rust-lang.org/alloc/vec/struct.Vec.html),
and thus off-limits (because the `alloc` crate requires `#![feature(alloc)]`).
2019-01-08 00:16:10 -05:00
Also, `Box` is right out for the same reason.
2018-12-26 10:19:34 -05:00
2019-01-04 00:08:36 -05:00
Whether writing code for embedded devices or not, the important thing in both situations
2019-01-08 00:16:10 -05:00
is how much you know *before your application starts* about what its memory usage will look like.
In embedded devices, there's a small, fixed amount of memory to use.
In a browser, you have no idea how large [google.com](https://www.google.com)'s home page is until you start
2019-01-04 00:08:36 -05:00
trying to download it. The compiler uses this information (or lack thereof) to optimize
how memory is used; put simply, your code runs faster when the compiler can guarantee exactly
how much memory your program needs while it's running. This post is all about understanding
the optimization tricks the compiler uses, and how you can help the compiler and make
your programs more efficient.
2019-01-08 00:16:10 -05:00
Now let's address some conditions and caveats before going much further:
2019-01-04 00:08:36 -05:00
2019-01-08 00:16:10 -05:00
- We'll focus on "safe" Rust only; `unsafe` lets you use platform-specific allocation API's
(think the [libc] and [winapi] implementations of [malloc]) that we'll ignore.
- We'll assume a "debug" build of Rust code (what you get with `cargo run` and `cargo test`)
and address (hehe) "release" mode at the end (`cargo run --release` and `cargo test --release`).
- Because of the nature of the content, some (very simple) assembly-level code is involved.
We'll keep this to a minimum, but I [needed](https://stackoverflow.com/a/4584131/1454178)
a [refresher](https://stackoverflow.com/a/26026278/1454178) on the `push` and `pop`
[instructions](http://www.cs.virginia.edu/~evans/cs216/guides/x86.html)
while writing this post.
And a final warning worth repeating:
2018-12-26 10:19:34 -05:00
> Rust does not currently have a rigorously and formally defined memory model.
2019-01-08 00:16:10 -05:00
>
> -- [the docs](https://doc.rust-lang.org/std/ptr/fn.read_volatile.html)
2018-12-19 22:50:57 -05:00
2019-01-04 00:08:36 -05:00
# Stacking Up: Non-Heap Memory Types
2019-01-08 00:16:10 -05:00
We'll start with the ["happy path"](https://en.wikipedia.org/wiki/Happy_path):
what happens when Rust is able to figure out *at compile time* how much memory
will be used in your program.
This is important because of the extra optimizations Rust uses when it can predict
how much memory is needed! Let's go over a quick example:
```rust
const MICROS_PER_MILLI: u32 = 1000;
const NANOS_PER_MICRO: u32 = 1000;
pub fn millis_to_nanos(millis: u32) -> u32 {
let micros = millis * MICROS_PER_MILLI;
let nanos = micros * NANOS_PER_MICRO;
return nanos;
}
```
-- [Compiler Explorer](https://godbolt.org/z/tOwngk)
Forgive the overly simple code, but this shows off what the compiler can figure out
about your program:
1. There's one `u32` passed to the function, and two `u32`'s used in the function body.
Each one is 4 bytes, for a total of 12 bytes. We can temporarily reserve space for all
variables because we know exactly how much space is needed.
- If you're looking at the assembly: `millis` is stored in `edi`,
2019-01-15 22:42:26 -05:00
`micros` is stored in `eax`, and `nanos` is stored in `ecx`.
The `eax` register is re-used to store the final result.
2019-01-08 00:16:10 -05:00
2. Because `MICROS_PER_MILLI` and `NANOS_PER_MICRO` are constants, the compiler never
allocates memory, and just burns the constants into the final program.
2019-01-15 22:54:21 -05:00
- Look for the instructions `mov edi, 1000` and `mov ecx, 1000`.
2019-01-08 00:16:10 -05:00
Given this information, the compiler can efficiently lay out your memory usage so
that the program never needs to ask the kernel/allocator for memory! This example
was a bit silly though, so let's talk about the more interesting details.
2019-01-21 13:26:39 -05:00
## **const** and **static**: Program Allocations
2019-01-08 00:16:10 -05:00
2019-01-15 22:42:26 -05:00
The first memory type we'll look at is pretty special: when Rust can prove that
2019-01-21 13:26:39 -05:00
a *value* is fixed for the life of a program, and when a *reference* is valid for
the duration of the program (`static`, not specifically `'static`).
Understanding the distinction between value and reference is important for reasons
2019-01-15 22:42:26 -05:00
we'll go into below. The
[full specification](https://github.com/rust-lang/rfcs/blob/master/text/0246-const-vs-static.md)
2019-01-21 13:26:39 -05:00
for these two memory types is available, but we'll take a hands-on approach to the topic.
2019-01-15 22:42:26 -05:00
### **const**
The quick summary is this: `const` declares a read-only block of memory that is loaded
as part of your program binary (during the call to [exec(3)](https://linux.die.net/man/3/exec)).
Any `const` value resulting from calling a `const fn` is guaranteed to be materialized
at compile-time (meaning that access at runtime will not invoke the `const fn`),
2019-01-21 13:26:39 -05:00
even though the `const fn` functions are available at run-time as well. The compiler
can choose to copy the constant value wherever it is deemed practical. Getting the address
of a `const` value is legal, but not guaranteed to be the same even when referring to the
same named identifier.
The first point is a bit strange - "read-only memory".
[The Rust book](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants)
mentions in a couple places that using `mut` with constants is illegal,
but it's also important to demonstrate just how immutable they are. *Typically* in Rust
you can use "inner mutability" to modify things that aren't declared `mut`.
2019-01-15 22:42:26 -05:00
[`RefCell`](https://doc.rust-lang.org/std/cell/struct.RefCell.html) provides an API
to guarantee at runtime that some consistency rules are enforced:
2019-01-08 00:16:10 -05:00
2019-01-15 22:42:26 -05:00
```rust
use std::cell::RefCell;
fn my_mutator(cell: &RefCell<u8>) {
// Even though we're given an immutable reference,
// the `replace` method allows us to modify the inner value.
cell.replace(14);
}
fn main() {
let cell = RefCell::new(25);
// Prints out 25
println!("Cell: {:?}", cell);
my_mutator(&cell);
// Prints out 14
println!("Cell: {:?}", cell);
}
```
-- [Rust Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=8e4bea1a718edaff4507944e825a54b2)
When `const` is involved though, modifications are silently ignored:
```rust
use std::cell::RefCell;
const CELL: RefCell<u8> = RefCell::new(25);
fn my_mutator(cell: &RefCell<u8>) {
cell.replace(14);
}
fn main() {
// First line prints 25 as expected
println!("Cell: {:?}", &CELL);
my_mutator(&CELL);
// Second line *still* prints 25
println!("Cell: {:?}", &CELL);
}
```
-- [Rust Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=88fe98110c33c1b3a51e341f48b8ae00)
And a second example using [`Once`](https://doc.rust-lang.org/std/sync/struct.Once.html):
```rust
use std::sync::Once;
const SURPRISE: Once = Once::new();
fn main() {
// This is how `Once` is supposed to be used
SURPRISE.call_once(|| println!("Initializing..."));
// Because `Once` is a `const` value, we never record it
// having been initialized the first time, and this closure
// will also execute.
SURPRISE.call_once(|| println!("Initializing again???"));
}
```
-- [Rust Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=c3cc5979b5e5434eca0f9ec4a06ee0ed)
2019-01-21 13:26:39 -05:00
When the [`const` specification](https://github.com/rust-lang/rfcs/blob/26197104b7bb9a5a35db243d639aee6e46d35d75/text/0246-const-vs-static.md)
refers to ["rvalues"](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3055.pdf), this is
what they mean. [Clippy](https://github.com/rust-lang/rust-clippy) will treat this as an error,
2019-01-15 22:42:26 -05:00
but it's still something to be aware of.
The next thing to mention is that `const` values are loaded into memory *as part of your program binary*.
Because of this, any `const` values declared in your program will be "realized" at compile-time;
2019-01-21 13:26:39 -05:00
accessing them may trigger a main-memory lookup (with a fixed address, so your CPU may
be able to prefetch the value), but that's it.
2019-01-15 22:42:26 -05:00
```rust
use std::cell::RefCell;
const CELL: RefCell<u32> = RefCell::new(24);
pub fn multiply(value: u32) -> u32 {
value * (*CELL.get_mut())
}
```
-- [Compiler Explorer](https://godbolt.org/z/ZMjmdM)
The compiler only creates one `RefCell`, and uses it everywhere. However, that value
is fully realized at compile time, and is fully stored in the `.L__unnamed_1` section.
If it's helpful though, the compiler can choose to copy `const` values.
```rust
const FACTOR: u32 = 1000;
pub fn multiply(value: u32) -> u32 {
value * FACTOR
}
pub fn multiply_twice(value: u32) -> u32 {
value * FACTOR * FACTOR
}
```
-- [Compiler Explorer](https://godbolt.org/z/Qc7tHM)
In this example, the `FACTOR` value is turned into the `mov edi, 1000` instruction
in both the `multiply` and `multiply_twice` functions; the "1000" value is never
2019-01-21 13:26:39 -05:00
"stored" anywhere, as it's small enough to inline into the assembly instructions.
2019-01-15 22:42:26 -05:00
Finally, getting the address of a `const` value is possible but not guaranteed
to be unique (given that the compiler can choose to copy values). In my testing
I was never able to get the compiler to copy a `const` value and get differing pointers,
but the specifications are clear enough: *don't rely on pointers to `const`
2019-01-21 13:26:39 -05:00
values being consistent*. To be frank, caring about locations for `const` values
is almost certainly a code smell.
2019-01-15 22:42:26 -05:00
### **static**
2019-01-04 00:08:36 -05:00
2019-01-21 13:26:39 -05:00
1. What's going on with `lazy_static!()`?
2. What's going on with `thread_local!()`?
2019-01-04 00:08:36 -05:00
2019-01-08 00:16:10 -05:00
## **push** and **pop**: Stack Allocations
2018-12-19 23:21:54 -05:00
Example: Why doesn't `Vec::new()` go to the allocator?
Questions:
1. What is the "Push" instruction? Why do we like the stack?
2. How does Rust allocate arguments to the function?
3. How does Rust allocate variables created in the function but never returned?
4. How does Rust allocate variables created in the function and returned?
5. How do Option<> or Result<> affect structs?
6. How are arrays allocated?
7. Legal to pass an array as an argument?
2019-01-21 13:26:39 -05:00
8. Can you force a heap allocation with arrays that are larger than stack size?
- Check `ulimit -s`
2018-12-19 23:21:54 -05:00
2019-01-01 14:31:15 -05:00
# Piling On - Rust and the Heap
2018-12-19 23:21:54 -05:00
Example: How to trigger a heap allocation
Questions:
1. Where do collection types allocate memory?
2. Does a Box<> always allocate heap?
2019-01-01 14:31:15 -05:00
- Yes, with exception of compiler optimizations
2018-12-19 23:21:54 -05:00
3. Passing Box<Trait> vs. genericizing/monomorphization
2019-01-01 14:31:15 -05:00
- If it uses `dyn Trait`, it's on the heap.
2018-12-26 10:19:34 -05:00
4. Other pointer types? Do Rc<>/Arc<> force heap allocation?
2019-01-01 14:31:15 -05:00
- Maybe? Part of the alloc crate, but should use qadapt to check
2019-01-21 13:26:39 -05:00
5. How many allocations happen before `main()` is called?
2018-12-19 23:21:54 -05:00
2019-01-01 14:31:15 -05:00
# Compiler Optimizations Make Everything Complicated
2018-12-19 23:21:54 -05:00
2018-12-26 10:19:34 -05:00
Example: Compiler stripping out allocations of Box<>, Vec::push()
2019-01-01 14:31:15 -05:00
# Appendix and Further Reading
2018-12-26 10:19:34 -05:00
[embedonomicon]: https://docs.rust-embedded.org/embedonomicon/
[libc]: CRATES.IO LINK
[winapi]: CRATES.IO LINK
[malloc]: MANPAGE LINK