normal-grain-merge 0.1.0__cp311-cp311-win_amd64.whl → 0.1.1__cp311-cp311-win_amd64.whl

normal_grain_merge/normal_grain_merge.c

@@ -2,6 +2,8 @@
 #include <stdio.h>
 #include <math.h>
 #include <float.h>
+#include <stdint.h>
+#include <string.h>
 #include <Python.h>
 #include <numpy/arrayobject.h>
 #include <smmintrin.h>
@@ -339,19 +341,25 @@ static void kernel_scalar_rgba(const uint8_t *base, const uint8_t *texture,
 }
 
 /* ---------- AVX2 helpers ----------
-   Interleaved RGB(A) is awkward for SIMD. For a skeleton that still uses AVX2, we use gathers
-   over a stride (3 or 4) to pull 8 pixels for a given channel into a vector.
-   You can later replace gathers with better deinterleaving if needed.
+   Interleaved RGB(A) is awkward for SIMD. We build 8-lane vectors per channel by
+   reusing the scalar u8x4 -> f32 helpers instead of relying on gathers.
 */
 
-/* Convert 8 u8 interleaved samples addressed by idx to float32 in [0,1]. */
-static inline __m256 gather_u8_block_to_unit_f32_avx2(const uint8_t *block_ptr,
-                                                      __m256i idx,
-                                                      __m256i mask_ff,
-                                                      __m256 inv255) {
-    __m256i v32 = _mm256_i32gather_epi32((const int*)block_ptr, idx, 1);
-    v32 = _mm256_and_si256(v32, mask_ff);
-    return _mm256_mul_ps(_mm256_cvtepi32_ps(v32), inv255);
+/* Forward declaration; definition shared with the SSE helpers later in the file. */
+static inline __m128 u8x4_to_unit_f32(uint8_t a, uint8_t b, uint8_t c, uint8_t d);
+
+/* Build 8-lane [0,1] floats for one channel from interleaved RGB. No gathers. */
+static inline __m256 load8_rgb_channel_to_unit_f32(const uint8_t *p, int ch /*0,1,2*/) {
+    /* pixel i, channel ch is at p[3*i + ch] */
+    __m128 lo = u8x4_to_unit_f32(p[3*0 + ch], p[3*1 + ch], p[3*2 + ch], p[3*3 + ch]);
+    __m128 hi = u8x4_to_unit_f32(p[3*4 + ch], p[3*5 + ch], p[3*6 + ch], p[3*7 + ch]);
+    return _mm256_set_m128(hi, lo);
+}
+
+static inline __m256 load8_rgba_channel_to_unit_f32(const uint8_t *p, int ch /*0..3*/) {
+    __m128 lo = u8x4_to_unit_f32(p[4*0 + ch], p[4*1 + ch], p[4*2 + ch], p[4*3 + ch]);
+    __m128 hi = u8x4_to_unit_f32(p[4*4 + ch], p[4*5 + ch], p[4*6 + ch], p[4*7 + ch]);
+    return _mm256_set_m128(hi, lo);
 }
 
 static inline __m256 mul_add_ps256(__m256 a, __m256 b, __m256 c) {
@@ -387,25 +395,67 @@ static inline __m256 nan_to_num_ps(__m256 x) {
     return _mm256_blendv_ps(_mm256_set1_ps(0.0f), x, cmp);
 }
 
-/* Truncate [0,1] floats to uint8 and scatter to interleaved RGB output. */
-static inline void store_unit_f32_to_u8_rgb8_avx2(__m256 fr, __m256 fg, __m256 fb,
-                                                  uint8_t *out_ptr, npy_intp start_idx) {
-    __m256 scale = _mm256_set1_ps(255.0f);
-    __m256i ir = _mm256_cvttps_epi32(_mm256_mul_ps(fr, scale));
-    __m256i ig = _mm256_cvttps_epi32(_mm256_mul_ps(fg, scale));
-    __m256i ib = _mm256_cvttps_epi32(_mm256_mul_ps(fb, scale));
-
-    int r[8], g[8], b[8];
-    _mm256_storeu_si256((__m256i*)r, ir);
-    _mm256_storeu_si256((__m256i*)g, ig);
-    _mm256_storeu_si256((__m256i*)b, ib);
-
-    for (int k = 0; k < 8; ++k) {
-        const npy_intp p = start_idx + k;
-        out_ptr[3*p+0] = (uint8_t)(r[k] < 0 ? 0 : r[k] > 255 ? 255 : r[k]);
-        out_ptr[3*p+1] = (uint8_t)(g[k] < 0 ? 0 : g[k] > 255 ? 255 : g[k]);
-        out_ptr[3*p+2] = (uint8_t)(b[k] < 0 ? 0 : b[k] > 255 ? 255 : b[k]);
-    }
+/* Convert 4 float32 RGB vectors in [0,1] to uint8_t RGBRGBRGBRGB without branches. */
+static inline void store_unit_f32_to_u8_rgb4(__m128 fr, __m128 fg, __m128 fb,
+                                             uint8_t *out_ptr) {
+    const __m128 scale = _mm_set1_ps(255.0f);
+    const __m128i zero = _mm_setzero_si128();
+    const __m128i max255 = _mm_set1_epi32(255);
+
+    __m128i ir = _mm_cvttps_epi32(_mm_mul_ps(fr, scale));
+    __m128i ig = _mm_cvttps_epi32(_mm_mul_ps(fg, scale));
+    __m128i ib = _mm_cvttps_epi32(_mm_mul_ps(fb, scale));
+
+    ir = _mm_min_epi32(_mm_max_epi32(ir, zero), max255);
+    ig = _mm_min_epi32(_mm_max_epi32(ig, zero), max255);
+    ib = _mm_min_epi32(_mm_max_epi32(ib, zero), max255);
+
+    __m128i ir16 = _mm_packus_epi32(ir, zero);
+    __m128i ig16 = _mm_packus_epi32(ig, zero);
+    __m128i ib16 = _mm_packus_epi32(ib, zero);
+
+    __m128i ir8 = _mm_packus_epi16(ir16, zero);
+    __m128i ig8 = _mm_packus_epi16(ig16, zero);
+    __m128i ib8 = _mm_packus_epi16(ib16, zero);
+
+    const __m128i mask_r = _mm_setr_epi8(
+        0, (char)0x80, (char)0x80, 1,
+        (char)0x80, (char)0x80, 2, (char)0x80,
+        (char)0x80, 3, (char)0x80, (char)0x80,
+        (char)0x80, (char)0x80, (char)0x80, (char)0x80);
+    const __m128i mask_g = _mm_setr_epi8(
+        (char)0x80, 0, (char)0x80, (char)0x80,
+        1, (char)0x80, (char)0x80, 2,
+        (char)0x80, (char)0x80, 3, (char)0x80,
+        (char)0x80, (char)0x80, (char)0x80, (char)0x80);
+    const __m128i mask_b = _mm_setr_epi8(
+        (char)0x80, (char)0x80, 0, (char)0x80,
+        (char)0x80, 1, (char)0x80, (char)0x80,
+        2, (char)0x80, (char)0x80, 3,
+        (char)0x80, (char)0x80, (char)0x80, (char)0x80);
+
+    __m128i packed = _mm_or_si128(
+        _mm_or_si128(_mm_shuffle_epi8(ir8, mask_r),
+                     _mm_shuffle_epi8(ig8, mask_g)),
+        _mm_shuffle_epi8(ib8, mask_b));
+
+    _mm_storel_epi64((__m128i*)out_ptr, packed);
+    __m128i tail_vec = _mm_srli_si128(packed, 8);
+    uint32_t tail = (uint32_t)_mm_cvtsi128_si32(tail_vec);
+    memcpy(out_ptr + 8, &tail, sizeof(tail));
+}
+
+/* Pack 8 lanes of fr/fg/fb in [0,1] to 24 bytes RGBRGB... and store. */
+static inline void store8_unit_f32_to_u8_rgb(__m256 fr, __m256 fg, __m256 fb, uint8_t *out) {
+    __m128 fr_lo = _mm256_castps256_ps128(fr);
+    __m128 fg_lo = _mm256_castps256_ps128(fg);
+    __m128 fb_lo = _mm256_castps256_ps128(fb);
+    store_unit_f32_to_u8_rgb4(fr_lo, fg_lo, fb_lo, out);
+
+    __m128 fr_hi = _mm256_extractf128_ps(fr, 1);
+    __m128 fg_hi = _mm256_extractf128_ps(fg, 1);
+    __m128 fb_hi = _mm256_extractf128_ps(fb, 1);
+    store_unit_f32_to_u8_rgb4(fr_hi, fg_hi, fb_hi, out + 12);
 }
 
 /* texture is RGB: texture_alpha = im_alpha broadcast, inverse_tpa = 1 - texture_alpha */
@@ -413,8 +463,6 @@ static void kernel_avx2_rgb(const uint8_t *base, const uint8_t *texture,
                             const uint8_t *skin, const uint8_t *im_alpha,
                             uint8_t *out, npy_intp pixels) {
     const __m256 inv255 = _mm256_set1_ps(1.0f/255.0f);
-    const __m256i mask_ff = _mm256_set1_epi32(0xFF);
-    const __m256i idx_rgb = _mm256_setr_epi32(0, 3, 6, 9, 12, 15, 18, 21);
     const __m256 half = _mm256_set1_ps(0.5f);
     const __m256 one  = _mm256_set1_ps(1.0f);
     const __m256 w    = _mm256_set1_ps((float)SKIN_WEIGHT);
@@ -427,19 +475,19 @@ static void kernel_avx2_rgb(const uint8_t *base, const uint8_t *texture,
         const uint8_t *skin_blk = skin + 3*i;
 
         /* base RGB in [0,1] */
-        __m256 fb_r = gather_u8_block_to_unit_f32_avx2(base_blk + 0, idx_rgb, mask_ff, inv255);
-        __m256 fb_g = gather_u8_block_to_unit_f32_avx2(base_blk + 1, idx_rgb, mask_ff, inv255);
-        __m256 fb_b = gather_u8_block_to_unit_f32_avx2(base_blk + 2, idx_rgb, mask_ff, inv255);
+        __m256 fb_r = load8_rgb_channel_to_unit_f32(base_blk, 0);
+        __m256 fb_g = load8_rgb_channel_to_unit_f32(base_blk, 1);
+        __m256 fb_b = load8_rgb_channel_to_unit_f32(base_blk, 2);
 
         /* texture RGB in [0,1] */
-        __m256 ft_r = gather_u8_block_to_unit_f32_avx2(tex_blk + 0, idx_rgb, mask_ff, inv255);
-        __m256 ft_g = gather_u8_block_to_unit_f32_avx2(tex_blk + 1, idx_rgb, mask_ff, inv255);
-        __m256 ft_b = gather_u8_block_to_unit_f32_avx2(tex_blk + 2, idx_rgb, mask_ff, inv255);
+        __m256 ft_r = load8_rgb_channel_to_unit_f32(tex_blk, 0);
+        __m256 ft_g = load8_rgb_channel_to_unit_f32(tex_blk, 1);
+        __m256 ft_b = load8_rgb_channel_to_unit_f32(tex_blk, 2);
 
         /* skin RGB in [0,1] */
-        __m256 fs_r = gather_u8_block_to_unit_f32_avx2(skin_blk + 0, idx_rgb, mask_ff, inv255);
-        __m256 fs_g = gather_u8_block_to_unit_f32_avx2(skin_blk + 1, idx_rgb, mask_ff, inv255);
-        __m256 fs_b = gather_u8_block_to_unit_f32_avx2(skin_blk + 2, idx_rgb, mask_ff, inv255);
+        __m256 fs_r = load8_rgb_channel_to_unit_f32(skin_blk, 0);
+        __m256 fs_g = load8_rgb_channel_to_unit_f32(skin_blk, 1);
+        __m256 fs_b = load8_rgb_channel_to_unit_f32(skin_blk, 2);
 
         /* texture_alpha = im_alpha */
         __m256 fa_im = load8_u8_to_unit_f32_avx2(im_alpha + i, inv255);
@@ -470,7 +518,7 @@ static void kernel_avx2_rgb(const uint8_t *base, const uint8_t *texture,
         __m256 fg = mul_add_ps256(gm_g, fa_im, _mm256_mul_ps(fb_g, fit_a));
         __m256 fb = mul_add_ps256(gm_b, fa_im, _mm256_mul_ps(fb_b, fit_a));
 
-        store_unit_f32_to_u8_rgb8_avx2(fr, fg, fb, out, i);
+        store8_unit_f32_to_u8_rgb(fr, fg, fb, out + 3*i);
     }
 
     if (i < pixels) {
@@ -484,9 +532,6 @@ static void kernel_avx2_rgba(const uint8_t *base, const uint8_t *texture,
                              const uint8_t *skin, const uint8_t *im_alpha,
                              uint8_t *out, npy_intp pixels) {
     const __m256 inv255 = _mm256_set1_ps(1.0f/255.0f);
-    const __m256i mask_ff = _mm256_set1_epi32(0xFF);
-    const __m256i idx_rgb  = _mm256_setr_epi32(0, 3, 6, 9, 12, 15, 18, 21);
-    const __m256i idx_rgba = _mm256_setr_epi32(0, 4, 8, 12, 16, 20, 24, 28);
     const __m256 half = _mm256_set1_ps(0.5f);
     const __m256 one  = _mm256_set1_ps(1.0f);
     const __m256 w    = _mm256_set1_ps((float)SKIN_WEIGHT);
@@ -498,18 +543,18 @@ static void kernel_avx2_rgba(const uint8_t *base, const uint8_t *texture,
         const uint8_t *tex_blk  = texture + 4*i;
         const uint8_t *skin_blk = skin + 3*i;
 
-        __m256 fb_r = gather_u8_block_to_unit_f32_avx2(base_blk + 0, idx_rgb, mask_ff, inv255);
-        __m256 fb_g = gather_u8_block_to_unit_f32_avx2(base_blk + 1, idx_rgb, mask_ff, inv255);
-        __m256 fb_b = gather_u8_block_to_unit_f32_avx2(base_blk + 2, idx_rgb, mask_ff, inv255);
+        __m256 fb_r = load8_rgb_channel_to_unit_f32(base_blk, 0);
+        __m256 fb_g = load8_rgb_channel_to_unit_f32(base_blk, 1);
+        __m256 fb_b = load8_rgb_channel_to_unit_f32(base_blk, 2);
 
-        __m256 ft_r = gather_u8_block_to_unit_f32_avx2(tex_blk + 0, idx_rgba, mask_ff, inv255);
-        __m256 ft_g = gather_u8_block_to_unit_f32_avx2(tex_blk + 1, idx_rgba, mask_ff, inv255);
-        __m256 ft_b = gather_u8_block_to_unit_f32_avx2(tex_blk + 2, idx_rgba, mask_ff, inv255);
-        __m256 ft_a = gather_u8_block_to_unit_f32_avx2(tex_blk + 3, idx_rgba, mask_ff, inv255);  /* texture alpha */
+        __m256 ft_r = load8_rgba_channel_to_unit_f32(tex_blk, 0);
+        __m256 ft_g = load8_rgba_channel_to_unit_f32(tex_blk, 1);
+        __m256 ft_b = load8_rgba_channel_to_unit_f32(tex_blk, 2);
+        __m256 ft_a = load8_rgba_channel_to_unit_f32(tex_blk, 3);  /* texture alpha */
 
-        __m256 fs_r = gather_u8_block_to_unit_f32_avx2(skin_blk + 0, idx_rgb, mask_ff, inv255);
-        __m256 fs_g = gather_u8_block_to_unit_f32_avx2(skin_blk + 1, idx_rgb, mask_ff, inv255);
-        __m256 fs_b = gather_u8_block_to_unit_f32_avx2(skin_blk + 2, idx_rgb, mask_ff, inv255);
+        __m256 fs_r = load8_rgb_channel_to_unit_f32(skin_blk, 0);
+        __m256 fs_g = load8_rgb_channel_to_unit_f32(skin_blk, 1);
+        __m256 fs_b = load8_rgb_channel_to_unit_f32(skin_blk, 2);
 
         __m256 fa_im = load8_u8_to_unit_f32_avx2(im_alpha + i, inv255);
         __m256 fta   = _mm256_mul_ps(ft_a, fa_im);           /* texture_alpha */
@@ -535,7 +580,7 @@ static void kernel_avx2_rgba(const uint8_t *base, const uint8_t *texture,
         __m256 fg = mul_add_ps256(gm_g, fta, _mm256_mul_ps(fb_g, fit_a));
         __m256 fb = mul_add_ps256(gm_b, fta, _mm256_mul_ps(fb_b, fit_a));
 
-        store_unit_f32_to_u8_rgb8_avx2(fr, fg, fb, out, i);
+        store8_unit_f32_to_u8_rgb(fr, fg, fb, out + 3*i);
     }
 
     if (i < pixels) {
@@ -631,19 +676,7 @@ static void kernel_sse42_rgb(const uint8_t *base, const uint8_t *texture,
         __m128 fg = mul_add_ps128(gm_g, fa_im, _mm_mul_ps(fb_g, fit_a));
         __m128 fb = mul_add_ps128(gm_b, fa_im, _mm_mul_ps(fb_b, fit_a));
 
-        float rr[4], gg[4], bb[4];
-        _mm_storeu_ps(rr, fr);
-        _mm_storeu_ps(gg, fg);
-        _mm_storeu_ps(bb, fb);
-
-        for (int k = 0; k < 4; ++k) {
-            int r = (int)(rr[k] * 255.0f);
-            int g = (int)(gg[k] * 255.0f);
-            int b = (int)(bb[k] * 255.0f);
-            out[3*(i+k)+0] = (uint8_t)(r < 0 ? 0 : r > 255 ? 255 : r);
-            out[3*(i+k)+1] = (uint8_t)(g < 0 ? 0 : g > 255 ? 255 : g);
-            out[3*(i+k)+2] = (uint8_t)(b < 0 ? 0 : b > 255 ? 255 : b);
-        }
+        store_unit_f32_to_u8_rgb4(fr, fg, fb, out + 3*i);
     }
 
     if (i < pixels) {
@@ -709,19 +742,7 @@ static void kernel_sse42_rgba(const uint8_t *base, const uint8_t *texture,
         __m128 fg = mul_add_ps128(gm_g, fta, _mm_mul_ps(fb_g, fit_a));
         __m128 fb = mul_add_ps128(gm_b, fta, _mm_mul_ps(fb_b, fit_a));
 
-        float rr[4], gg[4], bb[4];
-        _mm_storeu_ps(rr, fr);
-        _mm_storeu_ps(gg, fg);
-        _mm_storeu_ps(bb, fb);
-
-        for (int k = 0; k < 4; ++k) {
-            int r = (int)(rr[k] * 255.0f);
-            int g = (int)(gg[k] * 255.0f);
-            int b = (int)(bb[k] * 255.0f);
-            out[3*(i+k)+0] = (uint8_t)(r < 0 ? 0 : r > 255 ? 255 : r);
-            out[3*(i+k)+1] = (uint8_t)(g < 0 ? 0 : g > 255 ? 255 : g);
-            out[3*(i+k)+2] = (uint8_t)(b < 0 ? 0 : b > 255 ? 255 : b);
-        }
+        store_unit_f32_to_u8_rgb4(fr, fg, fb, out + 3*i);
     }
 
     if (i < pixels) {

{normal_grain_merge-0.1.0.dist-info → normal_grain_merge-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: normal_grain_merge
-Version: 0.1.0
+Version: 0.1.1
 Summary: Fused normal and grain merge C extension
 Author: Samuel Howard
 License: MIT
@@ -92,18 +92,18 @@ How much of a speedup is this? All numbers are from a Ryzen 7 4800H running Ubun
 
 | Method/Kernel     | Average Iteration Time |
 |-------------------|------------------------|
-| C scalar kernel   | 0.016007s              |
-| C SSE4.2 kernel   | 0.011155s              |
-| C AVX2 kernel     | 0.014575s              |
-| NumPy version     | 0.190392s              |
-| Old NumPy version | 0.274065s              |
+| C scalar kernel   | 0.016076s              |
+| C SSE4.2 kernel   | 0.007300s              |
+| C AVX2 kernel     | 0.007113s              |
+| NumPy version     | 0.169621s              |
+| Old NumPy version | 0.254648s              |
 
 | Method Comparison  | Speedup  |
 |--------------------|----------|
-| NumPy -> scalar    | 91.5927% |
-| NumPy -> SSE4.2    | 94.1409% |
-| NumPy -> AVX2      | 92.3448% |
-| Old np -> SSE4.2   | 95.9297% |
-| Old np -> AVX2     | 94.6819% |
-| C scalar -> SSE4.2 | 30.3086% |
-| C scalar -> AVX2   | 8.9448%  |
+| NumPy -> scalar    | 90.5223% |
+| NumPy -> SSE4.2    | 95.6965% |
+| NumPy -> AVX2      | 95.8063% |
+| Old np -> SSE4.2   | 97.1334% |
+| Old np -> AVX2     | 97.2066% |
+| C scalar -> SSE4.2 | 54.5933% |
+| C scalar -> AVX2   | 55.7525% |

normal_grain_merge-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+normal_grain_merge/__init__.py,sha256=Roc1wQ7_13LG_Z3Bd82zhk8wn7R1BrcO63fCdsvnnJU,89
+normal_grain_merge/kernel_kind.py,sha256=3cP4WRQSG9ZZeHsrXpXJ5Kcc8wABsmRSgex0rwRT8K4,162
+normal_grain_merge/normal_grain_merge.c,sha256=6bwB2LgwW6jzENlRuZVpzXCdQhsnjYSqIcWb0ua0948,37118
+normal_grain_merge/normal_grain_merge.cp311-win_amd64.pyd,sha256=BSHqoawfSkO9QDg3_-vlruLQ--ljYnSBYMbHPaj-2Oc,24576
+normal_grain_merge/normal_grain_merge.pyi,sha256=HXa55A0wdcmzPpJzi7qgJws5y2q_uGjdJZQXzTkw9vc,1089
+normal_grain_merge-0.1.1.dist-info/licenses/LICENSE,sha256=qbUDFP46iOpV1ouBhpqjX-kS_cCVMHgrLBNcdTlq7Qc,1089
+normal_grain_merge-0.1.1.dist-info/METADATA,sha256=iyQQ6xdYZSd_NxoT9s1yQ4ZvtlsJm8f2cUw8mG7a_30,3597
+normal_grain_merge-0.1.1.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
+normal_grain_merge-0.1.1.dist-info/top_level.txt,sha256=jfUAUKWrxBshHvZ0xTu3uF5VJsUpbWp5NkxUj8OXqu8,19
+normal_grain_merge-0.1.1.dist-info/RECORD,,

normal_grain_merge-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-normal_grain_merge/__init__.py,sha256=Roc1wQ7_13LG_Z3Bd82zhk8wn7R1BrcO63fCdsvnnJU,89
-normal_grain_merge/kernel_kind.py,sha256=3cP4WRQSG9ZZeHsrXpXJ5Kcc8wABsmRSgex0rwRT8K4,162
-normal_grain_merge/normal_grain_merge.c,sha256=QKMkKq10Q66x0pYZpocDGvtGN2XOl81Or1VJ_Pz9oyY,36906
-normal_grain_merge/normal_grain_merge.cp311-win_amd64.pyd,sha256=gYo094j-HY2uOboPX-aYypaP_uCS80UdfBDvCuFL_7Y,24576
-normal_grain_merge/normal_grain_merge.pyi,sha256=HXa55A0wdcmzPpJzi7qgJws5y2q_uGjdJZQXzTkw9vc,1089
-normal_grain_merge-0.1.0.dist-info/licenses/LICENSE,sha256=qbUDFP46iOpV1ouBhpqjX-kS_cCVMHgrLBNcdTlq7Qc,1089
-normal_grain_merge-0.1.0.dist-info/METADATA,sha256=-wcYnjNnihzu7IeJkzbjB1hE0PFgS-wFuMbiebyaxOA,3597
-normal_grain_merge-0.1.0.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
-normal_grain_merge-0.1.0.dist-info/top_level.txt,sha256=jfUAUKWrxBshHvZ0xTu3uF5VJsUpbWp5NkxUj8OXqu8,19
-normal_grain_merge-0.1.0.dist-info/RECORD,,