How to find biggest variant in an enum in Rust?

Question

I'm trying to improve the performance of a rust program, which requires me to reduce the size of some large enums. For example

enum EE {
    A, // 0
    B(i32), //4
    C(i64), // 8
    D(String), // 24
    E { // 16
        x: i64,
        y: i32,
    },
}

fn main() {
    println!("{}", std::mem::size_of::<EE>()); // 32
}

prints 32. But if I want to know the size of EE::A, I get a compile error

error[E0573]: expected type, found variant `EE::A`
  --> src/main.rs:14:40
   |
14 |     println!("{}", std::mem::size_of::<EE::A>());
   |                                        ^^^^^
   |                                        |
   |                                        not a type
   |                                        help: try using the variant's enum: `crate::EE`

error: aborting due to previous error

error: could not compile `play_rust`.

Is there a way to find out which variant takes the most space?

Answer 1

If you can use a nightly compiler, you can now use rustc's -Zprint-type-sizes flag to show the size of each variant. Be warned, it's a noisy flag! Using the code from your example gives:

$ RUSTFLAGS=-Zprint-type-sizes cargo +nightly build --release
[..]
print-type-size type: `EE`: 32 bytes, alignment: 8 bytes
print-type-size     discriminant: 4 bytes
print-type-size     variant `D`: 28 bytes
print-type-size         padding: 4 bytes
print-type-size         field `.0`: 24 bytes, alignment: 8 bytes
print-type-size     variant `C`: 12 bytes
print-type-size         padding: 4 bytes
print-type-size         field `.0`: 8 bytes, alignment: 8 bytes
print-type-size     variant `E`: 12 bytes
print-type-size         field `.y`: 4 bytes
print-type-size         field `.x`: 8 bytes
print-type-size     variant `B`: 4 bytes
print-type-size         field `.0`: 4 bytes
print-type-size     variant `A`: 0 bytes
[..]

Where we can see EE::A is 0 bytes.

Answer 2

No, there is no way to get the size of just one variant of an enum. The best you can do is get the size of what the variant contains, as if it were a standalone struct:

    println!("sizeof EE::A: {}", std::mem::size_of::<()>());         // 0
    println!("sizeof EE::B: {}", std::mem::size_of::<i32>());        // 4
    println!("sizeof EE::C: {}", std::mem::size_of::<i64>());        // 8
    println!("sizeof EE::D: {}", std::mem::size_of::<String>());     // 24
    println!("sizeof EE::E: {}", std::mem::size_of::<(i64, i32)>()); // 16

Even this isn't especially useful because it includes padding bytes that may be used to store the tag; as you point out, the size of the enum can be reduced to 16 if D is shrunk to a single pointer, but you can't know that from looking at just the sizes. If y were instead defined as i64, the size of each variant would be the same, but the size of the enum would need to be 24. Alignment is another confounding factor that makes the size of an enum more complex than just "the size of the largest variant plus the tag".

Of course, this is all highly platform-dependent, and your code should not rely on any enum having a particular layout (unless you can guarantee it with a #[repr] annotation).

If you have a particular enum you're worried about, it's not difficult to get the size of each contained type. Clippy also has a lint for enums with extreme size differences between variants. However, I don't recommend using size alone to make manual optimizations to enum layouts, or boxing things that are only a few pointers in size -- indirection suppresses other kinds of optimizations the compiler may be able to do. If you prioritize minimal space usage you may accidentally make your code much slower in the process.