Fix benchmarkRenderers, implement a real SIMD DrawCursor and benchmark it

Author: Stovent

benchmarks/benchmarkRenderers.cpp

@@ -7,7 +7,9 @@
 #include <string_view>
 
 static constexpr size_t WIDTH = 768;
+static constexpr size_t HEIGHT = 280;
 static constexpr size_t FRAMES = 10000;
+static constexpr size_t FRAMES_CURSOR = 10'000'000;
 
 static constexpr std::array<uint8_t, WIDTH> LINEA{};
 static constexpr std::array<uint8_t, WIDTH> LINEB{};
@@ -23,15 +25,14 @@ static void benchmarkRenderer(std::string_view name)
     renderer.m_codingMethod[B] = CODINGB;
     renderer.m_bps[A] = BPS;
     renderer.m_bps[B] = BPS;
+    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL);
     renderer.m_mix = true;
 
-    const size_t height = renderer.m_plane[A].m_height;
-
     // Benchmark
     const std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
     for(size_t f = 0; f < FRAMES; ++f)
     {
-        for(size_t y = 0; y < height; ++y)
+        for(size_t y = 0; y < HEIGHT; ++y)
         {
             renderer.DrawLine(LINEA.data(), LINEB.data());
         }
@@ -41,21 +42,48 @@ static void benchmarkRenderer(std::string_view name)
     const std::chrono::high_resolution_clock::time_point finish = std::chrono::high_resolution_clock::now();
     const std::chrono::nanoseconds delta = finish - start;
 
-    std::print("{} ", name);
-    std::println("{}  {}  {}/f  {}",
+    std::println("{} {}  {}  {}/f  {}",
+        name,
         delta,
         std::chrono::duration_cast<std::chrono::microseconds>(delta),
         std::chrono::duration_cast<std::chrono::microseconds>(delta / FRAMES),
         std::chrono::duration_cast<std::chrono::milliseconds>(delta)
     );
 }
 
+template<typename RENDERER>
+static void benchmarkRendererCursor(std::string_view name)
+{
+    RENDERER renderer;
+    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL);
+
+    // Benchmark
+    const std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
+    for(size_t f = 0; f < FRAMES_CURSOR; ++f)
+    {
+        renderer.DrawCursor();
+    }
+    const std::chrono::high_resolution_clock::time_point finish = std::chrono::high_resolution_clock::now();
+    const std::chrono::nanoseconds delta = finish - start;
+
+    std::println("{} {}  {}  {}/f  {}",
+        name,
+        delta,
+        std::chrono::duration_cast<std::chrono::microseconds>(delta),
+        delta / FRAMES_CURSOR,
+        std::chrono::duration_cast<std::chrono::milliseconds>(delta)
+    );
+}
+
 int main()
 {
     constexpr Video::Renderer::BitsPerPixel NORMAL_8 = Video::Renderer::BitsPerPixel::Normal8;
     constexpr Video::Renderer::BitsPerPixel DOUBLE_4 = Video::Renderer::BitsPerPixel::Double4;
     // constexpr Video::Renderer::BitsPerPixel HIGH_8 = Video::Renderer::BitsPerPixel::High8;
 
+    benchmarkRendererCursor<Video::RendererSoftware>("Cursor Soft");
+    benchmarkRendererCursor<Video::RendererSIMD>("Cursor SIMD");
+
     benchmarkRenderer<Video::RendererSoftware, NORMAL_8, ICM(OFF), ICM(RGB555)>("Normal Soft RGB555");
     benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(OFF), ICM(RGB555)>("Normal SIMD RGB555");
 

src/CDI/Video/RendererSIMD.cpp

@@ -132,37 +132,25 @@ void RendererSIMD::DrawCursor() noexcept
 
     const Pixel color = backdropCursorColorToPixel(m_cursorColor);
 
-    Plane::iterator it = m_cursorPlane.begin();
-    for(size_t y = 0; y < m_cursorPlane.m_height; ++y)
+    using SIMDCursorLine = stdx::fixed_size_simd<uint32_t, 16>;
+    using SIMDCursorLineMask = SIMDCursorLine::mask_type;
+    static constexpr SIMDCursorLine SHIFTER([] (uint32_t i) { return 15 - i; });
+
+    int patternIndex = 0;
+    for(Plane::iterator dst = m_cursorPlane.begin(); dst < m_cursorPlane.end(); dst += SIMDCursorLine::size(), ++patternIndex)
     {
-        for(int x = static_cast<int>(m_cursorPlane.m_width) - 1; x >= 0; --x)
-        {
-            const uint16_t mask = (1 << x);
-            if(m_cursorPatterns[y] & mask)
-                *it = color;
-            else
-                *it = BLACK_PIXEL;
-            ++it;
-        }
-    }
+        // Convert pattern to a mask.
+        SIMDCursorLine patternSimd = m_cursorPatterns[patternIndex];
+        patternSimd >>= SHIFTER;
+        patternSimd &= 1;
+        const SIMDCursorLineMask patternMask = patternSimd == 1;
 
-    // TODO: try in SIMD.
-//     using FixedPixelSIMD = stdx::fixed_size_simd<uint32_t, 16>;
-//     int pattern = 0;
-//     for(PlaneSIMD::iterator it = m_cursorPlane.begin(); it < m_cursorPlane.end(); it += FixedPixelSIMD::size(), ++pattern)
-//     {
-//         FixedPixelSIMD pixel{&*it, stdx::element_aligned};
-//
-//         for(int x = m_cursorPlane.m_width - 1, pix = 0; --x >= 0; pix++)
-//         {
-//             const uint16_t mask = (1 << x);
-//             if(m_cursorPatterns[pattern] & mask)
-//                 pixel[pix] = color;
-//             else
-//                 pixel[pix] = black;
-//         }
-//         pixel.copy_to(&*it, stdx::element_aligned);
-//     }
+        const SIMDCursorLine colorSimd{color.AsU32()};
+
+        SIMDCursorLine cursorPixels = BLACK_PIXEL.AsU32();
+        stdx::where(patternMask, cursorPixels) = colorSimd;
+        cursorPixels.copy_to(dst->AsU32Pointer(), stdx::element_aligned);
+    }
 }
 
 /** \brief Overlays or mix all the planes to the final screen.