An Introduction to GCC Compiler Intrinsics in Vector Processing

PowerPC Altivec Types and Debugging

PowerPC Processors with Altivec (also known as VMX and Velocity Engine) add the keyword "vector" to their types. They're all 16 bytes long. The following are some Altivec vector types:

• vector unsigned char: 16 unsigned chars
• vector signed char: 16 signed chars
• vector bool char: 16 unsigned chars (0 false, 255 true)
• vector unsigned short: 8 unsigned shorts
• vector signed short: 8 signed shorts
• vector bool short: 8 unsigned shorts (0 false, 65535 true)
• vector unsigned int: 4 unsigned ints
• vector signed int: 4 signed ints
• vector bool int: 4 unsigned ints (0 false, 2^32 -1 true)
• vector float: 4 floats

The debugger prints these vectors as collections of individual elements.

ARM Neon Types and Debugging

On ARM processors that have Neon extensions available, the Neon types follow the pattern [type]x[elementcount]_t. Types include those in the following list:

• uint64x1_t - single 64-bit unsigned integer
• uint32x2_t - pair of 32-bit unsigned integers
• uint16x4_t - four 16-bit unsigned integers
• uint8x8_t - eight 8-bit unsigned integers
• int32x2_t - pair of 32-bit signed integers
• int16x4_t - four 16-bit signed integers
• int8x8_t - eight 8-bit signed integers
• int64x1_t - single 64-bit signed integer
• float32x2_t - pair of 32-bit floats
• uint32x4_t - four 32-bit unsigned integers
• uint16x8_t - eight 16-bit unsigned integers
• uint8x16_t - 16 8-bit unsigned integers
• int32x4_t - four 32-bit signed integers
• int16x8_t - eight 16-bit signed integers
• int8x16_t - 16 8-bit signed integers
• uint64x2_t - pair of 64-bit unsigned integers
• int64x2_t - pair of 64-bit signed integers
• float32x4_t - four 32-bit floats
• uint32x4_t - four 32-bit unsigned integers
• uint16x8_t - eight 16-bit unsigned integers

The debugger prints these vectors as collections of individual elements.

There are examples of these in the samples/simple directory.

Now that we've covered the vector types, let's talk about vector programs.

As Ian Ollman points out, vector programs are blitters. They load data from memory, process it, then store it to memory elsewhere. Moving data between memory and vector registers is necessary, but it's overhead. Taking big bites of data from memory, processing it, then writing it back to memory will minimize that overhead.

Alignment is another aspect of data movement to watch for. Use GCC's "aligned" attribute to align data sources and destinations on 16-bit boundaries for best performance. For instance:

float anarray[4] __attribute__((aligned(16))) = { 1.2, 3.5, 1.7, 2.8 };

Failure to align can result in getting the right answer, silently getting the wrong answer or crashing. Techniques are available for handling unaligned data, but they are slower than using aligned data. There are examples of these in the sample code.

The sample code uses intrinsics for vector operations on X86, Altivec and Neon. These intrinsics follow naming conventions to make them easier to decode. Here are the naming conventions:

Altivec intrinsics are prefixed with "vec_". C++ style overloading accomodates the different type arguments.

Neon intrinsics follow the naming scheme [opname][flags]_[type]. A "q" flag means it operates on quad word (128-bit) vectors.

X86 intrinsics are follow the naming convention _mm_[opname]_[suffix]

    suffix    s single-precision floating point
              d double-precision floating point
              i128 signed 128-bit integer
              i64 signed 64-bit integer
              u64 unsigned 64-bit integer
              i32 signed 32-bit integer
              u32 unsigned 32-bit integer
              i16 signed 16-bit integer
              u16 unsigned 16-bit integer
              i8 signed 8-bit integer
              u8 unsigned 8-bit integer
              pi# 64-bit vector of packed #-bit integers
              pu# 64-bit vector of packed #-bit unsigned integers
              epi# 128-bit vector of packed #-bit unsigned integers
              epu# 128-bit vector of packed #-bit unsigned integers
              ps 128-bit vector of packed single precision floats
              ss 128-bit vector of one single precision float
              pd 128-bit vector of double precision floats
              sd 128-bit vector of one double precision (128-bit) float
              si64 64-bit vector of single 64-bit integer
              si128 128 bit vector

Table 2 lists the intrinsics used in the sample code.

Table 2. Subset of vector operators and intrinsics used in the examples.