Skip to content
Snippets Groups Projects

Draft: Add working cache code for fftw

Open Draft: Add working cache code for fftw
add_fftw_cache into master
4 unresolved threads
Open Mattia Mancini requested to merge add_fftw_cache into master
4 unresolved threads

Merge request reports

Loading
Loading

Activity

Filter activity
  • Approvals
  • Assignees & reviewers
  • Comments (from bots)
  • Comments (from users)
  • Commits & branches
  • Edits
  • Labels
  • Lock status
  • Mentions
  • Merge request status
  • Tracking
src/math/convolution.cc
25 void manual_destroy(fftwf_plan plan) {
26 if (plan != nullptr) fftwf_destroy_plan(plan);
27 }
28
29 class SmartFFTPlan
30 : public std::unique_ptr<fftwf_plan_s, decltype(&manual_destroy)> {
31 public:
32 SmartFFTPlan()
33 : std::unique_ptr<fftwf_plan_s, decltype(&manual_destroy)>(
34 nullptr, manual_destroy) {}
35 explicit SmartFFTPlan(fftwf_plan plan)
36 : std::unique_ptr<fftwf_plan_s, decltype(&manual_destroy)>(
37 plan, manual_destroy) {}
38 SmartFFTPlan(const SmartFFTPlan&) = delete;
39 SmartFFTPlan& operator=(const SmartFFTPlan&) = delete;
40 SmartFFTPlan(SmartFFTPlan&&) = default;
  • Wiebe van Breukelen
    Wiebe van Breukelen @breukelen started a thread on the diff
    • src/math/convolution.cc
    77 std::unique_lock<std::shared_mutex> lock_r(fftwplanner_rw_mutex_);
    78
    79 for (size_t size : sizes) {
    80 fftwplanner_cached_plans_[FFTW_KEY(T, size)] = MakePlan(T, size);
    81 }
    82 }
    83
    84 void ClearCache() {
    85 std::unique_lock<std::shared_mutex> lock_rw(fftwplanner_rw_mutex_);
    86
    87 fftwplanner_cached_plans_.clear();
    88 }
    89
    90 template <FFTWType T>
    91 fftwf_plan GetOrPlan(size_t size) {
    92 std::shared_lock<std::shared_mutex> read_lock(fftwplanner_rw_mutex_);
  • Wiebe van Breukelen
    Wiebe van Breukelen @breukelen started a thread on the diff
    • src/math/convolution.cc
    123 254 float* temp_data = fftwf_alloc_real(image_size);
    124 255 fftwf_complex* fft_image_data = fftwf_alloc_complex(complex_size);
    125 256 fftwf_complex* fft_kernel_data = fftwf_alloc_complex(complex_size);
    257 fftwf_plan plan_r2c = nullptr, plan_c2c_forward = nullptr,
    258 plan_c2c_backward = nullptr, plan_c2r = nullptr;
    126 259
    127 fftwf_plan plan_r2c =
    128 fftwf_plan_dft_r2c_1d(image_width, nullptr, nullptr, FFTW_ESTIMATE);
    129 fftwf_plan plan_c2c_forward = fftwf_plan_dft_1d(
    130 image_height, nullptr, nullptr, FFTW_FORWARD, FFTW_ESTIMATE);
    131 fftwf_plan plan_c2c_backward = fftwf_plan_dft_1d(
    132 image_height, nullptr, nullptr, FFTW_BACKWARD, FFTW_ESTIMATE);
    133 fftwf_plan plan_c2r =
    134 fftwf_plan_dft_c2r_1d(image_width, nullptr, nullptr, FFTW_ESTIMATE);
    260 if (use_cache) {
    261 plan_r2c = GetFFTWCache()->GetOrPlan<FFTWType::R2C>(image_width);
    • Wiebe van Breukelen
      Wiebe van Breukelen @breukelen ·
      Developer

      Since GetFFTWCache returns a singleton, could you just fetch the FTTWPlannerCache pointer once and then use it in subsequent calls? The fftwplanner_cache_ pointer accessibility is set to private, therefore, it is only deallocated in case FTTWPlannerCache is destroyed (when it goes out of scope)

    • Please register or sign in to reply
  • Wiebe van Breukelen
    Wiebe van Breukelen @breukelen started a thread on the diff
    • src/math/convolution.cc
    131 FTTWPlannerCache* GetFFTWCache() {
    132 if (fftwplanner_cache_ == nullptr) {
    133 std::unique_lock<std::shared_mutex> lock(fftwplanner_rw_mutex_);
    134 fftwplanner_cache_ = new FTTWPlannerCache();
    135 }
    136 return fftwplanner_cache_;
    137 }
    138 } // namespace
    139
    18 140 namespace schaapcommon::math {
    19 141
    142 void CleanWisdom() { fftwf_cleanup(); };
    20 143 void MakeFftwfPlannerThreadSafe() { fftwf_make_planner_thread_safe(); }
    21 144
    145 void PlanMultiFFTW(std::vector<size_t> height, std::vector<size_t> width) {
    146 GetFFTWCache()->PlanMulti<FFTWType::C2C_FORWARD>(height);
    Please register or sign in to reply