Compile an example

Arm Performance Libraries include a number of example programs to compile and run. The examples are located in /opt/arm/<armpl_dir>/examples/, or <install_dir>/<armpl_dir>/examples/, if you have installed to a different location than the default.

Example

The fftw_dft_r2c_1d_c_example.c example does the following:

  • Creates an FFTW plan for a one-dimensional, real-to-Hermitian Fourier transform, and a plan for its inverse, Hermitian-to-real transform.
  • Executes the first plan to output the transformed values in y.
  • Destroys the first plan.
  • Prints the components of the transform.
  • Executes the second plan to get the original data, unscaled.
  • Destroys the second plan.
  • Outputs the original and restored values, scaled (they should be identical).

/*
 * fftw_dft_r2c_1d: FFT of a real sequence
 *
 * ARMPL version 19.3 Copyright ARM 2019
 */

#include <armpl.h>
#include <complex.h>
#include <fftw3.h>
#include <math.h>
#include <stdio.h>

int main(void) {
#define NMAX 20
	double xx[NMAX];
	double x[NMAX];
	// The output vector is of size (n/2)+1 as it is Hermitian
	fftw_complex y[NMAX / 2 + 1];

	printf(
	    "ARMPL example: FFT of a real sequence using fftw_plan_dft_r2c_1d\n");
	printf(
	    "----------------------------------------------------------------\n");
	printf("\n");

	/* The sequence of double data */
	int n = 7;
	x[0] = 0.34907;
	x[1] = 0.54890;
	x[2] = 0.74776;
	x[3] = 0.94459;
	x[4] = 1.13850;
	x[5] = 1.32850;
	x[6] = 1.51370;

	// Use dcopy to copy the values into another array (preserve input)
	cblas_dcopy(n, x, 1, xx, 1);

	// Initialise a plan for a real-to-complex 1d transform from x->y
	fftw_plan forward_plan = fftw_plan_dft_r2c_1d(n, x, y, FFTW_ESTIMATE);
	// Initialise a plan for a complex-to-real 1d transform from y->x (inverse)
	fftw_plan inverse_plan = fftw_plan_dft_c2r_1d(n, y, x, FFTW_ESTIMATE);

	// Execute the forward plan and then deallocate the plan
	/* NOTE: FFTW does NOT compute a normalised transform -
	 * returned array will contain unscaled values */
	fftw_execute(forward_plan);
	fftw_destroy_plan(forward_plan);

	printf("Components of discrete Fourier transform:\n");
	printf("\n");
	int j;
	for (j = 0; j <= n / 2; j++)
		// Scale factor of 1/sqrt(n) to output normalised data
		printf("%4d   (%7.4f%7.4f)\n", j + 1, creal(y[j]) / sqrt(n),
		       cimag(y[j]) / sqrt(n));

	// Execute the reverse plan and then deallocate the plan
	/* NOTE: FFTW does NOT compute a normalised transform -
	 * returned array will contain unscaled values */
	fftw_execute(inverse_plan);
	fftw_destroy_plan(inverse_plan);

	printf("\n");
	printf("Original sequence as restored by inverse transform:\n");
	printf("\n");
	printf("       Original  Restored\n");
	for (j = 0; j < n; j++)
		// Scale factor of 1/n to output normalised data
		printf("%4d   %7.4f   %7.4f\n", j + 1, xx[j], x[j] / n);
	return 0;
} 

Compile the example as follows:

  1. Compile the source fftw_dft_r2c_1d_c_example.c to generate an object file:

    Compiler Command
    armclang armclang -c -armpl -mcpu=native fftw_dft_r2c_1d_c_example.c -o fftw_dft_r2c_1d_c_example.o
    gcc gcc -c -I<install_dir>/include fftw_dft_r2c_1d_c_example.c -o fftw_dft_r2c_1d_c_example.o
  2. Link the object code into an executable:

    Compiler Command
    armclang armclang fftw_dft_r2c_1d_c_example.o -o fftw_dft_r2c_1d_c_example.exe -armpl -mcpu=native -lm
    gcc gcc fftw_dft_r2c_1d_c_example.o -L<install_dir>/lib -o fftw_dft_r2c_1d_c_example.exe -larmpl_lp64 -lgfortran -lm

    The linker and compiler options are:

    • -armpl is recommended when compiling and linking with the arm compiler.
    • -mcpu=native is recommended when using the Arm Compiler, to allow the compiler to infer from the host system which libraries to use.
    • -L<install_dir>/lib adds the Arm Performance Libraries location to the library search path.
    • -larmpl_lp64 links against the Arm Performance Libraries.
    • -lgfortran links against the gcc Fortran runtime libraries. This is required because the Arm Performance Libraries include Fortran code.
    • -lm links against the standard math libraries.
  3. Run the executable on your Arm system:

    ./fftw_dft_r2c_1d_c_example.exe

    The executable produces output as follows:

    ARMPL example: FFT of a real sequence using fftw_plan_dft_r2c_1d
    ----------------------------------------------------------------
    
    Components of discrete Fourier transform:
    
       1   ( 2.4836 0.0000)
       2   (-0.2660 0.5309)
       3   (-0.2577 0.2030)
       4   (-0.2564 0.0581)
    
    Original sequence as restored by inverse transform:
    
           Original  Restored
       1    0.3491    0.3491
       2    0.5489    0.5489
       3    0.7478    0.7478
       4    0.9446    0.9446
       5    1.1385    1.1385
       6    1.3285    1.3285
       7    1.5137    1.5137

Previous Next