sse2neon

A C/C++ header file that converts Intel SSE intrinsics to Arm/Aarch64 NEON intrinsics.

Introduction

sse2neon is a translator of Intel SSE (Streaming SIMD Extensions) intrinsics to Arm NEON, shortening the time needed to get an Arm working program that then can be used to extract profiles and to identify hot paths in the code. The header file sse2neon.h contains several of the functions provided by Intel intrinsic headers such as <xmmintrin.h>, only implemented with NEON-based counterparts to produce the exact semantics of the intrinsics.

Mapping and Coverage

Header file	Extension
<mmintrin.h>	MMX
<xmmintrin.h>	SSE
<emmintrin.h>	SSE2
<pmmintrin.h>	SSE3
<tmmintrin.h>	SSSE3
<smmintrin.h>	SSE4.1
<nmmintrin.h>	SSE4.2
<wmmintrin.h>	AES

sse2neon aims to support SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AES extension.

In order to deliver NEON-equivalent intrinsics for all SSE intrinsics used widely, please be aware that some SSE intrinsics exist a direct mapping with a concrete NEON-equivalent intrinsic. Others, unfortunately, lack a 1:1 mapping, meaning that their equivalents are built utilizing a number of NEON intrinsics.

For example, SSE intrinsic _mm_loadu_si128 has a direct NEON mapping (vld1q_s32), but SSE intrinsic _mm_maddubs_epi16 has to be implemented with 13+ NEON instructions.

Floating-point compatibility

Some conversions require several NEON intrinsics, which may produce inconsistent results compared to their SSE counterparts due to differences in the arithmetic rules of IEEE-754.

Taking a possible conversion of _mm_rsqrt_ps as example:

__m128 _mm_rsqrt_ps(__m128 in)
{
    float32x4_t out = vrsqrteq_f32(vreinterpretq_f32_m128(in));

    out = vmulq_f32(
        out, vrsqrtsq_f32(vmulq_f32(vreinterpretq_f32_m128(in), out), out));

    return vreinterpretq_m128_f32(out);
}

The _mm_rsqrt_ps conversion will produce NaN if a source value is 0.0 (first INF for the reciprocal square root of 0.0, then INF * 0.0 using vmulq_f32). In contrast, the SSE counterpart produces INF if a source value is 0.0. As a result, additional treatments should be applied to ensure consistency between the conversion and its SSE counterpart.

Requirement

Developers are advised to utilize sse2neon.h with GCC version 10 or higher, or Clang version 11 or higher. While sse2neon.h might be compatible with earlier versions, certain vector operation errors have been identified in those versions. For further details, refer to the discussion in issue #622.

Usage

• Put the file sse2neon.h in to your source code directory.

• Locate the following SSE header files included in the code:

#include <xmmintrin.h>
#include <emmintrin.h>

{p,t,s,n,w}mmintrin.h could be replaceable as well.

• Replace them with:

#include "sse2neon.h"

• Explicitly specify platform-specific options to gcc/clang compilers.
  • On ARMv8-A 64-bit targets, you should specify the following compiler option: (Remove crypto and/or crc if your architecture does not support cryptographic and/or CRC32 extensions)

  -march=armv8-a+fp+simd+crypto+crc

  • On ARMv8-A 32-bit targets, you should specify the following compiler option:

  -mfpu=neon-fp-armv8

  • On ARMv7-A targets, you need to append the following compiler option:

  -mfpu=neon

Compile-time Configurations

Though floating-point operations in NEON use the IEEE single-precision format, NEON does not fully comply to the IEEE standard when inputs or results are denormal or NaN values for minimizing power consumption as well as maximizing performance. Considering the balance between correctness and performance, sse2neon recognizes the following compile-time configurations:

• SSE2NEON_PRECISE_MINMAX: Enable precise implementation of _mm_min_{ps,pd} and _mm_max_{ps,pd}. If you need consistent results such as handling with NaN values, enable it.
• SSE2NEON_PRECISE_DIV: Enable precise implementation of _mm_rcp_ps and _mm_div_ps by additional Netwon-Raphson iteration for accuracy.
• SSE2NEON_PRECISE_SQRT: Enable precise implementation of _mm_sqrt_ps and _mm_rsqrt_ps by additional Netwon-Raphson iteration for accuracy.
• SSE2NEON_PRECISE_DP: Enable precise implementation of _mm_dp_pd. When the conditional bit is not set, the corresponding multiplication would not be executed.
• SSE2NEON_SUPPRESS_WARNINGS: Set this macro to disable the warning which is emitted by default when optimizations are enabled.

The above are turned off by default, and you should define the corresponding macro(s) as 1 before including sse2neon.h if you need the precise implementations.

Run Built-in Test Suite

sse2neon provides a unified interface for developing test cases. These test cases are located in tests directory, and the input data is specified at runtime. Use the following commands to perform test cases:

$ make check

For running check with enabling features, you can use assign the features with FEATURE command. If none is assigned, then the command will be the same as simply calling make check. The following command enable crypto and crc features in the tests.

$ make FEATURE=crypto+crc check

For running check on certain CPU, setting the mode of FPU, etc., you can also assign the desired options with ARCH_CFLAGS command. If none is assigned, the command acts as same as calling make check. For instance, to run tests on Cortex-A53 with enabling ARM VFPv4 extension and NEON:

$ make ARCH_CFLAGS="-mcpu=cortex-a53 -mfpu=neon-vfpv4" check

Running tests on hosts other than ARM platform

For running tests on hosts other than ARM platform, you can specify GNU toolchain for cross compilation with CROSS_COMPILE command. QEMU should be installed in advance.

For ARMv8-A running in 64-bit mode type:

$ make CROSS_COMPILE=aarch64-linux-gnu- check # ARMv8-A

For ARMv7-A type:

$ make CROSS_COMPILE=arm-linux-gnueabihf- check # ARMv7-A

For ARMv8-A running in 32-bit mode (A32 instruction set) type:

$ make \
  CROSS_COMPILE=arm-linux-gnueabihf- \
  ARCH_CFLAGS="-mcpu=cortex-a32 -mfpu=neon-fp-armv8" \
  check 

Check the details via Test Suite for SSE2NEON.

Optimization

The SSE2NEON project is designed with performance-sensitive scenarios in mind, and as such, optimization options (e.g. O1, O2) can lead to misbehavior under specific circumstances. For example, frequent changes to the rounding mode or repeated calls to _MM_SET_DENORMALS_ZERO_MODE() may introduce unintended behavior.

Enforcing no optimizations for specific intrinsics could solve these boundary cases but may negatively impact general performance. Therefore, we have decided to prioritize performance and shift the responsibility for handling such edge cases to developers.

It is important to be aware of these potential pitfalls when enabling optimizations and ensure that your code accounts for these scenarios if necessary.

Adoptions

Here is a partial list of open source projects that have adopted sse2neon for Arm/Aarch64 support.

• Aaru Data Preservation Suite is a fully-featured software package to preserve all storage media from the very old to the cutting edge, as well as to give detailed information about any supported image file (whether from Aaru or not) and to extract the files from those images.
• aether-game-utils is a collection of cross platform utilities for quickly creating small game prototypes in C++.
• ALE, aka Assembly Likelihood Evaluation, is a tool for evaluating accuracy of assemblies without the need of a reference genome.
• AnchorWave, Anchored Wavefront Alignment, identifies collinear regions via conserved anchors (full-length CDS and full-length exon have been implemented currently) and breaks collinear regions into shorter fragments, i.e., anchor and inter-anchor intervals.
• ATAK-CIV, Android Tactical Assault Kit for Civilian Use, is the official geospatial-temporal and situational awareness tool used by the US Government.
• Apache Doris is a Massively Parallel Processing (MPP) based interactive SQL data warehousing for reporting and analysis.
• Apache Impala is a lightning-fast, distributed SQL queries for petabytes of data stored in Apache Hadoop clusters.
• Apache Kudu completes Hadoop's storage layer to enable fast analytics on fast data.
• apollo is a high performance, flexible architecture which accelerates the development of Autonomous Vehicles.
• ares is a cross-platform, open source, multi-system emulator, focusing on accuracy and preservation.
• ART is an implementation in OCaml of Adaptive Radix Tree (ART).
• Async is a set of c++ primitives that allows efficient and rapid development in C++17 on GNU/Linux systems.
• avec is a little library for using SIMD instructions on both x86 and Arm.
• BEAGLE is a high-performance library that can perform the core calculations at the heart of most Bayesian and Maximum Likelihood phylogenetics packages.
• BitMagic implements compressed bit-vectors and containers (vectors) based on ideas of bit-slicing transform and Rank-Select compression, offering sets of method to architect your applications to use HPC techniques to save memory (thus be able to fit more data in one compute unit) and improve storage and traffic patterns when storing data vectors and models in files or object stores.
• bipartite_motif_finder as known as BMF (Bipartite Motif Finder) is an open source tool for finding co-occurences of sequence motifs in genomic sequences.
• Blender is the free and open source 3D creation suite, supporting the entirety of the 3D pipeline.
• Boo is a cross-platform windowing and event manager similar to SDL or SFML, with additional 3D rendering functionality.
• Brickworks is a music DSP toolkit that supplies with the fundamental building blocks for creating and enhancing audio engines on any platform.
• CARTA is a new visualization tool designed for viewing radio astronomy images in CASA, FITS, MIRIAD, and HDF5 formats (using the IDIA custom schema for HDF5).
• Catcoon is a feedforward neural network implementation in C.
• compute-runtime, the Intel Graphics Compute Runtime for oneAPI Level Zero and OpenCL Driver, provides compute API support (Level Zero, OpenCL) for Intel graphics hardware architectures (HD Graphics, Xe).
• contour is a modern and actually fast virtual terminal emulator.
• Cog is a free and open source audio player for macOS.
• dab-cmdline provides entries for the functionality to handle Digital audio broadcasting (DAB)/DAB+ through some simple calls.
• DISTRHO is an open-source project for Cross-Platform Audio Plugins.
• Dragonfly is a modern in-memory datastore, fully compatible with Redis and Memcached APIs.
• EDGE is an advanced OpenGL source port spawned from the DOOM engine, with focus on easy development and expansion for modders and end-users.
• Embree is a collection of high-performance ray tracing kernels. Its target users are graphics application engineers who want to improve the performance of their photo-realistic rendering application by leveraging Embree's performance-optimized ray tracing kernels.
• emp-tool aims to provide a benchmark for secure computation and allowing other researchers to experiment and extend.
• Exudyn is a C++ based Python library for efficient simulation of flexible multibody dynamics systems.
• FoundationDB is a distributed database designed to handle large volumes of structured data across clusters of commodity servers.
• fsrc is capable of searching large codebases for text snippets.
• gmmlib is the Intel Graphics Memory Management Library that provides device specific and buffer management for the Intel Graphics Compute Runtime for OpenCL and the Intel Media Driver for VAAPI.
• HISE is a cross-platform open source audio application for building virtual instruments, emphasizing on sampling, but includes some basic synthesis features for making hybrid instruments as well as audio effects.
• iqtree2 is an efficient and versatile stochastic implementation to infer phylogenetic trees by maximum likelihood.
• indelPost is a Python library for indel processing via realignment and read-based phasing to resolve alignment ambiguities.
• IResearch is a cross-platform, high-performance document oriented search engine library written entirely in C++ with the focus on a pluggability of different ranking/similarity models.
• Kraken is a 3D animation platform redefining animation composition, collaborative workflows, simulation engines, skeletal rigging systems, and look development from storyboard to final render.
• kram is a wrapper to several popular encoders to and from PNG/KTX files with LDR/HDR and BC/ASTC/ETC2.
• Krita is a cross-platform application that offers an end-to-end solution for creating digital art files from scratch built on the KDE and Qt frameworks.
• libCML is a SLAM library and scientific tool, which include a novel fast thread-safe graph map implementation.
• libhdfs3 is implemented based on native Hadoop RPC protocol and Hadoop Distributed File System (HDFS), a highly fault-tolerant distributed fs, data transfer protocol.
• libpostal is a C library for parsing/normalizing street addresses around the world using statistical NLP and open data.
• libscapi stands for the "Secure Computation API", providing reliable, efficient, and highly flexible cryptographic infrastructure.
• libstreamvbyte is a C++ implementation of StreamVByte.
• libmatoya is a cross-platform application development library, providing various features such as common cryptography tasks.
• Loosejaw provides deep hybrid CPU/GPU digital signal processing.
• Madronalib enables efficient audio DSP on SIMD processors with readable and brief C++ code.
• minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database.
• mixed-fem is an open source reference implementation of Mixed Variational Finite Elements for Implicit Simulation of Deformables.
• MMseqs2 (Many-against-Many sequence searching) is a software suite to search and cluster huge protein and nucleotide sequence sets.
• MRIcroGL is a cross-platform tool for viewing NIfTI, DICOM, MGH, MHD, NRRD, AFNI format medical images.
• N2 is an approximate nearest neighborhoods algorithm library written in C++, providing a much faster search speed than other implementations when modeling large dataset.
• nanors is a tiny, performant implementation of Reed-Solomon codes, capable of reaching multi-gigabit speeds on a single core.
• niimath is a general image calculator with superior performance.
• NVIDIA GameWorks has been already used in a lot of games. These repositories are public on GitHub.
• Nx Meta Platform Open Source Components are used to build all Powered-by-Nx products including Nx Witness Video Management System (VMS).
• ofxNDI is an openFrameworks addon to allow sending and receiving images over a network using the NewTek Network Device Protocol.
• OGRE is a scene-oriented, flexible 3D engine written in C++ designed to make it easier and more intuitive for developers to produce games and demos utilising 3D hardware.
• Olive is a free non-linear video editor for Windows, macOS, and Linux.
• OpenColorIO a complete color management solution geared towards motion picture production with an emphasis on visual effects and computer animation.
• OpenXRay is an improved version of the X-Ray engine, used in world famous S.T.A.L.K.E.R. game series by GSC Game World.
• parallel-n64 is an optimized/rewritten Nintendo 64 emulator made specifically for Libretro.
• Pathfinder C++ is a fast, practical, GPU-based rasterizer for fonts and vector graphics using Vulkan and C++.
• PFFFT does 1D Fast Fourier Transforms, of single precision real and complex vectors.
• pixaccess provides the abstractions for integer and float bitmaps, pixels, and aliased (nearest neighbor) and anti-aliased (bi-linearly interpolated) pixel access.
• PlutoSDR Firmware is the customized firmware for the PlutoSDR that can be used to introduce fundamentals of Software Defined Radio (SDR) or Radio Frequency (RF) or Communications as advanced topics in electrical engineering in a self or instructor lead setting.
• PowerToys is a set of utilities for power users to tune and streamline their Windows experience for greater productivity.
• Pygame is cross-platform and designed to make it easy to write multimedia software, such as games, in Python.
• R:RandomFieldsUtils provides various utilities might be used in spatial statistics and elsewhere. (CRAN)
• RAxML is tool for Phylogenetic Analysis and Post-Analysis of Large Phylogenies.
• ReHLDS is fully compatible with latest Half-Life Dedicated Server (HLDS) with a lot of defects and (potential) bugs fixed.
• rkcommon represents a common set of C++ infrastructure and CMake utilities used by various components of Intel oneAPI Rendering Toolkit.
• RPCS3 is the world's first free and open-source PlayStation 3 emulator/debugger, written in C++.
• simd_utils is a header-only library implementing common mathematical functions using SIMD intrinsics.
• Sire is a molecular modelling framework that provides extensive functionality to manipulate representations of biomolecular systems.
• SMhasher provides comprehensive Hash function quality and speed tests.
• SNN++ implements a single layer non linear Spiking Neural Network for images classification and generation.
• Spack is a multi-platform package manager that builds and installs multiple versions and configurations of software.
• SRA is a collection of tools and libraries for using data in the INSDC Sequence Read Archives.
• srsLTE is an open source SDR LTE software suite.
• SSW is a fast implementation of the Smith-Waterman algorithm, which uses the SIMD instructions to parallelize the algorithm at the instruction level.
• Surge is an open source digital synthesizer.
• The Forge is a cross-platform rendering framework, providing building blocks to write your own game engine.
• Typesense is a fast, typo-tolerant search engine for building delightful search experiences.
• Vcpkg is a C++ Library Manager for Windows, Linux, and macOS.
• VelocyPack is a fast and compact format for serialization and storage.
• VOLK, Vector-Optimized Library of Kernel, is a sub-project of GNU Radio.
• Vowpal Wabbit is a machine learning system which pushes the frontier of machine learning with techniques such as online, hashing, allreduce, reductions, learning2search, active, and interactive learning.
• Winter is the top rated chess engine from Switzerland and has competed at top invite only computer chess events.
• XEVE (eXtra-fast Essential Video Encoder) is an open sourced and fast MPEG-5 EVC encoder.
• XMRig is an open source CPU miner for Monero cryptocurrency.
• xsimd provides a unified means for using SIMD intrinsics and parallelized, optimized mathematical functions.
• YACL is a C++ library contains modules and utilities which SecretFlow code depends on.

Related Projects

• SIMDe: fast and portable implementations of SIMD intrinsics on hardware which doesn't natively support them, such as calling SSE functions on ARM.
• CatBoost's sse2neon
• ARM_NEON_2_x86_SSE
• AvxToNeon
• sse2rvv: C header file that converts Intel SSE intrinsics to RISC-V Vector intrinsic.
• sse2msa: A C/C++ header file that converts Intel SSE intrinsics to MIPS/MIPS64 MSA intrinsics.
• sse2zig: Intel SSE intrinsics mapped to Zig vector extensions.
• POWER/PowerPC support for GCC contains a series of headers simplifying porting x86_64 code that makes explicit use of Intel intrinsics to powerpc64le (pure little-endian mode that has been introduced with the POWER8).
  • implementation: xmmintrin.h, emmintrin.h, pmmintrin.h, tmmintrin.h, smmintrin.h

Reference

• Intel Intrinsics Guide
• Microsoft: x86 intrinsics list
• Arm Neon Intrinsics Reference
• Neon Programmer's Guide for Armv8-A
• NEON Programmer's Guide
• qemu/target/i386/ops_sse.h: Comprehensive SSE instruction emulation in C. Ideal for semantic checks.
• Porting Takua Renderer to 64-bit ARM- Part 1
• Porting Takua Renderer to 64-bit ARM- Part 2
• Comparing SIMD on x86-64 and arm64
• Port with SSE2Neon and SIMDe
• Genomics: Optimizing the BWA aligner for Arm Servers
• Bit twiddling with Arm Neon: beating SSE movemasks, counting bits and more
• C/C++ on Graviton
• C/C++ on NVIDIA Grace
• Tune graphics-intensive games for Apple silicon
• Benchmarking and Testing of Qualcomm Snapdragon System-on-Chip for JPL Space Applications and Missions

Licensing

sse2neon is freely redistributable under the MIT License.