Add -od FFT range overdrive

Author: preda

src/Args.cpp

@@ -134,6 +134,12 @@ named "config.txt" in the prpll run directory.
                      - a list: 256:13:1K,8M
                      See the list of FFTs at the end.
 
+-od <value>        : Overdrive the FFT range (ROE, CARRY32 limits). This allows to use a lower FFT for a given
+                     exponent (thus faster), but increases the risk of errors. The presence of errors is detected,
+                     but the errors are nevertheless costly computationally and better avoided.
+                     A <value> of 1 extends the range by 0.1%% (and this would be acceptable); a value of 10
+                     extends the range by 1%% (and this would be quite too much WRT errors).
+
 -block <value>     : PRP block size, one of: 1000, 500, 200. Default 1000.
 -carry long|short  : force carry type. Short carry may be faster, but requires high bits/word.
 -prp <exponent>    : run a single PRP test and exit, ignoring worktodo.txt
@@ -277,6 +283,9 @@ void Args::parse(const string& line) {
         }
       }
       throw "info";
+    } else if (key == "-od") {
+      double od = stod(s);
+      fftOverdrive = 1 + od / 1000;
     } else if (key == "-tune") {
       assert(s.empty());
       doTune = true;

src/Args.h

@@ -84,6 +84,11 @@ class Args {
 
   u32 iters = 0;
   u32 nSavefiles = 20;
+
+  // Extend the range of the FFTs beyond what's safe WRT ROE and CARRY32.
+  // The FFT will handle up to fft.maxExp() * fftOverdrive
+  // May also take values <1 to lower the max E handled.
+  double fftOverdrive = 1;
 
   void printHelp();
 };

src/FFTConfig.cpp

@@ -1,6 +1,7 @@
 // Copyright (C) Mihai Preda.
 
 #include "FFTConfig.h"
+#include "Args.h"
 #include "common.h"
 #include "log.h"
 #include "TuneEntry.h"
@@ -183,35 +184,25 @@ FFTConfig FFTConfig::bestFit(const Args& args, u32 E, const string& spec) {
   // A FFT-spec was given, simply take the first FFT from the spec that can handle E
   if (!spec.empty()) {
     FFTConfig fft{spec};
-    if (fft.maxExp() < E) {
-      log("%s can not handle %u\n", fft.spec().c_str(), E);
-      throw "FFT size";
+    if (fft.maxExp() * args.fftOverdrive < E) {
+      log("Warning: %s (max %u) may be too small for %u\n", fft.spec().c_str(), fft.maxExp(), E);
     }
     return fft;
-    /*
-    for (const FFTShape& shape : FFTShape::multiSpec(spec)) {
-      for (u32 v = 0; v < N_VARIANT; ++v) {
-        if (FFTConfig fft{shape, v}; fft.maxExp() >= E) { return fft; }
-      }
-    }
-    log("%s can not handle %u\n", spec.c_str(), E);
-    throw "FFT size";
-    */
   }
 
   // No FFT-spec given, so choose from tune.txt the fastest FFT that can handle E
   vector<TuneEntry> tunes = TuneEntry::readTuneFile(args);
   for (const TuneEntry& e : tunes) {
     // The first acceptable is the best as they're sorted by cost
-    if (E <= e.fft.maxExp()) { return e.fft; }
+    if (E <= e.fft.maxExp() * args.fftOverdrive) { return e.fft; }
   }
 
   log("No FFTs found in tune.txt that can handle %u. Consider tuning with -tune\n", E);
 
   // Take the first FFT that can handle E
   for (const FFTShape& shape : FFTShape::allShapes()) {
     for (u32 v = 0; v < 4; ++v) {
-      if (FFTConfig fft{shape, v, CARRY_AUTO}; fft.maxExp() >= E) { return fft; }
+      if (FFTConfig fft{shape, v, CARRY_AUTO}; fft.maxExp() * args.fftOverdrive >= E) { return fft; }
     }
   }
 

src/Gpu.cpp

@@ -315,19 +315,16 @@ Gpu::Gpu(Queue* q, GpuCommon shared, FFTConfig fft, u32 E, const vector<KeyVal>&
   statsBits{u32(args.value("STATS", 0))},
   timeBufVect{profile.make("proofBufVect")}
 {    
-  // Sometimes we do want to run a FFT beyond a reasonable BPW (e.g. during -ztune), and these situations
-  // coincide with logFftSize == false
-  if (logFftSize && fft.maxExp() < E) {
-    log("Exponent %u is too large for FFT %s\n", E, fft.spec().c_str());
-    throw "FFT too small";
-  }
 
   float bitsPerWord = E / float(N);
-  if (logFftSize) { log("FFT: %s %s (%.2f bpw)\n", numberK(N).c_str(), fft.spec().c_str(), bitsPerWord); }
+  if (logFftSize) {
+    log("FFT: %s %s (%.2f bpw)\n", numberK(N).c_str(), fft.spec().c_str(), bitsPerWord);
 
-  if (bitsPerWord > 20) {
-    log("FFT size too small for exponent (%.2f bits/word).\n", bitsPerWord);
-    throw "FFT size too small";
+    // Sometimes we do want to run a FFT beyond a reasonable BPW (e.g. during -ztune), and these situations
+    // coincide with logFftSize == false
+    if (fft.maxExp() < E) {
+      log("Warning: %s (max %u) may be too small for %u\n", fft.spec().c_str(), fft.maxExp(), E);
+    }
   }
 
   if (bitsPerWord < FFTShape::MIN_BPW) {