cannam@127: /* fftw hook to be used in the benchmark program.  
cannam@127:    
cannam@127:    We keep it in a separate file because 
cannam@127: 
cannam@127:    1) bench.c is supposed to test the API---we do not want to #include
cannam@127:       "ifftw.h" and accidentally use internal symbols/macros.
cannam@127:    2) this code is a royal mess.  The messiness is due to
cannam@127:       A) confusion between internal fftw tensors and bench_tensor's
cannam@127:          (which we want to keep separate because the benchmark
cannam@127: 	  program tests other routines too)
cannam@127:       B) despite A), our desire to recycle the libbench verifier.
cannam@127: */
cannam@127: 
cannam@127: #include <stdio.h>
cannam@127: #include "bench-user.h"
cannam@127: 
cannam@127: #define CALLING_FFTW /* hack for Windows DLL nonsense */
cannam@127: #include "api.h"
cannam@127: #include "dft.h"
cannam@127: #include "rdft.h"
cannam@127: 
cannam@127: extern int paranoid; /* in bench.c */
cannam@127: extern X(plan) the_plan; /* in bench.c */
cannam@127: 
cannam@127: /*
cannam@127:   transform an fftw tensor into a bench_tensor.
cannam@127: */
cannam@127: static bench_tensor *fftw_tensor_to_bench_tensor(tensor *t)
cannam@127: {
cannam@127:      bench_tensor *bt = mktensor(t->rnk);
cannam@127: 
cannam@127:      if (FINITE_RNK(t->rnk)) {
cannam@127: 	  int i;
cannam@127: 	  for (i = 0; i < t->rnk; ++i) {
cannam@127: 	       /* FIXME: 64-bit unclean because of INT -> int conversion */
cannam@127: 	       bt->dims[i].n = t->dims[i].n;
cannam@127: 	       bt->dims[i].is = t->dims[i].is;
cannam@127: 	       bt->dims[i].os = t->dims[i].os;
cannam@127: 	       BENCH_ASSERT(bt->dims[i].n == t->dims[i].n);
cannam@127: 	       BENCH_ASSERT(bt->dims[i].is == t->dims[i].is);
cannam@127: 	       BENCH_ASSERT(bt->dims[i].os == t->dims[i].os);
cannam@127: 	  }
cannam@127:      }
cannam@127:      return bt;
cannam@127: }
cannam@127: 
cannam@127: /*
cannam@127:   transform an fftw problem into a bench_problem.
cannam@127: */
cannam@127: static bench_problem *fftw_problem_to_bench_problem(planner *plnr,
cannam@127: 						    const problem *p_)
cannam@127: {
cannam@127:      bench_problem *bp = 0;
cannam@127:      switch (p_->adt->problem_kind) {
cannam@127: 	 case PROBLEM_DFT:
cannam@127: 	 {
cannam@127: 	      const problem_dft *p = (const problem_dft *) p_;
cannam@127: 	  
cannam@127: 	      if (!p->ri || !p->ii)
cannam@127: 		   abort();
cannam@127: 
cannam@127: 	      bp = (bench_problem *) bench_malloc(sizeof(bench_problem));
cannam@127: 
cannam@127: 	      bp->kind = PROBLEM_COMPLEX;
cannam@127: 	      bp->sign = FFT_SIGN;
cannam@127: 	      bp->split = 1; /* tensor strides are in R's, not C's */
cannam@127: 	      bp->in = UNTAINT(p->ri);
cannam@127: 	      bp->out = UNTAINT(p->ro);
cannam@127: 	      bp->ini = UNTAINT(p->ii);
cannam@127: 	      bp->outi = UNTAINT(p->io);
cannam@127: 	      bp->inphys = bp->outphys = 0;
cannam@127: 	      bp->iphyssz = bp->ophyssz = 0;
cannam@127: 	      bp->in_place = p->ri == p->ro;
cannam@127: 	      bp->sz = fftw_tensor_to_bench_tensor(p->sz);
cannam@127: 	      bp->vecsz = fftw_tensor_to_bench_tensor(p->vecsz);
cannam@127: 	      bp->k = 0;
cannam@127: 	      break;
cannam@127: 	 }
cannam@127: 	 case PROBLEM_RDFT:
cannam@127: 	 {
cannam@127: 	      const problem_rdft *p = (const problem_rdft *) p_;
cannam@127: 	      int i;
cannam@127: 
cannam@127: 	      if (!p->I || !p->O)
cannam@127: 		   abort();
cannam@127: 
cannam@127: 	      for (i = 0; i < p->sz->rnk; ++i)
cannam@127: 		   switch (p->kind[i]) {
cannam@127: 		       case R2HC01:
cannam@127: 		       case R2HC10:
cannam@127: 		       case R2HC11:
cannam@127: 		       case HC2R01:
cannam@127: 		       case HC2R10:
cannam@127: 		       case HC2R11:
cannam@127: 			    return bp;
cannam@127: 		       default:
cannam@127: 			    ;
cannam@127: 		   }
cannam@127: 	  
cannam@127: 	      bp = (bench_problem *) bench_malloc(sizeof(bench_problem));
cannam@127: 
cannam@127: 	      bp->kind = PROBLEM_R2R;
cannam@127: 	      bp->sign = FFT_SIGN;
cannam@127: 	      bp->split = 0;
cannam@127: 	      bp->in = UNTAINT(p->I);
cannam@127: 	      bp->out = UNTAINT(p->O);
cannam@127: 	      bp->ini = bp->outi = 0;
cannam@127: 	      bp->inphys = bp->outphys = 0;
cannam@127: 	      bp->iphyssz = bp->ophyssz = 0;
cannam@127: 	      bp->in_place = p->I == p->O;
cannam@127: 	      bp->sz = fftw_tensor_to_bench_tensor(p->sz);
cannam@127: 	      bp->vecsz = fftw_tensor_to_bench_tensor(p->vecsz);
cannam@127: 	      bp->k = (r2r_kind_t *) bench_malloc(sizeof(r2r_kind_t) * p->sz->rnk);
cannam@127: 	      for (i = 0; i < p->sz->rnk; ++i)
cannam@127: 		   switch (p->kind[i]) {
cannam@127: 		       case R2HC: bp->k[i] = R2R_R2HC; break;
cannam@127: 		       case HC2R: bp->k[i] = R2R_HC2R; break;
cannam@127: 		       case DHT: bp->k[i] = R2R_DHT; break;
cannam@127: 		       case REDFT00: bp->k[i] = R2R_REDFT00; break;
cannam@127: 		       case REDFT01: bp->k[i] = R2R_REDFT01; break;
cannam@127: 		       case REDFT10: bp->k[i] = R2R_REDFT10; break;
cannam@127: 		       case REDFT11: bp->k[i] = R2R_REDFT11; break;
cannam@127: 		       case RODFT00: bp->k[i] = R2R_RODFT00; break;
cannam@127: 		       case RODFT01: bp->k[i] = R2R_RODFT01; break;
cannam@127: 		       case RODFT10: bp->k[i] = R2R_RODFT10; break;
cannam@127: 		       case RODFT11: bp->k[i] = R2R_RODFT11; break;
cannam@127: 		       default: CK(0);
cannam@127: 		   }
cannam@127: 	      break;
cannam@127: 	 }
cannam@127: 	 case PROBLEM_RDFT2:
cannam@127: 	 {
cannam@127: 	      const problem_rdft2 *p = (const problem_rdft2 *) p_;
cannam@127: 	      int rnk = p->sz->rnk;
cannam@127: 	  
cannam@127: 	      if (!p->r0 || !p->r1 || !p->cr || !p->ci)
cannam@127: 		   abort();
cannam@127: 	      
cannam@127: 	      /* give up verifying rdft2 R2HCII */
cannam@127: 	      if (p->kind != R2HC && p->kind != HC2R)
cannam@127: 		   return bp;
cannam@127: 
cannam@127: 	      if (rnk > 0) {
cannam@127: 		   /* can't verify separate even/odd arrays for now */
cannam@127: 		   if (2 * (p->r1 - p->r0) !=
cannam@127: 		       ((p->kind == R2HC) ? 
cannam@127: 			p->sz->dims[rnk-1].is : p->sz->dims[rnk-1].os))
cannam@127: 			return bp;
cannam@127: 	      }
cannam@127: 
cannam@127: 	      bp = (bench_problem *) bench_malloc(sizeof(bench_problem));
cannam@127: 
cannam@127: 	      bp->kind = PROBLEM_REAL;
cannam@127: 	      bp->sign = p->kind == R2HC ? FFT_SIGN : -FFT_SIGN;
cannam@127: 	      bp->split = 1; /* tensor strides are in R's, not C's */
cannam@127: 	      if (p->kind == R2HC) {
cannam@127: 		   bp->sign = FFT_SIGN;
cannam@127: 		   bp->in = UNTAINT(p->r0);
cannam@127: 		   bp->out = UNTAINT(p->cr);
cannam@127: 		   bp->ini = 0;
cannam@127: 		   bp->outi = UNTAINT(p->ci);
cannam@127: 	      }
cannam@127: 	      else {
cannam@127: 		   bp->sign = -FFT_SIGN;
cannam@127: 		   bp->out = UNTAINT(p->r0);
cannam@127: 		   bp->in = UNTAINT(p->cr);
cannam@127: 		   bp->outi = 0;
cannam@127: 		   bp->ini = UNTAINT(p->ci);
cannam@127: 	      }
cannam@127: 	      bp->inphys = bp->outphys = 0;
cannam@127: 	      bp->iphyssz = bp->ophyssz = 0;
cannam@127: 	      bp->in_place = p->r0 == p->cr;
cannam@127: 	      bp->sz = fftw_tensor_to_bench_tensor(p->sz);
cannam@127: 	      if (rnk > 0) {
cannam@127: 		   if (p->kind == R2HC)
cannam@127: 			bp->sz->dims[rnk-1].is /= 2;
cannam@127: 		   else 
cannam@127: 			bp->sz->dims[rnk-1].os /= 2;
cannam@127: 	      }
cannam@127: 	      bp->vecsz = fftw_tensor_to_bench_tensor(p->vecsz);
cannam@127: 	      bp->k = 0;
cannam@127: 	      break;
cannam@127: 	 }
cannam@127: 	 default: 
cannam@127: 	      abort();
cannam@127:      }
cannam@127: 
cannam@127:      bp->userinfo = 0;
cannam@127:      bp->pstring = 0;
cannam@127:      bp->destroy_input = !NO_DESTROY_INPUTP(plnr);
cannam@127: 
cannam@127:      return bp;
cannam@127: }
cannam@127: 
cannam@127: static void hook(planner *plnr, plan *pln, const problem *p_, int optimalp)
cannam@127: {
cannam@127:      int rounds = 5;
cannam@127:      double tol = SINGLE_PRECISION ? 1.0e-3 : 1.0e-10;
cannam@127:      UNUSED(optimalp);
cannam@127: 
cannam@127:      if (verbose > 5) {
cannam@127: 	  printer *pr = X(mkprinter_file)(stdout);
cannam@127: 	  pr->print(pr, "%P:%(%p%)\n", p_, pln);
cannam@127: 	  X(printer_destroy)(pr);
cannam@127: 	  printf("cost %g  \n\n", pln->pcost);
cannam@127:      }
cannam@127: 
cannam@127:      if (paranoid) {
cannam@127: 	  bench_problem *bp;
cannam@127: 
cannam@127: 	  bp = fftw_problem_to_bench_problem(plnr, p_);
cannam@127: 	  if (bp) {
cannam@127: 	       X(plan) the_plan_save = the_plan;
cannam@127: 
cannam@127: 	       the_plan = (apiplan *) MALLOC(sizeof(apiplan), PLANS);
cannam@127: 	       the_plan->pln = pln;
cannam@127: 	       the_plan->prb = (problem *) p_;
cannam@127: 
cannam@127: 	       X(plan_awake)(pln, AWAKE_SQRTN_TABLE);
cannam@127: 	       verify_problem(bp, rounds, tol);
cannam@127: 	       X(plan_awake)(pln, SLEEPY);
cannam@127: 
cannam@127: 	       X(ifree)(the_plan);
cannam@127: 	       the_plan = the_plan_save;
cannam@127: 
cannam@127: 	       problem_destroy(bp);
cannam@127: 	  }
cannam@127: 
cannam@127:      }
cannam@127: }
cannam@127: 
cannam@127: static void paranoid_checks(void)
cannam@127: {
cannam@127:      /* FIXME: assumes char = 8 bits, which is false on at least one
cannam@127: 	DSP I know of. */
cannam@127: #if 0
cannam@127:      /* if flags_t is not 64 bits i want to know it. */
cannam@127:      CK(sizeof(flags_t) == 8);
cannam@127: 
cannam@127:      CK(sizeof(md5uint) >= 4);
cannam@127: #endif
cannam@127: 
cannam@127:      CK(sizeof(uintptr_t) >= sizeof(R *));
cannam@127: 
cannam@127:      CK(sizeof(INT) >= sizeof(R *));
cannam@127: }
cannam@127: 
cannam@127: void install_hook(void)
cannam@127: {
cannam@127:      planner *plnr = X(the_planner)();
cannam@127:      plnr->hook = hook;
cannam@127:      paranoid_checks();
cannam@127: }
cannam@127: 
cannam@127: void uninstall_hook(void)
cannam@127: {
cannam@127:      planner *plnr = X(the_planner)();
cannam@127:      plnr->hook = 0;
cannam@127: }