using physical threads

include/finufft/finufft_utils.hpp

@@ -12,9 +12,8 @@
 //  using chrono since the interface is portable between linux and windows
 
 namespace finufft::utils {
-
 template<typename T>
 FINUFFT_EXPORT FINUFFT_ALWAYS_INLINE void FINUFFT_CDECL arrayrange(BIGINT n, const T *a,
                                                                    T *lo, T *hi)
 // With a a length-n array, writes out min(a) to lo and max(a) to hi,
 // so that all a values lie in [lo,hi].
@@ -28,7 +27,7 @@
   }
 }
 template<typename T>
 FINUFFT_EXPORT FINUFFT_ALWAYS_INLINE void FINUFFT_CDECL arraywidcen(BIGINT n, const T *a,
                                                                     T *w, T *c)
 // Writes out w = half-width and c = center of an interval enclosing all a[n]'s
 // Only chooses a nonzero center if this increases w by less than fraction
@@ -59,8 +58,9 @@
   double initial;
 };
 
-// openmp helpers
-int get_num_threads_parallel_block();
+FINUFFT_NEVER_INLINE int getPhysicalCoreCount();
+
+FINUFFT_NEVER_INLINE int get_num_threads_parallel_block();
 
 } // namespace finufft::utils
 

src/finufft_core.cpp

@@ -265,7 +265,7 @@
     Outputs:
     phihat - real Fourier transform evaluated at freq k
    */
   FINUFFT_ALWAYS_INLINE T operator()(T k) {
     T x = 0;
     for (size_t n = 0; n < z.size(); ++n)
       x += f[n] * 2 * cos(k * z[n]); // pos & neg freq pair.  use T cos!
@@ -590,8 +590,8 @@
 
 #ifdef _OPENMP
   // choose overall # threads...
-  int ompmaxnthr = MY_OMP_GET_MAX_THREADS();
-  int nthr       = ompmaxnthr; // default: use as many as OMP gives us
+  int ompmaxnthr = getPhysicalCoreCount();
+  int nthr       = ompmaxnthr; // default: use as many physical cores as possible
   // (the above could be set, or suggested set, to 1 for small enough problems...)
   if (opts.nthreads > 0) {
     nthr = opts.nthreads; // user override, now without limit
@@ -609,6 +609,9 @@
             __func__, opts.nthreads);
 #endif
   opts.nthreads = nthr; // store actual # thr planned for
+  if (opts.debug > 1) {
+    printf("[%s] opts.nthreads=%d\n", __func__, nthr);
+  }
   // (this sets/limits all downstream spread/interp, 1dkernel, and FFT thread counts...)
 
   // choose batchSize for types 1,2 or 3... (uses int ceil(b/a)=1+(b-1)/a trick)

src/finufft_utils.cpp

@@ -4,6 +4,19 @@
 // For self-test see ../test/testutils.cpp.      Barnett 2017-2020.
 
 #include <cstdint>
+#include <iostream>
+#include <string>
+
+#if defined(_WIN32)
+#include <vector>
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#elif defined(__linux__)
+#include <fstream>
+#include <set>
+#endif
 
 #include <finufft/finufft_utils.hpp>
 
@@ -57,6 +70,102 @@ double CNTime::elapsedsec() const
   return nowsec - initial;
 }
 
+// Returns the number of physical CPU cores (excluding hyper-threaded logical cores)
+int getPhysicalCoreCount() {
+  int physicalCoreCount = 0;
+
+#if defined(_WIN32)
+  // Determine the size of the buffer.
+  DWORD bufferSize = 0;
+  if (GetLogicalProcessorInformation(nullptr, &bufferSize) == FALSE &&
+      GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+    // Leave physicalCoreCount as 0 if the call fails.
+    return physicalCoreCount;
+  }
+
+  // Calculate the number of entries and allocate a vector.
+  size_t entryCount = bufferSize / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+  std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> procInfo(entryCount);
+  if (GetLogicalProcessorInformation(procInfo.data(), &bufferSize) != FALSE) {
+    for (const auto &info : procInfo) {
+      if (info.Relationship == RelationProcessorCore) ++physicalCoreCount;
+    }
+  }
+
+#elif defined(__APPLE__)
+  // Retrieve the number of physical cores using sysctl.
+  int cores   = 0;
+  size_t size = sizeof(cores);
+  if (sysctlbyname("hw.physicalcpu", &cores, &size, nullptr, 0) == 0)
+    physicalCoreCount = static_cast<unsigned int>(cores);
+
+#elif defined(__linux__)
+  // Parse /proc/cpuinfo to count unique (physical id, core id) pairs.
+  std::ifstream cpuinfo("/proc/cpuinfo");
+  if (!cpuinfo.is_open()) return physicalCoreCount;
+
+  std::set<std::string> coreSet;
+  std::string line;
+  int physicalId = -1, coreId = -1;
+  bool foundPhysical = false, foundCore = false;
+
+  while (std::getline(cpuinfo, line)) {
+    // An empty line indicates the end of a processor block.
+    if (line.empty()) {
+      if (foundPhysical && foundCore)
+        coreSet.insert(std::to_string(physicalId) + "-" + std::to_string(coreId));
+      // Reset for the next processor block.
+      foundPhysical = foundCore = false;
+      physicalId = coreId = -1;
+    } else {
+      auto colonPos = line.find(':');
+      if (colonPos == std::string::npos) continue;
+      std::string key   = line.substr(0, colonPos);
+      std::string value = line.substr(colonPos + 1);
+      // Trim whitespace.
+      key.erase(key.find_last_not_of(" \t") + 1);
+      value.erase(0, value.find_first_not_of(" \t"));
+
+      if (key == "physical id") {
+        physicalId    = std::stoi(value);
+        foundPhysical = true;
+      } else if (key == "core id") {
+        coreId    = std::stoi(value);
+        foundCore = true;
+      }
+    }
+  }
+  // In case the file doesn't end with an empty line.
+  if (foundPhysical && foundCore)
+    coreSet.insert(std::to_string(physicalId) + "-" + std::to_string(coreId));
+
+  if (!coreSet.empty()) {
+    physicalCoreCount = static_cast<unsigned int>(coreSet.size());
+  } else {
+    // Fallback: try reading "cpu cores" from the first processor block.
+    cpuinfo.clear();
+    cpuinfo.seekg(0, std::ios::beg);
+    while (std::getline(cpuinfo, line)) {
+      auto colonPos = line.find(':');
+      if (colonPos != std::string::npos) {
+        std::string key   = line.substr(0, colonPos);
+        std::string value = line.substr(colonPos + 1);
+        key.erase(key.find_last_not_of(" \t") + 1);
+        value.erase(0, value.find_first_not_of(" \t"));
+        if (key == "cpu cores") {
+          physicalCoreCount = static_cast<unsigned int>(std::stoi(value));
+          break;
+        }
+      }
+    }
+  }
+#endif
+  if (physicalCoreCount == 0) {
+    return MY_OMP_GET_MAX_THREADS();
+  }
+  return physicalCoreCount;
+}
+
 // -------------------------- openmp helpers -------------------------------
 int get_num_threads_parallel_block()
 // return how many threads an omp parallel block would use.

test/CMakeLists.txt

@@ -36,11 +36,10 @@ target_compile_features(testutils PRIVATE cxx_std_17)
 finufft_link_test(testutils)
 add_test(NAME run_testutils COMMAND testutils WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 
-if(NOT FINUFFT_USE_DUCC0)
+if(NOT FINUFFT_USE_DUCC0 AND FINUFFT_USE_OPENMP)
     add_executable(fftw_lock_test fftw_lock_test.cpp)
     target_compile_features(fftw_lock_test PRIVATE cxx_std_17)
     finufft_link_test(fftw_lock_test)
-
     add_test(NAME run_fftw_lock_test COMMAND fftw_lock_test WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 endif()