tests/bench/map_points.cpp

/*
 * Copyright 2022 Rive
 */

#include "bench.hpp"

#include "rive/math/raw_path.hpp"

using namespace rive;

static void map(const Mat2D& m,
                std::vector<Vec2D>& dst,
                const std::vector<Vec2D>& pts)
{
    size_t n = pts.size();
#if 0
    // Scalar implementation.
    for (size_t i = 0; i < n; ++i)
        dst[i] = m * pts[i];
#else
    // Vector implementation.
    m.mapPoints(dst.data(), pts.data(), n);
#endif
}

// Measure the speed of Mat2D::mapPoints().
class MapPoints : public Bench
{
public:
    MapPoints(const Mat2D& matrix) : m_matrix(matrix)
    {
        m_points.resize(32768 / sizeof(Vec2D)); // 32k so we fit in L1.
        srand(0);
        for (Vec2D& pt : m_points)
            pt = Vec2D(float(rand()), float(rand())) * 100 / (float)RAND_MAX;
        m_dst.resize(m_points.size());
    }

private:
    int run() const override
    {
        map(m_matrix, m_dst, m_points);
        for (int i = 1; i < 4096; ++i)
            map(m_matrix, m_dst, m_dst);
        return static_cast<int>(m_dst.back().x);
    }

    Mat2D m_matrix;
    std::vector<Vec2D> m_points;
    mutable std::vector<Vec2D> m_dst;
};

class MapPointsScaleTrans : public MapPoints
{
public:
    MapPointsScaleTrans() : MapPoints(Mat2D(-2, 0, 0, 3, -4, 5)) {}
};

class MapPointsAffine : public MapPoints
{
public:
    MapPointsAffine() : MapPoints(Mat2D(2, -3, -4, 5, 6, -7)) {}
};

REGISTER_BENCH(MapPointsScaleTrans);
REGISTER_BENCH(MapPointsAffine);