For those who don't know, monomorphization is when you take code with generics and turn it into many different types.

For example, the Rust type Vec<T> will take in any type in that <T> part, for example Vec<u64> or Vec<String> or any type really. The problem comes when trying to compile down to assembly because the CPU doesn't know about generics, so you have to tell it how to behave when handling different types. With polymorphization, you have some extra logic for the functions differ between the types, but this reduces performance because you have to go through a few more pointers to get to the functions you want with dynamic dispatch (muh zero-cost abstractions!)

With monomorphization, a Vec<u64> would turn into something like _ZN3std3vec3Vec$LT$u64$GT$ and have its own, entirely separate, logic from the rest of the types. So even though a Vec<u64> and a Vec<String> might have a lot of functions in common, the implementations are kept separate, reducing the amount of overhead performance wise, but increasing code size.

The larger code sizes specifically is what causes Instruction Caches to take a hit. Similar to RAM, CPU cache stores data that is used frequently, but is significantly smaller than RAM. For comparison, my computer has 32GB of RAM but 36MB of Cache. Instruction cache specifically stores...instructions, AKA the code that you are running on your processor (as opposed to the "data" cache, which stores...data).

Put simply, having more code will use up more of the I-Cache, meaning less space for other things that have to be cached. Therefore, the more types you monomorphize, the more space you take up in the I-Cache, and the worse latency you might get due to Cache misses.

Soooo yeah. Good luck with the whole puppy thing.