Merge branch 'flatironinstitute:master' into ker-sym

Author: lu1and10

CMakeLists.txt

@@ -29,6 +29,10 @@ if (CMAKE_CXX_COMPILER_ID IN_LIST GNU_LIKE_FRONTENDS)
 endif ()
 
 include(CTest)
+# Set default build type to Release
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Set the default build type to Release" FORCE)
+endif()
 
 if (CMAKE_CXX_COMPILER_ID IN_LIST GNU_LIKE_FRONTENDS)
     if (CMAKE_SYSTEM_PROCESSOR MATCHES "ppc|ppc64|powerpc|powerpc64" OR (APPLE AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc|ppc64"))
@@ -53,6 +57,7 @@ option(FINUFFT_USE_CUDA "Whether to build CUDA accelerated FINUFFT library (libc
 option(FINUFFT_USE_CPU "Whether to build the ordinary FINUFFT library (libfinufft)." ON)
 option(FINUFFT_STATIC_LINKING "Whether to link the static FINUFFT library (libfinufft_static)." ON)
 option(FINUFFT_BUILD_DEVEL "Whether to build development executables" OFF)
+option(FINUFFT_USE_DUCC0 "Whether to use DUCC0 (instead of FFTW) for CPU FFTs" OFF)
 # sphinx tag (don't remove): @cmake_opts_end
 
 if (FINUFFT_USE_CPU)
@@ -70,9 +75,21 @@ if (FINUFFT_USE_CPU)
     set(FFTW_VERSION 3.3.10)
     set(XTL_VERSION 0.7.7)
     set(XSIMD_VERSION 13.0.0)
+    set(DUCC0_VERSION ducc0_0_34_0)
+    set(FINUFFT_FFTW_LIBRARIES)
     include(cmake/setupCPM.cmake)
-    include(cmake/setupFFTW.cmake)
     include(cmake/setupXSIMD.cmake)
+    if (FINUFFT_USE_DUCC0)
+        include(cmake/setupDUCC.cmake)
+    else ()
+        include(cmake/setupFFTW.cmake)
+    endif ()
+endif ()
+
+if (FINUFFT_USE_DUCC0)
+    set (FINUFFT_FFTLIBS ducc0)
+else ()
+    set (FINUFFT_FFTLIBS ${FINUFFT_FFTW_LIBRARIES})
 endif ()
 
 if (FINUFFT_BUILD_MATLAB)
@@ -101,7 +118,7 @@ endif ()
 
 # This set of sources is compiled twice, once in single precision and once in double precision
 # The single precision compilation is done with -DSINGLE
-set(FINUFFT_PRECISION_DEPENDENT_SOURCES src/finufft.cpp src/simpleinterfaces.cpp src/spreadinterp.cpp src/utils.cpp fortran/finufftfort.cpp)
+set(FINUFFT_PRECISION_DEPENDENT_SOURCES src/finufft.cpp src/fft.cpp src/simpleinterfaces.cpp src/spreadinterp.cpp src/utils.cpp fortran/finufftfort.cpp)
 
 # Set of compilers which behave like gcc
 set(FINUFFT_GNU_LIKE_COMPILERS AppleClang Clang GNU)
@@ -122,6 +139,11 @@ endfunction()
 
 # Utility function to link static/dynamic lib
 function(finufft_link_test target)
+
+    if (FINUFFT_USE_DUCC0)
+        target_compile_definitions(${target} PRIVATE FINUFFT_USE_DUCC0)
+    endif ()
+
     if (FINUFFT_STATIC_LINKING)
         target_link_libraries(${target} PRIVATE finufft_static)
         if (FINUFFT_USE_OPENMP)
@@ -169,37 +191,54 @@ function(set_finufft_options target)
         endif ()
     endif ()
 
-    # FFTW CMAKE file includes the APIs only as an install target, so we need to manually
-    # include them since we need them for build not for install
-    # trying to include them directly into the fftw and fftwf targets causes issues with
-    # the latest version of cmake, so we do it here instead.
-    if ((NOT FFTW_FOUND) OR (FINUFFT_FFTW_LIBRARIES STREQUAL DOWNLOAD))
-        list(GET FINUFFT_FFTW_LIBRARIES 0 element)
-        get_property(FFTW_SOURCE_DIR TARGET ${element} PROPERTY SOURCE_DIR)
-        set(FFTW_INCLUDE_DIR ${FFTW_SOURCE_DIR}/api)
-        target_include_directories(${target} PUBLIC ${FFTW_INCLUDE_DIR})
+    if (FINUFFT_USE_DUCC0)
+        target_compile_definitions(${target} PRIVATE FINUFFT_USE_DUCC0)
+    else ()
+        # FFTW CMAKE file includes the APIs only as an install target, so we need to manually
+        # include them since we need them for build not for install
+        # trying to include them directly into the fftw and fftwf targets causes issues with
+        # the latest version of cmake, so we do it here instead.
+        if ((NOT FFTW_FOUND) OR (FINUFFT_FFTW_LIBRARIES STREQUAL DOWNLOAD))
+            list(GET FINUFFT_FFTW_LIBRARIES 0 element)
+            get_property(FFTW_SOURCE_DIR TARGET ${element} PROPERTY SOURCE_DIR)
+            set(FFTW_INCLUDE_DIR ${FFTW_SOURCE_DIR}/api)
+            target_include_directories(${target} PUBLIC ${FFTW_INCLUDE_DIR})
+        endif ()
     endif ()
-    target_link_libraries(${target} PRIVATE xsimd)
-    target_link_libraries(${target} PUBLIC ${FINUFFT_FFTW_LIBRARIES})
+#    target_link_libraries(${target} PRIVATE xsimd)
+#    target_link_libraries(${target} PUBLIC ${FINUFFT_FFTW_LIBRARIES})
 endfunction()
 
 if (FINUFFT_USE_CPU)
     # Main finufft libraries
+    if (FINUFFT_USE_DUCC0)
+        # okay for now, to be cleaned up
+        set_finufft_options(ducc0)
+    endif ()
+
     add_library(finufft_f32 OBJECT ${FINUFFT_PRECISION_DEPENDENT_SOURCES})
     target_compile_definitions(finufft_f32 PRIVATE SINGLE)
     set_finufft_options(finufft_f32)
+    target_link_libraries(finufft_f32 PUBLIC ${FINUFFT_FFTLIBS})
+    target_link_libraries(finufft_f32 PRIVATE xsimd)
 
     add_library(finufft_f64 OBJECT ${FINUFFT_PRECISION_DEPENDENT_SOURCES})
     target_compile_definitions(finufft_f64 PRIVATE)
     set_finufft_options(finufft_f64)
+    target_link_libraries(finufft_f64 PUBLIC ${FINUFFT_FFTLIBS})
+    target_link_libraries(finufft_f64 PRIVATE xsimd)
     if (WIN32)
         add_library(finufft_f32_dll OBJECT ${FINUFFT_PRECISION_DEPENDENT_SOURCES})
         target_compile_definitions(finufft_f32_dll PRIVATE SINGLE dll_EXPORTS FINUFFT_DLL)
         set_finufft_options(finufft_f32_dll)
+        target_link_libraries(finufft_f32_dll PUBLIC ${FINUFFT_FFTLIBS})
+        target_link_libraries(finufft_f32_dll PRIVATE xsimd)
 
         add_library(finufft_f64_dll OBJECT ${FINUFFT_PRECISION_DEPENDENT_SOURCES})
         target_compile_definitions(finufft_f64_dll PRIVATE dll_EXPORTS FINUFFT_DLL)
         set_finufft_options(finufft_f64_dll)
+        target_link_libraries(finufft_f64_dll PUBLIC ${FINUFFT_FFTLIBS})
+        target_link_libraries(finufft_f64_dll PRIVATE xsimd)
     endif ()
 
     add_library(finufft SHARED src/utils_precindep.cpp contrib/legendre_rule_fast.cpp)

cmake/setupDUCC.cmake

@@ -0,0 +1,25 @@
+CPMAddPackage(
+        NAME ducc0
+        GIT_REPOSITORY https://gitlab.mpcdf.mpg.de/mtr/ducc.git
+        GIT_TAG ${DUCC0_VERSION}
+        DOWNLOAD_ONLY YES
+)
+
+
+if(ducc0_ADDED)
+    add_library(ducc0 STATIC
+            ${ducc0_SOURCE_DIR}/src/ducc0/infra/string_utils.cc
+            ${ducc0_SOURCE_DIR}/src/ducc0/infra/threading.cc
+            ${ducc0_SOURCE_DIR}/src/ducc0/infra/mav.cc
+            ${ducc0_SOURCE_DIR}/src/ducc0/math/gridding_kernel.cc
+            ${ducc0_SOURCE_DIR}/src/ducc0/math/gl_integrator.cc
+    )
+    target_include_directories(ducc0 PUBLIC ${ducc0_SOURCE_DIR}/src/)
+    target_compile_options(ducc0 PRIVATE -ffast-math)
+    target_compile_features(ducc0 PRIVATE cxx_std_17) # private because we do not want to propagate this requirement
+
+    if (NOT OpenMP_CXX_FOUND)
+        find_package(Threads REQUIRED)
+        target_link_libraries(ducc0 PRIVATE Threads::Threads)
+    endif ()
+endif ()

cmake/setupFFTW.cmake

@@ -44,7 +44,6 @@ if (FINUFFT_FFTW_LIBRARIES STREQUAL DEFAULT OR FINUFFT_FFTW_LIBRARIES STREQUAL D
                     EXCLUDE_FROM_ALL YES
                     GIT_SHALLOW YES
             )
-
             set(FINUFFT_FFTW_LIBRARIES fftw3 fftw3f)
             if (FINUFFT_USE_THREADS)
                 list(APPEND FINUFFT_FFTW_LIBRARIES fftw3_threads fftw3f_threads)

devel/CMakeLists.txt

@@ -21,4 +21,4 @@ add_executable(foldrescale foldrescale.cpp)
 target_link_libraries(foldrescale finufft benchmark xsimd)
 add_executable(padding padding.cpp)
 target_link_libraries(padding finufft xsimd)
-target_compile_options(padding PRIVATE -march=native)
+target_compile_options(padding PRIVATE -march=native)

docs/install.rst

@@ -59,13 +59,13 @@ The basic quick download, building, and test is then:
   cd finufft
   mkdir build
   cd build
-  cmake .. -D FINUFFT_BUILD_TESTS=ON --install-prefix /path/to/install
+  cmake .. -D FINUFFT_BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Release --install-prefix /path/to/install
   cmake --build . -j
   ctest
   cmake --install .
 
 
-Note: if you don't supply --install-prefix, it will default to ``/usr/local`` on most systems. If you don't
+Note: `Release` here is essential to get the best performing version. Also, if you don't supply `--install-prefix`, it will default to ``/usr/local`` on most systems. If you don't
 have root access, you must supply a prefix you can write to such as ``$HOME/local``. Now...
 
 In ``build``, this creates ``libfinufft_static.a`` and ``libfinufft.so``, and runs a test that should take a
@@ -104,7 +104,7 @@ For example, to configure, build and test the development preset (which builds t
 
 .. warning::
 
-  Intel compilers (unlike GPU compilers) currently engage ``fastmath`` behavior with ``-O2`` or ``-O3``. This may interfere with our use of ``std::isnan`` in our test codes. For this reason in the Intel presets ``icx`` and ``icc`` have set ``-fp-model=strict``. You may get more speed if you remove this flag.
+  Intel compilers (unlike GPU compilers) currently engage ``fastmath`` behavior with ``-O2`` or ``-O3``. This may interfere with our use of ``std::isfinite`` in our test codes. For this reason in the Intel presets ``icx`` and ``icc`` have set ``-fp-model=strict``. You may get more speed if you remove this flag, or try ``-fno-finite-math-only``.
 
 From other CMake projects, to use ``finufft`` as a library, simply add this repository as a subdirectory using
 ``add_subdirectory``, and use ``target_link_library(your_executable finufft)``.

include/finufft/defs.h

@@ -191,9 +191,7 @@
 // --------  FINUFFT's plan object, prec-switching version ------------------
 // NB: now private (the public C++ or C etc user sees an opaque pointer to it)
 
-// FFTW is needed since we include a FFTW plan in the FINUFFT plan...
-#include <finufft/fftw_defs.h> // (must come after complex.h)
-// (other FFT lib headers eg MKL could be here...)
+#include <finufft/fft.h> // (must come after complex.h)
 
 // group together a bunch of type 3 rescaling/centering/phasing parameters:
 #define TYPE3PARAMS FINUFFTIFY(_type3Params)
@@ -230,7 +228,7 @@ typedef struct FINUFFT_PLAN_S { // the main plan object, fully C++
   FLT *phiHat2;        // " y-axis.
   FLT *phiHat3;        // " z-axis.
 
-  FFTW_CPX *fwBatch;   // (batches of) fine grid(s) for FFTW to plan
+  CPX *fwBatch;        // (batches of) fine grid(s) for FFTW to plan
                        // & act on. Usually the largest working array
 
   BIGINT *sortIndices; // precomputed NU pt permutation, speeds spread/interp
@@ -249,7 +247,9 @@ typedef struct FINUFFT_PLAN_S { // the main plan object, fully C++
   FINUFFT_PLAN innerT2plan; // ptr used for type 2 in step 2 of type 3
 
   // other internal structs; each is C-compatible of course
+#ifndef FINUFFT_USE_DUCC0
   FFTW_PLAN fftwPlan;
+#endif
   finufft_opts opts; // this and spopts could be made ptrs
   finufft_spread_opts spopts;
 

include/finufft/fft.h

@@ -0,0 +1,18 @@
+#ifndef FINUFFT_INCLUDE_FINUFFT_FFT_H
+#define FINUFFT_INCLUDE_FINUFFT_FFT_H
+
+#ifdef FINUFFT_USE_DUCC0
+#include "ducc0/fft/fftnd_impl.h"
+#define FFTW_FORGET_WISDOM()   // temporary hack since some tests call this unconditionally
+#define FFTW_CLEANUP()         // temporary hack since some tests call this unconditionally
+#define FFTW_CLEANUP_THREADS() // temporary hack since some tests call this
+                               // unconditionally
+#else
+#include "fftw_defs.h"
+#endif
+#include <finufft/defs.h>
+
+int *gridsize_for_fft(FINUFFT_PLAN p);
+void do_fft(FINUFFT_PLAN p);
+
+#endif // FINUFFT_INCLUDE_FINUFFT_FFT_H

include/finufft/test_defs.h

@@ -20,9 +20,6 @@
 #include <finufft/utils_precindep.h>
 // prec-switching (via SINGLE) to set up FLT, CPX, BIGINT, FINUFFT1D1, etc...
 #include <finufft/defs.h>
-// since "many" (vector) tests need direct access to FFTW commands...
-// (although this now happens to be included in defs.h too)
-#include <finufft/fftw_defs.h>
 
 // std stuff for tester src
 #include <cstdio>

include/finufft_eitherprec.h

@@ -184,5 +184,3 @@ FINUFFT_EXPORT int FINUFFT_CDECL FINUFFTIFY(3d3many)(
 #undef FINUFFT_PLAN
 #undef FINUFFT_PLAN_S
 #undef FINUFFT_TYPE3PARAMS
-#undef FINUFFT_FFTW_CPX
-#undef FINUFFT_FFTW_PLAN

makefile

@@ -118,7 +118,7 @@ SOBJS_PI = src/utils_precindep.o
 SOBJSD = $(SOBJS) $(SOBJSF) $(SOBJS_PI)
 
 # double-prec library object files that also need single precision...
-OBJS = $(SOBJS) src/finufft.o src/simpleinterfaces.o fortran/finufftfort.o
+OBJS = $(SOBJS) src/finufft.o src/simpleinterfaces.o fortran/finufftfort.o src/fft.o
 # their single-prec versions
 OBJSF = $(OBJS:%.o=%_32.o)
 # precision-dependent library object files (compiled & linked only once)...