Add 2D DFT benchmark tool (#656)

* This patch adds support for 2D DFT benchmarking while fixing small bugs.

Author: shibatch

src/dft-tester/CMakeLists.txt

@@ -87,12 +87,22 @@ endif()
 set(TARGET_TEST_DFTPLANNER "test_dftplanner")
 add_executable(${TARGET_TEST_DFTPLANNER} test_dftplanner.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
 add_dependencies(${TARGET_TEST_DFTPLANNER} ${TARGET_HEADERS} ${TARGET_LIBSLEEF} ${TARGET_LIBDFT})
-target_compile_definitions(${TARGET_TEST_DFTPLANNER} PRIVATE ${COMMON_TARGET_DEFINITIONS})
+target_compile_definitions(${TARGET_TEST_DFTPLANNER} PRIVATE ${COMMON_TARGET_DEFINITIONS} MEASURE=1)
 target_link_libraries(${TARGET_TEST_DFTPLANNER} ${COMMON_LINK_LIBRARIES})
 set_target_properties(${TARGET_TEST_DFTPLANNER} PROPERTIES ${COMMON_TARGET_PROPERTIES})
 add_test(NAME ${TARGET_TEST_DFTPLANNER} COMMAND $<TARGET_FILE:${TARGET_TEST_DFTPLANNER}> ${PROJECT_BINARY_DIR}/test.plan)
 set_tests_properties(${TARGET_TEST_DFTPLANNER} PROPERTIES COST 2)
 
+# Target executable test_dftplannerest
+set(TARGET_TEST_DFTPLANNEREST "test_dftplannerest")
+add_executable(${TARGET_TEST_DFTPLANNEREST} test_dftplanner.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
+add_dependencies(${TARGET_TEST_DFTPLANNEREST} ${TARGET_HEADERS} ${TARGET_LIBSLEEF} ${TARGET_LIBDFT})
+target_compile_definitions(${TARGET_TEST_DFTPLANNEREST} PRIVATE ${COMMON_TARGET_DEFINITIONS})
+target_link_libraries(${TARGET_TEST_DFTPLANNEREST} ${COMMON_LINK_LIBRARIES})
+set_target_properties(${TARGET_TEST_DFTPLANNEREST} PROPERTIES ${COMMON_TARGET_PROPERTIES})
+add_test(NAME ${TARGET_TEST_DFTPLANNEREST} COMMAND $<TARGET_FILE:${TARGET_TEST_DFTPLANNEREST}> ${PROJECT_BINARY_DIR}/test.plan)
+set_tests_properties(${TARGET_TEST_DFTPLANNEREST} PROPERTIES COST 2)
+
 # Target executable roundtriptest1ddp
 set(TARGET_ROUNDTRIPTEST1DDP "roundtriptest1ddp")
 add_executable(${TARGET_ROUNDTRIPTEST1DDP} roundtriptest1d.c ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
@@ -181,21 +191,31 @@ if (LIBFFTW3 AND NOT SLEEF_DISABLE_FFTW)
   add_test_dft(${TARGET_FFTWTEST2DSP}_5_15 $<TARGET_FILE:${TARGET_FFTWTEST2DSP}> 5 15)
 
   if (SLEEF_LIBFFTW3_LIBRARIES)
-    # Target executable dftbench1ddp
-    set(TARGET_BENCH1DDP "dftbench1ddp")
-    add_executable(${TARGET_BENCH1DDP} bench1d.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
+    # Target executable dftbenchdp
+    set(TARGET_BENCH1DDP "dftbenchdp")
+    add_executable(${TARGET_BENCH1DDP} dftbench.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
     add_dependencies(${TARGET_BENCH1DDP} ${TARGET_HEADERS} ${TARGET_LIBSLEEF} ${TARGET_LIBDFT})
     target_compile_definitions(${TARGET_BENCH1DDP} PRIVATE ${COMMON_TARGET_DEFINITIONS} BASETYPEID=1)
     target_link_libraries(${TARGET_BENCH1DDP} ${COMMON_LINK_LIBRARIES} ${SLEEF_LIBFFTW3_LIBRARIES})
     set_target_properties(${TARGET_BENCH1DDP} PROPERTIES ${COMMON_TARGET_PROPERTIES})
 
-    # Target executable dftbench1dsp
-    set(TARGET_BENCH1DSP "dftbench1dsp")
-    add_executable(${TARGET_BENCH1DSP} bench1d.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
+    #add_test_dft("dftbenchdp1d" $<TARGET_FILE:${TARGET_BENCH1DDP}> 8 0 1000 1)
+    #set_tests_properties("dftbenchdp1d" PROPERTIES COST 3)
+    add_test_dft("dftbenchdp2d" $<TARGET_FILE:${TARGET_BENCH1DDP}> 8 8 1000 1)
+    set_tests_properties("dftbenchdp2d" PROPERTIES COST 3)
+
+    # Target executable dftbenchsp
+    set(TARGET_BENCH1DSP "dftbenchsp")
+    add_executable(${TARGET_BENCH1DSP} dftbench.cpp ${PROJECT_SOURCE_DIR}/include/sleefdft.h)
     add_dependencies(${TARGET_BENCH1DSP} ${TARGET_HEADERS} ${TARGET_LIBSLEEF} ${TARGET_LIBDFT})
     target_compile_definitions(${TARGET_BENCH1DSP} PRIVATE ${COMMON_TARGET_DEFINITIONS} BASETYPEID=2)
     target_link_libraries(${TARGET_BENCH1DSP} ${COMMON_LINK_LIBRARIES} ${SLEEF_LIBFFTW3_LIBRARIES})
     set_target_properties(${TARGET_BENCH1DSP} PROPERTIES ${COMMON_TARGET_PROPERTIES})
+
+    #add_test_dft("dftbenchsp1d" $<TARGET_FILE:${TARGET_BENCH1DSP}> 8 0 1000 1)
+    #set_tests_properties("dftbenchsp1d" PROPERTIES COST 3)
+    add_test_dft("dftbenchsp2d" $<TARGET_FILE:${TARGET_BENCH1DSP}> 8 8 1000 1)
+    set_tests_properties("dftbenchsp2d" PROPERTIES COST 3)
   endif()
 else(LIBFFTW3 AND NOT SLEEF_DISABLE_FFTW)
   if(MSVC OR SLEEF_CLANG_ON_WINDOWS)

src/dft-tester/bench1d.cpp src/dft-tester/dftbench.cppsrc/dft-tester/bench1d.cpp renamed to src/dft-tester/dftbench.cpp

@@ -33,9 +33,12 @@ typedef double xreal;
 #define FFTW_MALLOC fftw_malloc
 #define FFTW_FREE fftw_free
 #define FFTW_PLAN_DFT_1D fftw_plan_dft_1d
+#define FFTW_PLAN_DFT_2D fftw_plan_dft_2d
 #define FFTW_EXECUTE fftw_execute
 #define FFTW_DESTROY_PLAN fftw_destroy_plan
+#define FFTW_CLEANUP fftw_cleanup
 #define SLEEFDFT_INIT1D SleefDFT_double_init1d
+#define SLEEFDFT_INIT2D SleefDFT_double_init2d
 #elif BASETYPEID == 2
 typedef float xreal;
 #define FFTW_COMPLEX fftwf_complex
@@ -44,9 +47,12 @@ typedef float xreal;
 #define FFTW_MALLOC fftwf_malloc
 #define FFTW_FREE fftwf_free
 #define FFTW_PLAN_DFT_1D fftwf_plan_dft_1d
+#define FFTW_PLAN_DFT_2D fftwf_plan_dft_2d
 #define FFTW_EXECUTE fftwf_execute
 #define FFTW_DESTROY_PLAN fftwf_destroy_plan
+#define FFTW_CLEANUP fftwf_cleanup
 #define SLEEFDFT_INIT1D SleefDFT_float_init1d
+#define SLEEFDFT_INIT2D SleefDFT_float_init2d
 #else
 #error BASETYPEID not set
 #endif
@@ -75,31 +81,44 @@ class FFTFramework {
       niter *= 2;
     }
 
-    return (double)niter * ns / (t1 - t0);
+    return 1 + int64_t((double)niter * ns / (t1 - t0));
   }
 };
 
 template<typename cplx>
 class FWSleefDFT : public FFTFramework<cplx> {
-  const int n;
+  const int n, m;
   cplx* in;
   cplx* out;
   SleefDFT *plan;
 
 public:
-  FWSleefDFT(int n_, bool forward, bool mt=false) : n(n_) {
+  FWSleefDFT(int n_, int m_, bool forward, bool mt, bool check) : n(n_), m(m_) {
     SleefDFT_setDefaultVerboseFP(stderr);
     SleefDFT_setPlanFilePath(NULL, NULL, SLEEF_PLAN_RESET);
-    in  = (cplx*)Sleef_malloc(sizeof(cplx) * n);
-    out = (cplx*)Sleef_malloc(sizeof(cplx) * n);
-    plan = SLEEFDFT_INIT1D(n, (xreal*)in, (xreal*)out,
-      (forward ? SLEEF_MODE_FORWARD : SLEEF_MODE_BACKWARD) | SLEEF_MODE_MEASURE /* | SLEEF_MODE_VERBOSE*/ | (mt ? 0 : SLEEF_MODE_NO_MT));
-    vector<char> pathstr(1024);
-    SleefDFT_getPath(plan, pathstr.data(), pathstr.size());
-    cerr << pathstr.data() << endl;
+    in  = (cplx*)Sleef_malloc(sizeof(cplx) * n * m);
+    out = (cplx*)Sleef_malloc(sizeof(cplx) * n * m);
+
+    uint64_t mode = check ? SLEEF_MODE_ESTIMATE : SLEEF_MODE_MEASURE;
+    mode |= forward ? SLEEF_MODE_FORWARD : SLEEF_MODE_BACKWARD;
+    mode |= mt ? 0 : SLEEF_MODE_NO_MT;
+    //mode |= SLEEF_MODE_VERBOSE;
+
+    if (m == 1) {
+      plan = SLEEFDFT_INIT1D(n, (xreal*)in, (xreal*)out, mode);
+      vector<char> pathstr(1024);
+      SleefDFT_getPath(plan, pathstr.data(), pathstr.size());
+      cerr << pathstr.data() << endl;
+    } else {
+      plan = SLEEFDFT_INIT2D(n, m, (xreal*)in, (xreal*)out, mode);
+    }
   }
 
-  ~FWSleefDFT() { SleefDFT_dispose(plan); }
+  ~FWSleefDFT() {
+    SleefDFT_dispose(plan);
+    Sleef_free(out);
+    Sleef_free(in);
+  }
 
   cplx* getInPtr () { return in ; }
   cplx* getOutPtr() { return out; }
@@ -109,18 +128,23 @@ class FWSleefDFT : public FFTFramework<cplx> {
 
 template<typename cplx>
 class FWFFTW3 : public FFTFramework<cplx> {
-  const int n;
+  const int n, m;
   cplx* in;
   cplx* out;
   FFTW_PLAN plan;
 
 public:
-  FWFFTW3(int n_, bool forward, bool mt=false) : n(n_) {
+  FWFFTW3(int n_, int m_, bool forward, bool mt, bool check) : n(n_), m(m_) {
+    //FFTW_CLEANUP();
     FFTW_PLAN_WITH_NTHREADS(mt ? omp_get_max_threads() : 1);
-    in  = (cplx*)FFTW_MALLOC(sizeof(FFTW_COMPLEX) * n);
-    out = (cplx*)FFTW_MALLOC(sizeof(FFTW_COMPLEX) * n);
-    plan = FFTW_PLAN_DFT_1D(n, (FFTW_COMPLEX*)in, (FFTW_COMPLEX*)out,
-			    forward ? FFTW_FORWARD : FFTW_BACKWARD, FFTW_MEASURE);
+    in  = (cplx*)FFTW_MALLOC(sizeof(FFTW_COMPLEX) * n * m);
+    out = (cplx*)FFTW_MALLOC(sizeof(FFTW_COMPLEX) * n * m);
+    unsigned flags = check ? FFTW_ESTIMATE : FFTW_MEASURE;
+    if (m == 1) {
+      plan = FFTW_PLAN_DFT_1D(n, (FFTW_COMPLEX*)in, (FFTW_COMPLEX*)out, forward ? FFTW_FORWARD : FFTW_BACKWARD, flags);
+    } else {
+      plan = FFTW_PLAN_DFT_2D(n, m, (FFTW_COMPLEX*)in, (FFTW_COMPLEX*)out, forward ? FFTW_FORWARD : FFTW_BACKWARD, flags);
+    }
   }
 
   ~FWFFTW3() {
@@ -137,78 +161,83 @@ class FWFFTW3 : public FFTFramework<cplx> {
 
 int main(int argc, char **argv) {
   if (argc == 1) {
-    fprintf(stderr, "%s <log2n> <plan file name> <plan string>\n", argv[0]);
+    fprintf(stderr, "%s <log2n> <log2m> <measurement time in ms> <nrepeat>\n", argv[0]);
     exit(-1);
   }
 
   fftw_init_threads();
 
   double measureTimeMillis = 3000;
+  if (argc >= 4) measureTimeMillis = atof(argv[3]);
 
-  int backward = 0;
+  bool forward = true;
 
   int log2n = atoi(argv[1]);
   if (log2n < 0) {
-    backward = 1;
+    forward = false;
     log2n = -log2n;
   }
 
   const int n = 1 << log2n;
-  const int nrepeat = 8;
+
+  const int log2m = argc >= 3 ? atoi(argv[2]) : 0;
+  const int m = 1 << log2m;
+
+  cerr << "n = " << n << ", m = " << m << ", " << (forward ? "forward" : "backward") << endl;
+
+  const int nrepeat = argc >= 5 ? atoi(argv[4]) : 4;
 
   vector<double> mflops_sleefdftst, mflops_fftwst, mflops_sleefdftmt, mflops_fftwmt;
 
-#ifdef CHECK
+  vector<complex<xreal>> v(n * m);
+  for(int i=0;i<n * m;i++) {
+    v[i] = (2.0 * (rand() / (double)RAND_MAX) - 1) + (2.0 * (rand() / (double)RAND_MAX) - 1) * 1i;
+  }
+
   {
-    // Test if we are really computing the same values
+    // Check if we are really computing the same values
 
-    auto sleefdft = make_shared<FWSleefDFT<complex<xreal>>>(n, true);
-    auto fftw     = make_shared<FWFFTW3   <complex<xreal>>>(n, true);
+    auto sleefdft = make_shared<FWSleefDFT<complex<xreal>>>(n, m, forward, false, true);
+    auto fftw     = make_shared<FWFFTW3   <complex<xreal>>>(n, m, forward, false, true);
 
     complex<xreal> *in0  = sleefdft->getInPtr();
     complex<xreal> *out0 = sleefdft->getOutPtr();
     complex<xreal> *in1  = fftw->getInPtr();
     complex<xreal> *out1 = fftw->getOutPtr();
 
-    for(int i=0;i<n;i++) {
-      in0[i] = in1[i] = (2.0 * (rand() / (double)RAND_MAX) - 1) + (2.0 * (rand() / (double)RAND_MAX) - 1) * 1i;
-    }
+    for(int i=0;i<n * m;i++) in0[i] = in1[i] = v[i];
 
     sleefdft->execute();
     fftw    ->execute();
 
-    for(int i=0;i<n;i++) {
+    for(int i=0;i<n * m;i++) {
       if (std::real(abs((out0[i] - out1[i]) * (out0[i] - out1[i]))) > 0.1) {
 	cerr << "NG " << i << " : " << out0[i] << ", " << out1[i] << endl;
 	exit(-1);
       }
     }
+
+    cerr << "Check OK" << endl;
   }
-#endif
 
   for(int nr = 0;nr < nrepeat;nr++) {
-    cerr << endl << "n = " << n << "(" << log2n << "), nr = " << nr << endl;
-
-    cerr << "Planning SleefDFT ST" << endl;
-    auto sleefdftst = make_shared<FWSleefDFT<complex<xreal>>>(n, true, false);
-    cerr << "Planning FFTW ST" << endl;
-    auto fftwst     = make_shared<FWFFTW3   <complex<xreal>>>(n, true, false);
-    cerr << "Planning SleefDFT MT" << endl;
-    auto sleefdftmt = make_shared<FWSleefDFT<complex<xreal>>>(n, true, true);
-    cerr << "Planning FFTW MT" << endl;
-    auto fftwmt     = make_shared<FWFFTW3   <complex<xreal>>>(n, true, true);
-    cerr << "Planning done" << endl;
-
-    complex<xreal> *in0  = sleefdftst->getInPtr();
-    complex<xreal> *in1  = fftwst->getInPtr();
-
-    for(int i=0;i<n;i++) {
-      in0[i] = in1[i] = (2.0 * (rand() / (double)RAND_MAX) - 1) + (2.0 * (rand() / (double)RAND_MAX) - 1) * 1i;
-    }
+    cerr << endl;
+#if BASETYPEID == 1
+    cerr << "DP ";
+#elif BASETYPEID == 2
+    cerr << "SP ";
+#endif
+    cerr << "n = 2^" << log2n << " = " << n << ", m = 2^" << log2m << " = " << m << ", nr = " << nr << endl;
 
     //
 
     {
+      cerr << "Planning SleefDFT ST" << endl;
+      auto sleefdftst = make_shared<FWSleefDFT<complex<xreal>>>(n, m, forward, false, false);
+
+      complex<xreal> *in0  = sleefdftst->getInPtr();
+      for(int i=0;i<n * m;i++) in0[i] = v[i];
+
       auto niter = sleefdftst->niter(1000LL * 1000 * measureTimeMillis);
 
       cerr << "SleefDFT ST niter = " << niter << endl;
@@ -220,6 +249,7 @@ int main(int argc, char **argv) {
       int64_t tm1 = timens();
 
       double mflops = 5 * n * log2n / ((tm1 - tm0) / (double(niter)*1000));
+      if (m != 1) mflops *= m * log2m;
 
       fprintf(stderr, "%g Mflops\n", mflops);
 
@@ -229,6 +259,12 @@ int main(int argc, char **argv) {
     //
 
     {
+      cerr << "Planning FFTW ST" << endl;
+      auto fftwst = make_shared<FWFFTW3<complex<xreal>>>(n, m, forward, false, false);
+
+      complex<xreal> *in0  = fftwst->getInPtr();
+      for(int i=0;i<n * m;i++) in0[i] = v[i];
+
       auto niter  = fftwst->niter(1000LL * 1000 * measureTimeMillis);
 
       cerr << "FFTW ST niter = " << niter << endl;
@@ -240,6 +276,7 @@ int main(int argc, char **argv) {
       int64_t tm1 = timens();
 
       double mflops = 5 * n * log2n / ((tm1 - tm0) / (double(niter)*1000));
+      if (m != 1) mflops *= m * log2m;
 
       fprintf(stderr, "%g Mflops\n", mflops);
 
@@ -249,6 +286,12 @@ int main(int argc, char **argv) {
     //
 
     {
+      cerr << "Planning SleefDFT MT" << endl;
+      auto sleefdftmt = make_shared<FWSleefDFT<complex<xreal>>>(n, m, forward, true, false);
+
+      complex<xreal> *in0  = sleefdftmt->getInPtr();
+      for(int i=0;i<n * m;i++) in0[i] = v[i];
+
       auto niter = sleefdftmt->niter(1000LL * 1000 * measureTimeMillis);
 
       cerr << "SleefDFT MT niter = " << niter << endl;
@@ -260,6 +303,7 @@ int main(int argc, char **argv) {
       int64_t tm1 = timens();
 
       double mflops = 5 * n * log2n / ((tm1 - tm0) / (double(niter)*1000));
+      if (m != 1) mflops *= m * log2m;
 
       fprintf(stderr, "%g Mflops\n", mflops);
 
@@ -269,6 +313,12 @@ int main(int argc, char **argv) {
     //
 
     {
+      cerr << "Planning FFTW MT" << endl;
+      auto fftwmt = make_shared<FWFFTW3<complex<xreal>>>(n, m, forward, true, false);
+
+      complex<xreal> *in0  = fftwmt->getInPtr();
+      for(int i=0;i<n * m;i++) in0[i] = v[i];
+
       auto niter  = fftwmt->niter(1000LL * 1000 * measureTimeMillis);
 
       cerr << "FFTW MT niter = " << niter << endl;
@@ -280,14 +330,15 @@ int main(int argc, char **argv) {
       int64_t tm1 = timens();
 
       double mflops = 5 * n * log2n / ((tm1 - tm0) / (double(niter)*1000));
+      if (m != 1) mflops *= m * log2m;
 
       fprintf(stderr, "%g Mflops\n", mflops);
 
       mflops_fftwmt.push_back(mflops);
     }
   }
 
-  cout << log2n << ", ";
+  cout << log2n << ", " << log2m << ", ";
 
   {
     double f = 0;

src/dft-tester/test_dftplanner.cpp

@@ -31,10 +31,18 @@ int main(int argc, char **argv) {
   float *fin  = (float *)Sleef_malloc(1024*2 * sizeof(double));
   float *fout = (float *)Sleef_malloc(1024*2 * sizeof(double));
 
+#ifdef MEASURE
 #ifdef MULTITHREAD
   int mode = SLEEF_MODE_MEASURE | SLEEF_MODE_VERBOSE;
 #else
   int mode = SLEEF_MODE_MEASURE | SLEEF_MODE_VERBOSE | SLEEF_MODE_NO_MT;
+#endif
+#else
+#ifdef MULTITHREAD
+  int mode = SLEEF_MODE_ESTIMATE | SLEEF_MODE_VERBOSE;
+#else
+  int mode = SLEEF_MODE_ESTIMATE | SLEEF_MODE_VERBOSE | SLEEF_MODE_NO_MT;
+#endif
 #endif
 
   SleefDFT *p;