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: cannam@127: static planner_hook_t before_planner_hook = 0, after_planner_hook = 0; cannam@127: cannam@127: void X(set_planner_hooks)(planner_hook_t before, planner_hook_t after) cannam@127: { cannam@127: before_planner_hook = before; cannam@127: after_planner_hook = after; cannam@127: } cannam@127: cannam@127: static plan *mkplan0(planner *plnr, unsigned flags, cannam@127: const problem *prb, unsigned hash_info, cannam@127: wisdom_state_t wisdom_state) cannam@127: { cannam@127: /* map API flags into FFTW flags */ cannam@127: X(mapflags)(plnr, flags); cannam@127: cannam@127: plnr->flags.hash_info = hash_info; cannam@127: plnr->wisdom_state = wisdom_state; cannam@127: cannam@127: /* create plan */ cannam@127: return plnr->adt->mkplan(plnr, prb); cannam@127: } cannam@127: cannam@127: static unsigned force_estimator(unsigned flags) cannam@127: { cannam@127: flags &= ~(FFTW_MEASURE | FFTW_PATIENT | FFTW_EXHAUSTIVE); cannam@127: return (flags | FFTW_ESTIMATE); cannam@127: } cannam@127: cannam@127: static plan *mkplan(planner *plnr, unsigned flags, cannam@127: const problem *prb, unsigned hash_info) cannam@127: { cannam@127: plan *pln; cannam@127: cannam@127: pln = mkplan0(plnr, flags, prb, hash_info, WISDOM_NORMAL); cannam@127: cannam@127: if (plnr->wisdom_state == WISDOM_NORMAL && !pln) { cannam@127: /* maybe the planner failed because of inconsistent wisdom; cannam@127: plan again ignoring infeasible wisdom */ cannam@127: pln = mkplan0(plnr, force_estimator(flags), prb, cannam@127: hash_info, WISDOM_IGNORE_INFEASIBLE); cannam@127: } cannam@127: cannam@127: if (plnr->wisdom_state == WISDOM_IS_BOGUS) { cannam@127: /* if the planner detected a wisdom inconsistency, cannam@127: forget all wisdom and plan again */ cannam@127: plnr->adt->forget(plnr, FORGET_EVERYTHING); cannam@127: cannam@127: A(!pln); cannam@127: pln = mkplan0(plnr, flags, prb, hash_info, WISDOM_NORMAL); cannam@127: cannam@127: if (plnr->wisdom_state == WISDOM_IS_BOGUS) { cannam@127: /* if it still fails, plan without wisdom */ cannam@127: plnr->adt->forget(plnr, FORGET_EVERYTHING); cannam@127: cannam@127: A(!pln); cannam@127: pln = mkplan0(plnr, force_estimator(flags), cannam@127: prb, hash_info, WISDOM_IGNORE_ALL); cannam@127: } cannam@127: } cannam@127: cannam@127: return pln; cannam@127: } cannam@127: cannam@127: apiplan *X(mkapiplan)(int sign, unsigned flags, problem *prb) cannam@127: { cannam@127: apiplan *p = 0; cannam@127: plan *pln; cannam@127: unsigned flags_used_for_planning; cannam@127: planner *plnr; cannam@127: static const unsigned int pats[] = {FFTW_ESTIMATE, FFTW_MEASURE, cannam@127: FFTW_PATIENT, FFTW_EXHAUSTIVE}; cannam@127: int pat, pat_max; cannam@127: double pcost = 0; cannam@127: cannam@127: if (before_planner_hook) cannam@127: before_planner_hook(); cannam@127: cannam@127: plnr = X(the_planner)(); cannam@127: cannam@127: if (flags & FFTW_WISDOM_ONLY) { cannam@127: /* Special mode that returns a plan only if wisdom is present, cannam@127: and returns 0 otherwise. This is now documented in the manual, cannam@127: as a way to detect whether wisdom is available for a problem. */ cannam@127: flags_used_for_planning = flags; cannam@127: pln = mkplan0(plnr, flags, prb, 0, WISDOM_ONLY); cannam@127: } else { cannam@127: pat_max = flags & FFTW_ESTIMATE ? 0 : cannam@127: (flags & FFTW_EXHAUSTIVE ? 3 : cannam@127: (flags & FFTW_PATIENT ? 2 : 1)); cannam@127: pat = plnr->timelimit >= 0 ? 0 : pat_max; cannam@127: cannam@127: flags &= ~(FFTW_ESTIMATE | FFTW_MEASURE | cannam@127: FFTW_PATIENT | FFTW_EXHAUSTIVE); cannam@127: cannam@127: plnr->start_time = X(get_crude_time)(); cannam@127: cannam@127: /* plan at incrementally increasing patience until we run cannam@127: out of time */ cannam@127: for (pln = 0, flags_used_for_planning = 0; pat <= pat_max; ++pat) { cannam@127: plan *pln1; cannam@127: unsigned tmpflags = flags | pats[pat]; cannam@127: pln1 = mkplan(plnr, tmpflags, prb, 0u); cannam@127: cannam@127: if (!pln1) { cannam@127: /* don't bother continuing if planner failed or timed out */ cannam@127: A(!pln || plnr->timed_out); cannam@127: break; cannam@127: } cannam@127: cannam@127: X(plan_destroy_internal)(pln); cannam@127: pln = pln1; cannam@127: flags_used_for_planning = tmpflags; cannam@127: pcost = pln->pcost; cannam@127: } cannam@127: } cannam@127: cannam@127: if (pln) { cannam@127: /* build apiplan */ cannam@127: p = (apiplan *) MALLOC(sizeof(apiplan), PLANS); cannam@127: p->prb = prb; cannam@127: p->sign = sign; /* cache for execute_dft */ cannam@127: cannam@127: /* re-create plan from wisdom, adding blessing */ cannam@127: p->pln = mkplan(plnr, flags_used_for_planning, prb, BLESSING); cannam@127: cannam@127: /* record pcost from most recent measurement for use in X(cost) */ cannam@127: p->pln->pcost = pcost; cannam@127: cannam@127: if (sizeof(trigreal) > sizeof(R)) { cannam@127: /* this is probably faster, and we have enough trigreal cannam@127: bits to maintain accuracy */ cannam@127: X(plan_awake)(p->pln, AWAKE_SQRTN_TABLE); cannam@127: } else { cannam@127: /* more accurate */ cannam@127: X(plan_awake)(p->pln, AWAKE_SINCOS); cannam@127: } cannam@127: cannam@127: /* we don't use pln for p->pln, above, since by re-creating the cannam@127: plan we might use more patient wisdom from a timed-out mkplan */ cannam@127: X(plan_destroy_internal)(pln); cannam@127: } else cannam@127: X(problem_destroy)(prb); cannam@127: cannam@127: /* discard all information not necessary to reconstruct the plan */ cannam@127: plnr->adt->forget(plnr, FORGET_ACCURSED); cannam@127: cannam@127: #ifdef FFTW_RANDOM_ESTIMATOR cannam@127: X(random_estimate_seed)++; /* subsequent "random" plans are distinct */ cannam@127: #endif cannam@127: cannam@127: if (after_planner_hook) cannam@127: after_planner_hook(); cannam@127: cannam@127: return p; cannam@127: } cannam@127: cannam@127: void X(destroy_plan)(X(plan) p) cannam@127: { cannam@127: if (p) { cannam@127: X(plan_awake)(p->pln, SLEEPY); cannam@127: X(plan_destroy_internal)(p->pln); cannam@127: X(problem_destroy)(p->prb); cannam@127: X(ifree)(p); cannam@127: } cannam@127: } cannam@127: cannam@127: int X(alignment_of)(R *p) cannam@127: { cannam@127: return X(ialignment_of(p)); cannam@127: }