Supporting SIMD blending for ARM architecture

- LLM-generated NEON blender is now used for ARM targets.

Author: tyoma

.github/workflows/cmake.yml

@@ -2,9 +2,7 @@ name: Build / Test
 
 on:
   push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+    branches: '*'
 
 env:
   BUILD_TYPE: Release
@@ -17,7 +15,9 @@ jobs:
         config:
           - os: ubuntu-latest
           - os: macos-latest
+          - os: macos-15-intel
           - os: windows-latest
+          - os: windows-11-arm
 
     steps:
     - uses: actions/checkout@v2

agge/blenders_simd.h

@@ -3,12 +3,24 @@
 #include "config.h"
 #include "pixel.h"
 
-#include <emmintrin.h>
+#if defined(AGGE_ARCH_INTEL)
+	#include <emmintrin.h>
+#elif defined(AGGE_ARCH_ARM)
+	#include <arm_neon.h>
+#else
+	#error "Unsupported architecture"
+#endif
 
 namespace agge
 {
 	namespace simd
 	{
+#if defined(AGGE_ARCH_INTEL)
+		typedef __m128i uint16x8_t;
+#elif defined(AGGE_ARCH_ARM)
+		typedef ::uint16x8_t uint16x8_t;
+#endif
+
 		// This blender requires and assumes the following:
 		// 1. Result of blending of empty covers vector (n == 0) is undefined;
 		// 2. Covers vector must be accessible beyond the length (n) up to the nearest multiple of 4;
@@ -26,10 +38,10 @@ namespace agge
 			void operator ()(pixel *pixels, int x, int y, count_t n, const cover_type *covers) const;
 
 		private:
-			static void blend4(pixel *pixels, __m128i color_u16, __m128i alpha_u16, unsigned int covers_packed);
+			static void blend4(pixel *pixels, uint16x8_t color_u16, uint16x8_t alpha_u16, unsigned int covers_packed);
 
 		private:
-			__m128i _color_u16, _alpha_u16;
+			uint16x8_t _color_u16, _alpha_u16;
 			pixel _components;
 			static unsigned int _tail_mask[5];
 		};
@@ -39,8 +51,8 @@ namespace agge
 		AGGE_INLINE void blender_solid_color::operator ()(pixel *pixels, int /*x*/, int /*y*/, count_t n,
 			const cover_type *covers) const
 		{
-			const __m128i alpha_u16 = _mm_load_si128(&_alpha_u16);
-			const __m128i color_u16 = _mm_load_si128(&_color_u16);
+			const uint16x8_t alpha_u16 = _alpha_u16;
+			const uint16x8_t color_u16 = _color_u16;
 
 			for (; n > 4; pixels += 4, covers += 4, n -= 4)
 				blend4(pixels, color_u16, alpha_u16, *reinterpret_cast<const unsigned int *>(covers));

agge/config.h

@@ -23,8 +23,10 @@
 	#elif defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5T__)
 		#define AGGE_ARCH_ARM 5
 	#else
-		#define AGGE_ARCH_ARM 1
+		#define AGGE_ARCH_ARM
 	#endif
+#elif defined(__aarch64__)
+	#define AGGE_ARCH_ARM 8
 #else
 	#define AGGE_ARCH_GENERIC
 #endif

samples/balls-async/balls-async.cpp

@@ -40,7 +40,7 @@ namespace
 		}
 
 		virtual void schedule(function<void()> &&task, mt::milliseconds defer_by) override
-		{	_underlying.schedule(move(task), defer_by);	}
+		{	_underlying.schedule(std::move(task), defer_by);	}
 
 	private:
 		void run()
@@ -86,11 +86,11 @@ namespace
 					if (_ready.empty())
 						_pending.push_back(completion);
 					else
-						item = move(_ready.back()), _ready.pop_back();
+						item = std::move(_ready.back()), _ready.pop_back();
 				}
 				if (item)
-					completion->set(move(item));
-				return task< shared_ptr<T> >(move(completion));
+					completion->set(std::move(item));
+				return task< shared_ptr<T> >(std::move(completion));
 			}
 
 			void put_back(const shared_ptr<T> &item)
@@ -104,7 +104,7 @@ namespace
 					if (_pending.empty())
 						_ready.push_back(item);
 					else
-						completion = move(_pending.back()), _pending.pop_back();
+						completion = std::move(_pending.back()), _pending.pop_back();
 				}
 
 				if (completion)

samples/common/shell.h

@@ -2,7 +2,7 @@
 
 #include <agge/bitmap.h>
 #include <agge/blenders.h>
-#include <agge/blenders_generic.h>
+#include <agge/blenders_simd.h>
 #include <agge/config.h>
 
 #if defined(AGGE_PLATFORM_ANDROID)
@@ -25,14 +25,7 @@
 
 #endif
 
-#if defined(AGGE_ARCH_INTEL)
-	#include <agge/blenders_simd.h>
-
-	typedef agge::blender_solid_color<agge::simd::blender_solid_color, platform_pixel_order> platform_blender_solid_color;
-
-#else
-	typedef agge::blender_solid_color_rgb<agge::pixel32, platform_pixel_order> platform_blender_solid_color;
-#endif
+typedef agge::blender_solid_color<agge::simd::blender_solid_color, platform_pixel_order> platform_blender_solid_color;
 
 struct services;
 

src/agge/CMakeLists.txt

@@ -5,6 +5,7 @@ add_compile_options($<$<CXX_COMPILER_ID:GNU,Clang,AppleClang>:-std=c++03>)
 set(AGGE_SOURCES
 	color.cpp
 	curves.cpp
+	blenders_simd.cpp
 	dash.cpp
 	figures.cpp
 	hybrid_event.cpp
@@ -15,12 +16,6 @@ set(AGGE_SOURCES
 	vector_rasterizer.cpp
 )
 
-if (AGGE_ARCHITECTURE STREQUAL "intel")
-	set(AGGE_SOURCES ${AGGE_SOURCES}
-		blenders_intel.cpp
-	)
-endif()
-
 if (WIN32)
 	set(AGGE_SOURCES ${AGGE_SOURCES}
 		platform/win32/bitmap.cpp

src/agge/blenders_arm.cpp

@@ -0,0 +1,82 @@
+#include <agge/blenders_simd.h>
+
+namespace agge
+{
+	namespace simd
+	{
+		unsigned int blender_solid_color::_tail_mask[5] = {
+			0x00000000, 0x000000FF, 0x0000FFFF, 0x00FFFFFF, 0xFFFFFFFF,
+		};
+
+		namespace
+		{
+			uint16x8_t make_color_u16(pixel32 components)
+			{
+				const uint8x8_t c = vcreate_u8(reinterpret_cast<const unsigned int &>(components));
+				const uint16x8_t c_u16 = vmovl_u8(c);
+
+				return vcombine_u16(vget_low_u16(c_u16), vget_low_u16(c_u16));
+			}
+
+			uint16x8_t make_alpha_u16(unsigned int alpha)
+			{
+				alpha = (alpha << 6) + 505 * alpha / 1000;
+				return vdupq_n_u16(static_cast<uint16_t>(alpha));
+			}
+		}
+
+
+		blender_solid_color::blender_solid_color(pixel components, uint8_t alpha)
+			: _color_u16(make_color_u16(components)), _alpha_u16(make_alpha_u16(alpha)), _components(components)
+		{	}
+
+		void blender_solid_color::operator ()(pixel *pixels, int /*x*/, int /*y*/, count_t n) const
+		{
+			for (; n; --n, ++pixels)
+				*pixels = _components;
+		}
+
+		void blender_solid_color::blend4(pixel *pixels, uint16x8_t color_u16, uint16x8_t alpha_u16, unsigned int covers_packed)
+		{
+			uint8x8_t covers = vdup_n_u8(0);
+			covers = vset_lane_u8(static_cast<uint8_t>(covers_packed >> 0), covers, 0);
+			covers = vset_lane_u8(static_cast<uint8_t>(covers_packed >> 8), covers, 1);
+			covers = vset_lane_u8(static_cast<uint8_t>(covers_packed >> 16), covers, 2);
+			covers = vset_lane_u8(static_cast<uint8_t>(covers_packed >> 24), covers, 3);
+
+			const uint16x4_t covers_u16 = vget_low_u16(vshlq_n_u16(vmovl_u8(covers), 8));
+			const uint16x4_t alpha = vshrn_n_u32(vmull_u16(covers_u16, vget_low_u16(alpha_u16)), 16);
+
+			const uint16_t a0 = vget_lane_u16(alpha, 0);
+			const uint16_t a1 = vget_lane_u16(alpha, 1);
+			const uint16_t a2 = vget_lane_u16(alpha, 2);
+			const uint16_t a3 = vget_lane_u16(alpha, 3);
+
+			const int16x8_t alpha10 = vreinterpretq_s16_u16(vcombine_u16(vdup_n_u16(a0), vdup_n_u16(a1)));
+			const int16x8_t alpha32 = vreinterpretq_s16_u16(vcombine_u16(vdup_n_u16(a2), vdup_n_u16(a3)));
+
+			const uint8x16_t source_u8 = vld1q_u8(reinterpret_cast<uint8_t *>(pixels));
+			const int16x8_t source10 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(source_u8)));
+			const int16x8_t source32 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(source_u8)));
+
+			const int16x8_t d10 = vshlq_n_s16(vsubq_s16(source10, vreinterpretq_s16_u16(color_u16)), 2);
+			const int16x8_t d32 = vshlq_n_s16(vsubq_s16(source32, vreinterpretq_s16_u16(color_u16)), 2);
+
+			const int32x4_t m10l = vmull_s16(vget_low_s16(d10), vget_low_s16(alpha10));
+			const int32x4_t m10h = vmull_s16(vget_high_s16(d10), vget_high_s16(alpha10));
+			const int32x4_t m32l = vmull_s16(vget_low_s16(d32), vget_low_s16(alpha32));
+			const int32x4_t m32h = vmull_s16(vget_high_s16(d32), vget_high_s16(alpha32));
+
+			const int16x8_t c10 = vcombine_s16(vshrn_n_s32(m10l, 16), vshrn_n_s32(m10h, 16));
+			const int16x8_t c32 = vcombine_s16(vshrn_n_s32(m32l, 16), vshrn_n_s32(m32h, 16));
+
+			const int16x8_t r10 = vsubq_s16(source10, c10);
+			const int16x8_t r32 = vsubq_s16(source32, c32);
+
+			const uint8x8_t result10 = vqmovun_s16(r10);
+			const uint8x8_t result32 = vqmovun_s16(r32);
+
+			vst1q_u8(reinterpret_cast<uint8_t *>(pixels), vcombine_u8(result10, result32));
+		}
+	}
+}

src/agge/blenders_intel.cpp

@@ -10,18 +10,18 @@ namespace agge
 
 		namespace
 		{
-			__m128i make_color_u16(pixel32 components)
+			uint16x8_t make_color_u16(pixel32 components)
 			{
-				__m128i t = _mm_cvtsi32_si128(reinterpret_cast<const unsigned int &>(components));
+				uint16x8_t t = _mm_cvtsi32_si128(reinterpret_cast<const unsigned int &>(components));
 
 				t = _mm_unpacklo_epi8(t, _mm_setzero_si128());
 				return _mm_unpacklo_epi64(t, t);
 			}
 
-			__m128i make_alpha_u16(unsigned int alpha)
+			uint16x8_t make_alpha_u16(unsigned int alpha)
 			{
 				alpha = (alpha << 6) + 505 * alpha / 1000;
-				__m128i t = _mm_shufflelo_epi16(_mm_cvtsi32_si128(alpha), 0);
+				uint16x8_t t = _mm_shufflelo_epi16(_mm_cvtsi32_si128(alpha), 0);
 				return _mm_unpacklo_epi64(t, t);
 			}
 		}
@@ -37,15 +37,15 @@ namespace agge
 				*pixels = _components;
 		}
 
-		void blender_solid_color::blend4(pixel *pixels, __m128i color_u16, __m128i alpha_u16, unsigned int covers_packed)
+		void blender_solid_color::blend4(pixel *pixels, uint16x8_t color_u16, uint16x8_t alpha_u16, unsigned int covers_packed)
 		{
-			__m128i alpha = _mm_mulhi_epu16(_mm_unpacklo_epi8(_mm_setzero_si128(), _mm_cvtsi32_si128(covers_packed)),
+			uint16x8_t alpha = _mm_mulhi_epu16(_mm_unpacklo_epi8(_mm_setzero_si128(), _mm_cvtsi32_si128(covers_packed)),
 				alpha_u16);
 
 			alpha = _mm_unpacklo_epi16(alpha, alpha);
 
-			__m128i source10 = _mm_loadu_si128(reinterpret_cast<__m128i *>(pixels));
-			__m128i	source32 = _mm_unpackhi_epi8(source10, _mm_setzero_si128());
+			uint16x8_t source10 = _mm_loadu_si128(reinterpret_cast<uint16x8_t *>(pixels));
+			uint16x8_t	source32 = _mm_unpackhi_epi8(source10, _mm_setzero_si128());
 						source10 = _mm_unpacklo_epi8(source10, _mm_setzero_si128());
 
 			// source -= ((source - color) << 2) * alpha >> 16;
@@ -54,7 +54,7 @@ namespace agge
 			source10 = _mm_sub_epi16(source10, _mm_mulhi_epi16(_mm_slli_epi16(_mm_sub_epi16(source10, color_u16), 2),
 				_mm_unpacklo_epi32(alpha, alpha)));
 
-			_mm_storeu_si128(reinterpret_cast<__m128i *>(pixels), _mm_packus_epi16(source10, source32));
+			_mm_storeu_si128(reinterpret_cast<uint16x8_t *>(pixels), _mm_packus_epi16(source10, source32));
 		}
 	}
 }

src/agge/blenders_simd.cpp

@@ -0,0 +1,8 @@
+#include <agge/config.h>
+
+#if defined(AGGE_ARCH_INTEL)
+	#include "blenders_intel.cpp"
+#elif defined(AGGE_ARCH_ARM)
+	#include "blenders_arm.cpp"
+#else
+#endif

tests/agge/CMakeLists.txt

@@ -21,6 +21,7 @@ set(AGGE_TEST_SOURCES
 	RendererTests.cpp
 	RendererParallelTests.cpp
 	ScanlineAdapterTests.cpp
+	SIMDBlendersTests.cpp
 	StrokeFeaturesTests.cpp
 	StrokeTests.cpp
 	VectorRasterizerTests.cpp
@@ -31,9 +32,5 @@ if (WIN32)
 else()
 endif()
 
-if (AGGE_ARCHITECTURE STREQUAL "intel")
-	set(AGGE_TEST_SOURCES ${AGGE_TEST_SOURCES} SIMDBlendersTests.cpp)
-endif()	
-
 add_library(agge.tests SHARED ${AGGE_TEST_SOURCES})
 target_link_libraries(agge.tests agge tests-common utfia)