Rust interpreter gains 17% speed by replacing enum with 64-bit word encoding

The change replaces a Rust enum with a custom 64-bit tagged word encoding, reducing the size of each value from 16 bytes to 8 bytes. This directly cuts memory usage for large arrays or frequent allocations, a common bottleneck in dynamic language interpreters. The denser layout also improves cache locality, which can further boost performance by reducing memory access latency.

The optimization leverages alignment constraints on 64-bit systems, where heap pointers typically have their lowest 3 bits set to zero. These bits are repurposed to store type tags, allowing pointers, integers, and other values to coexist in a single 64-bit word. Integers are given a zero tag to simplify arithmetic operations, while floats and other types require additional bitwise instructions to unpack. This introduces a trade-off: memory efficiency improves, but some operations become slightly more expensive due to the extra instructions.

The 17% performance gain suggests that the reduction in memory overhead outweighed the cost of the additional bitwise operations. This outcome may not generalize to all interpreters, as it depends on the workload and the frequency of operations requiring unpacking. For example, workloads heavy in floating-point arithmetic might see less benefit due to the higher cost of unpacking floats. The approach is most effective when the interpreter frequently allocates or traverses large data structures, such as arrays or dictionaries.

This change highlights the importance of memory layout in performance-critical code. While Rust’s tagged enums are ergonomic and safe, they may not always be the most efficient choice for systems where memory usage is a bottleneck. Engineers working on interpreters or virtual machines should consider custom encodings when standard language features introduce unnecessary overhead. However, such optimizations come with maintenance costs, as they require manual bit manipulation and careful handling of edge cases, such as large integers or misaligned pointers.