Bluestein Algorithm

.clang-tidy

@@ -14,6 +14,7 @@ Checks: >
   performance-*,
   -performance-avoid-endl,
   readability-*,
+  -readability-magic-numbers,
   -readability-function-cognitive-complexity,
   -readability-identifier-length,
   -readability-named-parameter,

src/portfft/common/bluestein.hpp

@@ -0,0 +1,80 @@
+/***************************************************************************
+ *
+ *  Copyright (C) Codeplay Software Ltd.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  Codeplay's portFFT
+ *
+ **************************************************************************/
+
+#ifndef PORTFFT_COMMON_BLUESTEIN_HPP
+#define PORTFFT_COMMON_BLUESTEIN_HPP
+
+#include "portfft/common/host_fft.hpp"
+#include "portfft/defines.hpp"
+
+#include <cmath>
+#include <complex>
+#include <sycl/sycl.hpp>
+
+namespace portfft {
+namespace detail {
+/**
+ * Utility function to get chirp signal and fft
+ * @tparam T Scalar Type
+ * @param ptr Host Pointer containing the load/store modifiers.
+ * @param committed_size original problem size
+ * @param dimension_size padded size
+ */
+template <typename T>
+void get_fft_chirp_signal(T* ptr, std::size_t committed_size, std::size_t dimension_size) {
+  using ctype = std::complex<T>;
+  ctype* chirp_signal = (ctype*)calloc(dimension_size, sizeof(ctype));
+  ctype* chirp_fft = (ctype*)malloc(dimension_size * sizeof(ctype));
+  for (std::size_t i = 0; i < committed_size; i++) {
+    double theta = M_PI * static_cast<double>(i * i) / static_cast<double>(committed_size);
+    chirp_signal[i] = ctype(static_cast<T>(std::cos(theta)), static_cast<T>(std::sin(theta)));
+  }
+  std::size_t num_zeros = dimension_size - 2 * committed_size + 1;
+  for (std::size_t i = 0; i < committed_size; i++) {
+    chirp_signal[committed_size + num_zeros + i - 1] = chirp_signal[committed_size - i];
+  }
+  naive_dft(chirp_signal, chirp_fft, dimension_size);
+  std::memcpy(ptr, reinterpret_cast<T*>(&chirp_fft[0]), 2 * dimension_size * sizeof(T));
+  free(chirp_signal);
+  free(chirp_fft);
+}
+
+/**
+ * Populates input modifiers required for bluestein
+ * @tparam T Scalar Type
+ * @param ptr Host Pointer containing the load/store modifiers.
+ * @param committed_size original problem size
+ * @param dimension_size padded size
+ */
+template <typename T>
+void populate_bluestein_input_modifiers(T* ptr, std::size_t committed_size, std::size_t dimension_size) {
+  using ctype = std::complex<T>;
+  ctype* scratch = (ctype*)calloc(dimension_size, sizeof(ctype));
+  for (std::size_t i = 0; i < committed_size; i++) {
+    double theta = -M_PI * static_cast<double>(i * i) / static_cast<double>(committed_size);
+    scratch[i] = ctype(static_cast<T>(std::cos(theta)), static_cast<T>(std::sin(theta)));
+  }
+  std::memcpy(ptr, reinterpret_cast<T*>(&scratch[0]), 2 * dimension_size * sizeof(T));
+  free(scratch);
+}
+}  // namespace detail
+}  // namespace portfft
+
+#endif

src/portfft/common/host_fft.hpp

@@ -0,0 +1,53 @@
+/***************************************************************************
+ *
+ *  Copyright (C) Codeplay Software Ltd.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  Codeplay's portFFT
+ *
+ **************************************************************************/
+
+#ifndef PORTFFT_COMMON_HOST_FFT_HPP
+#define PORTFFT_COMMON_HOST_FFT_HPP
+
+#include "portfft/defines.hpp"
+#include <complex>
+
+namespace portfft {
+namespace detail {
+
+/**
+ * Host Naive DFT. Works OOP only
+ * @tparam T Scalar Type
+ * @param input input pointer
+ * @param output output pointer
+ * @param fft_size fft size
+ */
+template <typename T>
+void naive_dft(std::complex<T>* input, std::complex<T>* output, IdxGlobal fft_size) {
+  using ctype = std::complex<T>;
+  for (int i = 0; i < fft_size; i++) {
+    ctype temp = ctype(0, 0);
+    for (int j = 0; j < fft_size; j++) {
+      ctype multiplier = ctype(static_cast<T>(std::cos((-2 * M_PI * i * j) / static_cast<double>(fft_size))),
+                               static_cast<T>(std::sin((-2 * M_PI * i * j) / static_cast<double>(fft_size))));
+      temp += input[j] * multiplier;
+    }
+    output[i] = temp;
+  }
+}
+}  // namespace detail
+}  // namespace portfft
+
+#endif

src/portfft/common/workgroup.hpp

@@ -60,15 +60,15 @@ namespace detail {
  * @tparam SubgroupSize Size of the subgroup
  * @tparam LocalT The type of the local view
  * @tparam T Scalar type
- * @param loc local accessor containing the input
+ * @param loc View of the local memory containing the input
  * @param loc_twiddles Pointer to twiddles to be used by sub group FFTs
  * @param wg_twiddles Pointer to precalculated twiddles which are to be used before second set of FFTs
  * @param scaling_factor Scalar factor with which the result is to be scaled
  * @param max_num_batches_in_local_mem Number of batches local memory is allocated for
  * @param batch_num_in_local Id of the local memory batch to work on
  * @param load_modifier_data Pointer to the load modifier data in global Memory
  * @param store_modifier_data Pointer to the store modifier data in global Memory
- * @param batch_num_in_kernel Absosulte batch from which batches loaded in local memory will be computed
+ * @param batch_num_in_kernel Absolute batch from which batches loaded in local memory will be computed
  * @param dft_size Size of each DFT to calculate
  * @param stride_within_dft Stride between elements of each DFT - also the number of the DFTs in the inner dimension
  * @param ndfts_in_outer_dimension Number of DFTs in outer dimension
@@ -300,13 +300,13 @@ __attribute__((always_inline)) inline void dimension_dft(
  * @tparam LocalT Local memory view type
  * @tparam T Scalar type
  *
- * @param loc A view of a local accessor containing input
+ * @param loc View of the local memory containing the input
  * @param loc_twiddles Pointer to twiddles to be used by sub group FFTs
  * @param wg_twiddles Pointer to precalculated twiddles which are to be used before second set of FFTs
  * @param scaling_factor Scalar factor with which the result is to be scaled
  * @param max_num_batches_in_local_mem Number of batches local memory is allocated for
  * @param batch_num_in_local Id of the local memory batch to work on
- * @param batch_num_in_kernel Absosulte batch from which batches loaded in local memory will be computed
+ * @param batch_num_in_kernel Absolute batch from which batches loaded in local memory will be computed
  * @param load_modifier_data Pointer to the load modifier data in global Memory
  * @param store_modifier_data Pointer to the store modifier data in global Memory
  * @param fft_size Problem Size