Chris@10: @node Installation and Customization, Acknowledgments, Upgrading from FFTW version 2, Top
Chris@10: @chapter Installation and Customization
Chris@10: @cindex installation
Chris@10: 
Chris@10: This chapter describes the installation and customization of FFTW, the
Chris@10: latest version of which may be downloaded from
Chris@10: @uref{http://www.fftw.org, the FFTW home page}.
Chris@10: 
Chris@10: In principle, FFTW should work on any system with an ANSI C compiler
Chris@10: (@code{gcc} is fine).  However, planner time is drastically reduced if
Chris@10: FFTW can exploit a hardware cycle counter; FFTW comes with cycle-counter
Chris@10: support for all modern general-purpose CPUs, but you may need to add a
Chris@10: couple of lines of code if your compiler is not yet supported
Chris@10: (@pxref{Cycle Counters}).  (On Unix, there will be a warning at the end
Chris@10: of the @code{configure} output if no cycle counter is found.)
Chris@10: @cindex cycle counter
Chris@10: @cindex compiler
Chris@10: @cindex portability
Chris@10: 
Chris@10: 
Chris@10: Installation of FFTW is simplest if you have a Unix or a GNU system,
Chris@10: such as GNU/Linux, and we describe this case in the first section below,
Chris@10: including the use of special configuration options to e.g. install
Chris@10: different precisions or exploit optimizations for particular
Chris@10: architectures (e.g. SIMD).  Compilation on non-Unix systems is a more
Chris@10: manual process, but we outline the procedure in the second section.  It
Chris@10: is also likely that pre-compiled binaries will be available for popular
Chris@10: systems.
Chris@10: 
Chris@10: Finally, we describe how you can customize FFTW for particular needs by
Chris@10: generating @emph{codelets} for fast transforms of sizes not supported
Chris@10: efficiently by the standard FFTW distribution.
Chris@10: @cindex codelet
Chris@10: 
Chris@10: @menu
Chris@10: * Installation on Unix::        
Chris@10: * Installation on non-Unix systems::  
Chris@10: * Cycle Counters::              
Chris@10: * Generating your own code::    
Chris@10: @end menu
Chris@10: 
Chris@10: @c ------------------------------------------------------------
Chris@10: 
Chris@10: @node Installation on Unix, Installation on non-Unix systems, Installation and Customization, Installation and Customization
Chris@10: @section Installation on Unix
Chris@10: 
Chris@10: FFTW comes with a @code{configure} program in the GNU style.
Chris@10: Installation can be as simple as:
Chris@10: @fpindex configure
Chris@10: 
Chris@10: @example
Chris@10: ./configure
Chris@10: make
Chris@10: make install
Chris@10: @end example
Chris@10: 
Chris@10: This will build the uniprocessor complex and real transform libraries
Chris@10: along with the test programs.  (We recommend that you use GNU
Chris@10: @code{make} if it is available; on some systems it is called
Chris@10: @code{gmake}.)  The ``@code{make install}'' command installs the fftw
Chris@10: and rfftw libraries in standard places, and typically requires root
Chris@10: privileges (unless you specify a different install directory with the
Chris@10: @code{--prefix} flag to @code{configure}).  You can also type
Chris@10: ``@code{make check}'' to put the FFTW test programs through their paces.
Chris@10: If you have problems during configuration or compilation, you may want
Chris@10: to run ``@code{make distclean}'' before trying again; this ensures that
Chris@10: you don't have any stale files left over from previous compilation
Chris@10: attempts.
Chris@10: 
Chris@10: The @code{configure} script chooses the @code{gcc} compiler by default,
Chris@10: if it is available; you can select some other compiler with:
Chris@10: @example
Chris@10: ./configure CC="@r{@i{<the name of your C compiler>}}"
Chris@10: @end example
Chris@10: 
Chris@10: The @code{configure} script knows good @code{CFLAGS} (C compiler flags)
Chris@10: @cindex compiler flags
Chris@10: for a few systems.  If your system is not known, the @code{configure}
Chris@10: script will print out a warning.  In this case, you should re-configure
Chris@10: FFTW with the command
Chris@10: @example
Chris@10: ./configure CFLAGS="@r{@i{<write your CFLAGS here>}}"
Chris@10: @end example
Chris@10: and then compile as usual.  If you do find an optimal set of
Chris@10: @code{CFLAGS} for your system, please let us know what they are (along
Chris@10: with the output of @code{config.guess}) so that we can include them in
Chris@10: future releases.
Chris@10: 
Chris@10: @code{configure} supports all the standard flags defined by the GNU
Chris@10: Coding Standards; see the @code{INSTALL} file in FFTW or
Chris@10: @uref{http://www.gnu.org/prep/standards/html_node/index.html, the GNU web page}.
Chris@10: Note especially @code{--help} to list all flags and
Chris@10: @code{--enable-shared} to create shared, rather than static, libraries.
Chris@10: @code{configure} also accepts a few FFTW-specific flags, particularly:
Chris@10: 
Chris@10: @itemize @bullet
Chris@10: 
Chris@10: @item
Chris@10: @cindex precision
Chris@10: @code{--enable-float}: Produces a single-precision version of FFTW
Chris@10: (@code{float}) instead of the default double-precision (@code{double}).
Chris@10: @xref{Precision}.
Chris@10: 
Chris@10: @item
Chris@10: @cindex precision
Chris@10: @code{--enable-long-double}: Produces a long-double precision version of
Chris@10: FFTW (@code{long double}) instead of the default double-precision
Chris@10: (@code{double}).  The @code{configure} script will halt with an error
Chris@10: message if @code{long double} is the same size as @code{double} on your
Chris@10: machine/compiler.  @xref{Precision}.
Chris@10: 
Chris@10: @item
Chris@10: @cindex precision
Chris@10: @code{--enable-quad-precision}: Produces a quadruple-precision version
Chris@10: of FFTW using the nonstandard @code{__float128} type provided by
Chris@10: @code{gcc} 4.6 or later on x86, x86-64, and Itanium architectures,
Chris@10: instead of the default double-precision (@code{double}).  The
Chris@10: @code{configure} script will halt with an error message if the
Chris@10: compiler is not @code{gcc} version 4.6 or later or if @code{gcc}'s
Chris@10: @code{libquadmath} library is not installed.  @xref{Precision}.
Chris@10: 
Chris@10: @item
Chris@10: @cindex threads
Chris@10: @code{--enable-threads}: Enables compilation and installation of the
Chris@10: FFTW threads library (@pxref{Multi-threaded FFTW}), which provides a
Chris@10: simple interface to parallel transforms for SMP systems.  By default,
Chris@10: the threads routines are not compiled.
Chris@10: 
Chris@10: @item
Chris@10: @code{--enable-openmp}: Like @code{--enable-threads}, but using OpenMP
Chris@10: compiler directives in order to induce parallelism rather than
Chris@10: spawning its own threads directly, and installing an @samp{fftw3_omp} library
Chris@10: rather than an @samp{fftw3_threads} library (@pxref{Multi-threaded           
Chris@10: FFTW}).  You can use both @code{--enable-openmp} and @code{--enable-threads}
Chris@10: since they compile/install libraries with different names.  By default,
Chris@10: the OpenMP routines are not compiled.
Chris@10: 
Chris@10: @item
Chris@10: @code{--with-combined-threads}: By default, if @code{--enable-threads}
Chris@10: is used, the threads support is compiled into a separate library that
Chris@10: must be linked in addition to the main FFTW library.  This is so that
Chris@10: users of the serial library do not need to link the system threads
Chris@10: libraries.  If @code{--with-combined-threads} is specified, however,
Chris@10: then no separate threads library is created, and threads are included
Chris@10: in the main FFTW library.  This is mainly useful under Windows, where
Chris@10: no system threads library is required and inter-library dependencies
Chris@10: are problematic.
Chris@10: 
Chris@10: @item
Chris@10: @cindex MPI
Chris@10: @code{--enable-mpi}: Enables compilation and installation of the FFTW
Chris@10: MPI library (@pxref{Distributed-memory FFTW with MPI}), which provides
Chris@10: parallel transforms for distributed-memory systems with MPI.  (By
Chris@10: default, the MPI routines are not compiled.)  @xref{FFTW MPI
Chris@10: Installation}.
Chris@10: 
Chris@10: @item
Chris@10: @cindex Fortran-callable wrappers
Chris@10: @code{--disable-fortran}: Disables inclusion of legacy-Fortran
Chris@10: wrapper routines (@pxref{Calling FFTW from Legacy Fortran}) in the standard
Chris@10: FFTW libraries.  These wrapper routines increase the library size by
Chris@10: only a negligible amount, so they are included by default as long as
Chris@10: the @code{configure} script finds a Fortran compiler on your system.
Chris@10: (To specify a particular Fortran compiler @i{foo}, pass
Chris@10: @code{F77=}@i{foo} to @code{configure}.)
Chris@10: 
Chris@10: @item
Chris@10: @code{--with-g77-wrappers}: By default, when Fortran wrappers are
Chris@10: included, the wrappers employ the linking conventions of the Fortran
Chris@10: compiler detected by the @code{configure} script.  If this compiler is
Chris@10: GNU @code{g77}, however, then @emph{two} versions of the wrappers are
Chris@10: included: one with @code{g77}'s idiosyncratic convention of appending
Chris@10: two underscores to identifiers, and one with the more common
Chris@10: convention of appending only a single underscore.  This way, the same
Chris@10: FFTW library will work with both @code{g77} and other Fortran
Chris@10: compilers, such as GNU @code{gfortran}.  However, the converse is not
Chris@10: true: if you configure with a different compiler, then the
Chris@10: @code{g77}-compatible wrappers are not included.  By specifying
Chris@10: @code{--with-g77-wrappers}, the @code{g77}-compatible wrappers are
Chris@10: included in addition to wrappers for whatever Fortran compiler
Chris@10: @code{configure} finds.
Chris@10: @fpindex g77
Chris@10: 
Chris@10: @item
Chris@10: @code{--with-slow-timer}: Disables the use of hardware cycle counters,
Chris@10: and falls back on @code{gettimeofday} or @code{clock}.  This greatly
Chris@10: worsens performance, and should generally not be used (unless you don't
Chris@10: have a cycle counter but still really want an optimized plan regardless
Chris@10: of the time).  @xref{Cycle Counters}.
Chris@10: 
Chris@10: @item
Chris@10: @code{--enable-sse}, @code{--enable-sse2}, @code{--enable-avx},
Chris@10: @code{--enable-altivec}, @code{--enable-neon}: Enable the compilation of
Chris@10: SIMD code for SSE (Pentium III+), SSE2 (Pentium IV+), AVX (Sandy Bridge,
Chris@10: Interlagos), AltiVec (PowerPC G4+), NEON (some ARM processors).  SSE,
Chris@10: AltiVec, and NEON only work with @code{--enable-float} (above).  SSE2
Chris@10: works in both single and double precision (and is simply SSE in single
Chris@10: precision).  The resulting code will @emph{still work} on earlier CPUs
Chris@10: lacking the SIMD extensions (SIMD is automatically disabled, although
Chris@10: the FFTW library is still larger).
Chris@10: @itemize @minus
Chris@10: @item
Chris@10: These options require a compiler supporting SIMD extensions, and
Chris@10: compiler support is always a bit flaky: see the FFTW FAQ for a list of
Chris@10: compiler versions that have problems compiling FFTW.
Chris@10: @item
Chris@10: With AltiVec and @code{gcc}, you may have to use the
Chris@10: @code{-mabi=altivec} option when compiling any code that links to FFTW,
Chris@10: in order to properly align the stack; otherwise, FFTW could crash when
Chris@10: it tries to use an AltiVec feature.  (This is not necessary on MacOS X.)
Chris@10: @item
Chris@10: With SSE/SSE2 and @code{gcc}, you should use a version of gcc that
Chris@10: properly aligns the stack when compiling any code that links to FFTW.
Chris@10: By default, @code{gcc} 2.95 and later versions align the stack as
Chris@10: needed, but you should not compile FFTW with the @code{-Os} option or the
Chris@10: @code{-mpreferred-stack-boundary} option with an argument less than 4.
Chris@10: @item
Chris@10: Because of the large variety of ARM processors and ABIs, FFTW
Chris@10: does not attempt to guess the correct @code{gcc} flags for generating
Chris@10: NEON code.  In general, you will have to provide them on the command line.
Chris@10: This command line is known to have worked at least once:
Chris@10: @example
Chris@10: ./configure --with-slow-timer --host=arm-linux-gnueabi \
Chris@10:   --enable-single --enable-neon \
Chris@10:   "CC=arm-linux-gnueabi-gcc -march=armv7-a -mfloat-abi=softfp"
Chris@10: @end example
Chris@10: @end itemize
Chris@10: 
Chris@10: @end itemize
Chris@10: 
Chris@10: @cindex compiler
Chris@10: To force @code{configure} to use a particular C compiler @i{foo}
Chris@10: (instead of the default, usually @code{gcc}), pass @code{CC=}@i{foo} to the 
Chris@10: @code{configure} script; you may also need to set the flags via the variable
Chris@10: @code{CFLAGS} as described above.
Chris@10: @cindex compiler flags
Chris@10: 
Chris@10: @c ------------------------------------------------------------
Chris@10: @node Installation on non-Unix systems, Cycle Counters, Installation on Unix, Installation and Customization
Chris@10: @section Installation on non-Unix systems
Chris@10: 
Chris@10: It should be relatively straightforward to compile FFTW even on non-Unix
Chris@10: systems lacking the niceties of a @code{configure} script.  Basically,
Chris@10: you need to edit the @code{config.h} header (copy it from
Chris@10: @code{config.h.in}) to @code{#define} the various options and compiler
Chris@10: characteristics, and then compile all the @samp{.c} files in the
Chris@10: relevant directories.  
Chris@10: 
Chris@10: The @code{config.h} header contains about 100 options to set, each one
Chris@10: initially an @code{#undef}, each documented with a comment, and most of
Chris@10: them fairly obvious.  For most of the options, you should simply
Chris@10: @code{#define} them to @code{1} if they are applicable, although a few
Chris@10: options require a particular value (e.g. @code{SIZEOF_LONG_LONG} should
Chris@10: be defined to the size of the @code{long long} type, in bytes, or zero
Chris@10: if it is not supported).  We will likely post some sample
Chris@10: @code{config.h} files for various operating systems and compilers for
Chris@10: you to use (at least as a starting point).  Please let us know if you
Chris@10: have to hand-create a configuration file (and/or a pre-compiled binary)
Chris@10: that you want to share.
Chris@10: 
Chris@10: To create the FFTW library, you will then need to compile all of the
Chris@10: @samp{.c} files in the @code{kernel}, @code{dft}, @code{dft/scalar},
Chris@10: @code{dft/scalar/codelets}, @code{rdft}, @code{rdft/scalar},
Chris@10: @code{rdft/scalar/r2cf}, @code{rdft/scalar/r2cb},
Chris@10: @code{rdft/scalar/r2r}, @code{reodft}, and @code{api} directories.
Chris@10: If you are compiling with SIMD support (e.g. you defined
Chris@10: @code{HAVE_SSE2} in @code{config.h}), then you also need to compile
Chris@10: the @code{.c} files in the @code{simd-support},
Chris@10: @code{@{dft,rdft@}/simd}, @code{@{dft,rdft@}/simd/*} directories.
Chris@10: 
Chris@10: Once these files are all compiled, link them into a library, or a shared
Chris@10: library, or directly into your program.
Chris@10: 
Chris@10: To compile the FFTW test program, additionally compile the code in the
Chris@10: @code{libbench2/} directory, and link it into a library.  Then compile
Chris@10: the code in the @code{tests/} directory and link it to the
Chris@10: @code{libbench2} and FFTW libraries.  To compile the @code{fftw-wisdom}
Chris@10: (command-line) tool (@pxref{Wisdom Utilities}), compile
Chris@10: @code{tools/fftw-wisdom.c} and link it to the @code{libbench2} and FFTW
Chris@10: libraries
Chris@10: 
Chris@10: @c ------------------------------------------------------------
Chris@10: @node Cycle Counters, Generating your own code, Installation on non-Unix systems, Installation and Customization
Chris@10: @section Cycle Counters
Chris@10: @cindex cycle counter
Chris@10: 
Chris@10: FFTW's planner actually executes and times different possible FFT
Chris@10: algorithms in order to pick the fastest plan for a given @math{n}.  In
Chris@10: order to do this in as short a time as possible, however, the timer must
Chris@10: have a very high resolution, and to accomplish this we employ the
Chris@10: hardware @dfn{cycle counters} that are available on most CPUs.
Chris@10: Currently, FFTW supports the cycle counters on x86, PowerPC/POWER, Alpha,
Chris@10: UltraSPARC (SPARC v9), IA64, PA-RISC, and MIPS processors.
Chris@10: 
Chris@10: @cindex compiler
Chris@10: Access to the cycle counters, unfortunately, is a compiler and/or
Chris@10: operating-system dependent task, often requiring inline assembly
Chris@10: language, and it may be that your compiler is not supported.  If you are
Chris@10: @emph{not} supported, FFTW will by default fall back on its estimator
Chris@10: (effectively using @code{FFTW_ESTIMATE} for all plans).
Chris@10: @ctindex FFTW_ESTIMATE
Chris@10: 
Chris@10: You can add support by editing the file @code{kernel/cycle.h}; normally,
Chris@10: this will involve adapting one of the examples already present in order
Chris@10: to use the inline-assembler syntax for your C compiler, and will only
Chris@10: require a couple of lines of code.  Anyone adding support for a new
Chris@10: system to @code{cycle.h} is encouraged to email us at @email{fftw@@fftw.org}.
Chris@10: 
Chris@10: If a cycle counter is not available on your system (e.g. some embedded
Chris@10: processor), and you don't want to use estimated plans, as a last resort
Chris@10: you can use the @code{--with-slow-timer} option to @code{configure} (on
Chris@10: Unix) or @code{#define WITH_SLOW_TIMER} in @code{config.h} (elsewhere).
Chris@10: This will use the much lower-resolution @code{gettimeofday} function, or even
Chris@10: @code{clock} if the former is unavailable, and planning will be
Chris@10: extremely slow.
Chris@10: 
Chris@10: @c ------------------------------------------------------------
Chris@10: @node Generating your own code,  , Cycle Counters, Installation and Customization
Chris@10: @section Generating your own code
Chris@10: @cindex code generator
Chris@10: 
Chris@10: The directory @code{genfft} contains the programs that were used to
Chris@10: generate FFTW's ``codelets,'' which are hard-coded transforms of small
Chris@10: sizes.
Chris@10: @cindex codelet
Chris@10: We do not expect casual users to employ the generator, which is a rather
Chris@10: sophisticated program that generates directed acyclic graphs of FFT
Chris@10: algorithms and performs algebraic simplifications on them.  It was
Chris@10: written in Objective Caml, a dialect of ML, which is available at
Chris@10: @uref{http://caml.inria.fr/ocaml/index.en.html}.
Chris@10: @cindex Caml
Chris@10: 
Chris@10: 
Chris@10: If you have Objective Caml installed (along with recent versions of
Chris@10: GNU @code{autoconf}, @code{automake}, and @code{libtool}), then you
Chris@10: can change the set of codelets that are generated or play with the
Chris@10: generation options.  The set of generated codelets is specified by the
Chris@10: @code{@{dft,rdft@}/@{codelets,simd@}/*/Makefile.am} files.  For example, you can add
Chris@10: efficient REDFT codelets of small sizes by modifying
Chris@10: @code{rdft/codelets/r2r/Makefile.am}.
Chris@10: @cindex REDFT
Chris@10: After you modify any @code{Makefile.am} files, you can type @code{sh
Chris@10: bootstrap.sh} in the top-level directory followed by @code{make} to
Chris@10: re-generate the files.
Chris@10: 
Chris@10: We do not provide more details about the code-generation process, since
Chris@10: we do not expect that most users will need to generate their own code.
Chris@10: However, feel free to contact us at @email{fftw@@fftw.org} if
Chris@10: you are interested in the subject.
Chris@10: 
Chris@10: @cindex monadic programming
Chris@10: You might find it interesting to learn Caml and/or some modern
Chris@10: programming techniques that we used in the generator (including monadic
Chris@10: programming), especially if you heard the rumor that Java and
Chris@10: object-oriented programming are the latest advancement in the field.
Chris@10: The internal operation of the codelet generator is described in the
Chris@10: paper, ``A Fast Fourier Transform Compiler,'' by M. Frigo, which is
Chris@10: available from the @uref{http://www.fftw.org,FFTW home page} and also
Chris@10: appeared in the @cite{Proceedings of the 1999 ACM SIGPLAN Conference on
Chris@10: Programming Language Design and Implementation (PLDI)}.
Chris@10: