Tune sieve array size (#159)

Author: kimwalisch

ChangeLog

@@ -1,7 +1,8 @@
-Changes in version 12.7, 17/02/2025
+Changes in version 12.7, 24/02/2025
 ===================================
 
 * EratBig.cpp: Simplify bucket handling.
+* Erat.cpp: Tune sieve size using FACTOR_SIEVESIZE.
 * README.md: Add Sponsors section.
 
 Changes in version 12.6, 11/11/2024

include/primesieve/config.hpp

@@ -2,7 +2,7 @@
 /// @file   config.hpp
 /// @brief  primesieve compile time constants.
 ///
-/// Copyright (C) 2024 Kim Walisch, <kim.walisch@gmail.com>
+/// Copyright (C) 2025 Kim Walisch, <kim.walisch@gmail.com>
 ///
 /// This file is distributed under the BSD License. See the COPYING
 /// file in the top level directory.
@@ -60,6 +60,21 @@ constexpr uint64_t MAX_CACHE_ITERATOR = 1 << 30;
 ///
 constexpr uint64_t MIN_THREAD_DISTANCE = (uint64_t) 1e7;
 
+/// sieveSize = sqrt(stop) * FACTOR_SIEVESIZE.
+///
+/// Using a larger FACTOR_SIEVESIZE increases the segment size in the
+/// sieve of Eratosthenes and hence reduces the number of operations
+/// used by the algorithm. However, as a drawback a larger segment
+/// size is less cache efficient and hence performance may deteriorate
+/// on CPUs with limited L2 cache bandwidth (especially when using
+/// multi-threading).
+///
+/// Using FACTOR_SIEVESIZE = 2.0 performs well for counting the
+/// primes < 10^11 using multi-threading on both the Apple M3 CPU and
+/// the Intel Arrow Lake 245K CPU (from 2024).
+///
+constexpr double FACTOR_SIEVESIZE = 2.0;
+
 /// Sieving primes <= (L1D_CACHE_BYTES * FACTOR_ERATSMALL) are
 /// processed in EratSmall. When FACTOR_ERATSMALL is small fewer
 /// sieving primes are processed in EratSmall.cpp and more sieving

src/Erat.cpp

@@ -3,7 +3,7 @@
 /// @brief  The Erat class manages prime sieving using the
 ///         EratSmall, EratMedium, EratBig classes.
 ///
-/// Copyright (C) 2024 Kim Walisch, <kim.walisch@gmail.com>
+/// Copyright (C) 2025 Kim Walisch, <kim.walisch@gmail.com>
 ///
 /// This file is distributed under the BSD License. See the COPYING
 /// file in the top level directory.
@@ -110,20 +110,34 @@ void Erat::initAlgorithms(uint64_t maxSieveSize,
   uint64_t minSieveSize = std::min(l1CacheSize, maxSieveSize);
 
   // ================================================================
-  // 2. sieveSize = inBetween(minSieveSize, sqrtStop, maxSieveSize)
+  // 2. sieveSize = sqrt(stop) * FACTOR_SIEVESIZE
+  // ================================================================
+
+  // Using a larger FACTOR_SIEVESIZE increases the segment size
+  // in the sieve of Eratosthenes and hence reduces the number
+  // of operations used by the algorithm. However, as a drawback
+  // a larger segment size is less cache efficient and hence
+  // performance may deteriorate on CPUs with limited L2 cache
+  // bandwidth (especially when using multi-threading).
+  uint64_t sieveSize = uint64_t(sqrtStop * config::FACTOR_SIEVESIZE);
+
+  // ================================================================
+  // 3. L1CacheSize <= sieveSize <= L2CacheSize
   // ================================================================
 
   // For small stop numbers a small sieve array size that
   // matches the CPU's L1 data cache size performs best.
-  // For larger stop numbers a sieve array size that is
-  // within [L1CacheSize, L2CacheSize] usually performs best.
-  uint64_t sieveSize = inBetween(minSieveSize, sqrtStop, maxSieveSize);
+  // For larger stop numbers a sieve array size that is ~
+  // L2CacheSize usually performs best. Hence our sieve size
+  // increases dynamically based on the stop number but it
+  // can never exceed the L2CacheSize (or maxSieveSize).
+  sieveSize = inBetween(minSieveSize, sieveSize, maxSieveSize);
   sieveSize = inBetween(16 << 10, sieveSize, 8192 << 10);
   sieveSize = ceilDiv(sieveSize, sizeof(uint64_t)) * sizeof(uint64_t);
   minSieveSize = std::min(l1CacheSize, sieveSize);
 
   // ================================================================
-  // 3. Initialize upper bounds for EratSmall & EratMedium
+  // 4. Initialize upper bounds for EratSmall & EratMedium
   // ================================================================
 
   // Small sieving primes are processed using the EratSmall
@@ -134,7 +148,7 @@ void Erat::initAlgorithms(uint64_t maxSieveSize,
   maxEratMedium_ = (uint64_t) (sieveSize * config::FACTOR_ERATMEDIUM);
 
   // ================================================================
-  // 4. EratBig requires a power of 2 sieve size
+  // 5. EratBig requires a power of 2 sieve size
   // ================================================================
 
   if (sqrtStop > maxEratMedium_)
@@ -146,14 +160,14 @@ void Erat::initAlgorithms(uint64_t maxSieveSize,
   }
 
   // ================================================================
-  // 5. Ensure we allocate the smallest possible amount of memory
+  // 6. Ensure we allocate the smallest possible amount of memory
   // ================================================================
 
   maxEratSmall_ = std::min(maxEratSmall_, sqrtStop);
   maxEratMedium_ = std::min(maxEratMedium_, sqrtStop);
 
   // ================================================================
-  // 6. Initialize segment bounds
+  // 7. Initialize segment bounds
   // ================================================================
 
   // The 8 bits of each byte of the sieve array correspond to
@@ -168,7 +182,7 @@ void Erat::initAlgorithms(uint64_t maxSieveSize,
   segmentHigh_ = std::min(segmentHigh_, stop_);
 
   // ================================================================
-  // 7. Use tiny sieveSize if possible
+  // 8. Use tiny sieveSize if possible
   // ================================================================
 
   // If we are sieving just a single segment
@@ -184,7 +198,7 @@ void Erat::initAlgorithms(uint64_t maxSieveSize,
   }
 
   // ================================================================
-  // 8. Finally, initialize EratSmall, EratMedium & EratBig
+  // 9. Finally, initialize EratSmall, EratMedium & EratBig
   // ================================================================
 
   ASSERT(sieveSize % sizeof(uint64_t) == 0);