cannam@167: /* cannam@167: * Copyright (c) 2003, 2007-14 Matteo Frigo cannam@167: * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology cannam@167: * cannam@167: * This program is free software; you can redistribute it and/or modify cannam@167: * it under the terms of the GNU General Public License as published by cannam@167: * the Free Software Foundation; either version 2 of the License, or cannam@167: * (at your option) any later version. cannam@167: * cannam@167: * This program is distributed in the hope that it will be useful, cannam@167: * but WITHOUT ANY WARRANTY; without even the implied warranty of cannam@167: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the cannam@167: * GNU General Public License for more details. cannam@167: * cannam@167: * You should have received a copy of the GNU General Public License cannam@167: * along with this program; if not, write to the Free Software cannam@167: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA cannam@167: * cannam@167: */ cannam@167: cannam@167: #include "api/api.h" cannam@167: #include cannam@167: cannam@167: /* a flag operation: x is either a flag, in which case xm == 0, or cannam@167: a mask, in which case xm == x; using this we can compactly code cannam@167: the various bit operations via (flags & x) ^ xm or (flags | x) ^ xm. */ cannam@167: typedef struct { cannam@167: unsigned x, xm; cannam@167: } flagmask; cannam@167: cannam@167: typedef struct { cannam@167: flagmask flag; cannam@167: flagmask op; cannam@167: } flagop; cannam@167: cannam@167: #define FLAGP(f, msk)(((f) & (msk).x) ^ (msk).xm) cannam@167: #define OP(f, msk)(((f) | (msk).x) ^ (msk).xm) cannam@167: cannam@167: #define YES(x) {x, 0} cannam@167: #define NO(x) {x, x} cannam@167: #define IMPLIES(predicate, consequence) { predicate, consequence } cannam@167: #define EQV(a, b) IMPLIES(YES(a), YES(b)), IMPLIES(NO(a), NO(b)) cannam@167: #define NEQV(a, b) IMPLIES(YES(a), NO(b)), IMPLIES(NO(a), YES(b)) cannam@167: cannam@167: static void map_flags(unsigned *iflags, unsigned *oflags, cannam@167: const flagop flagmap[], size_t nmap) cannam@167: { cannam@167: size_t i; cannam@167: for (i = 0; i < nmap; ++i) cannam@167: if (FLAGP(*iflags, flagmap[i].flag)) cannam@167: *oflags = OP(*oflags, flagmap[i].op); cannam@167: } cannam@167: cannam@167: /* encoding of the planner timelimit into a BITS_FOR_TIMELIMIT-bits cannam@167: nonnegative integer, such that we can still view the integer as cannam@167: ``impatience'': higher means *lower* time limit, and 0 is the cannam@167: highest possible value (about 1 year of calendar time) */ cannam@167: static unsigned timelimit_to_flags(double timelimit) cannam@167: { cannam@167: const double tmax = 365 * 24 * 3600; cannam@167: const double tstep = 1.05; cannam@167: const int nsteps = (1 << BITS_FOR_TIMELIMIT); cannam@167: int x; cannam@167: cannam@167: if (timelimit < 0 || timelimit >= tmax) cannam@167: return 0; cannam@167: if (timelimit <= 1.0e-10) cannam@167: return nsteps - 1; cannam@167: cannam@167: x = (int) (0.5 + (log(tmax / timelimit) / log(tstep))); cannam@167: cannam@167: if (x < 0) x = 0; cannam@167: if (x >= nsteps) x = nsteps - 1; cannam@167: return x; cannam@167: } cannam@167: cannam@167: void X(mapflags)(planner *plnr, unsigned flags) cannam@167: { cannam@167: unsigned l, u, t; cannam@167: cannam@167: /* map of api flags -> api flags, to implement consistency rules cannam@167: and combination flags */ cannam@167: const flagop self_flagmap[] = { cannam@167: /* in some cases (notably for halfcomplex->real transforms), cannam@167: DESTROY_INPUT is the default, so we need to support cannam@167: an inverse flag to disable it. cannam@167: cannam@167: (PRESERVE, DESTROY) -> (PRESERVE, DESTROY) cannam@167: (0, 0) (1, 0) cannam@167: (0, 1) (0, 1) cannam@167: (1, 0) (1, 0) cannam@167: (1, 1) (1, 0) cannam@167: */ cannam@167: IMPLIES(YES(FFTW_PRESERVE_INPUT), NO(FFTW_DESTROY_INPUT)), cannam@167: IMPLIES(NO(FFTW_DESTROY_INPUT), YES(FFTW_PRESERVE_INPUT)), cannam@167: cannam@167: IMPLIES(YES(FFTW_EXHAUSTIVE), YES(FFTW_PATIENT)), cannam@167: cannam@167: IMPLIES(YES(FFTW_ESTIMATE), NO(FFTW_PATIENT)), cannam@167: IMPLIES(YES(FFTW_ESTIMATE), cannam@167: YES(FFTW_ESTIMATE_PATIENT cannam@167: | FFTW_NO_INDIRECT_OP cannam@167: | FFTW_ALLOW_PRUNING)), cannam@167: cannam@167: IMPLIES(NO(FFTW_EXHAUSTIVE), cannam@167: YES(FFTW_NO_SLOW)), cannam@167: cannam@167: /* a canonical set of fftw2-like impatience flags */ cannam@167: IMPLIES(NO(FFTW_PATIENT), cannam@167: YES(FFTW_NO_VRECURSE cannam@167: | FFTW_NO_RANK_SPLITS cannam@167: | FFTW_NO_VRANK_SPLITS cannam@167: | FFTW_NO_NONTHREADED cannam@167: | FFTW_NO_DFT_R2HC cannam@167: | FFTW_NO_FIXED_RADIX_LARGE_N cannam@167: | FFTW_BELIEVE_PCOST)) cannam@167: }; cannam@167: cannam@167: /* map of (processed) api flags to internal problem/planner flags */ cannam@167: const flagop l_flagmap[] = { cannam@167: EQV(FFTW_PRESERVE_INPUT, NO_DESTROY_INPUT), cannam@167: EQV(FFTW_NO_SIMD, NO_SIMD), cannam@167: EQV(FFTW_CONSERVE_MEMORY, CONSERVE_MEMORY), cannam@167: EQV(FFTW_NO_BUFFERING, NO_BUFFERING), cannam@167: NEQV(FFTW_ALLOW_LARGE_GENERIC, NO_LARGE_GENERIC) cannam@167: }; cannam@167: cannam@167: const flagop u_flagmap[] = { cannam@167: IMPLIES(YES(FFTW_EXHAUSTIVE), NO(0xFFFFFFFF)), cannam@167: IMPLIES(NO(FFTW_EXHAUSTIVE), YES(NO_UGLY)), cannam@167: cannam@167: /* the following are undocumented, "beyond-guru" flags that cannam@167: require some understanding of FFTW internals */ cannam@167: EQV(FFTW_ESTIMATE_PATIENT, ESTIMATE), cannam@167: EQV(FFTW_ALLOW_PRUNING, ALLOW_PRUNING), cannam@167: EQV(FFTW_BELIEVE_PCOST, BELIEVE_PCOST), cannam@167: EQV(FFTW_NO_DFT_R2HC, NO_DFT_R2HC), cannam@167: EQV(FFTW_NO_NONTHREADED, NO_NONTHREADED), cannam@167: EQV(FFTW_NO_INDIRECT_OP, NO_INDIRECT_OP), cannam@167: EQV(FFTW_NO_RANK_SPLITS, NO_RANK_SPLITS), cannam@167: EQV(FFTW_NO_VRANK_SPLITS, NO_VRANK_SPLITS), cannam@167: EQV(FFTW_NO_VRECURSE, NO_VRECURSE), cannam@167: EQV(FFTW_NO_SLOW, NO_SLOW), cannam@167: EQV(FFTW_NO_FIXED_RADIX_LARGE_N, NO_FIXED_RADIX_LARGE_N) cannam@167: }; cannam@167: cannam@167: map_flags(&flags, &flags, self_flagmap, NELEM(self_flagmap)); cannam@167: cannam@167: l = u = 0; cannam@167: map_flags(&flags, &l, l_flagmap, NELEM(l_flagmap)); cannam@167: map_flags(&flags, &u, u_flagmap, NELEM(u_flagmap)); cannam@167: cannam@167: /* enforce l <= u */ cannam@167: PLNR_L(plnr) = l; cannam@167: PLNR_U(plnr) = u | l; cannam@167: cannam@167: /* assert that the conversion didn't lose bits */ cannam@167: A(PLNR_L(plnr) == l); cannam@167: A(PLNR_U(plnr) == (u | l)); cannam@167: cannam@167: /* compute flags representation of the timelimit */ cannam@167: t = timelimit_to_flags(plnr->timelimit); cannam@167: cannam@167: PLNR_TIMELIMIT_IMPATIENCE(plnr) = t; cannam@167: A(PLNR_TIMELIMIT_IMPATIENCE(plnr) == t); cannam@167: }