5.9 Performance Considerations for Numeric Types

Different numeric types offer trade-offs between memory usage, value range, and computational performance.

  • i32/u32: Often the “sweet spot” for general-purpose integer arithmetic. They perform well on both 32-bit and 64-bit architectures. i32 is the default integer type for good reason.
  • i64/u64: Highly efficient on 64-bit CPUs, offering a much larger range than 32-bit types. They might incur a slight performance cost on 32-bit CPUs for operations that aren’t natively supported. Necessary when values might exceed the approx. +/- 2 billion range of i32.
  • i128/u128: Provide a very large range but are not natively supported by most current hardware. Arithmetic operations are typically emulated by the compiler using multiple lower-level instructions, making them significantly slower than 64-bit (or even 32-bit) operations. Use only when the extremely large range is strictly required.
  • f64: The default floating-point type. Modern 64-bit CPUs often have dedicated hardware for double-precision floating-point math, making f64 operations as fast as, or sometimes even faster than, f32 operations, while offering significantly higher precision.
  • f32: Primarily useful when memory usage is a major concern (e.g., large arrays of floats in graphics, simulations, or machine learning) or when interacting with hardware or external libraries specifically requiring single precision (e.g., GPU programming APIs). Performance relative to f64 varies by CPU.
  • Smaller Types (i8/u8, i16/u16): Can significantly reduce memory consumption, especially in large arrays or data structures, potentially improving cache locality and performance. However, CPUs often perform arithmetic most efficiently on their native register size (typically 32 or 64 bits). Operations involving smaller types might require extra instructions for loading, sign-extension (for signed types), or zero-extension (for unsigned types) before the actual arithmetic, which can sometimes negate the memory savings in terms of speed. The impact is highly context-dependent.
  • isize/usize: Designed to match the architecture’s pointer size. Use these primarily for indexing into collections (arrays, vectors, slices), representing memory sizes, and pointer arithmetic. Avoid using them for general numeric calculations unless directly related to memory addressing or collection capacity/indices, as their size varies between architectures (32 vs 64 bits), which could affect portability if used for non-memory-related logic.

General Advice: Begin with the defaults (i32, f64). Choose other types based on specific requirements: range needs (i64, u64, i128), memory constraints (i8, u16, f32), or indexing/memory size representation (usize). If performance is critical, profile your code rather than making assumptions about the speed of different types. Be mindful that explicit as casts between numeric types, while necessary for type safety, are not entirely free and represent computations that take some amount of time.