NFFT Logo 3.2.2
nfft_benchomp.c
00001 /*
00002  * Copyright (c) 2002, 2012 Jens Keiner, Stefan Kunis, Daniel Potts
00003  *
00004  * This program is free software; you can redistribute it and/or modify it under
00005  * the terms of the GNU General Public License as published by the Free Software
00006  * Foundation; either version 2 of the License, or (at your option) any later
00007  * version.
00008  *
00009  * This program is distributed in the hope that it will be useful, but WITHOUT
00010  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00011  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
00012  * details.
00013  *
00014  * You should have received a copy of the GNU General Public License along with
00015  * this program; if not, write to the Free Software Foundation, Inc., 51
00016  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00017  */
00018 #include <stdio.h>
00019 #include <stdlib.h>
00020 #include <string.h>
00021 #include <unistd.h>
00022 
00023 #include "config.h"
00024 
00025 #include <nfft3.h>
00026 #include <nfft3util.h>
00027 
00028 #define NREPEAT 5
00029 
00030 static FILE* file_out_tex = NULL;
00031 
00032 int get_nthreads_array(int **arr)
00033 {
00034   int max_threads = nfft_get_omp_num_threads();
00035   int alloc_num = 2;
00036   int k;
00037   int ret_number = 0;
00038   int max_threads_pw2 = (max_threads / 2) * 2 == max_threads ? 1 : 0;
00039 
00040   if (max_threads <= 5)
00041   {
00042     *arr = (int*) malloc(max_threads*sizeof(int));
00043     for (k = 0; k < max_threads; k++)
00044       *(*arr + k) = k+1;
00045     return max_threads;
00046   }
00047 
00048   for (k = 1; k <= max_threads; k*=2, alloc_num++);
00049 
00050   *arr = (int*) malloc(alloc_num*sizeof(int));
00051 
00052   for (k = 1; k <= max_threads; k*=2)
00053   {
00054     if (k != max_threads && 2*k > max_threads && max_threads_pw2)
00055     {
00056       *(*arr + ret_number) = max_threads/2;
00057       ret_number++;
00058     }
00059 
00060     *(*arr + ret_number) = k;
00061     ret_number++;
00062 
00063     if (k != max_threads && 2*k > max_threads)
00064     {
00065       *(*arr + ret_number) = max_threads;
00066       ret_number++;
00067       break;
00068     }
00069   }
00070 
00071   return ret_number;
00072 } 
00073   
00074 
00075 void check_result_value(const int val, const int ok, const char *msg)
00076 {
00077   if (val != ok)
00078   {
00079     fprintf(stderr, "ERROR %s: %d not %d\n", msg, val, ok);
00080 
00081     exit(1);
00082   }
00083 }
00084 
00085 void run_test_create(int d, int trafo_adjoint, int N, int M, double sigma)
00086 {
00087   char cmd[1025];
00088 
00089   if (d==1)
00090     snprintf(cmd, 1024, "./nfft_benchomp_createdataset %d %d %d %d %lg > nfft_benchomp_test.data", d, trafo_adjoint, N, M, sigma);
00091   else if (d==2)  
00092     snprintf(cmd, 1024, "./nfft_benchomp_createdataset %d %d %d %d %d %lg > nfft_benchomp_test.data", d, trafo_adjoint, N, N, M, sigma);
00093   else if (d==3)  
00094     snprintf(cmd, 1024, "./nfft_benchomp_createdataset %d %d %d %d %d %d %lg > nfft_benchomp_test.data", d, trafo_adjoint, N, N, N, M, sigma);
00095   else if (d==4)  
00096     snprintf(cmd, 1024, "./nfft_benchomp_createdataset %d %d %d %d %d %d %d %lg > nfft_benchomp_test.data", d, trafo_adjoint, N, N, N, N, M, sigma);
00097   else
00098     exit(1);
00099   fprintf(stderr, "%s\n", cmd);
00100   check_result_value(system(cmd), 0, "createdataset");
00101 }
00102 
00103 void run_test_init_output()
00104 {
00105   FILE *f = fopen("nfft_benchomp_test.result", "w");
00106   if (f!= NULL)
00107     fclose(f);
00108 }
00109 
00110 typedef struct
00111 {
00112   int d;
00113   int trafo_adjoint;
00114   int N;
00115   int M;
00116   double sigma;
00117   int m;
00118   int flags;
00119 } s_param;
00120 
00121 typedef struct
00122 {
00123   double avg;
00124   double min;
00125   double max;
00126 } s_resval;
00127 
00128 typedef struct
00129 {
00130   int nthreads;
00131   s_resval resval[6];
00132 } s_result;
00133 
00134 typedef struct
00135 {
00136   s_param param;
00137   s_result *results;
00138   int nresults;
00139 } s_testset;
00140 
00141 void run_test(s_resval *res, int nrepeat, int m, int flags, int nthreads)
00142 {
00143   char cmd[1025];
00144   int r,t;
00145   
00146   for (t = 0; t < 6; t++)
00147   {
00148     res[t].avg = 0.0; res[t].min = 1.0/0.0; res[t].max = 0.0;
00149   }
00150 
00151   if (nthreads < 2)
00152     snprintf(cmd, 1024, "./nfft_benchomp_detail_single %d %d < nfft_benchomp_test.data > nfft_benchomp_test.out", m, flags);
00153   else
00154     snprintf(cmd, 1024, "./nfft_benchomp_detail_threads %d %d %d < nfft_benchomp_test.data > nfft_benchomp_test.out", m, flags, nthreads);
00155   fprintf(stderr, "%s\n", cmd);
00156   check_result_value(system(cmd), 0, cmd);
00157 
00158   for (r = 0; r < nrepeat; r++)
00159   {
00160     int retval;
00161     double v[6];
00162     FILE *f;
00163     check_result_value(system(cmd), 0, cmd);
00164     f = fopen("nfft_benchomp_test.out", "r");
00165     retval = fscanf(f, "%lg %lg %lg %lg %lg %lg", v, v+1, v+2, v+3, v+4, v+5);
00166     check_result_value(retval, 6, "read nfft_benchomp_test.out");
00167     fclose(f);
00168 
00169     for (t = 0; t < 6; t++)
00170     {
00171       res[t].avg += v[t];
00172       if (res[t].min > v[t])
00173         res[t].min = v[t];
00174       if (res[t].max < v[t])
00175         res[t].max = v[t];
00176     }
00177   }
00178 
00179   for (t = 0; t < 6; t++)
00180     res[t].avg /= nrepeat;
00181 
00182   fprintf(stderr, "%d %d: ", nthreads, nrepeat);
00183   for (t = 0; t < 6; t++)
00184     fprintf(stderr, "%.3e %.3e %.3e | ", res[t].avg, res[t].min, res[t].max);
00185   fprintf(stderr, "\n");
00186 }
00187 
00188 const char *get_psi_string(int flags)
00189 {
00190   if (flags & PRE_ONE_PSI)
00191     return "unknownPSI";
00192 
00193   return "nopsi";
00194 }
00195 const char *get_sort_string(int flags)
00196 {
00197   if (flags & NFFT_SORT_NODES)
00198     return "sorted";
00199 
00200     return "unsorted";
00201 }
00202 
00203 const char *get_adjoint_omp_string(int flags)
00204 {
00205   if (flags & NFFT_OMP_BLOCKWISE_ADJOINT)
00206     return "blockwise";
00207 
00208     return "";
00209 }
00210 
00211 #define MASK_D (1U<<0)
00212 #define MASK_TA (1U<<1)
00213 #define MASK_N (1U<<2)
00214 #define MASK_SIGMA (1U<<3)
00215 #define MASK_M (1U<<4)
00216 #define MASK_WINM (1U<<5)
00217 #define MASK_FLAGS_PSI (1U<<6)
00218 #define MASK_FLAGS_SORT (1U<<7)
00219 #define MASK_FLAGS_BW (1U<<8)
00220 
00221 unsigned int determine_different_parameters(s_testset *testsets, int ntestsets)
00222 {
00223   int t;
00224   unsigned int mask = 0;
00225 
00226   if (ntestsets < 2)
00227     return 0;
00228 
00229   for (t = 1; t < ntestsets; t++)
00230   {
00231     if (testsets[t-1].param.d != testsets[t].param.d)
00232       mask |= MASK_D;
00233     if (testsets[t-1].param.trafo_adjoint != testsets[t].param.trafo_adjoint)
00234       mask |= MASK_TA;
00235     if (testsets[t-1].param.N != testsets[t].param.N)
00236       mask |= MASK_N;
00237     if (testsets[t-1].param.sigma != testsets[t].param.sigma)
00238       mask |= MASK_SIGMA;
00239     if (testsets[t-1].param.M != testsets[t].param.M)
00240       mask |= MASK_M;
00241     if (testsets[t-1].param.m != testsets[t].param.m)
00242       mask |= MASK_WINM;
00243     if ((testsets[t-1].param.flags & PRE_ONE_PSI) != (testsets[t].param.flags & PRE_ONE_PSI))
00244       mask |= MASK_FLAGS_PSI;
00245     if ((testsets[t-1].param.flags & NFFT_SORT_NODES) != (testsets[t].param.flags & NFFT_SORT_NODES))
00246       mask |= MASK_FLAGS_SORT;
00247     if ((testsets[t-1].param.flags & NFFT_OMP_BLOCKWISE_ADJOINT) != (testsets[t].param.flags & NFFT_OMP_BLOCKWISE_ADJOINT))
00248       mask |= MASK_FLAGS_BW;
00249   }
00250 
00251   return mask;
00252 }
00253 
00254 void get_plot_title(char *outstr, int maxlen, char *hostname, s_param param, unsigned int diff_mask)
00255 {
00256   unsigned int mask = ~diff_mask;
00257   int offset = 0;
00258   int len;
00259 
00260   len = snprintf(outstr, maxlen, "%s", hostname);
00261   if (len < 0 || len+offset >= maxlen-1) return;
00262   offset += len;
00263 
00264   if (mask & MASK_D)
00265   {
00266     len = snprintf(outstr+offset, maxlen-offset, " %dd", param.d);
00267     if (len < 0 || len+offset >= maxlen-1) return;
00268     offset += len;
00269   }
00270 
00271   if (mask & MASK_TA)
00272   {
00273     len = snprintf(outstr+offset, maxlen-offset, " $\\mathrm{NFFT}%s$", param.trafo_adjoint==0?"":"^\\top");
00274     if (len < 0 || len+offset >= maxlen-1) return;
00275     offset += len;
00276   }
00277 
00278   if (mask & MASK_N)
00279   {
00280     len = snprintf(outstr+offset, maxlen-offset, " N=%d", param.N);
00281     if (len < 0 || len+offset >= maxlen-1) return;
00282     offset += len;
00283   }
00284 
00285   if (mask & MASK_SIGMA)
00286   {
00287     len = snprintf(outstr+offset, maxlen-offset, " N=%g", param.sigma);
00288     if (len < 0 || len+offset >= maxlen-1) return;
00289     offset += len;
00290   }
00291 
00292   if (mask & MASK_M)
00293   {
00294     len = snprintf(outstr+offset, maxlen-offset, " M=%d", param.M);
00295     if (len < 0 || len+offset >= maxlen-1) return;
00296     offset += len;
00297   }
00298 
00299   if (mask & MASK_WINM)
00300   {
00301     len = snprintf(outstr+offset, maxlen-offset, " m=%d", param.m);
00302     if (len < 0 || len+offset >= maxlen-1) return;
00303     offset += len;
00304   }
00305 
00306   if (mask & MASK_FLAGS_PSI)
00307   {
00308     len = snprintf(outstr+offset, maxlen-offset, " %s", get_psi_string(param.flags));
00309     if (len < 0 || len+offset >= maxlen-1) return;
00310     offset += len;
00311   }
00312 
00313   if (mask & MASK_FLAGS_SORT)
00314   {
00315     len = snprintf(outstr+offset, maxlen-offset, " %s", get_sort_string(param.flags));
00316     if (len < 0 || len+offset >= maxlen-1) return;
00317     offset += len;
00318   }
00319 
00320   if ((mask & MASK_FLAGS_BW) && strlen(get_adjoint_omp_string(param.flags)) > 0)
00321   {
00322     len = snprintf(outstr+offset, maxlen-offset, " %s", get_adjoint_omp_string(param.flags));
00323     if (len < 0 || len+offset >= maxlen-1) return;
00324     offset += len;
00325   }
00326 }
00327 
00328 void print_output_speedup_total_tref(FILE *out, s_testset *testsets, int ntestsets, double tref)
00329 {
00330   int i, t;
00331   char hostname[1025];
00332   char plottitle[1025];
00333   unsigned int diff_mask = determine_different_parameters(testsets, ntestsets);
00334 
00335   if (gethostname(hostname, 1024) != 0)
00336     strncpy(hostname, "unnamed", 1024);
00337 
00338   get_plot_title(plottitle, 1024, hostname, testsets[0].param, diff_mask | MASK_FLAGS_SORT);
00339 
00340   fprintf(out, "\\begin{tikzpicture}\n");
00341   fprintf(out, "\\begin{axis}[");
00342   fprintf(out, "width=0.9\\textwidth, height=0.6\\textwidth, x tick label style={ /pgf/number format/1000 sep=}, xlabel=Number of threads, ylabel=Speedup, xtick=data, legend style={ legend pos = north west, legend columns=1}, ymajorgrids=true, yminorgrids=true, minor y tick num=4, ");
00343   fprintf(out, " title={%s}", plottitle);
00344   fprintf(out, " ]\n");
00345 
00346   for (t = 0; t < ntestsets; t++)
00347   {
00348     s_testset testset = testsets[t];
00349     fprintf(stderr, "%s %dd $\\mathrm{NFFT}%s$ N=%d $\\sigma$=%g M=%d m=%d %s %s %s}", hostname, testset.param.d, testset.param.trafo_adjoint==0?"":"^\\top", testset.param.N, testset.param.sigma, testset.param.M, testset.param.m, get_psi_string(testset.param.flags), get_sort_string(testset.param.flags), get_adjoint_omp_string(testset.param.flags));
00350     fprintf(stderr, "\n");
00351 
00352     fprintf(out, "\\addplot coordinates {");
00353     for (i = 0; i < testset.nresults; i++)
00354       fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, tref/testset.results[i].resval[5].avg);
00355     fprintf(out, "};\n");
00356 
00357     for (i = 0; i < testset.nresults; i++)
00358     {
00359       fprintf(stderr, "%d:%.3f  ", testset.results[i].nthreads, tref/testset.results[i].resval[5].avg);
00360     }
00361     fprintf(stderr, "\n\n");
00362   }
00363 
00364   fprintf(out, "\\legend{{");
00365   for (t = 0; t < ntestsets; t++)
00366   {
00367     char title[256];
00368     if (t > 0)
00369       fprintf(out, "},{");
00370     get_plot_title(title, 255, "", testsets[t].param, ~(diff_mask | MASK_FLAGS_SORT));
00371     fprintf(out, "%s", title);
00372   }
00373   fprintf(out, "}}\n");
00374   fprintf(out, "\\end{axis}\n");
00375   fprintf(out, "\\end{tikzpicture}\n");
00376   fprintf(out, "\n\n");
00377 
00378   fflush(out);
00379 }
00380 
00381 void print_output_speedup_total(FILE *out, s_testset *testsets, int ntestsets)
00382 {
00383   double tref = 1.0/0.0;
00384   int t, k;
00385 
00386   for (t = 0; t < ntestsets; t++)
00387     for (k = 0; k < testsets[t].nresults; k++)
00388       if (testsets[t].results[k].nthreads == 1 && testsets[t].results[k].resval[5].avg < tref)
00389         tref = testsets[t].results[k].resval[5].avg;
00390 
00391   print_output_speedup_total_tref(out, testsets, ntestsets, tref);
00392 }
00393 
00394 void print_output_histo_DFBRT(FILE *out, s_testset testset)
00395 {
00396   int i, size = testset.nresults;
00397   char hostname[1025];
00398 
00399   if (gethostname(hostname, 1024) != 0)
00400     strncpy(hostname, "unnamed", 1024);
00401 
00402   fprintf(out, "\\begin{tikzpicture}\n");
00403   fprintf(out, "\\begin{axis}[");
00404   fprintf(out, "width=0.9\\textwidth, height=0.6\\textwidth, ");
00405   fprintf(out, "symbolic x coords={");
00406   for (i = 0; i < size; i++)
00407     if (i > 0)
00408       fprintf(out, ",%d", testset.results[i].nthreads);
00409     else
00410       fprintf(out, "%d", testset.results[i].nthreads);
00411 fprintf(stderr, "FLAGS: %d\n", testset.param.flags);
00412 
00413   fprintf(out, "}, x tick label style={ /pgf/number format/1000 sep=}, xlabel=Number of threads, ylabel=Time in s, xtick=data, legend style={legend columns=-1}, ybar, bar width=7pt, ymajorgrids=true, yminorgrids=true, minor y tick num=1, ");
00414   fprintf(out, " title={%s %dd $\\mathrm{NFFT}%s$ N=%d $\\sigma$=%g M=%d m=%d %s %s %s}", hostname, testset.param.d, testset.param.trafo_adjoint==0?"":"^\\top", testset.param.N, testset.param.sigma, testset.param.M, testset.param.m, get_psi_string(testset.param.flags), get_sort_string(testset.param.flags), get_adjoint_omp_string(testset.param.flags));
00415   fprintf(out, " ]\n");
00416   fprintf(out, "\\addplot coordinates {");
00417   for (i = 0; i < size; i++)
00418     fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, testset.results[i].resval[1].avg);
00419   fprintf(out, "};\n");
00420 
00421   fprintf(out, "\\addplot coordinates {");
00422   for (i = 0; i < size; i++)
00423     fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, testset.results[i].resval[2].avg);
00424   fprintf(out, "};\n");
00425 
00426   fprintf(out, "\\addplot coordinates {");
00427   for (i = 0; i < size; i++)
00428     fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, testset.results[i].resval[3].avg);
00429   fprintf(out, "};\n");
00430 
00431   fprintf(out, "\\addplot coordinates {");
00432   for (i = 0; i < size; i++)
00433     fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, testset.results[i].resval[0].avg + testset.results[i].resval[4].avg);
00434   fprintf(out, "};\n");
00435 
00436   fprintf(out, "\\addplot coordinates {");
00437   for (i = 0; i < size; i++)
00438     fprintf(out, "(%d, %.6e) ", testset.results[i].nthreads, testset.results[i].resval[5].avg);
00439   fprintf(out, "};\n");
00440   fprintf(out, "\\legend{D,F,B,rest,total}\n");
00441   fprintf(out, "\\end{axis}\n");
00442   fprintf(out, "\\end{tikzpicture}\n");
00443   fprintf(out, "\n\n");
00444 
00445   fflush(out);
00446 }
00447 
00448 void run_testset(s_testset *testset, int d, int trafo_adjoint, int N, int M, double sigma, int m, int flags, int *nthreads_array, int n_threads_array_size)
00449 {
00450   int i;
00451   testset->param.d = d;
00452   testset->param.trafo_adjoint = trafo_adjoint;
00453   testset->param.N = N;
00454   testset->param.M = M;
00455   testset->param.sigma = sigma;
00456   testset->param.m = m;
00457   testset->param.flags = flags;
00458 
00459   testset->results = (s_result*) malloc(n_threads_array_size*sizeof(s_result));
00460   testset->nresults = n_threads_array_size;
00461 
00462   run_test_create(testset->param.d, testset->param.trafo_adjoint, testset->param.N, testset->param.M, testset->param.sigma);
00463   for (i = 0; i < n_threads_array_size; i++)
00464   {
00465     testset->results[i].nthreads = nthreads_array[i];
00466     run_test(testset->results[i].resval, NREPEAT, testset->param.m, testset->param.flags, testset->results[i].nthreads = nthreads_array[i]);
00467   }
00468 
00469 }
00470 
00471 void test1(int *nthreads_array, int n_threads_array_size, int m)
00472 {
00473   s_testset testsets[15];
00474 
00475   run_testset(&testsets[0], 1, 0, 2097152, 2097152, 2.0, m, 0, nthreads_array, n_threads_array_size);
00476 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00477   print_output_histo_DFBRT(file_out_tex, testsets[0]);
00478 #endif
00479 
00480   run_testset(&testsets[1], 1, 0, 2097152, 2097152, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00481 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00482   print_output_histo_DFBRT(file_out_tex, testsets[1]);
00483 #endif
00484 
00485   print_output_speedup_total(file_out_tex, testsets, 2);
00486 
00487   run_testset(&testsets[2], 1, 1, 2097152, 2097152, 2.0, m, 0, nthreads_array, n_threads_array_size);
00488 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00489   print_output_histo_DFBRT(file_out_tex, testsets[2]);
00490 #endif
00491 
00492   run_testset(&testsets[3], 1, 1, 2097152, 2097152, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00493 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00494   print_output_histo_DFBRT(file_out_tex, testsets[3]);
00495 #endif
00496 
00497   run_testset(&testsets[4], 1, 1, 2097152, 2097152, 2.0, m, NFFT_SORT_NODES | NFFT_OMP_BLOCKWISE_ADJOINT, nthreads_array, n_threads_array_size);
00498 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00499   print_output_histo_DFBRT(file_out_tex, testsets[4]);
00500 #endif
00501 
00502   print_output_speedup_total(file_out_tex, testsets+2, 3);
00503 
00504   run_testset(&testsets[5], 2, 0, 1024, 1048576, 2.0, m, 0, nthreads_array, n_threads_array_size);
00505 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00506   print_output_histo_DFBRT(file_out_tex, testsets[5]);
00507 #endif
00508 
00509   run_testset(&testsets[6], 2, 0, 1024, 1048576, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00510 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00511   print_output_histo_DFBRT(file_out_tex, testsets[6]);
00512 #endif
00513 
00514   print_output_speedup_total(file_out_tex, testsets+5, 2);
00515 
00516   run_testset(&testsets[7], 2, 1, 1024, 1048576, 2.0, m, 0, nthreads_array, n_threads_array_size);
00517 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00518   print_output_histo_DFBRT(file_out_tex, testsets[7]);
00519 #endif
00520 
00521   run_testset(&testsets[8], 2, 1, 1024, 1048576, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00522 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00523   print_output_histo_DFBRT(file_out_tex, testsets[8]);
00524 #endif
00525 
00526   run_testset(&testsets[9], 2, 1, 1024, 1048576, 2.0, m, NFFT_SORT_NODES | NFFT_OMP_BLOCKWISE_ADJOINT, nthreads_array, n_threads_array_size);
00527 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00528   print_output_histo_DFBRT(file_out_tex, testsets[9]);
00529 #endif
00530 
00531   print_output_speedup_total(file_out_tex, testsets+7, 3);
00532 
00533   run_testset(&testsets[10], 3, 0, 128, 2097152, 2.0, m, 0, nthreads_array, n_threads_array_size);
00534 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00535   print_output_histo_DFBRT(file_out_tex, testsets[10]);
00536 #endif
00537 
00538   run_testset(&testsets[11], 3, 0, 128, 2097152, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00539 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00540   print_output_histo_DFBRT(file_out_tex, testsets[11]);
00541 #endif
00542 
00543   print_output_speedup_total(file_out_tex, testsets+10, 2);
00544 
00545   run_testset(&testsets[12], 3, 1, 128, 2097152, 2.0, m, 0, nthreads_array, n_threads_array_size);
00546 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00547   print_output_histo_DFBRT(file_out_tex, testsets[12]);
00548 #endif
00549 
00550   run_testset(&testsets[13], 3, 1, 128, 2097152, 2.0, m, NFFT_SORT_NODES, nthreads_array, n_threads_array_size);
00551 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00552   print_output_histo_DFBRT(file_out_tex, testsets[13]);
00553 #endif
00554 
00555   run_testset(&testsets[14], 3, 1, 128, 2097152, 2.0, m, NFFT_SORT_NODES | NFFT_OMP_BLOCKWISE_ADJOINT, nthreads_array, n_threads_array_size);
00556 #if defined MEASURE_TIME && defined MEASURE_TIME_FFTW
00557   print_output_histo_DFBRT(file_out_tex, testsets[14]);
00558 #endif
00559 
00560   print_output_speedup_total(file_out_tex, testsets+12, 3);
00561 
00562 }
00563 
00564 int main(int argc, char** argv)
00565 {
00566   int *nthreads_array;
00567   int n_threads_array_size = get_nthreads_array(&nthreads_array);
00568   int k;
00569 
00570 #if !(defined MEASURE_TIME && defined MEASURE_TIME_FFTW)
00571   fprintf(stderr, "WARNING: Detailed time measurements for NFFT are not activated.\n");
00572   fprintf(stderr, "For more detailed plots, please re-run the configure script with options\n");
00573   fprintf(stderr, "--enable-measure-time --enable-measure-time-fftw --enable-openmp\n");
00574   fprintf(stderr, "and run \"make clean all\"\n\n");
00575 #endif
00576 
00577   for (k = 0; k < n_threads_array_size; k++)
00578     fprintf(stderr, "%d ", nthreads_array[k]);
00579   fprintf(stderr, "\n");
00580 
00581   file_out_tex = fopen("nfft_benchomp_results_plots.tex", "w");
00582 
00583   test1(nthreads_array, n_threads_array_size, 2);
00584   test1(nthreads_array, n_threads_array_size, 4);
00585   test1(nthreads_array, n_threads_array_size, 6);
00586 
00587   fclose(file_out_tex);
00588 
00589   return 0;
00590 }

Generated on Fri Oct 12 2012 by Doxygen 1.8.0-20120409