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