FindFFTW.cmake 16.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
###
#
# @copyright (c) 2009-2014 The University of Tennessee and The University
#                          of Tennessee Research Foundation.
#                          All rights reserved.
# @copyright (c) 2012-2014 Inria. All rights reserved.
# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
#
###
#
# - Find FFTW Version 3 include dirs and libraries
# Use this module by invoking find_package with the form:
#  find_package(FFTW
#               [REQUIRED] # Fail with error if fftw is not found
#               [COMPONENTS MKL]
#
#  COMPONENTS can be some of the following:
#   - MKL:     to detect the FFTW from Intel MKL
#   - THREADS: to detect the Threads version of FFTW
#   - OMP:     to detect the OpenMP version of FFTW
#   - SIMPLE:  to detect the FFTW simple precision fftw3f
#   - DOUBLE:  to detect the FFTW double precision fftw3 (default)
#   - LONG:    to detect the FFTW long double precision fftw3l
#   - QUAD:    to detect the FFTW quadruple precision fftw3q
#
# This module finds headers and fftw library.
# Results are reported in variables:
#  FFTW_FOUND            - True if headers and requested libraries were found
29 30
#  FFTW_C_FLAGS          - list of required compilation flags (excluding -I)
#  FFTW_LINKER_FLAGS     - list of required linker flags (excluding -l and -L)
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
#  FFTW_INCLUDE_DIRS     - fftw include directories
#  FFTW_LIBRARY_DIRS     - Link directories for fftw libraries
#  FFTW_LIBRARIES        - fftw component libraries to be linked
#  FFTW_INCLUDE_DIRS_DEP - fftw + dependencies include directories
#  FFTW_LIBRARY_DIRS_DEP - fftw + dependencies link directories
#  FFTW_LIBRARIES_DEP    - fftw libraries + dependencies
#
# The user can give specific paths where to find the libraries adding cmake
# options at configure (ex: cmake path/to/project -DFFTW_DIR=path/to/fftw):
#  FFTW_DIR             - Where to find the base directory of fftw
#  FFTW_INCDIR          - Where to find the header files
#  FFTW_LIBDIR          - Where to find the library files

#=============================================================================
# Copyright 2012-2013 Inria
# Copyright 2012-2013 Emmanuel Agullo
# Copyright 2012-2013 Mathieu Faverge
# Copyright 2012      Cedric Castagnede
# Copyright 2013      Florent Pruvost
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file MORSE-Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of Morse, substitute the full
#  License text for the above reference.)


if (NOT FFTW_FOUND)
63
    set(FFTW_DIR "" CACHE PATH "Installation directory of FFTW library")
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
    if (NOT FFTW_FIND_QUIETLY)
        message(STATUS "A cache variable, namely FFTW_DIR, has been set to specify the install directory of FFTW")
    endif()
endif()

# Set the version to find
set(FFTW_LOOK_FOR_MKL OFF)
set(FFTW_LOOK_FOR_THREADS OFF)
set(FFTW_LOOK_FOR_OMP OFF)
set(FFTW_LOOK_FOR_FFTW_SIMPLE OFF)
set(FFTW_LOOK_FOR_FFTW_DOUBLE ON)
set(FFTW_LOOK_FOR_FFTW_LONG OFF)
set(FFTW_LOOK_FOR_FFTW_QUAD OFF)

if( FFTW_FIND_COMPONENTS )
    foreach( component ${FFTW_FIND_COMPONENTS} )
        if (${component} STREQUAL "THREADS")
            # means we look for the Threads version of FFTW
            set(FFTW_LOOK_FOR_THREADS ON)
        endif()
        if (${component} STREQUAL "OMP")
            # means we look for the OpenMP version of FFTW
            set(FFTW_LOOK_FOR_OMP ON)
        endif()
        if (${component} STREQUAL "SIMPLE")
            # means we look for FFTW simple precision (fftw3f)
            set(FFTW_LOOK_FOR_FFTW_SIMPLE ON)
            set(FFTW_LOOK_FOR_FFTW_DOUBLE OFF)
            set(FFTW_LOOK_FOR_FFTW_LONG OFF)
            set(FFTW_LOOK_FOR_FFTW_QUAD OFF)
        endif()
        if (${component} STREQUAL "DOUBLE")
            # means we look for FFTW double precision (fftw3)
            set(FFTW_LOOK_FOR_FFTW_SIMPLE OFF)
            set(FFTW_LOOK_FOR_FFTW_DOUBLE ON)
            set(FFTW_LOOK_FOR_FFTW_LONG OFF)
            set(FFTW_LOOK_FOR_FFTW_QUAD OFF)
        endif()
        if (${component} STREQUAL "LONG")
            # means we look for FFTW long double precision (fftw3l)
            set(FFTW_LOOK_FOR_FFTW_SIMPLE OFF)
            set(FFTW_LOOK_FOR_FFTW_DOUBLE OFF)
            set(FFTW_LOOK_FOR_FFTW_LONG ON)
            set(FFTW_LOOK_FOR_FFTW_QUAD OFF)
        endif()
        if (${component} STREQUAL "QUAD")
            # means we look for FFTW quad precision (fftw3q)
            set(FFTW_LOOK_FOR_FFTW_SIMPLE OFF)
            set(FFTW_LOOK_FOR_FFTW_DOUBLE OFF)
            set(FFTW_LOOK_FOR_FFTW_LONG OFF)
            set(FFTW_LOOK_FOR_FFTW_QUAD ON)
        endif()
        if (${component} STREQUAL "MKL")
            # means we look for the Intel MKL version of FFTW
            set(FFTW_LOOK_FOR_MKL ON)
            if (FFTW_LOOK_FOR_FFTW_LONG)
                message(WARNING "Looking for FFTW -- long precision functions do not exist in MKL FFTW")
                set(FFTW_LOOK_FOR_FFTW_LONG OFF)
            endif()
            if (FFTW_LOOK_FOR_FFTW_QUAD)
                message(WARNING "Looking for FFTW -- quadruple functions do not exist in MKL FFTW")
                set(FFTW_LOOK_FOR_FFTW_QUAD OFF)
            endif()
        endif()
    endforeach()
endif()

if (FFTW_LOOK_FOR_THREADS)
132
    if (FFTW_FIND_REQUIRED AND FFTW_FIND_REQUIRED_THREADS)
133 134 135 136 137 138 139
        find_package(Threads REQUIRED)
    else()
        find_package(Threads)
    endif()
endif()

if (FFTW_LOOK_FOR_OMP)
140
    if (FFTW_FIND_REQUIRED AND FFTW_FIND_REQUIRED_OMP)
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
        find_package(OpenMP REQUIRED)
    else()
        find_package(OpenMP)
    endif()
endif()

if( NOT FFTW_FOUND )

    # Looking for include
    # -------------------

    # Add system include paths to search include
    # ------------------------------------------
    unset(_inc_env)
    if(WIN32)
        string(REPLACE ":" ";" _inc_env "$ENV{INCLUDE}")
    else()
        string(REPLACE ":" ";" _path_env "$ENV{INCLUDE}")
        list(APPEND _inc_env "${_path_env}")
        string(REPLACE ":" ";" _path_env "$ENV{C_INCLUDE_PATH}")
        list(APPEND _inc_env "${_path_env}")
        string(REPLACE ":" ";" _path_env "$ENV{CPATH}")
        list(APPEND _inc_env "${_path_env}")
        string(REPLACE ":" ";" _path_env "$ENV{INCLUDE_PATH}")
        list(APPEND _inc_env "${_path_env}")
    endif()
    list(APPEND _inc_env "${CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES}")
    list(APPEND _inc_env "${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}")
    list(REMOVE_DUPLICATES _inc_env)

    # set paths where to look for
    set(PATH_TO_LOOK_FOR "${_inc_env}")

    # Try to find the fftw header in the given paths
    # -------------------------------------------------
    # call cmake macro to find the header path
    if(FFTW_INCDIR)
        set(FFTW_fftw3.h_DIRS "FFTW_fftw3.h_DIRS-NOTFOUND")
        find_path(FFTW_fftw3.h_DIRS
          NAMES fftw3.h
          HINTS ${FFTW_INCDIR})
    else()
        if(FFTW_DIR)
            set(FFTW_fftw3.h_DIRS "FFTW_fftw3.h_DIRS-NOTFOUND")
            find_path(FFTW_fftw3.h_DIRS
              NAMES fftw3.h
              HINTS ${FFTW_DIR}
              PATH_SUFFIXES include)
        else()
            set(FFTW_fftw3.h_DIRS "FFTW_fftw3.h_DIRS-NOTFOUND")
            find_path(FFTW_fftw3.h_DIRS
                      NAMES fftw3.h
                      HINTS ${PATH_TO_LOOK_FOR})
        endif()
    endif()
    mark_as_advanced(FFTW_fftw3.h_DIRS)

    # Add path to cmake variable
    # ------------------------------------
    if (FFTW_fftw3.h_DIRS)
        set(FFTW_INCLUDE_DIRS "${FFTW_fftw3.h_DIRS}")
    else ()
        set(FFTW_INCLUDE_DIRS "FFTW_INCLUDE_DIRS-NOTFOUND")
        if(NOT FFTW_FIND_QUIETLY)
            message(STATUS "Looking for FFTW -- fftw3.h not found")
        endif()
    endif ()


    # Looking for lib
    # ---------------

    # Add system library paths to search lib
    # --------------------------------------
    unset(_lib_env)
    if(WIN32)
        string(REPLACE ":" ";" _lib_env "$ENV{LIB}")
    else()
        if(APPLE)
            string(REPLACE ":" ";" _lib_env "$ENV{DYLD_LIBRARY_PATH}")
        else()
            string(REPLACE ":" ";" _lib_env "$ENV{LD_LIBRARY_PATH}")
        endif()
        list(APPEND _lib_env "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}")
        list(APPEND _lib_env "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
    endif()
    list(REMOVE_DUPLICATES _lib_env)

    # set paths where to look for
    set(PATH_TO_LOOK_FOR "${_lib_env}")

    if(FFTW_LOOK_FOR_FFTW_SIMPLE)
        set(FFTW_PREC "f")
        set(FFTW_PREC_TESTFUNC "s")
    elseif(FFTW_LOOK_FOR_FFTW_DOUBLE)
        set(FFTW_PREC "")
        set(FFTW_PREC_TESTFUNC "d")
    elseif(FFTW_LOOK_FOR_FFTW_LONG)
        set(FFTW_PREC "l")
        set(FFTW_PREC_TESTFUNC "l")
    elseif(FFTW_LOOK_FOR_FFTW_QUAD)
        set(FFTW_PREC "q")
        set(FFTW_PREC_TESTFUNC "q")
    endif()

    if (FFTW_LOOK_FOR_MKL)

        set(FFTW_libs_to_find "mkl_intel_lp64;mkl_sequential;mkl_core")

        # Try to find the MKL fftw lib in the given paths
        # -----------------------------------------------

        # call cmake macro to find the lib path
        if(FFTW_LIBDIR)
            foreach(fftw_lib ${FFTW_libs_to_find})
                set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                find_library(FFTW_${fftw_lib}_LIBRARY
                    NAMES ${fftw_lib}
                    HINTS ${FFTW_LIBDIR})
            endforeach()
        else()
            if(FFTW_DIR)
                foreach(fftw_lib ${FFTW_libs_to_find})
                    set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                    find_library(FFTW_${fftw_lib}_LIBRARY
                        NAMES ${fftw_lib}
                        HINTS ${FFTW_DIR}
                        PATH_SUFFIXES lib lib32 lib64)
                endforeach()
            else()
                foreach(fftw_lib ${FFTW_libs_to_find})
                    set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                    find_library(FFTW_${fftw_lib}_LIBRARY
                             NAMES ${fftw_lib}
                             HINTS ${PATH_TO_LOOK_FOR})
                endforeach()
            endif()
        endif()

    else(FFTW_LOOK_FOR_MKL)

        if (FFTW_LOOK_FOR_THREADS)
            set(FFTW_libs_to_find "fftw3${FFTW_PREC}_threads;fftw3${FFTW_PREC}")
        elseif (FFTW_LOOK_FOR_OMP)
            set(FFTW_libs_to_find "fftw3${FFTW_PREC}_omp;fftw3${FFTW_PREC}")
        else()
            set(FFTW_libs_to_find "fftw3${FFTW_PREC}")
        endif()

        # Try to find the fftw lib in the given paths
        # ----------------------------------------------

        # call cmake macro to find the lib path
        if(FFTW_LIBDIR)
            foreach(fftw_lib ${FFTW_libs_to_find})
                set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                find_library(FFTW_${fftw_lib}_LIBRARY
                    NAMES ${fftw_lib}
                    HINTS ${FFTW_LIBDIR})
            endforeach()
        else()
            if(FFTW_DIR)
                foreach(fftw_lib ${FFTW_libs_to_find})
                    set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                    find_library(FFTW_${fftw_lib}_LIBRARY
                        NAMES ${fftw_lib}
                        HINTS ${FFTW_DIR}
                        PATH_SUFFIXES lib lib32 lib64)
                endforeach()
            else()
                foreach(fftw_lib ${FFTW_libs_to_find})
                    set(FFTW_${fftw_lib}_LIBRARY "FFTW_${fftw_lib}_LIBRARY-NOTFOUND")
                    find_library(FFTW_${fftw_lib}_LIBRARY
                             NAMES ${fftw_lib}
                             HINTS ${PATH_TO_LOOK_FOR})
                endforeach()
            endif()
        endif()

    endif(FFTW_LOOK_FOR_MKL)

    # If found, add path to cmake variable
    # ------------------------------------
    set(FFTW_LIBRARIES "")
    set(FFTW_LIBRARY_DIRS "")
    foreach(fftw_lib ${FFTW_libs_to_find})

        if (FFTW_${fftw_lib}_LIBRARY)
            get_filename_component(${fftw_lib}_lib_path "${FFTW_${fftw_lib}_LIBRARY}" PATH)
            # set cmake variables
            list(APPEND FFTW_LIBRARIES "${FFTW_${fftw_lib}_LIBRARY}")
            list(APPEND FFTW_LIBRARY_DIRS "${${fftw_lib}_lib_path}")
        else ()
            list(APPEND FFTW_LIBRARIES "${FFTW_${fftw_lib}_LIBRARY}")
            if (NOT FFTW_FIND_QUIETLY)
                message(STATUS "Looking for FFTW -- lib ${fftw_lib} not found")
            endif()
        endif ()
        mark_as_advanced(FFTW_${fftw_lib}_LIBRARY)

    endforeach()

    list(REMOVE_DUPLICATES FFTW_INCLUDE_DIRS)
    list(REMOVE_DUPLICATES FFTW_LIBRARY_DIRS)

    # check a function to validate the find
    if(FFTW_LIBRARIES)

349 350
        set(REQUIRED_FLAGS)
        set(REQUIRED_LDFLAGS)
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
        set(REQUIRED_INCDIRS)
        set(REQUIRED_LIBDIRS)
        set(REQUIRED_LIBS)

        # FFTW
        if (FFTW_INCLUDE_DIRS)
            set(REQUIRED_INCDIRS "${FFTW_INCLUDE_DIRS}")
        endif()
        if (FFTW_LIBRARY_DIRS)
            set(REQUIRED_LIBDIRS "${FFTW_LIBRARY_DIRS}")
        endif()
        set(REQUIRED_LIBS "${FFTW_LIBRARIES}")
        # THREADS
        if (FFTW_LOOK_FOR_THREADS)
            list(APPEND REQUIRED_LIBS "${CMAKE_THREAD_LIBS_INIT}")
        endif()
        # OMP
        if(FFTW_LOOK_FOR_OMP)
            if (CMAKE_C_COMPILER MATCHES ".+gcc.*")
370
                set(REQUIRED_FLAGS "-fopenmp")
371 372 373 374
            endif()
        endif()
        # MKL
        if(FFTW_LOOK_FOR_MKL)
375
            list(APPEND REQUIRED_LIBS "${CMAKE_THREAD_LIBS_INIT};-lm")
376 377 378
            if (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_SYSTEM_NAME STREQUAL "Linux")
                list(APPEND REQUIRED_LDFLAGS "-Wl,--no-as-needed")
            endif()
379 380 381 382 383
        endif()

        # set required libraries for link
        set(CMAKE_REQUIRED_INCLUDES "${REQUIRED_INCDIRS}")
        set(CMAKE_REQUIRED_LIBRARIES)
384
        list(APPEND CMAKE_REQUIRED_LIBRARIES "${REQUIRED_LDFLAGS}")
385 386 387 388
        foreach(lib_dir ${REQUIRED_LIBDIRS})
            list(APPEND CMAKE_REQUIRED_LIBRARIES "-L${lib_dir}")
        endforeach()
        list(APPEND CMAKE_REQUIRED_LIBRARIES "${REQUIRED_LIBS}")
389
        list(APPEND CMAKE_REQUIRED_FLAGS "${REQUIRED_FLAGS}")
390
        string(REGEX REPLACE "^ -" "-" CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
391 392 393 394 395 396 397 398 399 400 401 402

        # test link
        unset(FFTW_WORKS CACHE)
        include(CheckFunctionExists)
        check_function_exists(${FFTW_PREC_TESTFUNC}fftw_execute_ FFTW_WORKS)
        mark_as_advanced(FFTW_WORKS)

        if(FFTW_WORKS)
            # save link with dependencies
            set(FFTW_LIBRARIES_DEP "${REQUIRED_LIBS}")
            set(FFTW_LIBRARY_DIRS_DEP "${REQUIRED_LIBDIRS}")
            set(FFTW_INCLUDE_DIRS_DEP "${REQUIRED_INCDIRS}")
403 404
            set(FFTW_C_FLAGS "${REQUIRED_FLAGS}")
            set(FFTW_LINKER_FLAGS "${REQUIRED_LDFLAGS}")
405 406
            list(REMOVE_DUPLICATES FFTW_LIBRARY_DIRS_DEP)
            list(REMOVE_DUPLICATES FFTW_INCLUDE_DIRS_DEP)
407
            list(REMOVE_DUPLICATES FFTW_LINKER_FLAGS)
408 409 410 411 412
        else()
            if(NOT FFTW_FIND_QUIETLY)
                message(STATUS "Looking for FFTW : test of ${FFTW_PREC_TESTFUNC}fftw_execute_ with fftw library fails")
                message(STATUS "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}")
                message(STATUS "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}")
413
                message(STATUS "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}")
414 415 416 417 418 419 420 421 422 423 424 425
                message(STATUS "Check in CMakeFiles/CMakeError.log to figure out why it fails")
            endif()
        else()
            set(FFTW_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
        endif()
        set(CMAKE_REQUIRED_INCLUDES)
        set(CMAKE_REQUIRED_FLAGS)
        set(CMAKE_REQUIRED_LIBRARIES)
    endif(FFTW_LIBRARIES)

endif( NOT FFTW_FOUND )

426 427 428 429 430 431 432 433
if (FFTW_LIBRARIES AND NOT FFTW_DIR)
    list(GET FFTW_LIBRARIES 0 first_lib)
    get_filename_component(first_lib_path "${first_lib}" PATH)
    if (${first_lib_path} MATCHES "(/lib(32|64)?$)|(/lib/intel64$|/lib/ia32$)")
        string(REGEX REPLACE "(/lib(32|64)?$)|(/lib/intel64$|/lib/ia32$)" "" not_cached_dir "${first_lib_path}")
        set(FFTW_DIR "${not_cached_dir}" CACHE PATH "Installation directory of FFTW library" FORCE)
    endif()
endif()
434 435 436 437 438 439 440 441

# check that FFTW has been found
# -------------------------------
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(FFTW DEFAULT_MSG
                                  FFTW_LIBRARIES
                                  FFTW_INCLUDE_DIRS
                                  FFTW_WORKS)