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