The C++20 SIMD library EVE (Expressive Vector Engine) has sparked an interesting technical discussion within the developer community, particularly regarding its approach to runtime dispatch and cross-platform compatibility. While the library aims to provide high-performance vectorized operations, its design choices have led to both praise and criticism from experienced developers.
Runtime Dispatch and Architecture Support
A significant point of debate centers on EVE's handling of different SIMD instruction sets. Unlike some competitors such as xsimd, EVE opts for a dynamic dispatch approach through DLLs rather than using template parameters for feature levels. This design decision has drawn mixed reactions from the community, with some developers expressing concerns about the practicality of managing multiple DLLs for different architectures.
You can create your kernel/function so that the simd level is a template parameter, and then you can use simple branching [...] I've also used it for benchmarking to see if my code scales to different simd widths well and it's a huge help.
Supported Instruction Sets:
- Intel: SSE2, SSSE3, SSE3, SSE4.1, SSE4.2, AVX, AVX2, FMA3, AVX512
- ARM: NEON A32/A64 (64 & 128 bits), ASIMD, SVE (fixed sizes: 128, 256, 512 bits)
Key Features:
- C++20 based implementation
- Algorithms support (find, search, remove, set_intersection)
- SOA (Structure of Arrays) support
- Optimized codegen with unrolling/alignment
- Masked lane operations
- Dynamic dispatch via DLL approach
Current Limitations:
- No runtime-sized SVE/RVV support
- Limited MSVC compatibility
- Requires C++20 compliant compiler
Strengths and Implementation Challenges
EVE's maintainers have highlighted several distinctive features, including comprehensive algorithm support, efficient SOA (Structure of Arrays) handling, and optimized codegen with careful attention to unrolling and data access alignment. However, the library faces some notable challenges, including limited support for runtime-sized SVE/RVV operations and compatibility issues with MSVC due to C++20 requirements.
Developer Experience and Documentation
The community feedback suggests that while EVE offers powerful features like masked lane operations in a declarative style, the learning curve can be steep. Developers have noted that the documentation could be more comprehensive, particularly for basic operations like creating fixed-size vectors for shader operations. This highlights a common challenge in highly technical libraries: balancing advanced features with accessibility.
Cross-Platform Considerations
One notable aspect of EVE's implementation is its approach to cross-platform support. The library currently supports a wide range of instruction sets across Intel and ARM architectures, including SSE2 through AVX512 for Intel and various NEON implementations for ARM. AMD processors are also supported through their x86 compatibility, though this wasn't explicitly highlighted in the original documentation.
The ongoing discussion reveals the complex trade-offs involved in designing modern SIMD libraries, particularly as the C++ ecosystem continues to evolve with features like modules. While EVE's approach may not suit every use case, it represents an important contribution to the field of high-performance computing in C++.
Reference: EVE - the Expressive Vector Engine