From 183ab64110ee0838e17e5e68264f27d9816188c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D1=8B=D1=87=D0=BA=D0=BE=D0=B2=20=D0=90=D0=BD=D0=B4?= =?UTF-8?q?=D1=80=D0=B5=D0=B9?= Date: Wed, 12 Apr 2017 16:24:20 +0000 Subject: [PATCH] git-svn-id: svn://db.shs.com.ru/pip@342 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5 --- main.cpp | 16 +++------ src/math/pifft_p.h | 85 ++++++++++++++++++++++++++++++---------------- 2 files changed, 60 insertions(+), 41 deletions(-) diff --git a/main.cpp b/main.cpp index 12de35b0..df93d5c9 100644 --- a/main.cpp +++ b/main.cpp @@ -41,19 +41,13 @@ int asize(ssize_t s, size_t pid_rsize) { return (1 << t); } int main(int argc, char *argv[]) { - PIDeque in; - for (int i = 0; i < 5; ++i) - in << i%10; - /*PIFFTWd fft; - fft.preparePlan(50, PIFFTWd::foReal); - PIVector out = fft.calcFFT(in);*/ - piCout << in.data(); - in.align(); - piCout << in.data(); - in = PIDeque(); + PIVector in; for (int i = 0; i < 50; ++i) in << i%10; - piCout << in.data(); + PIFFTWf fft; + fft.preparePlan(50, PIFFTWf::foReal); + PIVector out = fft.calcFFT(in); + piCout << out; /*for (int i = 0; i < 16; ++i) { piCout << asize(i, 100); } diff --git a/src/math/pifft_p.h b/src/math/pifft_p.h index a3fe041e..0caf2446 100644 --- a/src/math/pifft_p.h +++ b/src/math/pifft_p.h @@ -42,6 +42,8 @@ class PIFFTW_Private public: explicit PIFFTW_Private() { plan = 0; + p_in = p_out = 0; + p_inr = 0; #ifdef PIP_FFTW // fftwf_m #else @@ -49,74 +51,94 @@ public: #endif p_makeThreadSafe(); } - ~PIFFTW_Private() {p_destroyPlan(plan);} + ~PIFFTW_Private() { + p_destroyPlan(plan); + delVec(p_in); + delVec(p_out); + delVec(p_inr); + } const PIVector > & calcFFT(const PIVector > & in) { if (prepare != PlanParams(in.size(), fo_complex)) { - p_out.resize(in.size()); + newVec(p_in, in.size()); + newVec(p_out, in.size()); piCout << "[PIFFTW]" << "creating plan"; - p_createPlan_c2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_FORWARD, FFTW_ESTIMATE | FFTW_UNALIGNED); + p_createPlan_c2c_1d(plan, in.size(), p_in, p_out, FFTW_FORWARD, FFTW_ESTIMATE); + v_out.resize(in.size()); prepare = PlanParams(in.size(), fo_complex); } - p_executePlan_c2c(plan, in.data(), p_out.data()); - return p_out; + memcpy(p_in, in.data(), sizeof(complex) * in.size()); + p_executePlan(plan); + memcpy(v_out.data(), p_out, sizeof(complex) * v_out.size()); + return v_out; } const PIVector > & calcFFT(const PIVector & in) { if (prepare != PlanParams(in.size(), fo_real)) { - p_out.resize(in.size()); + newVec(p_inr, in.size()); + newVec(p_out, in.size()); piCout << "[PIFFTW]" << "creating plan"; - p_createPlan_r2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_ESTIMATE | FFTW_UNALIGNED); + p_createPlan_r2c_1d(plan, in.size(), p_inr, p_out, FFTW_ESTIMATE); + v_out.resize(in.size()); prepare = PlanParams(in.size(), fo_real); } - p_executePlan_r2c(plan, in.data(), p_out.data()); - return p_out; + memcpy(p_inr, in.data(), sizeof(T) * in.size()); + p_executePlan(plan); + memcpy(v_out.data(), p_out, sizeof(complex) * v_out.size()); + return v_out; } const PIVector > & calcFFTinverse(const PIVector > & in) { - if (prepare != PlanParams(in.size(), fo_inverse)) { - p_out.resize(in.size()); + if (prepare != PlanParams(in.size(), fo_complex)) { + newVec(p_in, in.size()); + newVec(p_out, in.size()); piCout << "[PIFFTW]" << "creating plan"; - p_createPlan_c2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_UNALIGNED); - prepare = PlanParams(in.size(), fo_inverse); + p_createPlan_c2c_1d(plan, in.size(), p_in, p_out, FFTW_BACKWARD, FFTW_ESTIMATE); + v_out.resize(in.size()); + prepare = PlanParams(in.size(), fo_complex); } - p_executePlan_c2c(plan, in.data(), p_out.data()); - return p_out; + memcpy(p_in, in.data(), sizeof(complex) * in.size()); + p_executePlan(plan); + memcpy(v_out.data(), p_out, sizeof(complex) * v_out.size()); + return v_out; } enum FFT_Operation {fo_real, fo_complex, fo_inverse}; void preparePlan(int size, int op) { - p_inr.clear(); - p_in.clear(); - p_out.clear(); switch ((FFT_Operation)op) { case fo_real: - p_inr.resize(size); - p_out.resize(size); - p_createPlan_r2c_1d(plan, size, p_inr.data(), p_out.data(), FFTW_MEASURE | FFTW_UNALIGNED); + newVec(p_inr, size); + newVec(p_out, size); + p_createPlan_r2c_1d(plan, size, p_inr, p_out, FFTW_MEASURE); break; case fo_complex: - p_in.resize(size); - p_out.resize(size); - p_createPlan_c2c_1d(plan, size, p_in.data(), p_out.data(), FFTW_FORWARD, FFTW_MEASURE | FFTW_UNALIGNED); + newVec(p_in, size); + newVec(p_out, size); + p_createPlan_c2c_1d(plan, size, p_in, p_out, FFTW_FORWARD, FFTW_MEASURE); break; case fo_inverse: - p_in.resize(size); - p_out.resize(size); - p_createPlan_c2c_1d(plan, size, p_in.data(), p_out.data(), FFTW_BACKWARD, FFTW_MEASURE | FFTW_UNALIGNED); + newVec(p_in, size); + newVec(p_out, size); + p_createPlan_c2c_1d(plan, size, p_in, p_out, FFTW_BACKWARD, FFTW_MEASURE); break; default: size = 0; break; } + v_out.resize(size); prepare = PlanParams(size, (FFT_Operation)op); } inline void p_createPlan_c2c_1d(void *& plan, int size, const void * in, void * out, int dir, int flags) {} inline void p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) {} + inline void p_executePlan(void * plan) {} inline void p_executePlan_c2c(void * plan, const void * in, void * out) {} inline void p_executePlan_r2c(void * plan, const void * in, void * out) {} inline void p_destroyPlan(void *& plan) {} inline void p_makeThreadSafe() {} + template + inline void newVec(VT *& v, int size) {delVec(v); v = (VT*)amalloc(sizeof(VT) * size);} + template + inline void delVec(VT *& v) {if (v) afree(v); v = 0;} struct PlanParams { PlanParams() {size = 0; op = fo_complex;} @@ -128,9 +150,9 @@ public: FFT_Operation op; }; - PIVector > p_in; - PIVector p_inr; - PIVector > p_out; + complex * p_in, * p_out; + T * p_inr; + PIVector > v_out; void * plan; PlanParams prepare; }; @@ -141,6 +163,7 @@ template<> inline void PIFFTW_Private::p_createPlan_c2c_1d(void *& plan, plan = fftwf_plan_dft_1d(size, (fftwf_complex *)in, (fftwf_complex *)out, dir, flags);} template<> inline void PIFFTW_Private::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) { plan = fftwf_plan_dft_r2c_1d(size, (float *)in, (fftwf_complex *)out, flags);} +template<> inline void PIFFTW_Private::p_executePlan(void * plan) {fftwf_execute((fftwf_plan)plan);} template<> inline void PIFFTW_Private::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwf_execute_dft((fftwf_plan)plan, (fftwf_complex *)in, (fftwf_complex *)out);} template<> inline void PIFFTW_Private::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwf_execute_dft_r2c((fftwf_plan)plan, (float *)in, (fftwf_complex *)out);} template<> inline void PIFFTW_Private::p_destroyPlan(void *& plan) {if (plan) fftwf_destroy_plan((fftwf_plan)plan); plan = 0;} @@ -150,6 +173,7 @@ template<> inline void PIFFTW_Private::p_createPlan_c2c_1d(void *& plan, plan = fftw_plan_dft_1d(size, (fftw_complex *)in, (fftw_complex *)out, dir, flags);} template<> inline void PIFFTW_Private::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) { plan = fftw_plan_dft_r2c_1d(size, (double *)in, (fftw_complex *)out, flags);} +template<> inline void PIFFTW_Private::p_executePlan(void * plan) {fftw_execute((fftw_plan)plan);} template<> inline void PIFFTW_Private::p_executePlan_c2c(void * plan, const void * in, void * out) {fftw_execute_dft((fftw_plan)plan, (fftw_complex *)in, (fftw_complex *)out);} template<> inline void PIFFTW_Private::p_executePlan_r2c(void * plan, const void * in, void * out) {fftw_execute_dft_r2c((fftw_plan)plan, (double *)in, (fftw_complex *)out);} template<> inline void PIFFTW_Private::p_destroyPlan(void *& plan) {if (plan) fftw_destroy_plan((fftw_plan)plan); plan = 0;} @@ -160,6 +184,7 @@ template<> inline void PIFFTW_Private::p_createPlan_c2c_1d(void *& plan plan = fftwl_plan_dft_1d(size, (fftwl_complex *)in, (fftwl_complex *)out, dir, flags);} template<> inline void PIFFTW_Private::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) { plan = fftwl_plan_dft_r2c_1d(size, (ldouble *)in, (fftwl_complex *)out, flags);} +template<> inline void PIFFTW_Private::p_executePlan(void * plan) {fftwl_execute((fftwl_plan)plan);} template<> inline void PIFFTW_Private::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwl_execute_dft((fftwl_plan)plan, (fftwl_complex *)in, (fftwl_complex *)out);} template<> inline void PIFFTW_Private::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwl_execute_dft_r2c((fftwl_plan)plan, (ldouble *)in, (fftwl_complex *)out);} template<> inline void PIFFTW_Private::p_destroyPlan(void *& plan) {if (plan) fftwl_destroy_plan((fftwl_plan)plan); plan = 0;}