求Windows与OSX平台支持CPU dispatching的Intel C++编译器替代方案

I feel your pain entirely—ICC's persistent bugs, glacial 2-hour compile times, and broken PGO that spits out crash-inducing code are enough to drive any developer up the wall. The worst part is being stuck because of its one-of-a-kind CPU dispatching feature that's critical to your workflow. Let's break down viable alternatives that deliver that same dispatching capability without the headaches:

1. GCC with Function Multiversioning #

GCC 4.8 and later supports function multiversioning, which lets you compile multiple optimized versions of a function for different CPU architectures, with the runtime automatically picking the right one. This directly replaces ICC's CPU dispatching.

• How to use it:
  Mark your functions with target attributes for different CPU features, like:

  __attribute__((target("default")))
  void my_optimized_func() {
      // Fallback implementation
  }
  
  __attribute__((target("avx2")))
  void my_optimized_func() {
      // AVX2-optimized code
  }
  
  __attribute__((target("avx512f")))
  void my_optimized_func() {
      // AVX-512 optimized code
  }
  

• Benefits over ICC:
  • Compile times are drastically faster (minutes instead of hours)
  • PGO works reliably without generating crash-prone code
  • Far fewer compiler bugs in recent versions
  • Full cross-platform support

2. Clang/LLVM with Runtime CPU Detection #

Clang also supports function multiversioning (similar to GCC) and has robust runtime CPU feature detection via __builtin_cpu_supports(), making it easy to implement custom dispatching if you prefer more control.

• Key perks:
  • Even faster compilation than GCC in many cases
  • Excellent compatibility with modern C++ standards
  • Stable PGO implementation battle-tested in large codebases
  • Manual dispatching option: Use __builtin_cpu_supports("avx2") to branch to optimized code paths directly

3. SIMDEverywhere Library (Cross-Compiler Dispatching) #

If you want to avoid tying yourself to a specific compiler's syntax, the SIMDEverywhere library wraps CPU dispatching logic across GCC, Clang, ICC, and MSVC. It provides a unified API to write optimized code that automatically targets the host CPU's capabilities at runtime.

• Why it's great:
  • Lets you switch compilers without rewriting dispatching code
  • Handles all low-level feature detection and function routing for you
  • Supports a wide range of SIMD extensions (SSE, AVX, AVX2, NEON, etc.)

4. MSVC (Windows-Focused) #

If your workflow is Windows-only, MSVC has reliable CPU dispatching support via runtime feature checks and optimized function variants. You can use __cpuid to detect CPU features and call specialized function versions, or leverage MSVC's automatic vectorization with runtime checks.

• Note: MSVC's dispatching is a bit more manual than GCC/Clang's function multiversioning, but it integrates seamlessly with the Windows ecosystem.

Final Recommendation #

If you're working cross-platform, go with GCC or Clang + function multiversioning—they'll fix your compile time and PGO issues while delivering the CPU dispatching you need. If you want maximum portability across compilers, SIMDEverywhere is a fantastic middle ground.

内容的提问来源于stack exchange，提问作者Vojtěch Melda Meluzín