static int applicable(INT r, INT m, const planner *plnr)
{
UNUSED(r); UNUSED(m);
return (1
&& !NO_SLOWP(plnr)
);
}
static int applicable(const solver *ego, const problem *p_, const planner *plnr)
{
const problem_rdft *p = (const problem_rdft *) p_;
UNUSED(ego);
return (1
&& p->sz->rnk == 1
&& p->vecsz->rnk == 0
&& p->kind[0] == DHT
&& X(is_prime)(p->sz->dims[0].n)
&& p->sz->dims[0].n > 2
&& CIMPLIES(NO_SLOWP(plnr), p->sz->dims[0].n > RADER_MAX_SLOW)
/* proclaim the solver SLOW if p-1 is not easily
factorizable. Unlike in the complex case where
Bluestein can solve the problem, in the DHT case we
may have no other choice */
&& CIMPLIES(NO_SLOWP(plnr), X(factors_into_small_primes)(p->sz->dims[0].n - 1))
);
}
static int applicable(rdft_kind kind, INT r, INT m, const planner *plnr)
{
return (1
&& (kind == R2HC || kind == HC2R)
&& (m % 2)
&& (r % 2)
&& !NO_SLOWP(plnr)
);
}
static int applicable(const S *ego, const problem *p_,
const planner *plnr)
{
const problem_mpi_dft *p = (const problem_mpi_dft *) p_;
return (1
&& p->sz->rnk > 1
&& p->flags == 0 /* TRANSPOSED/SCRAMBLED_IN/OUT not supported */
&& (!ego->preserve_input || (!NO_DESTROY_INPUTP(plnr)
&& p->I != p->O))
&& XM(is_local_after)(1, p->sz, IB)
&& XM(is_local_after)(1, p->sz, OB)
&& (!NO_SLOWP(plnr) /* slow if dft-serial is applicable */
|| !XM(dft_serial_applicable)(p))
);
}
static int applicable(const solver *ego, const problem *p_,
const planner *plnr)
{
const problem_dft *p = (const problem_dft *) p_;
UNUSED(ego);
return (1
&& p->sz->rnk == 1
&& p->vecsz->rnk == 0
&& (p->sz->dims[0].n % 2) == 1
&& CIMPLIES(NO_LARGE_GENERICP(plnr), p->sz->dims[0].n < GENERIC_MIN_BAD)
&& CIMPLIES(NO_SLOWP(plnr), p->sz->dims[0].n > GENERIC_MAX_SLOW)
&& X(is_prime)(p->sz->dims[0].n)
);
}
static int applicable(const S *ego, const problem *p_,
const planner *plnr)
{
const problem_mpi_dft *p = (const problem_mpi_dft *) p_;
return (1
&& p->sz->rnk > 1
&& p->flags == TRANSPOSED_OUT
&& (!ego->preserve_input || (!NO_DESTROY_INPUTP(plnr)
&& p->I != p->O))
&& XM(is_local_after)(1, p->sz, IB)
&& XM(is_local_after)(2, p->sz, OB)
&& XM(num_blocks)(p->sz->dims[0].n, p->sz->dims[0].b[OB]) == 1
&& (!NO_SLOWP(plnr) /* slow if dft-serial is applicable */
|| !XM(dft_serial_applicable)(p))
);
}
static int applicable(const solver *ego, const problem *p_,
const planner *plnr)
{
const problem_dft *p = (const problem_dft *) p_;
UNUSED(ego);
return (1
&& p->sz->rnk == 1
&& p->vecsz->rnk == 0
/* FIXME: allow other sizes */
&& X(is_prime)(p->sz->dims[0].n)
/* FIXME: avoid infinite recursion of bluestein with itself.
This works because all factors in child problems are 2, 3, 5 */
&& p->sz->dims[0].n > 16
&& CIMPLIES(NO_SLOWP(plnr), p->sz->dims[0].n > BLUESTEIN_MAX_SLOW)
);
}
static int applicable(const S *ego, const problem *p_,
const planner *plnr, int *r)
{
const problem_mpi_transpose *p = (const problem_mpi_transpose *) p_;
int n_pes;
MPI_Comm_size(p->comm, &n_pes);
return (1
&& p->tblock * n_pes == p->ny
&& (!ego->preserve_input || (!NO_DESTROY_INPUTP(plnr)
&& p->I != p->O))
&& (*r = ego->radix(n_pes)) && *r < n_pes && *r > 1
&& enough_space(p->nx, p->ny, p->block, p->tblock, *r, n_pes)
&& (!CONSERVE_MEMORYP(plnr) || *r > 8
|| !X(toobig)((p->nx * (p->ny / n_pes) * p->vn) / *r))
&& (!NO_SLOWP(plnr) ||
(p->nx * (p->ny / n_pes) * p->vn) / n_pes <= SMALL_MESSAGE)
&& ONLY_TRANSPOSEDP(p->flags)
);
}
static int applicable(const S *ego, const problem *p_,
const planner *plnr)
{
const problem_mpi_dft *p = (const problem_mpi_dft *) p_;
int n_pes;
MPI_Comm_size(p->comm, &n_pes);
return (1
&& p->sz->rnk == 1
&& !(p->flags & ~RANK1_BIGVEC_ONLY)
&& (!ego->preserve_input || (!NO_DESTROY_INPUTP(plnr)
&& p->I != p->O))
&& (p->vn >= n_pes /* TODO: relax this, using more memory? */
|| (p->flags & RANK1_BIGVEC_ONLY))
&& XM(rearrange_applicable)(ego->rearrange,
p->sz->dims[0], p->vn, n_pes)
&& (!NO_SLOWP(plnr) /* slow if dft-serial is applicable */
|| !XM(dft_serial_applicable)(p))
);
}
static int applicable(const solver *ego, const problem *p, const planner *plnr)
{
return (!NO_SLOWP(plnr) && applicable0(ego, p));
}
static int applicable(const solver *ego, const problem *p, const planner *plnr)
{
UNUSED(ego);
return (!NO_SLOWP(plnr) && applicable0(p, plnr));
}