Memory Management in Rustc: Arenas and Interning

# Memory management in rustc Generally rustc tries to be pretty careful how it manages memory. The compiler allocates _a lot_ of data structures throughout compilation, and if we are not careful, it will take a lot of time and space to do so. One of the main way the compiler manages this is using [arena]s and [interning]. ## Arenas and Interning Since A LOT of data structures are created during compilation, for performance reasons, we allocate them from a global memory pool. Each are allocated once from a long-lived *arena*. This is called _arena allocation_. This system reduces allocations/deallocations of memory. It also allows for easy comparison of types (more on types [here](./ty.md)) for equality: for each interned type `X`, we implemented [`PartialEq` for X][peqimpl], so we can just compare pointers. The [`CtxtInterners`] type contains a bunch of maps of interned types and the arena itself. ### Example: `ty::TyKind` Taking the example of [`ty::TyKind`] which represents a type in the compiler (you can read more [here](./ty.md)). Each time we want to construct a type, the compiler doesn’t naively allocate from the buffer. Instead, we check if that type was already constructed. If it was, we just get the same pointer we had before, otherwise we make a fresh pointer. With this schema if we want to know if two types are the same, all we need to do is compare the pointers which is efficient. [`ty::TyKind`] should never be constructed on the stack, and it would be unusable if done so. You always allocate them from this arena and you always intern them so they are unique. At the beginning of the compilation we make a buffer and each time we need to allocate a type we use some of this memory buffer. If we run out of space we get another one. The lifetime of that buffer is `'tcx`. Our types are tied to that lifetime, so when compilation finishes all the memory related to that buffer is freed and our `'tcx` references would be invalid. In addition to types, there are a number of other arena-allocated data structures that you can allocate, and which are found in this module. Here are a few examples:

Rustc employs arenas and interning to efficiently manage memory during compilation. Arenas act as global memory pools from which data structures are allocated, reducing allocation/deallocation overhead. Interning ensures that identical data structures share the same memory address, allowing for efficient equality comparisons using pointer comparison. `CtxtInterners` stores interned types and the arena. `ty::TyKind` is an example of an interned type, where new types are only allocated if they don't already exist, ensuring uniqueness and efficient comparison. The lifetime of allocated data is tied to `'tcx`, which is freed at the end of compilation.