9.1 Installation on Unix

FFTW comes with a configure program in the GNU style. Installation can be as simple as:

./configure
make
make install

This will build the uniprocessor complex and real transform libraries along with the test programs. (We recommend that you use GNU make if it is available; on some systems it is called gmake.) The “make install” command installs the fftw and rfftw libraries in standard places, and typically requires root privileges (unless you specify a different install directory with the --prefix flag to configure). You can also type “make check” to put the FFTW test programs through their paces. If you have problems during configuration or compilation, you may want to run “make distclean” before trying again; this ensures that you don't have any stale files left over from previous compilation attempts.

The configure script chooses the gcc compiler by default, if it is available; you can select some other compiler with:

./configure CC="<the name of your C compiler>"

The configure script knows good CFLAGS (C compiler flags) for a few systems. If your system is not known, the configure script will print out a warning. In this case, you should re-configure FFTW with the command

./configure CFLAGS="<write your CFLAGS here>"

and then compile as usual. If you do find an optimal set of CFLAGS for your system, please let us know what they are (along with the output of config.guess) so that we can include them in future releases.

configure supports all the standard flags defined by the GNU Coding Standards; see the INSTALL file in FFTW or the GNU web page. Note especially --help to list all flags and --enable-shared to create shared, rather than static, libraries. configure also accepts a few FFTW-specific flags, particularly:

• --enable-portable-binary: Disable compiler optimizations that would produce unportable binaries. Important: Use this if you are distributing compiled binaries to people who may not use exactly the same processor as you.
• --with-gcc-arch=arch: When compiling with gcc, FFTW tries to deduce the current CPU in order to tell gcc what architecture to tune for; this option overrides that guess (i.e. arch should be a valid argument for gcc's -march or -mtune flags). You might do this because the deduced architecture was wrong or because you want to tune for a different CPU than the one you are compiling with. You can use --without-gcc-arch to disable architecture-specific tuning entirely. Note that if --enable-portable-binary is enabled (above), then we use -mtune but not -march, so the resulting binary will run on any architecture even though it is optimized for a particular one.
• --enable-float: Produces a single-precision version of FFTW (float) instead of the default double-precision (double). See section Precision.
• --enable-long-double: Produces a long-double precision version of FFTW (long double) instead of the default double-precision (double). The configure script will halt with an error message is long double is the same size as double on your machine/compiler. See section Precision.
• --enable-threads: Enables compilation and installation of the FFTW threads library (see section Multi-threaded FFTW), which provides a simple interface to parallel transforms for SMP systems. By default, the threads routines are not compiled.
• --enable-openmp: Like --enable-threads, but using OpenMP compiler directives in order to induce parallelism rather than spawning its own threads directly. Useful especially for programs already employing such directives, in order to minimize conflicts between different parallelization mechanisms. Use either --enable-openmp or --enable-threads, not both; in either case the multi-threaded FFTW interface/library (see section Multi-threaded FFTW) is compiled (with different back ends).
• --with-combined-threads: By default, if --enable-threads or --enable-openmp are used, the threads support is compiled into a separate library that must be linked in addition to the main FFTW library. This is so that users of the serial library do not need to link the system threads libraries. If --with-combined-threads is specified, however, then no separate threads library is created, and threads are included in the main FFTW library. This is mainly useful under Windows, where no system threads library is required and inter-library dependencies are problematic.
• --enable-cell: Enables code to exploit the Cell processor (see section FFTW on the Cell Processor), assuming you have the Cell SDK. By default, code for the Cell processor is not compiled.
• --disable-fortran: Disables inclusion of Fortran-callable wrapper routines (see section Calling FFTW from Fortran) in the standard FFTW libraries. These wrapper routines increase the library size by only a negligible amount, so they are included by default as long as the configure script finds a Fortran compiler on your system. (To specify a particular Fortran compiler foo, pass F77=foo to configure.)
• --with-g77-wrappers: By default, when Fortran wrappers are included, the wrappers employ the linking conventions of the Fortran compiler detected by the configure script. If this compiler is GNU g77, however, then two versions of the wrappers are included: one with g77's idiosyncratic convention of appending two underscores to identifiers, and one with the more common convention of appending only a single underscore. This way, the same FFTW library will work with both g77 and other Fortran compilers, such as GNU gfortran. However, the converse is not true: if you configure with a different compiler, then the g77-compatible wrappers are not included. By specifying --with-g77-wrappers, the g77-compatible wrappers are included in addition to wrappers for whatever Fortran compiler configure finds.
• --with-slow-timer: Disables the use of hardware cycle counters, and falls back on gettimeofday or clock. This greatly worsens performance, and should generally not be used (unless you don't have a cycle counter but still really want an optimized plan regardless of the time). See section Cycle Counters.
• --enable-sse, --enable-sse2, --enable-altivec, --enable-mips-ps: Enable the compilation of SIMD code for SSE (Pentium III+), SSE2 (Pentium IV+), AltiVec (PowerPC G4+), or MIPS PS. SSE, AltiVec, and MIPS PS only work with --enable-float (above), while SSE2 only works in double precision (the default). The resulting code will still work on earlier CPUs lacking the SIMD extensions (SIMD is automatically disabled, although the FFTW library is still larger).
  • - These options require a compiler supporting SIMD extensions, and compiler support is still a bit flaky: see the FFTW FAQ for a list of compiler versions that have problems compiling FFTW.
  • - With the Linux kernel, you may have to recompile the kernel with the option to support SSE/SSE2/AltiVec (see the “Processor type and features” settings).
  • - With AltiVec and gcc, you may have to use the -mabi=altivec option when compiling any code that links to FFTW, in order to properly align the stack; otherwise, FFTW could crash when it tries to use an AltiVec feature. (This is not necessary on MacOS X.)
  • - With SSE/SSE2 and gcc, you should use a version of gcc that properly aligns the stack when compiling any code that links to FFTW. By default, gcc 2.95 and later versions align the stack as needed, but you should not compile FFTW with the -Os option or the -mpreferred-stack-boundary option with an argument less than 4.

To force configure to use a particular C compiler foo (instead of the default, usually gcc), pass CC=foo to the configure script; you may also need to set the flags via the variable CFLAGS as described above.