From cccf41adf282adf1fb5cefa92ad1cac87cfa32c3 Mon Sep 17 00:00:00 2001 From: Vasyl Gello Date: Wed, 27 Jan 2021 12:42:34 +0200 Subject: [PATCH] Overhaul CMake makefiles * Minimum CMake version lowered to 3.6 (tested on 3.6.1) * Refactored CMake configuration options Signed-off-by: Vasyl Gello --- CMakeLists.txt | 402 ++++++++++++++++++++++++++++++++---------- cmake/JoinPaths.cmake | 23 +++ test/CMakeLists.txt | 44 +++-- tools/CMakeLists.txt | 13 +- 4 files changed, 369 insertions(+), 113 deletions(-) create mode 100644 cmake/JoinPaths.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 3c92eb6..b571664 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,149 +1,373 @@ -file(READ Makefile _MAKEFILE_CONTENTS) -string(REGEX MATCH "KFVER=([0-9]+)\n" KFVER_MATCH "${_MAKEFILE_CONTENTS}") -if(NOT KFVER_MATCH) - message(FATAL_ERROR "Cannot extract version from Makefile") -endif() -set(MAKEFILE_EXTRACTED_VERSION "${CMAKE_MATCH_1}") +# Directory for easier includes +# Anywhere you see include(...) you can check /cmake for that file +set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) -cmake_minimum_required(VERSION 3.13) +# +# Extract version from Makefile +# + +file(READ Makefile _MAKEFILE_CONTENTS) + +string(REGEX MATCH "KFVER_MAJOR = ([0-9]+)\n" KFVER_MAJOR_MATCH "${_MAKEFILE_CONTENTS}") +if(NOT KFVER_MAJOR_MATCH) + message(FATAL_ERROR "Cannot extract major (ABI) version from Makefile") +endif() +set(KFVER_MAJOR "${CMAKE_MATCH_1}") + +string(REGEX MATCH "KFVER_MINOR = ([0-9]+)\n" KFVER_MINOR_MATCH "${_MAKEFILE_CONTENTS}") +if(NOT KFVER_MINOR_MATCH) + message(FATAL_ERROR "Cannot extract minor version from Makefile") +endif() +set(KFVER_MINOR "${CMAKE_MATCH_1}") + +string(REGEX MATCH "KFVER_PATCH = ([0-9]+)\n" KFVER_PATCH_MATCH "${_MAKEFILE_CONTENTS}") +if(NOT KFVER_PATCH_MATCH) + message(FATAL_ERROR "Cannot extract patch version from Makefile") +endif() +set(KFVER_PATCH "${CMAKE_MATCH_1}") + +set(MAKEFILE_EXTRACTED_VERSION "${KFVER_MAJOR}.${KFVER_MINOR}.${KFVER_PATCH}") + +# +# Declare CMake project +# + +cmake_minimum_required(VERSION 3.6) project(kissfft VERSION "${MAKEFILE_EXTRACTED_VERSION}") -option(KISSFFT_SIMD "Build kissfft with SIMD" OFF) -option(KISSFFT_FLOAT "Build kissfft with float type" ON) -option(KISSFFT_OPENMP "Build kissfft with openmp" OFF) -option(KISSFFT_TOOLS "Build kissfft tools" ON) -option(KISSFFT_TEST "Build and enable kissfft tests" ON) -option(KISSFFT_INSTALL "Enable kissfft install" ON) +# +# CMake configuration options +# -if (KISSFFT_INSTALL) - include(GNUInstallDirs) +# Principal datatype: double, float (default), int16_t, int32_t, simd + +set(KISSFFT_DATATYPE "float" CACHE STRING "Principal datatype of kissfft: double, float (default), int16_t, int32_t, simd") + +# Additional options + +option(KISSFFT_OPENMP "Build kissfft with OpenMP support" OFF) +option(KISSFFT_PKGCONFIG "Build pkg-config files" ON) +option(KISSFFT_STATIC "Build kissfft as static (ON) or shared library (OFF)" OFF) +option(KISSFFT_TEST "Build kissfft tests" ON) +option(KISSFFT_TOOLS "Build kissfft command-line tools" ON) +option(KISSFFT_USE_ALLOCA "Use alloca instead of malloc" OFF) + +# +# Validate datatype +# + +if (NOT KISSFFT_DATATYPE MATCHES "^double$" AND + NOT KISSFFT_DATATYPE MATCHES "^float$" AND + NOT KISSFFT_DATATYPE MATCHES "^int16_t$" AND + NOT KISSFFT_DATATYPE MATCHES "^int32_t$" AND + NOT KISSFFT_DATATYPE MATCHES "^simd$") + message(FATAL_ERROR "Incorrect value of KISSFFT_DATATYPE! It can be one of: double, float, int16_t, int32_t, simd") endif() +# +# Print principal datatype +# + +message(STATUS "Building KissFFT with datatype: ${KISSFFT_DATATYPE}") +set(KISSFFT_OUTPUT_NAME "kissfft-${KISSFFT_DATATYPE}") + +# +# Validate KISSFFT_STATIC +# + +if (BUILD_SHARED_LIBS AND KISSFFT_STATIC) + message(FATAL_ERROR "Conflicting CMake configuration: -DBUILD_SHARED_LIBS=ON and -DKISSFFT_STATIC=ON") +endif() + +# +# Enable BUILD_SHARED_LIBS for shared library build before +# kissfft library is declared +# + +if (NOT KISSFFT_STATIC) + set(BUILD_SHARED_LIBS ON) + message(STATUS "Building shared library") +else() + message(STATUS "Building static library") +endif() + +# +# Detect C compiler and pass appropriate flags +# + if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|AppleClang") add_compile_options(-ffast-math -fomit-frame-pointer -W -Wall -Wcast-align -Wcast-qual -Wshadow -Wwrite-strings "$<$:-Wstrict-prototypes;-Wmissing-prototypes;-Wnested-externs;-Wbad-function-cast>") endif() -set(KISSFFT_FIXED_WIDTH_VALID 16 32) -set(KISSFFT_FIXED_WIDTH "16" CACHE STRING "Width of kissfft fixed integer (16/32)") -set_property(CACHE KISSFFT_FIXED_WIDTH PROPERTY STRINGS ${KISSFFT_FIXED_WIDTH_VALID}) -if(NOT KISSFFT_FIXED_WIDTH IN_LIST KISSFFT_FIXED_WIDTH_VALID) - message(FATAL_ERROR "KISSFFT_FIXED_WIDTH must be 16 or 32") +# +# Add GNUInstallDirs for GNU infrastructure before target)include_directories +# + +if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$" AND NOT CMAKE_CROSSCOMPILING) + include(GNUInstallDirs) endif() -set(KISSFFT_FLOAT_TYPE_VALID float double) -set(KISSFFT_FLOAT_TYPE "float" CACHE STRING "Floating type of kissfft (float/double)") -set_property(CACHE KISSFFT_FLOAT_TYPE PROPERTY STRINGS ${KISSFFT_FLOAT_TYPE_VALID}) -if(NOT KISSFFT_FLOAT_TYPE IN_LIST KISSFFT_FLOAT_TYPE_VALID) - message(FATAL_ERROR "KISSFFT_FLOAT_TYPE must be float or double") -endif() +# +# Declare PKGINCLUDEDIR for kissfft include path +# + +set(PKGINCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}/kissfft") +message(STATUS "PKGINCLUDEDIR is ${PKGINCLUDEDIR}") + +# +# Declare kissfft library ( libkissfft.a / libkissfft-${KISSFFT_DATATYPE}.so.${MAKEFILE_EXTRACTED_VERSION} ) +# add_library(kissfft kiss_fft.c - tools/kfc.c - tools/kiss_fftnd.c - tools/kiss_fftndr.c - tools/kiss_fftr.c) + kfc.c + kiss_fftnd.c + kiss_fftndr.c + kiss_fftr.c) target_include_directories(kissfft PUBLIC $ - $) + $) + +# +# Set compile definitions based on datatype and additional support flags +# set(KISSFFT_COMPILE_DEFINITIONS) -if(KISSFFT_SIMD) - list(APPEND KISSFFT_COMPILE_DEFINITIONS USE_SIMD) - set(KISSFFT_DATATYPE "simd") + +# +# double / float +# + +if(KISSFFT_DATATYPE MATCHES "^float$" OR KISSFFT_DATATYPE MATCHES "^double$") + list(APPEND KISSFFT_COMPILE_DEFINITIONS kiss_fft_scalar=${KISSFFT_DATATYPE}) else() - if(KISSFFT_FLOAT) - list(APPEND KISSFFT_COMPILE_DEFINITIONS kiss_fft_scalar=${KISSFFT_FLOAT_TYPE}) - set(KISSFFT_DATATYPE "${KISSFFT_FLOAT_TYPE}") + + # + # int16_t + # + + if(KISSFFT_DATATYPE MATCHES "^int16_t$") + list(APPEND KISSFFT_COMPILE_DEFINITIONS FIXED_POINT=16) else() - list(APPEND KISSFFT_COMPILE_DEFINITIONS KISSFFT_FIXED_POINT=${KISSFFT_FIXED_WIDTH}) - set(KISSFFT_DATATYPE "int${KISSFFT_FIXED_WIDTH}") + + # + # int32_t + # + + if(KISSFFT_DATATYPE MATCHES "^int32_t$") + list(APPEND KISSFFT_COMPILE_DEFINITIONS FIXED_POINT=32) + else() + + # + # simd + # + + if(KISSFFT_DATATYPE MATCHES "^simd$") + list(APPEND KISSFFT_COMPILE_DEFINITIONS USE_SIMD) + if (NOT MSVC) + target_compile_options(kissfft PRIVATE -msse) + else() + target_compile_options(kissfft PRIVATE "/arch:SSE") + endif() + endif() + endif() endif() endif() + +# +# OpenMP support +# + if(KISSFFT_OPENMP) if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|AppleClang") - target_compile_options(kissfft PRIVATE -fopenmp) - target_link_options(kissfft PUBLIC -fopenmp) + if (NOT MSVC) + target_compile_options(kissfft PRIVATE -fopenmp) + if(${CMAKE_VERSION} VERSION_LESS "3.13.0") + target_link_libraries(kissfft PRIVATE "-fopenmp") + else() + target_link_options(kissfft PRIVATE -fopenmp) + endif() + else() + target_compile_options(kissfft PRIVATE "/openmp") + if(${CMAKE_VERSION} VERSION_LESS "3.13.0") + target_link_libraries(kissfft PRIVATE "/openmp") + else() + target_link_options(kissfft PRIVATE "/openmp") + endif() + endif() + set(KISSFFT_EXPORT_SUFFIX "-openmp") + set(KISSFFT_OUTPUT_NAME "kissfft-${KISSFFT_DATATYPE}-openmp") else() - message(FATAL_ERROR "Don't know how to enable openmp for this compiler") + message(FATAL_ERROR "Don't know how to enable OpenMP for this compiler") endif() endif() -message(STATUS "Building KissFFT with datatype=${KISSFFT_DATATYPE}") -if(BUILD_SHARED_LIBS) +# +# Shared / static library +# + +if(NOT KISSFFT_STATIC) list(APPEND KISSFFT_COMPILE_DEFINITIONS KISS_FFT_SHARED) set_target_properties(kissfft PROPERTIES C_VISIBILITY_PRESET hidden) - set(KISSFFT_EXPORT_SUFFIX "-shared") + set(KISSFFT_EXPORT_SUFFIX "${KISSFFT_EXPORT_SUFFIX}-shared") else() - set(KISSFFT_EXPORT_SUFFIX "-static") + set(KISSFFT_EXPORT_SUFFIX "${KISSFFT_EXPORT_SUFFIX}-static") endif() + +# +# Alloca support +# + +if(KISSFFT_USE_ALLOCA) + list(APPEND KISSFFT_COMPILE_DEFINITIONS KISS_FFT_USE_ALLOCA) +endif() + +# Set library name, version, soversion and aliases + target_compile_definitions(kissfft PUBLIC ${KISSFFT_COMPILE_DEFINITIONS}) -set(KISSFFT_OUTPUT_NAME "kissfft_${KISSFFT_DATATYPE}") set_target_properties(kissfft PROPERTIES OUTPUT_NAME "${KISSFFT_OUTPUT_NAME}" DEFINE_SYMBOL KISS_FFT_BUILD - EXPORT_NAME "kissfft-${KISSFFT_DATATYPE}" - VERSION ${PROJECT_VERSION}) + EXPORT_NAME "${KISSFFT_OUTPUT_NAME}" + VERSION ${PROJECT_VERSION} + SOVERSION ${KFVER_MAJOR}) add_library(kissfft::kissfft ALIAS kissfft) -add_library(kissfft::kissff-${KISSFFT_DATATYPE} ALIAS kissfft) -if(CMAKE_SYSTEM_NAME STREQUAL "Linux") +add_library(kissfft::kissfft-${KISSFFT_DATATYPE} ALIAS kissfft) + +# +# Build with libm (-lm) on Linux and kFreeBSD +# + +if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$" AND NOT CMAKE_CROSSCOMPILING) target_link_libraries(kissfft PRIVATE m) endif() +# +# Define a helper function to define executable file +# + function(add_kissfft_executable NAME) add_executable(${NAME} ${ARGN}) target_link_libraries(${NAME} PRIVATE kissfft::kissfft) - if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + + # + # Build with libm (-lm) on Linux and kFreeBSD + # + + if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$" AND NOT CMAKE_CROSSCOMPILING) target_link_libraries(${NAME} PRIVATE m) endif() - set_target_properties(${NAME} PROPERTIES - OUTPUT_NAME "${NAME}_${KISSFFT_DATATYPE}") + + if (NOT KISSFFT_OPENMP) + set_target_properties(${NAME} PROPERTIES + OUTPUT_NAME "${NAME}-${KISSFFT_DATATYPE}") + else() + if (NOT MSVC) + target_compile_options(${NAME} PRIVATE -fopenmp) + if(${CMAKE_VERSION} VERSION_LESS "3.13.0") + target_link_libraries(${NAME} PRIVATE "-fopenmp") + else() + target_link_options(${NAME} PRIVATE -fopenmp) + endif() + else() + target_compile_options(${NAME} PRIVATE "/openmp") + if(${CMAKE_VERSION} VERSION_LESS "3.13.0") + target_link_libraries(${NAME} PRIVATE "/openmp") + else() + target_link_options(${NAME} PRIVATE "/openmp") + endif() + endif() + set_target_properties(${NAME} PROPERTIES + OUTPUT_NAME "${NAME}-${KISSFFT_DATATYPE}-openmp") + endif() endfunction() +# +# Perform installation of kissfft library and development files +# + +install(TARGETS kissfft EXPORT kissfft + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}") + +install(FILES kiss_fft.h + kissfft.hh + kissfft_i32.hh + kfc.h + kiss_fftnd.h + kiss_fftndr.h + kiss_fftr.h + DESTINATION "${PKGINCLUDEDIR}") + +set(KISSFFT_INSTALL_CMAKE "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" + CACHE FILEPATH "Install destination of kissfft cmake modules") +mark_as_advanced(KISSFFT_INSTALL_CMAKE) + +install(EXPORT kissfft DESTINATION "${KISSFFT_INSTALL_CMAKE}" + NAMESPACE "kissfft::" + FILE "${PROJECT_NAME}-${KISSFFT_DATATYPE}${KISSFFT_EXPORT_SUFFIX}-targets.cmake") +include(CMakePackageConfigHelpers) +configure_package_config_file(kissfft-config.cmake.in kissfft-config.cmake + INSTALL_DESTINATION "${KISSFFT_INSTALL_CMAKE}") +write_basic_package_version_file(kissfft-config-version.cmake COMPATIBILITY AnyNewerVersion) +install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kissfft-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/kissfft-config-version.cmake" + DESTINATION "${KISSFFT_INSTALL_CMAKE}") + +set(PKG_KISSFFT_DEFS) +foreach(_def ${KISSFFT_COMPILE_DEFINITIONS}) + set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} -D${_def}") +endforeach() +if (KISSFFT_PKGCONFIG) + include(JoinPaths) + set(PKGCONFIG_KISSFFT_PKGINCLUDEDIR "\${includedir}/kissfft") + set(PKGCONFIG_KISSFFT_PREFIX "${CMAKE_INSTALL_PREFIX}") + set(PKGCONFIG_KISSFFT_VERSION "${kissfft_VERSION}") + join_paths(PKGCONFIG_KISSFFT_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}") + join_paths(PKGCONFIG_KISSFFT_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + if(KISSFFT_DATATYPE MATCHES "^simd$") + list(APPEND KISSFFT_COMPILE_DEFINITIONS USE_SIMD) + if (NOT MSVC) + set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} -msse") + else() + set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} /ARCH:SSE") + endif() + endif() + if (NOT KISSFFT_OPENMP) + configure_file(kissfft.pc.in "kissfft-${KISSFFT_DATATYPE}.pc" @ONLY) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kissfft-${KISSFFT_DATATYPE}.pc" + DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") + else() + if (NOT MSVC) + set(PKG_OPENMP "-fopenmp") + set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} -fopenmp") + else() + set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} /openmp") + set(PKG_OPENMP "/openmp") + endif() + configure_file(kissfft.pc.in "kissfft-${KISSFFT_DATATYPE}-openmp.pc" @ONLY) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kissfft-${KISSFFT_DATATYPE}-openmp.pc" + DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") + endif() +endif() + +# +# Build and install tools if requested by user +# + if(KISSFFT_TOOLS) add_subdirectory(tools) endif() +# +# Build and run tests if requested by user +# + if(KISSFFT_TEST) enable_testing() add_subdirectory(test) endif() - -if (KISSFFT_INSTALL) - install(TARGETS kissfft EXPORT kissfft - ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" - LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" - RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}") - install(FILES kiss_fft.h - kissfft.hh - tools/kfc.h - tools/kiss_fftnd.h - tools/kiss_fftndr.h - tools/kiss_fftr.h - DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") - - set(KISSFFT_INSTALL_CMAKE "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" CACHE FILEPATH "Install destination of kissfft cmake modules") - mark_as_advanced(KISSFFT_INSTALL_CMAKE) - - install(EXPORT kissfft DESTINATION "${KISSFFT_INSTALL_CMAKE}" - NAMESPACE "kissfft::" - FILE "${PROJECT_NAME}-${KISSFFT_DATATYPE}${KISSFFT_EXPORT_SUFFIX}-targets.cmake") - include(CMakePackageConfigHelpers) - configure_package_config_file(kissfft-config.cmake.in kissfft-config.cmake - INSTALL_DESTINATION "${KISSFFT_INSTALL_CMAKE}") - write_basic_package_version_file(kissfft-config-version.cmake COMPATIBILITY AnyNewerVersion) - install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kissfft-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/kissfft-config-version.cmake" - DESTINATION "${KISSFFT_INSTALL_CMAKE}") - - set(PKG_KISSFFT_DEFS) - foreach(_def ${KISSFFT_COMPILE_DEFINITIONS}) - set(PKG_KISSFFT_DEFS "${PKG_KISSFFT_DEFS} -D${_def}") - endforeach() - configure_file(kissfft.pc.in "kissfft-${KISSFFT_DATATYPE}.pc" @ONLY) - install(FILES "${CMAKE_CURRENT_BINARY_DIR}/kissfft-${KISSFFT_DATATYPE}.pc" - DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") -endif() diff --git a/cmake/JoinPaths.cmake b/cmake/JoinPaths.cmake new file mode 100644 index 0000000..c68d91b --- /dev/null +++ b/cmake/JoinPaths.cmake @@ -0,0 +1,23 @@ +# This module provides function for joining paths +# known from most languages +# +# SPDX-License-Identifier: (MIT OR CC0-1.0) +# Copyright 2020 Jan Tojnar +# https://github.com/jtojnar/cmake-snips +# +# Modelled after Python’s os.path.join +# https://docs.python.org/3.7/library/os.path.html#os.path.join +# Windows not supported +function(join_paths joined_path first_path_segment) + set(temp_path "${first_path_segment}") + foreach(current_segment IN LISTS ARGN) + if(NOT ("${current_segment}" STREQUAL "")) + if(IS_ABSOLUTE "${current_segment}") + set(temp_path "${current_segment}") + else() + set(temp_path "${temp_path}/${current_segment}") + endif() + endif() + endforeach() + set(${joined_path} "${temp_path}" PARENT_SCOPE) +endfunction() diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 37c1598..0a0e403 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,23 +1,25 @@ -add_library(kissfft_help_library OBJECT - pstats.c - ../tools/kfc.c - ../tools/kiss_fftnd.c - ../tools/kiss_fftr.c - ../tools/kiss_fftndr.c -) -target_link_libraries(kissfft_help_library PRIVATE kissfft::kissfft) -target_include_directories(kissfft_help_library PRIVATE ../tools) - function(add_kissfft_test_executable NAME) - add_kissfft_executable(${NAME} ${ARGN} $) - target_include_directories(${NAME} PRIVATE ../tools) + add_kissfft_executable(${NAME} ${ARGN}) + target_include_directories(${NAME} PRIVATE ..) + add_test(NAME ${NAME} COMMAND ${NAME}) set_tests_properties(${NAME} PROPERTIES TIMEOUT 3600) endfunction() set(KISSFFT_TEST_NUMFFTS 10000) -add_kissfft_test_executable(bm_kiss benchkiss.c) +# +# Add tools-independent fastfilt_* (../tools/fft_*) executable without adding a test +# + +add_kissfft_executable(fastfilt ../tools/fftutil.c) +target_include_directories(fastfilt PRIVATE ..) + +# +# Add test executables and define tests +# + +add_kissfft_test_executable(bm_kiss benchkiss.c pstats.c) # add_test(NAME benchmar COMMAND ${NAME}) # set_tests_properties(${NAME} PROPERTIES TIMEOUT 3600) @@ -28,7 +30,7 @@ else() set(fftw3_pkg fftw3) endif() pkg_check_modules(fftw3 REQUIRED IMPORTED_TARGET ${fftw3_pkg}) -add_kissfft_test_executable(bm_fftw benchfftw.c) +add_kissfft_test_executable(bm_fftw benchfftw.c pstats.c) target_link_libraries(bm_fftw PRIVATE PkgConfig::fftw3) add_kissfft_test_executable(st twotonetest.c) @@ -41,9 +43,21 @@ add_kissfft_test_executable(tr test_real.c) add_kissfft_test_executable(testcpp testcpp.cc) +if(KISSFFT_DATATYPE MATCHES "^simd$") + add_kissfft_test_executable(tsimd test_simd.c) + target_compile_definitions(tsimd PRIVATE USE_SIMD) + if (NOT MSVC) + target_compile_options(kissfft PRIVATE -msse) + else() + target_compile_options(kissfft PRIVATE "/arch:SSE") + endif() +endif() + find_package(PythonInterp REQUIRED) add_test(NAME testkiss.py COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/testkiss.py") +list(APPEND TESTKISS_PY_ENV "KISSFFT_DATATYPE=${KISSFFT_DATATYPE}") +list(APPEND TESTKISS_PY_ENV "KISSFFT_OPENMP=${KISSFFT_OPENMP}") set_tests_properties(testkiss.py PROPERTIES TIMEOUT 3600 - ENVIRONMENT "DATATYPE=${KISSFFT_DATATYPE}" + ENVIRONMENT "${TESTKISS_PY_ENV}" WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt index 2c8cc59..d2b721d 100644 --- a/tools/CMakeLists.txt +++ b/tools/CMakeLists.txt @@ -6,14 +6,11 @@ target_compile_definitions(fastconv PRIVATE FAST_FILT_UTIL) add_kissfft_executable(fft fftutil.c) - -if (KISSFFT_INSTALL) - install(TARGETS fastconv fastconvr fft +install(TARGETS fastconv fastconvr fft ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) -endif() + PUBLIC_HEADER DESTINATION ${PKGINCLUDEDIR}) # psdpng does not build with "simd" datatype if(NOT KISSFFT_DATATYPE MATCHES "simd") @@ -21,13 +18,11 @@ if(NOT KISSFFT_DATATYPE MATCHES "simd") pkg_check_modules(libpng REQUIRED IMPORTED_TARGET libpng) add_kissfft_executable(psdpng psdpng.c) target_link_libraries(psdpng PRIVATE PkgConfig::libpng) - if (KISSFFT_INSTALL) - install(TARGETS psdpng + install(TARGETS psdpng ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) - endif() + PUBLIC_HEADER DESTINATION ${PKGINCLUDEDIR}) endif() #FIXME: dumphdr.c is not available