static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const problem_dft *p;
iodim *d;
const kdft_desc *e = ego->desc;
static const plan_adt padt = {
X(dft_solve), X(null_awake), print, destroy
};
UNUSED(plnr);
if (!applicable(ego_, p_, plnr))
return (plan *)0;
p = (const problem_dft *) p_;
pln = MKPLAN_DFT(P, &padt, apply);
d = p->sz->dims;
pln->k = ego->k;
pln->is = X(mkstride)(e->sz, d[0].is);
pln->os = X(mkstride)(e->sz, d[0].os);
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
pln->slv = ego;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(pln->vl / e->genus->vl, &e->ops, &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego, const problem *p_, planner *plnr)
{
const problem_dft *p = (const problem_dft *) p_;
P *pln;
INT n;
INT is, os;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
if (!applicable(ego, p_, plnr))
return (plan *) 0;
n = p->sz->dims[0].n;
is = p->sz->dims[0].is;
os = p->sz->dims[0].os;
pln = MKPLAN_DFT(P, &padt, apply);
if (!mkP(pln, n, is, os, p->ro, p->io, plnr)) {
X(ifree)(pln);
return (plan *) 0;
}
return &(pln->super.super);
}
static plan *mkplan(const solver *ego, const problem *p_, planner *plnr)
{
const problem_dft *p;
P *pln;
const iodim *d;
static const plan_adt padt = {
X(dft_solve), X(null_awake), print, X(plan_null_destroy)
};
UNUSED(ego);
if (!applicable(p_, plnr))
return (plan *) 0;
p = (const problem_dft *) p_;
d = p->vecsz->dims;
pln = MKPLAN_DFT(P, &padt,
X(transpose_simplep)(d, d+1, 1, X(imin)(d[0].is,d[0].os),
p->ri, p->ii) ? apply :
(X(transpose_slowp)(d, d+1, 2) ? apply_slow :
apply_general));
X(transpose_dims)(d, d+1, &pln->n, &pln->m, &pln->d, &pln->nd, &pln->md);
pln->offset = (p->ri - p->ii == 1) ? -1 : 0;
pln->s0 = d[0].is;
pln->s1 = d[0].os;
/* (4 loads + 4 stores) * (pln->n \choose 2)
(FIXME? underestimate for non-square) */
X(ops_other)(4 * pln->n * (pln->m - 1), &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const problem_rdft *p;
const S *ego = (const S *) ego_;
P *pln;
int retval;
static const plan_adt padt = {
X(rdft_solve), X(null_awake), print, X(plan_null_destroy)
};
UNUSED(plnr);
if (!applicable(ego, p_))
return (plan *) 0;
p = (const problem_rdft *) p_;
pln = MKPLAN_RDFT(P, &padt, ego->apply);
retval = fill_iodim(pln, p);
(void)retval; /* UNUSED unless DEBUG */
A(retval);
A(pln->vl > 0); /* because FINITE_RNK(p->vecsz->rnk) holds */
pln->nam = ego->nam;
/* X(tensor_sz)(p->vecsz) loads, X(tensor_sz)(p->vecsz) stores */
X(ops_other)(2 * X(tensor_sz)(p->vecsz), &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
P *pln;
const problem_rdft *p;
plan *cld;
static const plan_adt padt = {
fftwf_rdft_solve, awake, print, destroy
};
if (!applicable(ego_, p_, plnr))
return (plan *)0;
p = (const problem_rdft *) p_;
/* NO_DHT_R2HC stops infinite loops with rdft-dht.c */
cld = fftwf_mkplan_f_d(plnr,
fftwf_mkproblem_rdft_1(p->sz, p->vecsz,
p->I, p->O, R2HC),
NO_DHT_R2HC, 0, 0);
if (!cld) return (plan *)0;
pln = MKPLAN_RDFT(P, &padt, apply);
pln->n = p->sz->dims[0].n;
pln->os = p->sz->dims[0].os;
pln->cld = cld;
pln->super.super.ops = cld->ops;
pln->super.super.ops.other += 4 * ((pln->n - 1)/2);
pln->super.super.ops.add += 2 * ((pln->n - 1)/2);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
const problem_dft *p;
P *pln;
static const plan_adt padt = {
X(dft_solve), X(null_awake), print, X(plan_null_destroy)
};
UNUSED(plnr);
if (!applicable(ego_, p_))
return (plan *) 0;
p = (const problem_dft *) p_;
pln = MKPLAN_DFT(P, &padt, ego->adt->apply);
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
pln->slv = ego;
/* 2*vl loads, 2*vl stores */
X(ops_other)(4 * pln->vl, &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego, const problem *p_, planner *plnr)
{
const problem_dft *p;
P *pln;
INT n;
static const plan_adt padt = {
X(dft_solve), awake, print, X(plan_null_destroy)
};
if (!applicable(ego, p_, plnr))
return (plan *)0;
pln = MKPLAN_DFT(P, &padt, apply);
p = (const problem_dft *) p_;
pln->n = n = p->sz->dims[0].n;
pln->is = p->sz->dims[0].is;
pln->os = p->sz->dims[0].os;
pln->td = 0;
pln->super.super.ops.add = (n-1) * 5;
pln->super.super.ops.mul = 0;
pln->super.super.ops.fma = (n-1) * (n-1) ;
#if 0 /* these are nice pipelined sequential loads and should cost nothing */
pln->super.super.ops.other = (n-1)*(4 + 1 + 2 * (n-1)); /* approximate */
#endif
return &(pln->super.super);
}
int
applyfilter(client_t *client, Generic_t *node)
{
filter_type_t f = client->filter;
/* Grids are always summarized. */
if (node->id == GRID_NODE)
f = SUMMARY;
if (!applicable(f, node))
return 1; /* A non-fatal error. */
switch (f)
{
case NO_FILTER:
return 0;
case SUMMARY:
return source_summary((Source_t*) node, client);
default:
break;
}
return 0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
P *pln;
const problem_dft *p;
plan *cld;
INT ishift = 0, oshift = 0;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
UNUSED(ego_);
if (!applicable(p_, plnr))
return (plan *)0;
p = (const problem_dft *) p_;
{
tensor *ri_vec = X(mktensor_1d)(2, p->ii - p->ri, p->io - p->ro);
tensor *cld_vec = X(tensor_append)(ri_vec, p->vecsz);
int i;
for (i = 0; i < cld_vec->rnk; ++i) { /* make all istrides > 0 */
if (cld_vec->dims[i].is < 0) {
INT nm1 = cld_vec->dims[i].n - 1;
ishift -= nm1 * (cld_vec->dims[i].is *= -1);
oshift -= nm1 * (cld_vec->dims[i].os *= -1);
}
}
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft_1)(p->sz, cld_vec,
p->ri + ishift,
p->ro + oshift, R2HC));
X(tensor_destroy2)(ri_vec, cld_vec);
}
if (!cld) return (plan *)0;
pln = MKPLAN_DFT(P, &padt, apply);
if (p->sz->rnk == 0) {
pln->n = 1;
pln->os = 0;
}
else {
pln->n = p->sz->dims[0].n;
pln->os = p->sz->dims[0].os;
}
pln->ishift = ishift;
pln->oshift = oshift;
pln->cld = cld;
pln->super.super.ops = cld->ops;
pln->super.super.ops.other += 8 * ((pln->n - 1)/2);
pln->super.super.ops.add += 4 * ((pln->n - 1)/2);
pln->super.super.ops.other += 1; /* estimator hack for nop plans */
return &(pln->super.super);
}
static plan *mkcldw(const ct_solver *ego_,
INT r, INT irs, INT ors,
INT m, INT ms,
INT v, INT ivs, INT ovs,
INT mstart, INT mcount,
R *rio, R *iio,
planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const ct_desc *e = ego->desc;
INT extra_iter;
static const plan_adt padt = {
0, awake, print, destroy
};
A(mstart >= 0 && mstart + mcount <= m);
if (!applicable(ego,
r, irs, ors, m, ms, v, ivs, ovs, mstart, mstart + mcount,
rio, iio, plnr, &extra_iter))
return (plan *)0;
if (ego->bufferedp) {
pln = MKPLAN_DFTW(P, &padt, apply_buf);
} else {
pln = MKPLAN_DFTW(P, &padt, extra_iter ? apply_extra_iter : apply);
}
pln->k = ego->k;
pln->rs = X(mkstride)(r, irs);
pln->td = 0;
pln->r = r;
pln->m = m;
pln->ms = ms;
pln->v = v;
pln->vs = ivs;
pln->mb = mstart;
pln->me = mstart + mcount;
pln->slv = ego;
pln->brs = X(mkstride)(r, 2 * compute_batchsize(r));
pln->extra_iter = extra_iter;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(v * (mcount/e->genus->vl), &e->ops, &pln->super.super.ops);
if (ego->bufferedp) {
/* 8 load/stores * N * V */
pln->super.super.ops.other += 8 * r * mcount * v;
}
pln->super.super.could_prune_now_p =
(!ego->bufferedp && r >= 5 && r < 64 && m >= r);
return &(pln->super.super);
}
static plan *mkcldw(const hc2hc_solver *ego_,
rdft_kind kind, INT r, INT m, INT s, INT vl, INT vs,
INT mstart, INT mcount,
R *IO, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const hc2hc_desc *e = ego->desc;
plan *cld0, *cldm;
INT mstart1, mcount2;
static const plan_adt padt = {
0, awake, print, destroy
};
mstart1 = mstart + (mstart == 0);
mcount2 = 1 + 2 * (mcount - (mstart==0)
- (m%2 == 0 && mstart+mcount == (m+2)/2));
if (!applicable(ego, kind, r, m, s, vl, vs, mstart1, mcount2, IO, plnr))
return (plan *)0;
if (!X(hc2hc_mkcldrn)(kind, r, m, s, mstart, mcount,
IO, plnr, &cld0, &cldm))
return (plan *)0;
pln = MKPLAN_HC2HC(P, &padt, apply);
pln->k = ego->k;
pln->ios = X(mkstride)(r, m * s);
pln->td = 0;
pln->tdW = 0;
pln->r = r;
pln->m = m;
pln->s = s;
pln->vl = vl;
pln->vs = vs;
pln->slv = ego;
pln->cld0 = cld0;
pln->cldm = cldm;
pln->mstart1 = mstart1;
pln->mcount2 = mcount2;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(vl * (((mcount2 - 1) / 2) / e->genus->vl),
&e->ops, &pln->super.super.ops);
X(ops_madd2)(vl, &cld0->ops, &pln->super.super.ops);
X(ops_madd2)(vl, &cldm->ops, &pln->super.super.ops);
pln->super.super.could_prune_now_p = (r >= 5 && r < 64 && m >= r);
return &(pln->super.super);
}
bool SemanticsVisitor::applicable(TypeDescriptorList formalParams, TypeDescriptorList actualParams) {
if (formalParams.size() == 0 && actualParams.size() == 0) return true;
else if (formalParams.size() == 0 || actualParams.size() == 0) return false;
else {
if (bindable(formalParams.front(), actualParams.front()))
return applicable(
TypeDescriptorList(++formalParams.begin(), formalParams.end()),
TypeDescriptorList(++actualParams.begin(), actualParams.end())
);
return false;
}
}
static plan *mkcldw(const ct_solver *ego_,
int dec, INT r, INT m, INT s, INT vl, INT vs,
INT mstart, INT mcount,
R *rio, R *iio,
planner *plnr)
{
const S *ego = (const S *)ego_;
P *pln;
plan *cld = 0;
static const plan_adt padt = {
0, awake, print, destroy
};
A(mstart >= 0 && mstart + mcount <= m);
if (!applicable(r, m, plnr))
return (plan *)0;
cld = X(mkplan_d)(plnr,
X(mkproblem_dft_d)(
X(mktensor_1d)(r, m * s, m * s),
X(mktensor_2d)(mcount, s, s, vl, vs, vs),
rio, iio, rio, iio)
);
if (!cld) goto nada;
pln = MKPLAN_DFTW(P, &padt, dec == DECDIT ? apply_dit : apply_dif);
pln->slv = ego;
pln->cld = cld;
pln->r = r;
pln->m = m;
pln->s = s;
pln->vl = vl;
pln->vs = vs;
pln->mstart = mstart;
pln->mcount = mcount;
pln->dec = dec;
pln->td = 0;
{
double n0 = (r - 1) * (mcount - 1) * vl;
pln->super.super.ops = cld->ops;
pln->super.super.ops.mul += 8 * n0;
pln->super.super.ops.add += 4 * n0;
pln->super.super.ops.other += 8 * n0;
}
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cld);
return (plan *) 0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
const problem_rdft *p;
P *pln;
plan *cld1 = 0, *cld2 = 0;
tensor *sz1, *sz2, *vecszi, *sz2i;
int spltrnk;
static const plan_adt padt = {
X(rdft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr, &spltrnk))
return (plan *) 0;
p = (const problem_rdft *) p_;
X(tensor_split)(p->sz, &sz1, spltrnk, &sz2);
vecszi = X(tensor_copy_inplace)(p->vecsz, INPLACE_OS);
sz2i = X(tensor_copy_inplace)(sz2, INPLACE_OS);
cld1 = X(mkplan_d)(plnr,
X(mkproblem_rdft_d)(X(tensor_copy)(sz2),
X(tensor_append)(p->vecsz, sz1),
p->I, p->O, p->kind + spltrnk));
if (!cld1) goto nada;
cld2 = X(mkplan_d)(plnr,
X(mkproblem_rdft_d)(
X(tensor_copy_inplace)(sz1, INPLACE_OS),
X(tensor_append)(vecszi, sz2i),
p->O, p->O, p->kind));
if (!cld2) goto nada;
pln = MKPLAN_RDFT(P, &padt, apply);
pln->cld1 = cld1;
pln->cld2 = cld2;
pln->solver = ego;
X(ops_add)(&cld1->ops, &cld2->ops, &pln->super.super.ops);
X(tensor_destroy4)(sz2, sz1, vecszi, sz2i);
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cld2);
X(plan_destroy_internal)(cld1);
X(tensor_destroy4)(sz2, sz1, vecszi, sz2i);
return (plan *) 0;
}
static plan *mkplan(const solver *ego, const problem *p_, planner *plnr)
{
const problem_dft *p = (const problem_dft *) p_;
P *pln;
INT n, nb;
plan *cldf = 0;
R *buf = (R *) 0;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
if (!applicable(ego, p_, plnr))
return (plan *) 0;
n = p->sz->dims[0].n;
nb = choose_transform_size(2 * n - 1);
buf = (R *) MALLOC(2 * nb * sizeof(R), BUFFERS);
cldf = X(mkplan_f_d)(plnr,
X(mkproblem_dft_d)(X(mktensor_1d)(nb, 2, 2),
X(mktensor_1d)(1, 0, 0),
buf, buf+1,
buf, buf+1),
NO_SLOW, 0, 0);
if (!cldf) goto nada;
X(ifree)(buf);
pln = MKPLAN_DFT(P, &padt, apply);
pln->n = n;
pln->nb = nb;
pln->w = 0;
pln->W = 0;
pln->cldf = cldf;
pln->is = p->sz->dims[0].is;
pln->os = p->sz->dims[0].os;
X(ops_add)(&cldf->ops, &cldf->ops, &pln->super.super.ops);
pln->super.super.ops.add += 4 * n + 2 * nb;
pln->super.super.ops.mul += 8 * n + 4 * nb;
pln->super.super.ops.other += 6 * (n + nb);
return &(pln->super.super);
nada:
X(ifree0)(buf);
X(plan_destroy_internal)(cldf);
return (plan *)0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
const problem_rdft2 *p;
P *pln;
plan *cld;
int vdim;
iodim *d;
INT rvs, cvs;
static const plan_adt padt = {
X(rdft2_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr, &vdim))
return (plan *) 0;
p = (const problem_rdft2 *) p_;
d = p->vecsz->dims + vdim;
A(d->n > 1); /* or else, p->ri + d->is etc. are invalid */
X(rdft2_strides)(p->kind, d, &rvs, &cvs);
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft2_d)(
X(tensor_copy)(p->sz),
X(tensor_copy_except)(p->vecsz, vdim),
TAINT(p->r0, rvs), TAINT(p->r1, rvs),
TAINT(p->cr, cvs), TAINT(p->ci, cvs),
p->kind));
if (!cld) return (plan *) 0;
pln = MKPLAN_RDFT2(P, &padt, apply);
pln->cld = cld;
pln->vl = d->n;
pln->rvs = rvs;
pln->cvs = cvs;
pln->solver = ego;
X(ops_zero)(&pln->super.super.ops);
pln->super.super.ops.other = 3.14159; /* magic to prefer codelet loops */
X(ops_madd2)(pln->vl, &cld->ops, &pln->super.super.ops);
if (p->sz->rnk != 1 || (p->sz->dims[0].n > 128))
pln->super.super.pcost = pln->vl * cld->pcost;
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
P *pln;
const problem_rdft *p;
plan *cld;
R *buf;
INT n;
opcnt ops;
static const plan_adt padt = {
X(rdft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr))
return (plan *)0;
p = (const problem_rdft *) p_;
n = p->sz->dims[0].n - 1;
A(n > 0);
buf = (R *) MALLOC(sizeof(R) * n, BUFFERS);
cld = X(mkplan_d)(plnr, X(mkproblem_rdft_1_d)(X(mktensor_1d)(n, 1, 1),
X(mktensor_0d)(),
buf, buf, R2HC));
X(ifree)(buf);
if (!cld)
return (plan *)0;
pln = MKPLAN_RDFT(P, &padt, apply);
pln->n = n;
pln->is = p->sz->dims[0].is;
pln->os = p->sz->dims[0].os;
pln->cld = cld;
pln->td = 0;
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
X(ops_zero)(&ops);
ops.other = 8 + (n-1)/2 * 11 + (1 - n % 2) * 5;
ops.add = 2 + (n-1)/2 * 5;
ops.mul = (n-1)/2 * 3 + (1 - n % 2) * 1;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(pln->vl, &ops, &pln->super.super.ops);
X(ops_madd2)(pln->vl, &cld->ops, &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
P *pln;
const problem_dft *p;
plan *cld;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
UNUSED(ego_);
if (!applicable(p_, plnr))
return (plan *)0;
p = (const problem_dft *) p_;
{
tensor *ri_vec = X(mktensor_1d)(2, p->ii - p->ri, p->io - p->ro);
tensor *cld_vec = X(tensor_append)(ri_vec, p->vecsz);
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft_1)(p->sz, cld_vec,
p->ri, p->ro, R2HC));
X(tensor_destroy2)(ri_vec, cld_vec);
}
if (!cld) return (plan *)0;
pln = MKPLAN_DFT(P, &padt, apply);
#if ALLOW_RANK0
if (p->sz->rnk == 0) {
pln->n = 1;
pln->os = 0;
}
else
#endif
{
pln->n = p->sz->dims[0].n;
pln->os = p->sz->dims[0].os;
}
pln->cld = cld;
pln->super.super.ops = cld->ops;
pln->super.super.ops.other += 8 * ((pln->n - 1)/2);
pln->super.super.ops.add += 4 * ((pln->n - 1)/2);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego, const problem *p, planner *plnr)
{
static const plan_adt padt = {
X(dft_solve), X(null_awake), print, X(plan_null_destroy)
};
plan_dft *pln;
UNUSED(plnr);
if (!applicable(ego, p))
return (plan *) 0;
pln = MKPLAN_DFT(plan_dft, &padt, apply);
X(ops_zero)(&pln->super.ops);
return &(pln->super);
}
static plan *mkplan(const solver *ego, const problem *p, planner *plnr)
{
static const plan_adt padt = {
fftwf_rdft_solve, fftwf_null_awake, print, fftwf_plan_null_destroy
};
plan_rdft *pln;
UNUSED(plnr);
if (!applicable(ego, p))
return (plan *) 0;
pln = MKPLAN_RDFT(plan_rdft, &padt, apply);
fftwf_ops_zero(&pln->super.ops);
return &(pln->super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const problem_dft *p;
iodim *d;
const kdft_desc *e = ego->desc;
static const plan_adt padt = {
X(dft_solve), X(null_awake), print, destroy
};
UNUSED(plnr);
if (ego->bufferedp) {
if (!applicable_buf(ego_, p_, plnr))
return (plan *)0;
pln = MKPLAN_DFT(P, &padt, apply_buf);
} else {
int extra_iterp = 0;
if (!applicable(ego_, p_, plnr, &extra_iterp))
return (plan *)0;
pln = MKPLAN_DFT(P, &padt, extra_iterp ? apply_extra_iter : apply);
}
p = (const problem_dft *) p_;
d = p->sz->dims;
pln->k = ego->k;
pln->n = d[0].n;
pln->is = X(mkstride)(pln->n, d[0].is);
pln->os = X(mkstride)(pln->n, d[0].os);
pln->bufstride = X(mkstride)(pln->n, 2 * compute_batchsize(pln->n));
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
pln->slv = ego;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(pln->vl / e->genus->vl, &e->ops, &pln->super.super.ops);
if (ego->bufferedp)
pln->super.super.ops.other += 4 * pln->n * pln->vl;
pln->super.super.could_prune_now_p = !ego->bufferedp;
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
const problem_dft *p;
P *pln;
plan *cld;
int vdim;
iodim *d;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr, &vdim))
return (plan *) 0;
p = (const problem_dft *) p_;
d = p->vecsz->dims + vdim;
A(d->n > 1);
cld = X(mkplan_d)(plnr,
X(mkproblem_dft_d)(
X(tensor_copy)(p->sz),
X(tensor_copy_except)(p->vecsz, vdim),
TAINT(p->ri, d->is), TAINT(p->ii, d->is),
TAINT(p->ro, d->os), TAINT(p->io, d->os)));
if (!cld) return (plan *) 0;
pln = MKPLAN_DFT(P, &padt, apply);
pln->cld = cld;
pln->vl = d->n;
pln->ivs = d->is;
pln->ovs = d->os;
pln->solver = ego;
X(ops_zero)(&pln->super.super.ops);
pln->super.super.ops.other = 3.14159; /* magic to prefer codelet loops */
X(ops_madd2)(pln->vl, &cld->ops, &pln->super.super.ops);
if (p->sz->rnk != 1 || (p->sz->dims[0].n > 64))
pln->super.super.pcost = pln->vl * cld->pcost;
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const problem_rdft2 *p;
plan *cldcpy = (plan *) 0;
P *pln;
static const plan_adt padt = {
X(rdft2_solve), awake, print, destroy
};
UNUSED(ego_);
if (!applicable(p_))
return (plan *) 0;
p = (const problem_rdft2 *) p_;
if (p->kind == HC2R) {
cldcpy = X(mkplan_d)(plnr,
X(mkproblem_rdft_0_d)(
X(tensor_copy)(p->vecsz),
p->cr, p->r0));
if (!cldcpy) return (plan *) 0;
}
pln = MKPLAN_RDFT2(P, &padt,
p->kind == R2HC ?
(p->r0 == p->cr ? apply_r2hc_inplace : apply_r2hc)
: apply_hc2r);
if (p->kind == R2HC)
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
pln->cldcpy = cldcpy;
if (p->kind == R2HC) {
/* vl loads, 2*vl stores */
X(ops_other)(3 * pln->vl, &pln->super.super.ops);
}
else {
pln->super.super.ops = cldcpy->ops;
}
return &(pln->super.super);
}
static plan *mkcldw(const ct_solver *ego_,
INT r, INT irs, INT ors,
INT m, INT ms,
INT v, INT ivs, INT ovs,
INT mstart, INT mcount,
R *rio, R *iio,
planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const ct_desc *e = ego->desc;
static const plan_adt padt = {
0, awake, print, destroy
};
A(mstart >= 0 && mstart + mcount <= m);
if (!applicable(ego,
r, irs, ors, m, ms, v, ivs, ovs, mstart, mstart + mcount,
rio, iio, plnr))
return (plan *)0;
pln = MKPLAN_DFTW(P, &padt, apply);
pln->k = ego->k;
pln->rs = X(mkstride)(r, irs);
pln->vs = X(mkstride)(v, ivs);
pln->td = 0;
pln->r = r;
pln->m = m;
pln->ms = ms;
pln->v = v;
pln->mb = mstart;
pln->me = mstart + mcount;
pln->slv = ego;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(mcount/e->genus->vl, &e->ops, &pln->super.super.ops);
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const problem_rdft *p;
iodim *d;
static const plan_adt padt = {
fftwf_rdft_solve, fftwf_null_awake, print, destroy
};
UNUSED(plnr);
if (!applicable(ego_, p_))
return (plan *)0;
p = (const problem_rdft *) p_;
pln = MKPLAN_RDFT(P, &padt, apply);
d = p->sz->dims;
pln->k = ego->k;
pln->is = fftwf_mkstride(d->n, d->is);
pln->os = fftwf_mkstride(d->n, d->os);
fftwf_tensor_tornk1(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
pln->slv = ego;
fftwf_ops_zero(&pln->super.super.ops);
fftwf_ops_madd2(pln->vl / ego->desc->genus->vl,
&ego->desc->ops,
&pln->super.super.ops);
pln->super.super.could_prune_now_p = 1;
return &(pln->super.super);
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const problem_dft *p = (const problem_dft *) p_;
const S *ego = (const S *) ego_;
P *pln;
plan *cld = 0, *cldcpy = 0;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr))
return (plan *) 0;
cldcpy =
X(mkplan_d)(plnr,
X(mkproblem_dft_d)(X(mktensor_0d)(),
X(tensor_append)(p->vecsz, p->sz),
p->ri, p->ii, p->ro, p->io));
if (!cldcpy) goto nada;
cld = X(mkplan_f_d)(plnr, ego->adt->mkcld(p), NO_BUFFERING, 0, 0);
if (!cld) goto nada;
pln = MKPLAN_DFT(P, &padt, ego->adt->apply);
pln->cld = cld;
pln->cldcpy = cldcpy;
pln->slv = ego;
X(ops_add)(&cld->ops, &cldcpy->ops, &pln->super.super.ops);
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cld);
X(plan_destroy_internal)(cldcpy);
return (plan *)0;
}
void SemanticsVisitor::visit(CallingNode& cn) {
cn.getFunctionName()->accept(*this);
try {
if (FunctionAttributes* attr =
dynamic_cast<FunctionAttributes*>(
currentSymbolTable().retrieveSymbol(cn.getFunctionName()->name()))) {
if (applicable(
attr->getSignature(),
getArgTypes(cn.getArgList()))) {
} else {
errorLog() << "Provided parameter not applicable. Expected: " << cn.getFunctionName()->name() << "\n"; // TODO expected...print signature
cn.setType(0); // NOTICE by design, null attribute and error type is 0.
}
} else {
errorLog() << cn.getFunctionName()->name() << " is not a function name.\n";
cn.setType(0); // NOTICE by design, null attribute and error type is 0.
}
} catch (std::runtime_error& e) {
errorLog() << "Function " << cn.getFunctionName()->name() << " undeclared.\n";
cn.setType(0); // NOTICE by design, null attribute and error type is 0.
}
}
/* sacerdoti: An Object Oriented design in C.
* We use function pointers to approximate virtual method functions.
* A recursive-descent design.
*/
static int
tree_report(datum_t *key, datum_t *val, void *arg)
{
client_t *client = (client_t*) arg;
Generic_t *node = (Generic_t*) val->data;
int rc=0;
if (client->filter && !applicable(client->filter, node)) return 1;
rc = node->report_start(node, key, client, NULL);
if (rc) return 1;
applyfilter(client, node);
if (node->children)
{
/* Allow this to stop early (return code = 1) */
hash_foreach(node->children, tree_report, arg);
}
rc = node->report_end(node, client, NULL);
return rc;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const S *ego = (const S *) ego_;
const problem_rdft *p = (const problem_rdft *) p_;
P *pln;
INT n, npad;
INT is, os;
plan *cld1 = (plan *) 0;
plan *cld2 = (plan *) 0;
plan *cld_omega = (plan *) 0;
R *buf = (R *) 0;
problem *cldp;
static const plan_adt padt = {
X(rdft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr))
return (plan *) 0;
n = p->sz->dims[0].n;
is = p->sz->dims[0].is;
os = p->sz->dims[0].os;
if (ego->pad)
npad = choose_transform_size(2 * (n - 1) - 1);
else
npad = n - 1;
/* initial allocation for the purpose of planning */
buf = (R *) MALLOC(sizeof(R) * npad, BUFFERS);
cld1 = X(mkplan_f_d)(plnr,
X(mkproblem_rdft_1_d)(X(mktensor_1d)(npad, 1, 1),
X(mktensor_1d)(1, 0, 0),
buf, buf,
R2HC),
NO_SLOW, 0, 0);
if (!cld1) goto nada;
cldp =
X(mkproblem_rdft_1_d)(
X(mktensor_1d)(npad, 1, 1),
X(mktensor_1d)(1, 0, 0),
buf, buf,
#if R2HC_ONLY_CONV
R2HC
#else
HC2R
#endif
);
if (!(cld2 = X(mkplan_f_d)(plnr, cldp, NO_SLOW, 0, 0)))
goto nada;
/* plan for omega */
cld_omega = X(mkplan_f_d)(plnr,
X(mkproblem_rdft_1_d)(
X(mktensor_1d)(npad, 1, 1),
X(mktensor_1d)(1, 0, 0),
buf, buf, R2HC),
NO_SLOW, ESTIMATE, 0);
if (!cld_omega) goto nada;
/* deallocate buffers; let awake() or apply() allocate them for real */
X(ifree)(buf);
buf = 0;
pln = MKPLAN_RDFT(P, &padt, apply);
pln->cld1 = cld1;
pln->cld2 = cld2;
pln->cld_omega = cld_omega;
pln->omega = 0;
pln->n = n;
pln->npad = npad;
pln->is = is;
pln->os = os;
X(ops_add)(&cld1->ops, &cld2->ops, &pln->super.super.ops);
pln->super.super.ops.other += (npad/2-1)*6 + npad + n + (n-1) * ego->pad;
pln->super.super.ops.add += (npad/2-1)*2 + 2 + (n-1) * ego->pad;
pln->super.super.ops.mul += (npad/2-1)*4 + 2 + ego->pad;
#if R2HC_ONLY_CONV
pln->super.super.ops.other += n-2 - ego->pad;
pln->super.super.ops.add += (npad/2-1)*2 + (n-2) - ego->pad;
#endif
return &(pln->super.super);
nada:
X(ifree0)(buf);
X(plan_destroy_internal)(cld_omega);
X(plan_destroy_internal)(cld2);
X(plan_destroy_internal)(cld1);
return 0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
P *pln;
const problem_rdft *p;
plan *cld;
R *buf;
INT n;
opcnt ops;
static const plan_adt padt = {
X(rdft_solve), awake, print, destroy
};
if (!applicable(ego_, p_, plnr))
return (plan *)0;
p = (const problem_rdft *) p_;
n = p->sz->dims[0].n;
buf = (R *) MALLOC(sizeof(R) * n, BUFFERS);
cld = X(mkplan_d)(plnr, X(mkproblem_rdft_1_d)(X(mktensor_1d)(n, 1, 1),
X(mktensor_0d)(),
buf, buf, R2HC));
X(ifree)(buf);
if (!cld)
return (plan *)0;
switch (p->kind[0]) {
case REDFT01: pln = MKPLAN_RDFT(P, &padt, apply_re01); break;
case REDFT10: pln = MKPLAN_RDFT(P, &padt, apply_re10); break;
case RODFT01: pln = MKPLAN_RDFT(P, &padt, apply_ro01); break;
case RODFT10: pln = MKPLAN_RDFT(P, &padt, apply_ro10); break;
default: A(0); return (plan*)0;
}
pln->n = n;
pln->is = p->sz->dims[0].is;
pln->os = p->sz->dims[0].os;
pln->cld = cld;
pln->td = 0;
pln->kind = p->kind[0];
X(tensor_tornk1)(p->vecsz, &pln->vl, &pln->ivs, &pln->ovs);
X(ops_zero)(&ops);
ops.other = 4 + (n-1)/2 * 10 + (1 - n % 2) * 5;
if (p->kind[0] == REDFT01 || p->kind[0] == RODFT01) {
ops.add = (n-1)/2 * 6;
ops.mul = (n-1)/2 * 4 + (1 - n % 2) * 2;
}
else { /* 10 transforms */
ops.add = (n-1)/2 * 2;
ops.mul = 1 + (n-1)/2 * 6 + (1 - n % 2) * 2;
}
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(pln->vl, &ops, &pln->super.super.ops);
X(ops_madd2)(pln->vl, &cld->ops, &pln->super.super.ops);
return &(pln->super.super);
}
