static int applicable(const solver *ego_, const problem *p_,
const planner *plnr, int *dp)
{
const S *ego = (const S *)ego_;
const problem_dft *p;
if (!applicable0(ego_, p_, dp)) return 0;
/* fftw2 behavior */
if (NO_VRANK_SPLITSP(plnr) && (ego->vecloop_dim != ego->buddies[0]))
return 0;
p = (const problem_dft *) p_;
if (NO_UGLYP(plnr)) {
/* Heuristic: if the transform is multi-dimensional, and the
vector stride is less than the transform size, then we
probably want to use a rank>=2 plan first in order to combine
this vector with the transform-dimension vectors. */
{
iodim *d = p->vecsz->dims + *dp;
if (1
&& p->sz->rnk > 1
&& X(imin)(X(iabs)(d->is), X(iabs)(d->os))
< X(tensor_max_index)(p->sz)
)
return 0;
}
if (NO_NONTHREADEDP(plnr)) return 0; /* prefer threaded version */
}
return 1;
}
static int applicable(const solver *ego_, const problem *p_,
const planner *plnr, int *dp)
{
const S *ego = (const S *)ego_;
if (!applicable0(ego_, p_, dp)) return 0;
/* fftw2 behavior */
if (NO_VRANK_SPLITSP(plnr) && (ego->vecloop_dim != ego->buddies[0]))
return 0;
if (NO_UGLYP(plnr)) {
const problem_rdft2 *p = (const problem_rdft2 *) p_;
iodim *d = p->vecsz->dims + *dp;
/* Heuristic: if the transform is multi-dimensional, and the
vector stride is less than the transform size, then we
probably want to use a rank>=2 plan first in order to combine
this vector with the transform-dimension vectors. */
if (p->sz->rnk > 1
&& X(imin)(X(iabs)(d->is), X(iabs)(d->os))
< X(rdft2_tensor_max_index)(p->sz, p->kind)
)
return 0;
/* Heuristic: don't use a vrank-geq1 for rank-0 vrank-1
transforms, since this case is better handled by rank-0
solvers. */
if (p->sz->rnk == 0 && p->vecsz->rnk == 1) return 0;
if (NO_NONTHREADEDP(plnr))
return 0; /* prefer threaded version */
}
return 1;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const ct_solver *ego = (const ct_solver *) ego_;
const problem_dft *p;
P *pln = 0;
plan *cld = 0, *cldw = 0;
INT n, r, m, v, ivs, ovs;
iodim *d;
static const plan_adt padt = {
X(dft_solve), awake, print, destroy
};
if ((NO_NONTHREADEDP(plnr)) || !X(ct_applicable)(ego, p_, plnr))
return (plan *) 0;
p = (const problem_dft *) p_;
d = p->sz->dims;
n = d[0].n;
r = X(choose_radix)(ego->r, n);
m = n / r;
X(tensor_tornk1)(p->vecsz, &v, &ivs, &ovs);
switch (ego->dec) {
case DECDIT:
{
cldw = ego->mkcldw(ego,
r, m * d[0].os, m * d[0].os,
m, d[0].os,
v, ovs, ovs,
0, m,
p->ro, p->io, plnr);
if (!cldw) goto nada;
cld = X(mkplan_d)(plnr,
X(mkproblem_dft_d)(
X(mktensor_1d)(m, r * d[0].is, d[0].os),
X(mktensor_2d)(r, d[0].is, m * d[0].os,
v, ivs, ovs),
p->ri, p->ii, p->ro, p->io)
);
if (!cld) goto nada;
pln = MKPLAN_DFT(P, &padt, apply_dit);
break;
}
case DECDIF:
case DECDIF+TRANSPOSE:
{
INT cors, covs; /* cldw ors, ovs */
if (ego->dec == DECDIF+TRANSPOSE) {
cors = ivs;
covs = m * d[0].is;
/* ensure that we generate well-formed dftw subproblems */
/* FIXME: too conservative */
if (!(1
&& r == v
&& d[0].is == r * cors))
goto nada;
/* FIXME: allow in-place only for now, like in
fftw-3.[01] */
if (!(1
&& p->ri == p->ro
&& d[0].is == r * d[0].os
&& cors == d[0].os
&& covs == ovs
))
goto nada;
} else {
cors = m * d[0].is;
covs = ivs;
}
cldw = ego->mkcldw(ego,
r, m * d[0].is, cors,
m, d[0].is,
v, ivs, covs,
0, m,
p->ri, p->ii, plnr);
if (!cldw) goto nada;
cld = X(mkplan_d)(plnr,
X(mkproblem_dft_d)(
X(mktensor_1d)(m, d[0].is, r * d[0].os),
X(mktensor_2d)(r, cors, d[0].os,
v, covs, ovs),
p->ri, p->ii, p->ro, p->io)
);
if (!cld) goto nada;
pln = MKPLAN_DFT(P, &padt, apply_dif);
break;
}
default: A(0);
}
pln->cld = cld;
pln->cldw = cldw;
pln->r = r;
X(ops_add)(&cld->ops, &cldw->ops, &pln->super.super.ops);
/* inherit could_prune_now_p attribute from cldw */
pln->super.super.could_prune_now_p = cldw->could_prune_now_p;
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cldw);
X(plan_destroy_internal)(cld);
return (plan *) 0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const hc2hc_solver *ego = (const hc2hc_solver *) ego_;
const problem_rdft *p;
P *pln = 0;
plan *cld = 0, *cldw = 0;
INT n, r, m, vl, ivs, ovs;
iodim *d;
tensor *t1, *t2;
static const plan_adt padt = {
X(rdft_solve), awake, print, destroy
};
if (NO_NONTHREADEDP(plnr) || !X(hc2hc_applicable)(ego, p_, plnr))
return (plan *) 0;
p = (const problem_rdft *) p_;
d = p->sz->dims;
n = d[0].n;
r = X(choose_radix)(ego->r, n);
m = n / r;
X(tensor_tornk1)(p->vecsz, &vl, &ivs, &ovs);
switch (p->kind[0]) {
case R2HC:
cldw = ego->mkcldw(ego,
R2HC, r, m, d[0].os, vl, ovs, 0, (m+2)/2,
p->O, plnr);
if (!cldw) goto nada;
t1 = X(mktensor_1d)(r, d[0].is, m * d[0].os);
t2 = X(tensor_append)(t1, p->vecsz);
X(tensor_destroy)(t1);
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft_d)(
X(mktensor_1d)(m, r * d[0].is, d[0].os),
t2, p->I, p->O, p->kind)
);
if (!cld) goto nada;
pln = MKPLAN_RDFT(P, &padt, apply_dit);
break;
case HC2R:
cldw = ego->mkcldw(ego,
HC2R, r, m, d[0].is, vl, ivs, 0, (m+2)/2,
p->I, plnr);
if (!cldw) goto nada;
t1 = X(mktensor_1d)(r, m * d[0].is, d[0].os);
t2 = X(tensor_append)(t1, p->vecsz);
X(tensor_destroy)(t1);
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft_d)(
X(mktensor_1d)(m, d[0].is, r * d[0].os),
t2, p->I, p->O, p->kind)
);
if (!cld) goto nada;
pln = MKPLAN_RDFT(P, &padt, apply_dif);
break;
default:
A(0);
}
pln->cld = cld;
pln->cldw = cldw;
pln->r = r;
X(ops_add)(&cld->ops, &cldw->ops, &pln->super.super.ops);
/* inherit could_prune_now_p attribute from cldw */
pln->super.super.could_prune_now_p = cldw->could_prune_now_p;
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cldw);
X(plan_destroy_internal)(cld);
return (plan *) 0;
}
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
const hc2hc_solver *ego = (const hc2hc_solver *) ego_;
const problem_rdft *p;
P *pln = 0;
plan *cld = 0, *cldw = 0;
INT n, r, m, v, ivs, ovs;
iodim *d;
static const plan_adt padt = {
fftwf_rdft_solve, awake, print, destroy
};
if (NO_NONTHREADEDP(plnr) || !fftwf_hc2hc_applicable(ego, p_, plnr))
return (plan *) 0;
p = (const problem_rdft *) p_;
d = p->sz->dims;
n = d[0].n;
r = fftwf_choose_radix(ego->r, n);
m = n / r;
fftwf_tensor_tornk1(p->vecsz, &v, &ivs, &ovs);
switch (p->kind[0]) {
case R2HC:
cldw = ego->mkcldw(ego,
R2HC, r, m, d[0].os, v, ovs, 0, (m+2)/2,
p->O, plnr);
if (!cldw) goto nada;
cld = fftwf_mkplan_d(plnr,
fftwf_mkproblem_rdft_d(
fftwf_mktensor_1d(m, r * d[0].is, d[0].os),
fftwf_mktensor_2d(r, d[0].is, m * d[0].os,
v, ivs, ovs),
p->I, p->O, p->kind)
);
if (!cld) goto nada;
pln = MKPLAN_RDFT(P, &padt, apply_dit);
break;
case HC2R:
cldw = ego->mkcldw(ego,
HC2R, r, m, d[0].is, v, ivs, 0, (m+2)/2,
p->I, plnr);
if (!cldw) goto nada;
cld = fftwf_mkplan_d(plnr,
fftwf_mkproblem_rdft_d(
fftwf_mktensor_1d(m, d[0].is, r * d[0].os),
fftwf_mktensor_2d(r, m * d[0].is, d[0].os,
v, ivs, ovs),
p->I, p->O, p->kind)
);
if (!cld) goto nada;
pln = MKPLAN_RDFT(P, &padt, apply_dif);
break;
default:
A(0);
}
pln->cld = cld;
pln->cldw = cldw;
pln->r = r;
fftwf_ops_add(&cld->ops, &cldw->ops, &pln->super.super.ops);
/* inherit could_prune_now_p attribute from cldw */
pln->super.super.could_prune_now_p = cldw->could_prune_now_p;
return &(pln->super.super);
nada:
fftwf_plan_destroy_internal(cldw);
fftwf_plan_destroy_internal(cld);
return (plan *) 0;
}
