sequenzo 0.1.21__cp310-cp310-macosx_11_0_arm64.whl

sequenzo/dissimilarity_measures/src/xsimd/examples/mandelbrot.cpp

@@ -0,0 +1,330 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+// This file is derived from tsimd (MIT License)
+// https://github.com/ospray/tsimd/blob/master/benchmarks/mandelbrot.cpp
+// Author Jefferson Amstutz / intel
+
+#include <cstdio>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "pico_bench.hpp"
+
+#include <xsimd/xsimd.hpp>
+
+// helper function to write the rendered image as PPM file
+inline void writePPM(const std::string& fileName,
+                     const int sizeX,
+                     const int sizeY,
+                     const int* pixel)
+{
+    FILE* file = fopen(fileName.c_str(), "wb");
+    fprintf(file, "P6\n%i %i\n255\n", sizeX, sizeY);
+    unsigned char* out = (unsigned char*)alloca(3 * sizeX);
+    for (int y = 0; y < sizeY; y++)
+    {
+        const unsigned char* in = (const unsigned char*)&pixel[(sizeY - 1 - y) * sizeX];
+
+        for (int x = 0; x < sizeX; x++)
+        {
+            out[3 * x + 0] = in[4 * x + 0];
+            out[3 * x + 1] = in[4 * x + 1];
+            out[3 * x + 2] = in[4 * x + 2];
+        }
+
+        fwrite(out, 3 * sizeX, sizeof(char), file);
+    }
+    fprintf(file, "\n");
+    fclose(file);
+}
+
+namespace xsimd
+{
+
+    template <class arch>
+    inline batch<int, arch> mandel(const batch_bool<float, arch>& _active,
+                                   const batch<float, arch>& c_re,
+                                   const batch<float, arch>& c_im,
+                                   int maxIters)
+    {
+        using float_batch_type = batch<float, arch>;
+        using int_batch_type = batch<int, arch>;
+
+        constexpr std::size_t N = float_batch_type::size;
+
+        float_batch_type z_re = c_re;
+        float_batch_type z_im = c_im;
+        int_batch_type vi(0);
+
+        for (int i = 0; i < maxIters; ++i)
+        {
+            auto active = _active & ((z_re * z_re + z_im * z_im) <= float_batch_type(4.f));
+            if (!xsimd::any(active))
+            {
+                break;
+            }
+
+            float_batch_type new_re = z_re * z_re - z_im * z_im;
+            float_batch_type new_im = 2.f * z_re * z_im;
+
+            z_re = c_re + new_re;
+            z_im = c_im + new_im;
+
+            vi = select(batch_bool_cast<int>(active), vi + 1, vi);
+        }
+
+        return vi;
+    }
+
+    template <class arch>
+    void mandelbrot(float x0,
+                    float y0,
+                    float x1,
+                    float y1,
+                    int width,
+                    int height,
+                    int maxIters,
+                    int output[])
+    {
+        using float_batch_type = batch<float, arch>;
+        using int_batch_type = batch<int, arch>;
+
+        constexpr std::size_t N = float_batch_type::size;
+        float dx = (x1 - x0) / width;
+        float dy = (y1 - y0) / height;
+
+        float arange[N];
+        std::iota(&arange[0], &arange[N], 0.f);
+        // float_batch_type programIndex(&arange[0], xsimd::aligned_mode());
+
+        auto programIndex = float_batch_type::load(&arange[0], xsimd::aligned_mode());
+        // std::iota(programIndex.begin(), programIndex.end(), 0.f);
+
+        for (int j = 0; j < height; j++)
+        {
+            for (int i = 0; i < width; i += N)
+            {
+                float_batch_type x(x0 + (i + programIndex) * dx);
+                float_batch_type y(y0 + j * dy);
+
+                auto active = x < float_batch_type(width);
+
+                int base_index = (j * width + i);
+                auto result = mandel<arch>(active, x, y, maxIters);
+
+                // implement masked store!
+                // xsimd::store_aligned(result, output + base_index, active);
+                int_batch_type prev_data = int_batch_type::load_unaligned(output + base_index);
+                select(batch_bool_cast<int>(active), result, prev_data)
+                    .store_aligned(output + base_index);
+            }
+        }
+    }
+
+} // namespace xsimd
+
+// omp version ////////////////////////////////////////////////////////////////
+
+namespace omp
+{
+
+#pragma omp declare simd
+    template <typename T>
+    inline int mandel(T c_re, T c_im, int count)
+    {
+        T z_re = c_re, z_im = c_im;
+        int i;
+        for (i = 0; i < count; ++i)
+        {
+            if (z_re * z_re + z_im * z_im > 4.f)
+            {
+                break;
+            }
+
+            T new_re = z_re * z_re - z_im * z_im;
+            T new_im = 2.f * z_re * z_im;
+            z_re = c_re + new_re;
+            z_im = c_im + new_im;
+        }
+
+        return i;
+    }
+
+    void mandelbrot(float x0, float y0, float x1, float y1, int width,
+                    int height, int maxIterations, int output[])
+    {
+        float dx = (x1 - x0) / width;
+        float dy = (y1 - y0) / height;
+
+        for (int j = 0; j < height; j++)
+        {
+
+#pragma omp simd
+            for (int i = 0; i < width; ++i)
+            {
+                float x = x0 + i * dx;
+                float y = y0 + j * dy;
+
+                int index = (j * width + i);
+                output[index] = mandel<float>(x, y, maxIterations);
+            }
+        }
+    }
+
+} // namespace omp
+
+// scalar version /////////////////////////////////////////////////////////////
+
+namespace scalar
+{
+
+    inline int mandel(float c_re, float c_im, int count)
+    {
+        float z_re = c_re, z_im = c_im;
+        int i;
+        for (i = 0; i < count; ++i)
+        {
+            if (z_re * z_re + z_im * z_im > 4.f)
+            {
+                break;
+            }
+
+            float new_re = z_re * z_re - z_im * z_im;
+            float new_im = 2.f * z_re * z_im;
+            z_re = c_re + new_re;
+            z_im = c_im + new_im;
+        }
+
+        return i;
+    }
+
+    void mandelbrot(float x0, float y0, float x1, float y1,
+                    int width, int height, int maxIterations, int output[])
+    {
+        float dx = (x1 - x0) / width;
+        float dy = (y1 - y0) / height;
+
+        for (int j = 0; j < height; j++)
+        {
+            for (int i = 0; i < width; ++i)
+            {
+                float x = x0 + i * dx;
+                float y = y0 + j * dy;
+
+                int index = (j * width + i);
+                output[index] = mandel(x, y, maxIterations);
+            }
+        }
+    }
+
+} // namespace scalar
+
+// run simd version of mandelbrot benchmark for a specific arch
+template <class arch, class bencher_t, size_t Align>
+void run_arch(
+    bencher_t& bencher,
+    float x0,
+    float y0,
+    float x1,
+    float y1,
+    int width,
+    int height,
+    int maxIters,
+    std::vector<int, xsimd::aligned_allocator<int, Align>>& buffer)
+{
+    std::fill(buffer.begin(), buffer.end(), 0);
+    auto stats = bencher([&]()
+                         { xsimd::mandelbrot<arch>(x0, y0, x1, y1, width, height, maxIters, buffer.data()); });
+
+    const float scalar_min = stats.min().count();
+
+    std::cout << '\n'
+              << arch::name() << " " << stats << '\n';
+    auto filename = std::string("mandelbrot_") + std::string(arch::name()) + std::string(".ppm");
+    writePPM(filename.c_str(), width, height, buffer.data());
+}
+
+template <class T>
+struct run_archlist;
+
+// run simd version of mandelbrot benchmark for a list
+// of archs
+template <class... Arch>
+struct run_archlist<xsimd::arch_list<Arch...>>
+{
+    template <class bencher_t, size_t Align>
+    static void run(
+        bencher_t& bencher,
+        float x0,
+        float y0,
+        float x1,
+        float y1,
+        int width,
+        int height,
+        int maxIters,
+        std::vector<int, xsimd::aligned_allocator<int, Align>>& buffer)
+    {
+        (void)std::initializer_list<int> { (run_arch<Arch>(bencher, x0, y0, x1, x1, width, height, maxIters, buffer), 0)... };
+    }
+};
+
+int main()
+{
+    using namespace std::chrono;
+
+    const unsigned int width = 1024;
+    const unsigned int height = 768;
+    const float x0 = -2;
+    const float x1 = 1;
+    const float y0 = -1;
+    const float y1 = 1;
+    const int maxIters = 256;
+
+    std::vector<int, xsimd::aligned_allocator<int>> buf(width * height);
+
+    auto bencher = pico_bench::Benchmarker<milliseconds> { 64, seconds { 10 } };
+
+    std::cout << "starting benchmarks (results in 'ms')... " << '\n';
+
+    // scalar run ///////////////////////////////////////////////////////////////
+
+    std::fill(buf.begin(), buf.end(), 0);
+
+    auto stats_scalar = bencher([&]()
+                                { scalar::mandelbrot(x0, y0, x1, y1, width, height, maxIters, buf.data()); });
+
+    const float scalar_min = stats_scalar.min().count();
+
+    std::cout << '\n'
+              << "scalar " << stats_scalar << '\n';
+
+    writePPM("mandelbrot_scalar.ppm", width, height, buf.data());
+
+    // omp run //////////////////////////////////////////////////////////////////
+
+    std::fill(buf.begin(), buf.end(), 0);
+
+    auto stats_omp = bencher([&]()
+                             { omp::mandelbrot(x0, y0, x1, y1, width, height, maxIters, buf.data()); });
+
+    const float omp_min = stats_omp.min().count();
+
+    std::cout << '\n'
+              << "omp " << stats_omp << '\n';
+
+    writePPM("mandelbrot_omp.ppm", width, height, buf.data());
+
+    run_archlist<xsimd::supported_architectures>::run(bencher, x0, y0, x1, y1, width, height, maxIters, buf);
+
+    return 0;
+}

sequenzo/dissimilarity_measures/src/xsimd/examples/pico_bench.hpp

@@ -0,0 +1,246 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+// This file is derived from tsimd (MIT License)
+// https://github.com/ospray/tsimd/blob/master/benchmarks/pico_bench.h
+// Author Jefferson Amstutz / intel
+
+#ifndef PICO_BENCH_H
+#define PICO_BENCH_H
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cmath>
+#include <iterator>
+#include <numeric>
+#include <ostream>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace pico_bench
+{
+    /* Statistics on some time measurement value T, e.g. T =
+     * std::chrono::milliseconds T must be some std::chrono::duration type
+     */
+    template <typename T>
+    class Statistics
+    {
+        using rep = typename T::rep;
+        std::vector<T> samples;
+
+    public:
+        std::string time_suffix;
+
+        Statistics(std::vector<T> s)
+            : samples(s)
+        {
+            std::sort(std::begin(samples), std::end(samples));
+        }
+
+        T percentile(const float p) const
+        {
+            return percentile(p, samples);
+        }
+
+        // Winsorize the data, sets all entries above 100 - limit percentile and
+        // below limit percentile to the value of that percentile
+        void winsorize(const float limit)
+        {
+            winsorize(limit, samples);
+        }
+
+        T median() const
+        {
+            return percentile(50.0, samples);
+        }
+
+        T median_abs_dev() const
+        {
+            const auto m = median();
+            std::vector<T> deviations;
+            deviations.reserve(samples.size());
+            std::transform(std::begin(samples),
+                           std::end(samples),
+                           std::back_inserter(deviations),
+                           [&m](const T& t)
+                           { return T { std::abs((t - m).count()) }; });
+            std::sort(std::begin(deviations), std::end(deviations));
+            return percentile(50.0, deviations);
+        }
+
+        T mean() const
+        {
+            const auto m = std::accumulate(std::begin(samples), std::end(samples), T { 0 });
+            return m / samples.size();
+        }
+
+        T std_dev() const
+        {
+            const auto m = mean();
+            auto val = std::accumulate(
+                std::begin(samples), std::end(samples), T { 0 }, [&m](const T& p, const T& t)
+                { return T { static_cast<rep>(p.count() + std::pow((t - m).count(), 2)) }; });
+            return T { static_cast<rep>(std::sqrt(1.0 / static_cast<double>(samples.size())
+                                                  * static_cast<double>(val.count()))) };
+        }
+
+        T min() const
+        {
+            return samples.front();
+        }
+
+        T max() const
+        {
+            return samples.back();
+        }
+
+        std::size_t size() const
+        {
+            return samples.size();
+        }
+
+        const T& operator[](size_t i) const
+        {
+            return samples[i];
+        }
+
+    private:
+        // Winsorize the data, sets all entries above 100 - limit percentile and
+        // below limit percentile to the value of that percentile
+        static void winsorize(const float limit, std::vector<T>& samples)
+        {
+            const auto low = percentile(limit, samples);
+            const auto high = percentile(100.0 - limit, samples);
+            for (auto& t : samples)
+            {
+                if (t < low)
+                {
+                    t = low;
+                }
+                else if (t > high)
+                {
+                    t = high;
+                }
+            }
+        }
+        static T percentile(const float p, const std::vector<T>& samples)
+        {
+            assert(!samples.empty());
+            assert(p <= 100.0);
+            assert(p >= 0.0);
+            if (samples.size() == 1)
+            {
+                return samples.front();
+            }
+            if (p == 100.0)
+            {
+                return samples.back();
+            }
+            const double rank = p / 100.0 * (static_cast<double>(samples.size()) - 1.0);
+            const double low_r = std::floor(rank);
+            const double dist = rank - low_r;
+            const size_t k = static_cast<size_t>(low_r);
+            const auto low = samples[k];
+            const auto high = samples[k + 1];
+            return T { static_cast<rep>(low.count() + (high - low).count() * dist) };
+        }
+    };
+
+    /* Benchmarking measurment using some desired unit of time measurement,
+     * e.g. T = std::chrono::milliseconds. T must be some std::chrono::duration
+     */
+    template <typename T>
+    class Benchmarker
+    {
+        const size_t MAX_ITER;
+        const T MAX_RUNTIME;
+
+        template <typename Fn>
+        struct BenchWrapper
+        {
+            Fn fn;
+
+            BenchWrapper(Fn fn)
+                : fn(fn)
+            {
+            }
+            T operator()()
+            {
+                auto start = std::chrono::high_resolution_clock::now();
+                fn();
+                auto end = std::chrono::high_resolution_clock::now();
+                return std::chrono::duration_cast<T>(end - start);
+            }
+        };
+
+    public:
+        using stats_type = Statistics<T>;
+
+        // Benchmark the functions either max_iter times or until max_runtime
+        // seconds have elapsed max_runtime should be > 0
+        Benchmarker(const size_t max_iter, const std::chrono::seconds max_runtime)
+            : MAX_ITER(max_iter)
+            , MAX_RUNTIME(std::chrono::duration_cast<T>(max_runtime))
+        {
+        }
+        // Create a benchmarker that will run the function for the desired number of
+        // iterations, regardless of how long it takes
+        Benchmarker(const size_t max_iter)
+            : MAX_ITER(max_iter)
+            , MAX_RUNTIME(0)
+        {
+        }
+
+        template <typename Fn>
+        typename std::enable_if<std::is_void<decltype(std::declval<Fn>()())>::value,
+                                stats_type>::type
+        operator()(Fn fn) const
+        {
+            return (*this)(BenchWrapper<Fn> { fn });
+        }
+
+        template <typename Fn>
+        typename std::enable_if<std::is_same<decltype(std::declval<Fn>()()), T>::value,
+                                stats_type>::type
+        operator()(Fn fn) const
+        {
+            // Do a single un-timed warm up run
+            fn();
+            T elapsed { 0 };
+            std::vector<T> samples;
+            for (size_t i = 0; i < MAX_ITER && (MAX_RUNTIME.count() == 0 || elapsed < MAX_RUNTIME);
+                 ++i, elapsed += samples.back())
+            {
+                samples.push_back(fn());
+            }
+            return stats_type { samples };
+        }
+    };
+} // namespace pico_bench
+
+template <typename T>
+std::ostream&
+operator<<(std::ostream& os, const pico_bench::Statistics<T>& stats)
+{
+    os << "Statistics:\n"
+       << "\tmax: " << stats.max().count() << stats.time_suffix << "\n"
+       << "\tmin: " << stats.min().count() << stats.time_suffix << "\n"
+       << "\tmedian: " << stats.median().count() << stats.time_suffix << "\n"
+       << "\tmedian abs dev: " << stats.median_abs_dev().count() << stats.time_suffix << "\n"
+       << "\tmean: " << stats.mean().count() << stats.time_suffix << "\n"
+       << "\tstd dev: " << stats.std_dev().count() << stats.time_suffix << "\n"
+       << "\t# of samples: " << stats.size();
+    return os;
+}
+
+#endif