Basic Arithmetic

Toward the top of Listing 8-1 are the function declarations for example Ch08_01. Note that these declarations use the ZmmVal structure that you learned about in Chapter 7. The file Ch08_01.cpp contains two functions named PackedMathF32() and PackedMathF64(). These functions perform test case initialization for the SIMD calculating functions PackedMathF32_Iavx512() and PackedMathF64_Iavx512(). They also stream results to std::cout.

The file Ch08_01_fcpp.cpp begins with the definition of function PackedMathF32_Iavx512(). This function uses the C++ SIMD intrinsic function _mm512_load_ps() to initialize a_vals and b_vals. The next code block consists of C++ SIMD intrinsic function calls that perform various AVX-512 arithmetic operations using packed single-precision floating-point operands. This is followed by a series of _mm512_store_ps() calls that save the calculated results. Note that both _mm512_load_ps() and _mm512_store_ps() require their memory operands to be aligned on a 64-byte boundary.

Compare Operations

In Listing 8-2, the files Ch08_02.h and Ch08_02.cpp contain function declarations and test case initialization code for this source code example. The first function in file Ch08_02_fcpp.cpp, PackedCompareF32_Iavx512(), performs SIMD compare operations using packed single-precision floating-point operands. Unlike AVX and AVX2, AVX-512 SIMD floating-point compare operations return scalar integers that signify the results. In the current example, the C++ SIMD intrinsic function _mm512_cmp_ps_mask() returns an integer value of type __mmask16 . Each bit position of this 16-bit wide mask value reports the compare result for the corresponding SIMD operand element position (1 = compare predicate true, 0 = compare predicate false). Function _mm512_cmp_ps_mask() uses the same compare predicates that _mm256_cmp_ps() uses (see example Ch03_02).

Covariance Matrix

Mathematicians often use a statistical measure called covariance to quantify the extent to which two random variables vary together. When multiple random variables are being analyzed, it is common to calculate a matrix of all possible covariances. This matrix is called, unsurprisingly, a covariance matrix. Once calculated, a covariance matrix can be employed to perform a wide variety of advanced statistical analyses. Appendix B contains several references that you can consult if you are interested in learning more about covariance and covariance matrices.

The calculation of a covariance matrix begins with a sample data matrix as shown in Figure 8-1. In this figure, each row of matrix X represents one random variable (or feature). Each column in X is a multivariate observation. The elements c_ij in covariance matrix C are calculated using the following equation:

where i = 0, 1, ⋯, n_var − 1 and j = 0, 1, ⋯, n_var − 1. In these equations, the symbols n_obv and n_var signify the number of observations and variables, respectively. A covariance matrix is always a square (n_var × n_var) symmetric (c_ij = c_ji) matrix as shown in Figure 8-1. Each covariance matrix element c_ij represents the covariance between random variables x_i and x_j, and each main diagonal element c_ii is the variance for variable x_i.

Near the top of Listing 8-4 is the file Ch08_04.h, which begins with the definition of structure CMD (CMD = covariance matrix data). This structure contains the data matrix, the variable means vector, and the covariance matrix. Note that CMD also includes a simple constructor that allocates space for the three container objects using the specified n_vars and n_obvs. The source code that performs argument validation, test data initialization, and result comparisons is not shown in Listing 8-4 but included in the download software package.

The core calculating functions of source code example are in Ch08_08_fcpp.cpp, which begins with the definition of function CalcCovMatF64_Cpp(). This function uses standard C++ statements to calculate the covariance matrix and is included for comparison purposes. The code in CalcCovMatF64_Cpp() is split into two major sections. The first section calculates the mean for each variable (or row) in data matrix x. The second section calculates the covariances. Note that function CalcCovMatF64_Cpp() exploits the fact that a covariance matrix is symmetric and only carries out a complete calculation when i <= j is true. If i <= j is false, CalcCovMatF64_Cpp() executes cov_mat[i][j] = cov_mat[j][j].

The next function in Ch08_04_fcpp.cpp is a SIMD inline function named ReduceAddF64(). This function reduces the double-precision floating-point elements of arguments a (__m512d), b (__m256d), and c (__m128d) to a scalar double-precision value. Note that ReduceAddF64() employs several C++ SIMD intrinsic functions to size-extend argument values b and c to packed 512-bit wide SIMD values. Doing this facilitates the use of the AVX-512 C++ SIMD intrinsic function _mm512_reduce_add_pd() to perform the reduction.

The final function in Listing 8-4 is named CalcCovMatF64_Iavx512(). Like its standard C++ counterpart, function CalcCovMatF64_Iavx512() uses distinct sections of code to calculate the variable means and the covariance matrix. The mean calculating while-loop employs __m512d, __m256d, __m128d, or scalar objects to perform its computations. Note that each if section verifies that enough elements are available in the current row before carrying out any SIMD calculations. Following the while-loop, CalcCovMatF64_Iavx512() invokes ReduceAddF64() to reduce sums_512, sums_256, and sums_128 to a scalar value. It then calculates var_means[i].

Matrix Multiplication

Near the top of Listing 8-5 is the source code for function MatrixMulF32_Iavx512(), which performs single-precision floating-point matrix multiplication. The primary difference between this function and the function MatrixMulF32_Iavx2() that you studied in example Ch05_02 is in the code that calculates the residual column mask for the current row. In example Ch05_02, function MatrixMulF32_Iavx2() used a SIMD integer (__m256i) mask. In this example, function MatrixMulF32_Iavx512() uses a scalar integer (__mmask16) mask since these are directly supported by AVX-512.

Matrix (4 x 4) Vector Multiplication

The source code in file Ch08_07_fcpp.cpp begins with a series of arrays that contain permutation indices. The AVX-512 implementation of the matrix-vector multiplication algorithm uses these indices to reorder the elements of the source matrix and vectors. The reason for this reordering is to facilitate the calculation of four matrix-vector products during each iteration of the for-loop. The definition of function MatVecMulF32_Cpp() follows the permutation indices. This function calculates matrix-vector (4 × 4, 4 × 1) products using standard C++ statements.

Following argument validation, function MatVecMulF32a_Iavx512() loads the permutation indices using a series of _mm512_load_epi32() calls. The ensuing call to _mm512_load_ps() loads matrix m into m_vals. This is followed by a series of four calls to _mm512_permutexvar_ps() that permute the elements in m_vals to generate four copies of each column in matrix m as shown in Figure 8-2.

Each iteration of the first for-loop in MatVecMulF32a_Iavx512() begins with a call to _mm512_load_ps() that loads a block of four vectors into va_vals. The next code block employs the C++ SIMD intrinsic function _mm512_permutexvar_ps() to reorder vector components W, X, Y, and Z. Figure 8-3 illustrates this operation in greater detail. Following the permutation, MatVecMulF32a_Iavx512() invokes _mm512_mul_ps() and _mm512_fmadd_ps() to calculate four matrix-vector products. The final call of the for-loop, _mm512_store_ps(), saves the just calculated matrix-vector products. The second for-loop in MatVecMulF32a_Iavx512() calculates any residual matrix-vector products if num_vec is not an integral multiple of num_vec_per_iteration.

1D Convolutions

The first function in Listing 8-8, Convolve1D_F32_Cpp(), implements a 1D discrete convolution using standard C++ statements. This function is identical to the one you saw in source code example Ch06_01 and is included again here for benchmarking purposes. The next function in Listing 8-8, named Convolve1D_F32_Iavx512(), uses AVX-512 C++ SIMD intrinsic functions to implement a 1D discrete convolution. This function is similar to the function Convolve1D_F32_Iavx2() that was presented in source example Ch06_01. The primary difference is that Convolve1D_F32_Iavx512() includes an extra code block near the top of the while-loop that processes signal elements y[i:i+15] using __m512 data types and the following C++ SIMD intrinsic functions: _mm512_loadu_ps(), _mm512_set1_ps(), _mm512_fmadd_ps(), and _mm512_storeu_ps(). The other code blocks in the while-loop process signal elements y[i:i+7], y[i:i+3], or y[i] using C++ SIMD intrinsic functions and data types just like function Convolve1D_F32_Iavx2() did in example Ch06_01.

Following Convolve1D_F32_Iavx512() in Listing 8-8 is the function Convolve1DKs5_F32_Iavx512(). This function implements a 1D discrete convolution using AVX-512 and is optimized for a five-element convolution kernel. Recall from the discussions in Chapter 6 that many real-world signal processing applications frequently employ size-optimized convolution functions since they are often faster than their variable-width counterparts. Note that the principal modification between the code in Convolve1DKs5_F32_Iavx512() and the Ch06_01 function Convolve1DKs5_F32_Iavx2() is that the former includes a code block near the top of the while-loop that processes signal elements y[i:i+15] using _m512 data types and AVX-512 C++ SIMD intrinsic functions.

2D Convolutions

The source code for file Ch08_09_fcpp.cpp that is shown in Listing 8-9 is somewhat lengthy but (hopefully) relatively straightforward to comprehend. It begins with the function Convolve1Dx2_F32_Cpp(), which implements a 2D discrete convolution using standard C++ statements. This function is identical to the one you studied in source code example Ch06_04 and is included again in this example for benchmarking purposes.

Also shown in Listing 8-9 is the SIMD calculating function Convolve1Dx2_F32_Iavx512(). This function, which is a modified version of function Convolve1Dx2_F32_Iavx2() (see Listing 6-4), performs a 2D discrete convolution using AVX-512 C++ SIMD intrinsic functions. In function Convolve1Dx2_F32_Iavx512(), note the inclusion of an extra if block in the x-axis section that processes image pixels using __m512 data types and the following C++ SIMD intrinsic functions: _mm512_loadu_ps(), _mm512_set1_ps(), _mm512_fmadd_ps(), and _mm512_storeu_ps(). A similar if block was also added to the y-axis section of Convolve1Dx2_F32_Iavx512().