Added avx512 struct for future portability

Author: stevenewald

CMakeLists.txt

@@ -26,6 +26,7 @@ add_library(
     source/graphics/color_conversions/color_conversions.cpp
     source/graphics/aspect_ratio/aspect_ratio.cpp
     source/mandelbrot/equations_simd.cpp
+    source/mandelbrot/equations.cpp
 )
 
 target_include_directories(

source/mandelbrot/equations.cpp

@@ -0,0 +1,28 @@
+#include "equations.hpp"
+
+#include "config.hpp"
+
+namespace fractal {
+// https://en.wikipedia.org/wiki/Mandelbrot_set#Formal_definition
+std::complex<complex_underlying>
+step(std::complex<complex_underlying> z_n, std::complex<complex_underlying> constant)
+{
+    return z_n * z_n + constant;
+}
+
+iteration_count compute_iterations(
+    std::complex<complex_underlying> z_0, std::complex<complex_underlying> constant,
+    iteration_count max_iters
+)
+{
+    iteration_count iterations = 0;
+    std::complex<complex_underlying> z_n = z_0;
+
+    while (iterations < max_iters && std::norm(z_n) < MANDELBROT_DIVERGENCE_NORM) {
+        z_n = step(z_n, constant);
+        ++iterations;
+    }
+
+    return iterations;
+}
+} // namespace fractal

source/mandelbrot/equations.hpp

@@ -1,29 +1,14 @@
 #pragma once
 
-#include "config.hpp"
 #include "units.hpp"
 
 namespace fractal {
 // https://en.wikipedia.org/wiki/Mandelbrot_set#Formal_definition
-inline std::complex<complex_underlying>
-step(std::complex<complex_underlying> z_n, std::complex<complex_underlying> constant)
-{
-    return z_n * z_n + constant;
-}
+std::complex<complex_underlying>
+step(std::complex<complex_underlying> z_n, std::complex<complex_underlying> constant);
 
-inline iteration_count compute_iterations(
+iteration_count compute_iterations(
     std::complex<complex_underlying> z_0, std::complex<complex_underlying> constant,
     iteration_count max_iters
-)
-{
-    iteration_count iterations = 0;
-    std::complex<complex_underlying> z_n = z_0;
-
-    while (iterations < max_iters && std::norm(z_n) < MANDELBROT_DIVERGENCE_NORM) {
-        z_n = step(z_n, constant);
-        ++iterations;
-    }
-
-    return iterations;
-}
+);
 } // namespace fractal

source/mandelbrot/equations_simd.cpp

@@ -1,31 +1,19 @@
+#include "config.hpp"
 #include "equations.hpp"
+#include "units.hpp"
 
 namespace fractal {
 std::array<iteration_count, 8> compute_iterations(
-    const std::array<std::complex<complex_underlying>, 8>& z_0,
-    const std::array<std::complex<complex_underlying>, 8>& constant,
-    iteration_count max_iters
+    const avx512_complex& z_0, const avx512_complex& constant, iteration_count max_iters
 )
 {
     static const auto SQUARED_DIVERGENCE =
         MANDELBROT_DIVERGENCE_NORM * MANDELBROT_DIVERGENCE_NORM;
 
-    alignas(64) std::array<double, 8> reals = {z_0[0].real(), z_0[1].real(),
-                                               z_0[2].real(), z_0[3].real(),
-                                               z_0[4].real(), z_0[5].real(),
-                                               z_0[6].real(), z_0[7].real()};
-    alignas(64) std::array<double, 8> imags = {z_0[0].imag(), z_0[1].imag(),
-                                               z_0[2].imag(), z_0[3].imag(),
-                                               z_0[4].imag(), z_0[5].imag(),
-                                               z_0[6].imag(), z_0[7].imag()};
-    alignas(64) std::array<double, 8> const_reals = {
-        constant[0].real(), constant[1].real(), constant[2].real(), constant[3].real(),
-        constant[4].real(), constant[5].real(), constant[6].real(), constant[7].real()
-    };
-    alignas(64) std::array<double, 8> const_imags = {
-        constant[0].imag(), constant[1].imag(), constant[2].imag(), constant[3].imag(),
-        constant[4].imag(), constant[5].imag(), constant[6].imag(), constant[7].imag()
-    };
+    alignas(64) std::array<double, 8> reals = z_0.real;
+    alignas(64) std::array<double, 8> imags = z_0.imaginary;
+    alignas(64) std::array<double, 8> const_reals = constant.real;
+    alignas(64) std::array<double, 8> const_imags = constant.imaginary;
 
     std::array<iteration_count, 8> solved_its = {0};
 

source/mandelbrot/equations_simd.hpp

@@ -6,14 +6,8 @@
 #include <immintrin.h>
 
 namespace fractal {
-// https://en.wikipedia.org/wiki/Mandelbrot_set#Formal_definition
-
-std::complex<complex_underlying>
-step(std::complex<complex_underlying> z_n, std::complex<complex_underlying> constant);
 
 std::array<iteration_count, 8> compute_iterations(
-    const std::array<std::complex<complex_underlying>, 8>& z_0,
-    const std::array<std::complex<complex_underlying>, 8>& constant,
-    iteration_count max_iters
+    const avx512_complex& z_0, const avx512_complex& constant, iteration_count max_iters
 );
 } // namespace fractal

source/mandelbrot/mandelbrot_window.cpp

@@ -24,15 +24,12 @@
 
 namespace fractal {
 void MandelbrotWindow::draw_coordinate_(
-    display_coordinate display_coord,
-    const std::array<std::complex<complex_underlying>, 8>& complex_coords
+    display_coordinate display_coord, const avx512_complex& complex_coords
 )
 {
-    static constexpr std::array<std::complex<complex_underlying>, 8> starts = {
-        std::complex<complex_underlying>{0, 0}
-    };
+    static constexpr avx512_complex START{};
     auto iterations =
-        compute_iterations(starts, complex_coords, MANDELBROT_MAX_ITERATIONS);
+        compute_iterations(START, complex_coords, MANDELBROT_MAX_ITERATIONS);
 
     for (size_t i = 0; i < 8; i++) {
         float iteration_ratio =
@@ -59,7 +56,12 @@ void MandelbrotWindow::on_resize_(display_domain new_domain_selection)
             coords[i] = to_complex.to_complex_projection(start_display_coord);
             start_display_coord.first++;
         }
-        draw_coordinate_(t, coords);
+        avx512_complex coords2{};
+        for (size_t i = 0; i < 8; i++) {
+            coords2.real[i] = coords[i].real();
+            coords2.imaginary[i] = coords[i].imag();
+        }
+        draw_coordinate_(t, coords2);
     };
 
     auto process_chunk = [&](display_domain::DisplayCoordinateIterator start,

source/mandelbrot/mandelbrot_window.hpp

@@ -3,6 +3,7 @@
 #include "config.hpp"
 #include "coordinates.hpp"
 #include "graphics/display_event_observer.hpp"
+#include "units.hpp"
 
 #include <SFML/Graphics/Drawable.hpp>
 #include <SFML/Graphics/Image.hpp>
@@ -22,8 +23,7 @@ class MandelbrotWindow : public DisplayEventObserver {
 
     void on_resize_(display_domain new_domain_selection);
     void draw_coordinate_(
-        display_coordinate display_coord,
-        const std::array<std::complex<complex_underlying>, 8>& complex_coords
+        display_coordinate display_coord, const avx512_complex& complex_coords
     );
 
 public:

source/units.hpp

@@ -15,6 +15,16 @@ using complex = boost::multiprecision::complex_adaptor<small_float>;*/
 
 using complex_underlying = double;
 
+struct avx512_complex {
+    std::array<complex_underlying, 8> real;
+    std::array<complex_underlying, 8> imaginary;
+
+    std::complex<complex_underlying> get_complex(uint8_t index)
+    {
+        return {real[index], imaginary[index]};
+    }
+};
+
 struct color {
     uint8_t red;
     uint8_t green;