Add support for 2D recommend tool

advisor.cpp

@@ -27,16 +27,20 @@ std::vector<Transform const *> *Advisor::recommend(
     Tristate::Tristate isBatched, Tristate::Tristate isFloat,
     Tristate::Tristate isForward, Tristate::Tristate isInPlace,
     Tristate::Tristate isReal, int maxSignalInc, int maxMemory,
-    bool allowTransposition, bool squareOnly, bool crop) {
+    bool disallowRotation, bool allowTransposition, bool disallowSizeOptimization,
+    int countOfOptimizedDimensions, bool squareOnly, bool crop) {
   Validator::validate(device);
   maxMemory = getMaxMemory(device, maxMemory);
-  Validator::validate(x, y, z, n, device, maxSignalInc, maxMemory, allowTransposition, squareOnly);
+  Validator::validate(x, y, z, n, device, maxSignalInc, maxMemory,
+                      countOfOptimizedDimensions, allowTransposition, squareOnly);
   GeneralTransform tr = GeneralTransform(device, x, y, z, n, isBatched, isFloat,
                                          isForward, isInPlace, isReal);
 
-  SizeOptimizer optimizer(CudaVersion::V_8, tr, allowTransposition);
+  SizeOptimizer optimizer(CudaVersion::V_12, tr, allowTransposition);
   std::vector<const Transform *> *result =
-      optimizer.optimize(howMany, maxSignalInc, maxMemory, squareOnly, crop);
+      optimizer.optimize(howMany, maxSignalInc, maxMemory, disallowRotation,
+                         disallowSizeOptimization, countOfOptimizedDimensions,
+                         squareOnly, crop);
   return result;
 }
 
@@ -45,11 +49,13 @@ std::vector<BenchmarkResult const *> *Advisor::find(
     Tristate::Tristate isBatched, Tristate::Tristate isFloat,
     Tristate::Tristate isForward, Tristate::Tristate isInPlace,
     Tristate::Tristate isReal, int maxSignalInc, int maxMemory,
-    bool allowTransposition, bool squareOnly, bool crop) {
+    bool disallowRotation, bool allowTransposition, bool disallowSizeOptimization,
+    int countOfOptimizedDimensions, bool squareOnly, bool crop) {
   std::vector<Transform const *> *candidates =
       recommend(howMany, device, x, y, z, n, isBatched, isFloat, isForward,
-                isInPlace, isReal, maxSignalInc, maxMemory, allowTransposition,
-                squareOnly, crop);
+                isInPlace, isReal, maxSignalInc, maxMemory, disallowRotation,
+                allowTransposition, disallowSizeOptimization,
+                countOfOptimizedDimensions, squareOnly, crop);
   std::vector<BenchmarkResult const *> *result = benchmark(*candidates);
   std::sort(result->begin(), result->end(), BenchmarkResult::execSort);
   delete candidates;
@@ -61,6 +67,11 @@ std::vector<BenchmarkResult const *> *Advisor::benchmark(
   std::vector<BenchmarkResult const *> *results =
       new std::vector<BenchmarkResult const *>();
   int size = transforms.size();
+
+  if (transforms.size() > 0) {
+    Benchmarker::benchmark(transforms.at(0));
+  }
+
   for (int i = 0; i < size; i++) {
     results->push_back(Benchmarker::benchmark(transforms.at(i)));
   }

advisor.h

@@ -25,7 +25,10 @@ class Advisor {
       Tristate::Tristate isInPlace = Tristate::TRUE,
       Tristate::Tristate isReal = Tristate::TRUE, int maxSignalInc = INT_MAX,
       int maxMemory = INT_MAX,
+      bool disallowRotation = false,
       bool allowTransposition = false,
+      bool disallowSizeOptimization = false,
+      int countOfOptimizedDimensions = MaxNumberOfOptimizedDimensions,
       bool squareOnly = false,
       bool crop = false);
 
@@ -37,7 +40,10 @@ class Advisor {
       Tristate::Tristate isInPlace = Tristate::TRUE,
       Tristate::Tristate isReal = Tristate::TRUE, int maxSignalInc = INT_MAX,
       int maxMemory = INT_MAX,
+      bool disallowRotation = false,
       bool allowTransposition = false,
+      bool disallowSizeOptimization = false,
+      int countOfOptimizedDimensions = MaxNumberOfOptimizedDimensions,
       bool squareOnly = false,
       bool crop = false);
 

generalTransform.cpp

@@ -12,7 +12,13 @@ GeneralTransform::GeneralTransform(int device, int X, int Y, int Z, int N,
       X(X),
       Y(Y),
       Z(Z),
+      originalX(X),
+      originalY(Y),
+      originalZ(Z),
       N(N),
+      kernelInvocationX(0),
+      kernelInvocationY(0),
+      kernelInvocationZ(0),
       isBatched(isBatched),
       isFloat(isFloat),
       isForward(isForward),
@@ -25,14 +31,24 @@ GeneralTransform::GeneralTransform(int X, int Y, int Z,
       X(X),
       Y(Y),
       Z(Z),
+      originalX(X),
+      originalY(Y),
+      originalZ(Z),
       N(tr.N),
+      kernelInvocationX(0),
+      kernelInvocationY(0),
+      kernelInvocationZ(0),
       isBatched(tr.isBatched),
       isFloat(tr.isFloat),
       isForward(tr.isForward),
       isInPlace(tr.isInPlace),
       isReal(tr.isReal) {}
 
-GeneralTransform::GeneralTransform(const GeneralTransform &tr) { *this = tr; }
+GeneralTransform::GeneralTransform(const GeneralTransform &tr)
+    : originalX(tr.originalX),
+      originalY(tr.originalY),
+      originalZ(tr.originalZ)
+      { *this = tr; }
 
 GeneralTransform &GeneralTransform::operator=(const GeneralTransform &tr) {
   if (this != &tr) {
@@ -46,6 +62,9 @@ GeneralTransform &GeneralTransform::operator=(const GeneralTransform &tr) {
     this->isForward = tr.isForward;
     this->isInPlace = tr.isInPlace;
     this->isReal = tr.isReal;
+    this->kernelInvocationX = tr.kernelInvocationX;
+    this->kernelInvocationY = tr.kernelInvocationY;
+    this->kernelInvocationZ = tr.kernelInvocationZ;
   }
   return *this;
 }

generalTransform.h

@@ -31,6 +31,15 @@ class GeneralTransform {
   Tristate::Tristate isInPlace;  // otherwise out-of-place
   Tristate::Tristate isReal;     // otherwise C2C
 
+  const int originalX;
+  const int originalY;
+  const int originalZ;
+
+  // number of kernel invocations for selected dimension
+  // the number of kernel invocations is decided separately for each dimension
+  int kernelInvocationX;
+  int kernelInvocationY;
+  int kernelInvocationZ;
 };
 
 }  // namespace cuFFTAdvisor

inputParser.cpp

@@ -21,6 +21,9 @@ InputParser::InputParser(int argc, char **argv) {
   maxSignalInc = parseMaxSignalInc();
   maxMemMB = parseMaxMemMB();
   allowTransposition = parseAllowTransposition();
+  disallowRotation = parseDisallowRotation();
+  disallowSizeOptimization = parseDisallowSizeOptimization();
+  countOfOptimizedDimensions = parseCountOfOptimizedDimensions();
   squareOnly = parseSquareOnly();
   crop = parseCrop();
 }
@@ -58,6 +61,20 @@ int InputParser::parseMaxMemMB() {
   return INT_MAX;
 }
 
+int InputParser::parseCountOfOptimizedDimensions() {
+  for (int i = 0; i < (argc - 1); i++) {
+    if (safeEquals(argv[i], "--countOfOptimizedDimensions")) {
+      if (NULL == argv[i + 1]) {
+        return -1;
+      }
+      int count = atoi(argv[i + 1]);
+      argv[i] = argv[i + 1] = NULL;
+      return count;
+    }
+  }
+  return MaxNumberOfOptimizedDimensions;
+}
+
 bool InputParser::reportUnparsed(FILE *stream) {
   bool error = false;
   if (NULL != stream) {
@@ -195,6 +212,26 @@ bool InputParser::parseAllowTransposition() {
   return false;
 }
 
+bool InputParser::parseDisallowRotation() {
+  for (int i = 0; i < argc; i++) {
+    if (safeEquals(argv[i], "--disallowRotation")) {
+      argv[i] = NULL;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool InputParser::parseDisallowSizeOptimization() {
+  for (int i = 0; i < argc; i++) {
+    if (safeEquals(argv[i], "--disallowSizeOptimization")) {
+      argv[i] = NULL;
+      return true;
+    }
+  }
+  return false;
+}
+
 bool InputParser::parseSquareOnly() {
   for (int i = 0; i < argc; i++) {
     if (safeEquals(argv[i], "--squareOnly")) {

inputParser.h

@@ -19,6 +19,9 @@ class InputParser {
   int maxSignalInc;
   int maxMemMB;
   bool allowTransposition;
+  bool disallowRotation;
+  bool disallowSizeOptimization;
+  int countOfOptimizedDimensions;
   bool squareOnly;
   bool crop;
   Tristate::Tristate isBatched;
@@ -35,6 +38,9 @@ class InputParser {
   int parseMaxSignalInc();
   int parseMaxMemMB();
   bool parseAllowTransposition();
+  bool parseDisallowRotation();
+  bool parseDisallowSizeOptimization();
+  int parseCountOfOptimizedDimensions();
   bool parseSquareOnly();
   bool parseCrop();
   Tristate::Tristate parseIsReal();

main.cpp

@@ -46,6 +46,12 @@ int printHelp() {
                "(swapping dimensions). Prohibited by default. Valid for "
                "'-find' only."
             << std::endl;
+  std::cout << "\t--disallowRotation : consider also rotation of X and Y axes "
+               "(swapping dimensions). Allowed by default."
+            << std::endl;
+  std::cout << "\t--disallowSizeOptimization : disable size optimization by padding/cropping. "
+               "Allowed by default."
+            << std::endl;
   std::cout << "\t--squareOnly : consider only square shapes "
                "(X dimension size will be used as a starting point). "
                "Incompatible with --allowTransposition."
@@ -61,6 +67,9 @@ int printHelp() {
   std::cout << "\t--maxMem MB : max memory (in MB) that transformation can "
                "use, default = device limit"
             << std::endl;
+  std::cout << "\t--countOfOptimizedDimensions COUNT : number of size dimensionsthat will be optimized, "
+               "Default: '3' for 3D signal, '2' for 2D signal, '1' for 1D signal"
+            << std::endl;
   return -1;
 }
 
@@ -109,8 +118,11 @@ int parseRecommend(int argc, char **argv, int howMany) {
             howMany, parser.device, parser.x, parser.y, parser.z, parser.n,
             parser.isBatched, parser.isFloat, parser.isForward,
             parser.isInPlace, parser.isReal, parser.maxSignalInc,
-            parser.maxMemMB, parser.allowTransposition, parser.squareOnly,
-            parser.crop);
+            parser.maxMemMB, parser.disallowRotation,
+            parser.allowTransposition,
+            parser.disallowSizeOptimization,
+            parser.countOfOptimizedDimensions,
+            parser.squareOnly, parser.crop);
 
     cuFFTAdvisor::Transform::printHeader(stdout);
     std::cout << std::endl;
@@ -142,8 +154,10 @@ int parseFind(int argc, char **argv, int howMany) {
                                     parser.isFloat, parser.isForward,
                                     parser.isInPlace, parser.isReal,
                                     parser.maxSignalInc, parser.maxMemMB,
-                                    parser.allowTransposition, parser.squareOnly,
-                                    parser.crop);
+                                    parser.disallowRotation, parser.allowTransposition,
+                                    parser.disallowSizeOptimization,
+                                    parser.countOfOptimizedDimensions,
+                                    parser.squareOnly, parser.crop);
 
     cuFFTAdvisor::BenchmarkResult::printHeader(stdout);
     std::cout << std::endl;