Update carry32 bpw and tune.txt

Author: preda

src/Args.cpp

@@ -278,7 +278,7 @@ void Args::parse(const string& line) {
       log(" FFT         | BPW   | Max exp (M)\n");
       for (const FFTShape& shape : FFTShape::multiSpec(s)) {
         for (u32 variant = 0; variant < FFTConfig::N_VARIANT; ++variant) {
-          FFTConfig fft{shape, variant, FFTConfig::CARRY_AUTO};
+          FFTConfig fft{shape, variant, CARRY_AUTO};
           log("%12s | %.2f | %5.1f\n", fft.spec().c_str(), fft.maxBpw(), fft.maxExp() / 1'000'000.0);
         }
       }

src/FFTConfig.cpp

@@ -112,11 +112,11 @@ FFTShape::FFTShape(const string& w, const string& m, const string& h) :
 double FFTShape::carry32BPW() const {
   // The formula below was validated empirically with -carryTune
 
-  // We observe that FFT 6.5M (1024:13:256) has safe carry32 up to 18.3 BPW
+  // We observe that FFT 6.5M (1024:13:256) has safe carry32 up to 18.35 BPW
   // while the 0.5*log2() models the impact of FFT size changes.
   // We model carry with a Gumbel distrib similar to the one used for ROE, and measure carry with
   // -use STATS=1. See -carryTune
-  return 18.3 + 0.5 * (log2(13 * 1024 * 512) - log2(size()));
+  return 18.35 + 0.5 * (log2(13 * 1024 * 512) - log2(size()));
 }
 
 bool FFTShape::needsLargeCarry(u32 E) const {

src/FFTConfig.h

@@ -47,25 +47,23 @@ class FFTShape {
   bool needsLargeCarry(u32 E) const;
 };
 
+enum CARRY_KIND { CARRY_32=0, CARRY_64=1, CARRY_AUTO=2};
+
 struct FFTConfig {
 public:
   static const u32 N_VARIANT = 4;
   static FFTConfig bestFit(const Args& args, u32 E, const std::string& spec);
 
-  enum CARRY_KIND { CARRY_AUTO, CARRY_32, CARRY_64};
-
   FFTShape shape{};
   u32 variant;
   u32 carry;
 
   explicit FFTConfig(const string& spec);
-  FFTConfig(FFTShape shape, u32 variant, u32 carry /* = CARRY_AUTO*/);
+  FFTConfig(FFTShape shape, u32 variant, u32 carry);
 
   std::string spec() const;
   u32 size() const { return shape.size(); }
   u32 maxExp()  const { return maxBpw() * shape.size(); }
 
   double maxBpw() const;
-
-  // bool needsLargeCarry(u32 E) const { return shape.needsLargeCarry(E); }
 };

src/Gpu.cpp

@@ -188,7 +188,7 @@ string clDefines(const Args& args, cl_device_id id, FFTConfig fft, const vector<
 
   if (isAmdGpu(id)) { defines += toDefine("AMDGPU", 1); }
 
-  if ((fft.carry == FFTConfig::CARRY_AUTO && fft.shape.needsLargeCarry(E)) || (fft.carry == FFTConfig::CARRY_64)) {
+  if ((fft.carry == CARRY_AUTO && fft.shape.needsLargeCarry(E)) || (fft.carry == CARRY_64)) {
     if (doLog) { log("Using CARRY64\n"); }
     defines += toDefine("CARRY64", 1);
   }
@@ -475,7 +475,31 @@ RoeInfo Gpu::readCarryStats() {
   assert(carry.size() == carryPos);
   bufStatsCarry.zero(carryPos);
   carryPos = 0;
-  return roeStat(carry);
+
+  RoeInfo ret = roeStat(carry);
+
+#if 0
+  log("%s\n", ret.toString().c_str());
+
+  std::sort(carry.begin(), carry.end());
+  File fo = File::openAppend("carry.txt");
+  auto it = carry.begin();
+  u32 n = carry.size();
+  u32 c = 0;
+  for (int i=0; i < 500; ++i) {
+    double y = 0.23 + (0.48 - 0.23) / 500 * i;
+    while (it < carry.end() && *it < y) {
+      ++c;
+      ++it;
+    }
+    fo.printf("%f %f\n", y, c / double(n));
+  }
+
+  // for (auto x : carry) { fo.printf("%f\n", x); }
+  fo.printf("\n\n");
+#endif
+
+  return ret;
 }
 
 template<typename T>

src/TuneEntry.cpp

@@ -79,6 +79,6 @@ void TuneEntry::writeTuneFile(const vector<TuneEntry>& results) {
     assert(r.cost >= prevCost && maxExp > prevMaxExp);
     prevCost = r.cost;
     prevMaxExp = maxExp;
-    tune->printf("%6.0f %14s # %u\n", r.cost, r.fft.spec().c_str(), maxExp);
+    tune->printf("%6.1f %14s # %u\n", r.cost, r.fft.spec().c_str(), maxExp);
   }
 }

src/tune.cpp

@@ -162,7 +162,7 @@ void Tune::ztune() {
     double bpw[4];
     double A[4];
     for (u32 variant = 0; variant < FFTConfig::N_VARIANT; ++variant) {
-      FFTConfig fft{shape, variant, FFTConfig::CARRY_AUTO};
+      FFTConfig fft{shape, variant, CARRY_AUTO};
       std::tie(bpw[variant], A[variant]) = maxBpw(fft);
     }
     string s = "\""s + shape.spec() + "\"";
@@ -178,7 +178,7 @@ void Tune::carryTune() {
   shared.args->flags["STATS"] = "1";
   u32 prevSize = 0;
   for (FFTShape shape : FFTShape::multiSpec(shared.args->fftSpec)) {
-    FFTConfig fft{shape, 3, FFTConfig::CARRY_AUTO};
+    FFTConfig fft{shape, 3, CARRY_AUTO};
     if (prevSize == fft.size()) { continue; }
     prevSize = fft.size();
 
@@ -194,7 +194,9 @@ void Tune::carryTune() {
     }
 
     double avg = (zv[0] + zv[1]) / 2;
-    log("%14s %.3f : %.3f (%.3f %.3f) %f\n", fft.spec().c_str(), mid, avg, zv[0], zv[1], m);
+    u32 exponent = fft.shape.carry32BPW() * fft.size();
+    double pErr100 = -expm1(-exp(-avg) * exponent * 100);
+    log("%14s %.3f : %.3f (%.3f %.3f) %f %.0f%%\n", fft.spec().c_str(), mid, avg, zv[0], zv[1], m, pErr100 * 100);
     fo.printf("%f %f\n", log2(fft.size()), avg);
   }
 }
@@ -223,7 +225,7 @@ void Tune::ctune() {
   }
 
   for (FFTShape shape : shapes) {
-    u32 exponent = primes.prevPrime(FFTConfig{shape, 0, FFTConfig::CARRY_AUTO}.maxExp());
+    u32 exponent = primes.prevPrime(FFTConfig{shape, 0, CARRY_AUTO}.maxExp());
     // log("tuning %10s with exponent %u\n", fft.shape.spec().c_str(), exponent);
 
     vector<int> bestPos(configsVect.size());
@@ -240,7 +242,7 @@ void Tune::ctune() {
         for (u32 k = i + 1; k < configsVect.size(); ++k) {
           add(c, configsVect[k][bestPos[k]]);
         }
-        auto cost = Gpu::make(q, exponent, shared, FFTConfig{shape, 0, FFTConfig::CARRY_AUTO}, c, false)->timePRP();
+        auto cost = Gpu::make(q, exponent, shared, FFTConfig{shape, 0, CARRY_AUTO}, c, false)->timePRP();
 
         bool isBest = (cost < best.cost);
         if (isBest) {
@@ -267,28 +269,28 @@ void Tune::tune() {
     double minCost = -1;
 
     // Time an exponent that's good for all variants and carry-config.
-    u32 exponent = primes.prevPrime(FFTConfig{shape, 0, FFTConfig::CARRY_32}.maxExp());
+    u32 exponent = primes.prevPrime(FFTConfig{shape, 0, CARRY_32}.maxExp());
 
     for (u32 variant = 0; variant < FFTConfig::N_VARIANT; ++variant) {
-      vector carryToTest{FFTConfig::CARRY_32};
-      // We need to test both carry-32 and carry-64 only when the carry cutoff BPW is within the range.
-      if (shape.carry32BPW() < FFTConfig{shape, variant, FFTConfig::CARRY_64}.maxBpw()) {
-        carryToTest.push_back(FFTConfig::CARRY_64);
+      vector carryToTest{CARRY_32};
+      // We need to test both carry-32 and carry-64 only when the carry transition is within the BPW range.
+      if (FFTConfig{shape, variant, CARRY_64}.maxBpw() > FFTConfig{shape, variant, CARRY_32}.maxBpw()) {
+        carryToTest.push_back(CARRY_64);
       }
 
       for (auto carry : carryToTest) {
         FFTConfig fft{shape, variant, carry};
 
         if (minCost > 0 && !TuneEntry{minCost, fft}.willUpdate(results)) {
-          log("skipped %s %9u\n", fft.spec().c_str(), fft.maxExp());
+          // log("skipped %s %9u\n", fft.spec().c_str(), fft.maxExp());
           continue;
         }
 
         double cost = Gpu::make(q, exponent, shared, fft, {}, false)->timePRP();
         if (minCost <= 0) { minCost = cost; }
 
         bool isUseful = TuneEntry{cost, fft}.update(results);
-        log("%c %6.0f %12s %9u\n", isUseful ? '*' : ' ', cost, fft.spec().c_str(), fft.maxExp());
+        log("%c %6.1f %12s %9u\n", isUseful ? '*' : ' ', cost, fft.spec().c_str(), fft.maxExp());
       }
     }
   }