Chris@10: /*
Chris@10:  * Copyright (c) 2003, 2007-11 Matteo Frigo
Chris@10:  * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
Chris@10:  *
Chris@10:  * This program is free software; you can redistribute it and/or modify
Chris@10:  * it under the terms of the GNU General Public License as published by
Chris@10:  * the Free Software Foundation; either version 2 of the License, or
Chris@10:  * (at your option) any later version.
Chris@10:  *
Chris@10:  * This program is distributed in the hope that it will be useful,
Chris@10:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
Chris@10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Chris@10:  * GNU General Public License for more details.
Chris@10:  *
Chris@10:  * You should have received a copy of the GNU General Public License
Chris@10:  * along with this program; if not, write to the Free Software
Chris@10:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
Chris@10:  *
Chris@10:  */
Chris@10: 
Chris@10: 
Chris@10: #include "ct-hc2c.h"
Chris@10: 
Chris@10: typedef struct {
Chris@10:      hc2c_solver super;
Chris@10:      const hc2c_desc *desc;
Chris@10:      int bufferedp;
Chris@10:      khc2c k;
Chris@10: } S;
Chris@10: 
Chris@10: typedef struct {
Chris@10:      plan_hc2c super;
Chris@10:      khc2c k;
Chris@10:      plan *cld0, *cldm; /* children for 0th and middle butterflies */
Chris@10:      INT r, m, v, extra_iter;
Chris@10:      INT ms, vs;
Chris@10:      stride rs, brs;
Chris@10:      twid *td;
Chris@10:      const S *slv;
Chris@10: } P;
Chris@10: 
Chris@10: /*************************************************************
Chris@10:   Nonbuffered code
Chris@10:  *************************************************************/
Chris@10: static void apply(const plan *ego_, R *cr, R *ci)
Chris@10: {
Chris@10:      const P *ego = (const P *) ego_;
Chris@10:      plan_rdft2 *cld0 = (plan_rdft2 *) ego->cld0;
Chris@10:      plan_rdft2 *cldm = (plan_rdft2 *) ego->cldm;
Chris@10:      INT i, m = ego->m, v = ego->v;
Chris@10:      INT ms = ego->ms, vs = ego->vs;
Chris@10: 
Chris@10:      for (i = 0; i < v; ++i, cr += vs, ci += vs) {
Chris@10: 	  cld0->apply((plan *) cld0, cr, ci, cr, ci);
Chris@10: 	  ego->k(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 		 ego->td->W, ego->rs, 1, (m+1)/2, ms);
Chris@10: 	  cldm->apply((plan *) cldm, cr + (m/2)*ms, ci + (m/2)*ms, 
Chris@10: 		      cr + (m/2)*ms, ci + (m/2)*ms);
Chris@10:      }
Chris@10: }
Chris@10: 
Chris@10: static void apply_extra_iter(const plan *ego_, R *cr, R *ci)
Chris@10: {
Chris@10:      const P *ego = (const P *) ego_;
Chris@10:      plan_rdft2 *cld0 = (plan_rdft2 *) ego->cld0;
Chris@10:      plan_rdft2 *cldm = (plan_rdft2 *) ego->cldm;
Chris@10:      INT i, m = ego->m, v = ego->v;
Chris@10:      INT ms = ego->ms, vs = ego->vs;
Chris@10:      INT mm = (m-1)/2;
Chris@10: 
Chris@10:      for (i = 0; i < v; ++i, cr += vs, ci += vs) {
Chris@10: 	  cld0->apply((plan *) cld0, cr, ci, cr, ci);
Chris@10: 
Chris@10: 	  /* for 4-way SIMD when (m+1)/2-1 is odd: iterate over an
Chris@10: 	     even vector length MM-1, and then execute the last
Chris@10: 	     iteration as a 2-vector with vector stride 0.  The
Chris@10: 	     twiddle factors of the second half of the last iteration
Chris@10: 	     are bogus, but we only store the results of the first
Chris@10: 	     half. */
Chris@10: 	  ego->k(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 		 ego->td->W, ego->rs, 1, mm, ms);
Chris@10: 	  ego->k(cr + mm*ms, ci + mm*ms, cr + (m-mm)*ms, ci + (m-mm)*ms,
Chris@10: 		 ego->td->W, ego->rs, mm, mm+2, 0);
Chris@10: 	  cldm->apply((plan *) cldm, cr + (m/2)*ms, ci + (m/2)*ms, 
Chris@10: 		      cr + (m/2)*ms, ci + (m/2)*ms);
Chris@10:      }
Chris@10: 
Chris@10: }
Chris@10: 
Chris@10: /*************************************************************
Chris@10:   Buffered code
Chris@10:  *************************************************************/
Chris@10: 
Chris@10: /* should not be 2^k to avoid associativity conflicts */
Chris@10: static INT compute_batchsize(INT radix)
Chris@10: {
Chris@10:      /* round up to multiple of 4 */
Chris@10:      radix += 3;
Chris@10:      radix &= -4;
Chris@10: 
Chris@10:      return (radix + 2);
Chris@10: }
Chris@10: 
Chris@10: static void dobatch(const P *ego, R *Rp, R *Ip, R *Rm, R *Im,
Chris@10: 		    INT mb, INT me, INT extra_iter, R *bufp)
Chris@10: {
Chris@10:      INT b = WS(ego->brs, 1);
Chris@10:      INT rs = WS(ego->rs, 1);
Chris@10:      INT ms = ego->ms;
Chris@10:      R *bufm = bufp + b - 2;
Chris@10: 
Chris@10:      X(cpy2d_pair_ci)(Rp + mb * ms, Ip + mb * ms, bufp, bufp + 1,
Chris@10: 		      ego->r / 2, rs, b,
Chris@10: 		      me - mb, ms, 2);
Chris@10:      X(cpy2d_pair_ci)(Rm - mb * ms, Im - mb * ms, bufm, bufm + 1,
Chris@10: 		      ego->r / 2, rs, b,
Chris@10: 		      me - mb, -ms, -2);
Chris@10:      ego->k(bufp, bufp + 1, bufm, bufm + 1, ego->td->W, 
Chris@10: 	    ego->brs, mb, me + extra_iter, 2);
Chris@10:      X(cpy2d_pair_co)(bufp, bufp + 1, Rp + mb * ms, Ip + mb * ms, 
Chris@10: 		      ego->r / 2, b, rs,
Chris@10: 		      me - mb, 2, ms);
Chris@10:      X(cpy2d_pair_co)(bufm, bufm + 1, Rm - mb * ms, Im - mb * ms,
Chris@10: 		      ego->r / 2, b, rs,
Chris@10: 		      me - mb, -2, -ms);
Chris@10: }
Chris@10: 
Chris@10: static void apply_buf(const plan *ego_, R *cr, R *ci)
Chris@10: {
Chris@10:      const P *ego = (const P *) ego_;
Chris@10:      plan_rdft2 *cld0 = (plan_rdft2 *) ego->cld0;
Chris@10:      plan_rdft2 *cldm = (plan_rdft2 *) ego->cldm;
Chris@10:      INT i, j, ms = ego->ms, v = ego->v;
Chris@10:      INT batchsz = compute_batchsize(ego->r);
Chris@10:      R *buf;
Chris@10:      INT mb = 1, me = (ego->m+1) / 2;
Chris@10:      size_t bufsz = ego->r * batchsz * 2 * sizeof(R);
Chris@10: 
Chris@10:      BUF_ALLOC(R *, buf, bufsz);
Chris@10: 
Chris@10:      for (i = 0; i < v; ++i, cr += ego->vs, ci += ego->vs) {
Chris@10: 	  R *Rp = cr;
Chris@10: 	  R *Ip = ci;
Chris@10: 	  R *Rm = cr + ego->m * ms;
Chris@10: 	  R *Im = ci + ego->m * ms;
Chris@10: 
Chris@10: 	  cld0->apply((plan *) cld0, Rp, Ip, Rp, Ip);
Chris@10: 
Chris@10: 	  for (j = mb; j + batchsz < me; j += batchsz) 
Chris@10: 	       dobatch(ego, Rp, Ip, Rm, Im, j, j + batchsz, 0, buf);
Chris@10: 
Chris@10: 	  dobatch(ego, Rp, Ip, Rm, Im, j, me, ego->extra_iter, buf);
Chris@10: 
Chris@10: 	  cldm->apply((plan *) cldm, 
Chris@10: 		      Rp + me * ms, Ip + me * ms,
Chris@10: 		      Rp + me * ms, Ip + me * ms);
Chris@10: 
Chris@10:      }
Chris@10: 
Chris@10:      BUF_FREE(buf, bufsz);
Chris@10: }
Chris@10: 
Chris@10: /*************************************************************
Chris@10:   common code
Chris@10:  *************************************************************/
Chris@10: static void awake(plan *ego_, enum wakefulness wakefulness)
Chris@10: {
Chris@10:      P *ego = (P *) ego_;
Chris@10: 
Chris@10:      X(plan_awake)(ego->cld0, wakefulness);
Chris@10:      X(plan_awake)(ego->cldm, wakefulness);
Chris@10:      X(twiddle_awake)(wakefulness, &ego->td, ego->slv->desc->tw, 
Chris@10: 		      ego->r * ego->m, ego->r, 
Chris@10: 		      (ego->m - 1) / 2 + ego->extra_iter);
Chris@10: }
Chris@10: 
Chris@10: static void destroy(plan *ego_)
Chris@10: {
Chris@10:      P *ego = (P *) ego_;
Chris@10:      X(plan_destroy_internal)(ego->cld0);
Chris@10:      X(plan_destroy_internal)(ego->cldm);
Chris@10:      X(stride_destroy)(ego->rs);
Chris@10:      X(stride_destroy)(ego->brs);
Chris@10: }
Chris@10: 
Chris@10: static void print(const plan *ego_, printer *p)
Chris@10: {
Chris@10:      const P *ego = (const P *) ego_;
Chris@10:      const S *slv = ego->slv;
Chris@10:      const hc2c_desc *e = slv->desc;
Chris@10: 
Chris@10:      if (slv->bufferedp)
Chris@10: 	  p->print(p, "(hc2c-directbuf/%D-%D/%D/%D%v \"%s\"%(%p%)%(%p%))",
Chris@10: 		   compute_batchsize(ego->r),
Chris@10: 		   ego->r, X(twiddle_length)(ego->r, e->tw),
Chris@10: 		   ego->extra_iter, ego->v, e->nam, 
Chris@10: 		   ego->cld0, ego->cldm);
Chris@10:      else
Chris@10: 	  p->print(p, "(hc2c-direct-%D/%D/%D%v \"%s\"%(%p%)%(%p%))",
Chris@10: 		   ego->r, X(twiddle_length)(ego->r, e->tw), 
Chris@10: 		   ego->extra_iter, ego->v, e->nam, 
Chris@10: 		   ego->cld0, ego->cldm);
Chris@10: }
Chris@10: 
Chris@10: static int applicable0(const S *ego, rdft_kind kind,
Chris@10: 		       INT r, INT rs,
Chris@10: 		       INT m, INT ms, 
Chris@10: 		       INT v, INT vs,
Chris@10: 		       const R *cr, const R *ci,
Chris@10: 		       const planner *plnr,
Chris@10: 		       INT *extra_iter)
Chris@10: {
Chris@10:      const hc2c_desc *e = ego->desc;
Chris@10:      UNUSED(v);
Chris@10: 
Chris@10:      return (
Chris@10: 	  1
Chris@10: 	  && r == e->radix
Chris@10: 	  && kind == e->genus->kind
Chris@10: 
Chris@10: 	  /* first v-loop iteration */
Chris@10: 	  && ((*extra_iter = 0,
Chris@10: 	       e->genus->okp(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 			     rs, 1, (m+1)/2, ms, plnr))
Chris@10: 	      ||
Chris@10: 	      (*extra_iter = 1,
Chris@10: 	       ((e->genus->okp(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 			       rs, 1, (m-1)/2, ms, plnr))
Chris@10: 		&&
Chris@10: 		(e->genus->okp(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 			       rs, (m-1)/2, (m-1)/2 + 2, 0, plnr)))))
Chris@10: 	  
Chris@10: 	  /* subsequent v-loop iterations */
Chris@10: 	  && (cr += vs, ci += vs, 1)
Chris@10: 
Chris@10: 	  && e->genus->okp(cr + ms, ci + ms, cr + (m-1)*ms, ci + (m-1)*ms,
Chris@10: 			   rs, 1, (m+1)/2 - *extra_iter, ms, plnr)
Chris@10: 	  );
Chris@10: }
Chris@10: 
Chris@10: static int applicable0_buf(const S *ego, rdft_kind kind,
Chris@10: 			   INT r, INT rs,
Chris@10: 			   INT m, INT ms, 
Chris@10: 			   INT v, INT vs,
Chris@10: 			   const R *cr, const R *ci,
Chris@10: 			   const planner *plnr, INT *extra_iter)
Chris@10: {
Chris@10:      const hc2c_desc *e = ego->desc;
Chris@10:      INT batchsz, brs;
Chris@10:      UNUSED(v); UNUSED(rs); UNUSED(ms); UNUSED(vs);
Chris@10: 
Chris@10:      return (
Chris@10: 	  1
Chris@10: 	  && r == e->radix
Chris@10: 	  && kind == e->genus->kind
Chris@10: 
Chris@10: 	  /* ignore cr, ci, use buffer */
Chris@10: 	  && (cr = (const R *)0, ci = cr + 1, 
Chris@10: 	      batchsz = compute_batchsize(r), 
Chris@10: 	      brs = 4 * batchsz, 1)
Chris@10: 
Chris@10: 	  && e->genus->okp(cr, ci, cr + brs - 2, ci + brs - 2, 
Chris@10: 			   brs, 1, 1+batchsz, 2, plnr)
Chris@10: 
Chris@10: 	  && ((*extra_iter = 0,
Chris@10: 	       e->genus->okp(cr, ci, cr + brs - 2, ci + brs - 2, 
Chris@10: 			     brs, 1, 1 + (((m-1)/2) % batchsz), 2, plnr))
Chris@10: 	      ||
Chris@10: 	      (*extra_iter = 1,
Chris@10: 	       e->genus->okp(cr, ci, cr + brs - 2, ci + brs - 2, 
Chris@10: 			     brs, 1, 1 + 1 + (((m-1)/2) % batchsz), 2, plnr)))
Chris@10: 	      
Chris@10: 	  );
Chris@10: }
Chris@10: 
Chris@10: static int applicable(const S *ego, rdft_kind kind,
Chris@10: 		      INT r, INT rs,
Chris@10: 		      INT m, INT ms, 
Chris@10: 		      INT v, INT vs,
Chris@10: 		      R *cr, R *ci,
Chris@10: 		      const planner *plnr, INT *extra_iter)
Chris@10: {
Chris@10:      if (ego->bufferedp) {
Chris@10: 	  if (!applicable0_buf(ego, kind, r, rs, m, ms, v, vs, cr, ci, plnr,
Chris@10: 			       extra_iter))
Chris@10: 	       return 0;
Chris@10:      } else {
Chris@10: 	  if (!applicable0(ego, kind, r, rs, m, ms, v, vs, cr, ci, plnr,
Chris@10: 			   extra_iter))
Chris@10: 	       return 0;
Chris@10:      }
Chris@10: 
Chris@10:      if (NO_UGLYP(plnr) && X(ct_uglyp)((ego->bufferedp? (INT)512 : (INT)16),
Chris@10: 				       v, m * r, r))
Chris@10: 	  return 0;
Chris@10: 
Chris@10:      return 1;
Chris@10: }
Chris@10: 
Chris@10: static plan *mkcldw(const hc2c_solver *ego_, rdft_kind kind,
Chris@10: 		    INT r, INT rs,
Chris@10: 		    INT m, INT ms, 
Chris@10: 		    INT v, INT vs,
Chris@10: 		    R *cr, R *ci,
Chris@10: 		    planner *plnr)
Chris@10: {
Chris@10:      const S *ego = (const S *) ego_;
Chris@10:      P *pln;
Chris@10:      const hc2c_desc *e = ego->desc;
Chris@10:      plan *cld0 = 0, *cldm = 0;
Chris@10:      INT imid = (m / 2) * ms;
Chris@10:      INT extra_iter;
Chris@10: 
Chris@10:      static const plan_adt padt = {
Chris@10: 	  0, awake, print, destroy
Chris@10:      };
Chris@10: 
Chris@10:      if (!applicable(ego, kind, r, rs, m, ms, v, vs, cr, ci, plnr, 
Chris@10: 		     &extra_iter))
Chris@10:           return (plan *)0;
Chris@10: 
Chris@10:      cld0 = X(mkplan_d)(
Chris@10: 	  plnr, 
Chris@10: 	  X(mkproblem_rdft2_d)(X(mktensor_1d)(r, rs, rs),
Chris@10: 			       X(mktensor_0d)(),
Chris@10: 			       TAINT(cr, vs), TAINT(ci, vs),
Chris@10: 			       TAINT(cr, vs), TAINT(ci, vs),
Chris@10: 			       kind));
Chris@10:      if (!cld0) goto nada;
Chris@10: 
Chris@10:      cldm = X(mkplan_d)(
Chris@10: 	  plnr, 
Chris@10: 	  X(mkproblem_rdft2_d)(((m % 2) ?
Chris@10: 				X(mktensor_0d)() : X(mktensor_1d)(r, rs, rs) ),
Chris@10: 			       X(mktensor_0d)(),
Chris@10: 			       TAINT(cr + imid, vs), TAINT(ci + imid, vs),
Chris@10: 			       TAINT(cr + imid, vs), TAINT(ci + imid, vs),
Chris@10: 			       kind == R2HC ? R2HCII : HC2RIII));
Chris@10:      if (!cldm) goto nada;
Chris@10: 
Chris@10:      if (ego->bufferedp)
Chris@10: 	  pln = MKPLAN_HC2C(P, &padt, apply_buf);
Chris@10:      else
Chris@10: 	  pln = MKPLAN_HC2C(P, &padt, extra_iter ? apply_extra_iter : apply);
Chris@10: 
Chris@10:      pln->k = ego->k;
Chris@10:      pln->td = 0;
Chris@10:      pln->r = r; pln->rs = X(mkstride)(r, rs);
Chris@10:      pln->m = m; pln->ms = ms;
Chris@10:      pln->v = v; pln->vs = vs;
Chris@10:      pln->slv = ego;
Chris@10:      pln->brs = X(mkstride)(r, 4 * compute_batchsize(r));
Chris@10:      pln->cld0 = cld0;
Chris@10:      pln->cldm = cldm;
Chris@10:      pln->extra_iter = extra_iter;
Chris@10: 
Chris@10:      X(ops_zero)(&pln->super.super.ops);
Chris@10:      X(ops_madd2)(v * (((m - 1) / 2) / e->genus->vl),
Chris@10: 		  &e->ops, &pln->super.super.ops);
Chris@10:      X(ops_madd2)(v, &cld0->ops, &pln->super.super.ops);
Chris@10:      X(ops_madd2)(v, &cldm->ops, &pln->super.super.ops);
Chris@10: 
Chris@10:      if (ego->bufferedp) 
Chris@10: 	  pln->super.super.ops.other += 4 * r * m * v;
Chris@10: 
Chris@10:      return &(pln->super.super);
Chris@10: 
Chris@10:  nada:
Chris@10:      X(plan_destroy_internal)(cld0);
Chris@10:      X(plan_destroy_internal)(cldm);
Chris@10:      return 0;
Chris@10: }
Chris@10: 
Chris@10: static void regone(planner *plnr, khc2c codelet,
Chris@10: 		   const hc2c_desc *desc, 
Chris@10: 		   hc2c_kind hc2ckind, 
Chris@10: 		   int bufferedp)
Chris@10: {
Chris@10:      S *slv = (S *)X(mksolver_hc2c)(sizeof(S), desc->radix, hc2ckind, mkcldw);
Chris@10:      slv->k = codelet;
Chris@10:      slv->desc = desc;
Chris@10:      slv->bufferedp = bufferedp;
Chris@10:      REGISTER_SOLVER(plnr, &(slv->super.super));
Chris@10: }
Chris@10: 
Chris@10: void X(regsolver_hc2c_direct)(planner *plnr, khc2c codelet,
Chris@10: 			      const hc2c_desc *desc,
Chris@10: 			      hc2c_kind hc2ckind)
Chris@10: {
Chris@10:      regone(plnr, codelet, desc, hc2ckind, /* bufferedp */0);
Chris@10:      regone(plnr, codelet, desc, hc2ckind, /* bufferedp */1);
Chris@10: }