00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
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 }