simd.h: renaming and fixing of shuffle template (AcademySoftwareFoundation#4739)

While I was investigating some SonarQube warnings about our simd
`shuffle<>` templates (which are a false positive and I have a separate
PR to simply silence it), I did get to thinking about the naming, and
want to make a couple changes:

* I decided that the 1-template-argument version of this function,
`shuffle<int i>(simd_type)` would actually be more clear and
self-documenting if renamed `broadcast_element` to emphasize that it is
taking just one simd lane/element and broadcasting it to all lanes. (The
multi-argument shuffle really is doing a true shuffle, giving an index
for each lane to make a permutation of swizzle, so I'm not renaming that
one.) To avoid breaking source compatibility, I am leaving the old name
as well as a synonym, but commenting it as deprecated and I will phase
out its use. It will disappear entirely from a future OIIO version
that's safe to break compatibility.

* For 16-wide simd, the 1-arg template we called shuffle was not doing
the same operation -- it was replicating one group of 4 elements instead
of a single element. We didn't use it anywhere, so I'm redefining it to
do the analogous thing as it does for 4-wide and 8-wide.

Signed-off-by: Larry Gritz <lg@larrygritz.com>

Author: lgritz

src/include/OpenImageIO/simd.h

@@ -619,8 +619,9 @@ class vbool4 {
 template<int i0, int i1, int i2, int i3>
 OIIO_FORCEINLINE vbool4 shuffle (const vbool4& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vbool4 shuffle (const vbool4& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vbool4 broadcast_element(const vbool4& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -770,8 +771,9 @@ class vbool8 {
 template<int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7>
 OIIO_FORCEINLINE vbool8 shuffle (const vbool8& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vbool8 shuffle (const vbool8& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vbool8 broadcast_element(const vbool8& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -1163,8 +1165,9 @@ vint4 srl (const vint4& val, const unsigned int bits);
 template<int i0, int i1, int i2, int i3>
 OIIO_FORCEINLINE vint4 shuffle (const vint4& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vint4 shuffle (const vint4& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vint4 broadcast_element(const vint4& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -1463,8 +1466,9 @@ vint8 srl (const vint8& val, const unsigned int bits);
 template<int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7>
 OIIO_FORCEINLINE vint8 shuffle (const vint8& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vint8 shuffle (const vint8& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vint8 broadcast_element(const vint8& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -1773,8 +1777,9 @@ template<int i> vint16 shuffle4 (const vint16& a);
 template<int i0, int i1, int i2, int i3>
 vint16 shuffle (const vint16& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> vint16 shuffle (const vint16& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> vint16 broadcast_element(const vint16& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -2098,8 +2103,9 @@ class vfloat4 {
 template<int i0, int i1, int i2, int i3>
 OIIO_FORCEINLINE vfloat4 shuffle (const vfloat4& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vfloat4 shuffle (const vfloat4& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vfloat4 broadcast_element(const vfloat4& a);
 
 /// Return { a[i0], a[i1], b[i2], b[i3] }, where i0..i3 are the extracted
 /// 2-bit indices packed into the template parameter i (going from the low
@@ -2721,8 +2727,8 @@ class vfloat8 {
 template<int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7>
 OIIO_FORCEINLINE vfloat8 shuffle (const vfloat8& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i,...>(a)
-template<int i> OIIO_FORCEINLINE vfloat8 shuffle (const vfloat8& a);
+/// broadcast_element<i>(a) is the same as shuffle<i,i,i,i,...>(a)
+template<int i> OIIO_FORCEINLINE vfloat8 broadcast_element(const vfloat8& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -3051,8 +3057,9 @@ template<int i> OIIO_FORCEINLINE vfloat16 shuffle4 (const vfloat16& a);
 template<int i0, int i1, int i2, int i3>
 OIIO_FORCEINLINE vfloat16 shuffle (const vfloat16& a);
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> vfloat16 shuffle (const vfloat16& a);
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> vfloat16 broadcast_element(const vfloat16& a);
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -3473,11 +3480,17 @@ OIIO_FORCEINLINE vbool4 shuffle (const vbool4& a) {
 #endif
 }
 
-/// shuffle<i>(a) is the same as shuffle<i,i,i,i>(a)
-template<int i> OIIO_FORCEINLINE vbool4 shuffle (const vbool4& a) {
+/// broadcast_element<i>(a) returns a simd variable in which all lanes have
+/// value a[i].
+template<int i> OIIO_FORCEINLINE vbool4 broadcast_element(const vbool4& a) {
     return shuffle<i,i,i,i>(a);
 }
 
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vbool4 shuffle(const vbool4& a) {
+    return broadcast_element<i>(a);
+}
+
 
 /// Helper: as rapid as possible extraction of one component, when the
 /// index is fixed.
@@ -3801,10 +3814,15 @@ OIIO_FORCEINLINE vbool8 shuffle (const vbool8& a) {
 #endif
 }
 
-template<int i> OIIO_FORCEINLINE vbool8 shuffle (const vbool8& a) {
+template<int i> OIIO_FORCEINLINE vbool8 broadcast_element(const vbool8& a) {
     return shuffle<i,i,i,i,i,i,i,i>(a);
 }
 
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vbool8 shuffle(const vbool8& a) {
+    return broadcast_element<i>(a);
+}
+
 
 template<int i>
 OIIO_FORCEINLINE bool extract (const vbool8& a) {
@@ -4744,7 +4762,14 @@ OIIO_FORCEINLINE vint4 shuffle (const vint4& a) {
 #endif
 }
 
-template<int i> OIIO_FORCEINLINE vint4 shuffle (const vint4& a) { return shuffle<i,i,i,i>(a); }
+template<int i> OIIO_FORCEINLINE vint4 broadcast_element(const vint4& a) {
+    return shuffle<i,i,i,i>(a);
+}
+
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vint4 shuffle(const vint4& a) {
+    return broadcast_element<i>(a);
+}
 
 
 template<int i>
@@ -5584,10 +5609,15 @@ OIIO_FORCEINLINE vint8 shuffle (const vint8& a) {
 #endif
 }
 
-template<int i> OIIO_FORCEINLINE vint8 shuffle (const vint8& a) {
+template<int i> OIIO_FORCEINLINE vint8 broadcast_element(const vint8& a) {
     return shuffle<i,i,i,i,i,i,i,i>(a);
 }
 
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vint8 shuffle(const vint8& a) {
+    return broadcast_element<i>(a);
+}
+
 
 template<int i>
 OIIO_FORCEINLINE int extract (const vint8& v) {
@@ -6395,8 +6425,15 @@ vint16 shuffle (const vint16& a) {
 #endif
 }
 
-template<int i> vint16 shuffle (const vint16& a) {
-    return shuffle<i,i,i,i> (a);
+template<int i> vint16 broadcast_element(const vint16& a) {
+    return a[i];
+}
+
+// DEPRECATED(3.1): old name and nonstandard use
+template<int i>
+OIIO_DEPRECATED("Use broadcast_element (3.1)")
+vint16 shuffle(const vint16& a) {
+    return broadcast_element<i> (a);
 }
 
 
@@ -7253,19 +7290,26 @@ OIIO_FORCEINLINE vfloat4 shuffle (const vfloat4& a) {
 #endif
 }
 
-template<int i> OIIO_FORCEINLINE vfloat4 shuffle (const vfloat4& a) { return shuffle<i,i,i,i>(a); }
+template<int i> OIIO_FORCEINLINE vfloat4 broadcast_element(const vfloat4& a) {
+    return shuffle<i,i,i,i>(a);
+}
+
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vfloat4 shuffle (const vfloat4& a) {
+    return broadcast_element<i>(a);
+}
 
 #if OIIO_SIMD_NEON
-template<> OIIO_FORCEINLINE vfloat4 shuffle<0> (const vfloat4& a) {
+template<> OIIO_FORCEINLINE vfloat4 broadcast_element<0> (const vfloat4& a) {
     float32x2_t t = vget_low_f32(a.simd()); return vdupq_lane_f32(t,0);
 }
-template<> OIIO_FORCEINLINE vfloat4 shuffle<1> (const vfloat4& a) {
+template<> OIIO_FORCEINLINE vfloat4 broadcast_element<1> (const vfloat4& a) {
     float32x2_t t = vget_low_f32(a.simd()); return vdupq_lane_f32(t,1);
 }
-template<> OIIO_FORCEINLINE vfloat4 shuffle<2> (const vfloat4& a) {
+template<> OIIO_FORCEINLINE vfloat4 broadcast_element<2> (const vfloat4& a) {
     float32x2_t t = vget_high_f32(a.simd()); return vdupq_lane_f32(t,0);
 }
-template<> OIIO_FORCEINLINE vfloat4 shuffle<3> (const vfloat4& a) {
+template<> OIIO_FORCEINLINE vfloat4 broadcast_element<3> (const vfloat4& a) {
     float32x2_t t = vget_high_f32(a.simd()); return vdupq_lane_f32(t,1);
 }
 #endif
@@ -8265,9 +8309,9 @@ OIIO_FORCEINLINE matrix44 matrix44::transposed () const {
 
 OIIO_FORCEINLINE vfloat3 matrix44::transformp (const vfloat3 &V) const {
 #if OIIO_SIMD_SSE
-    vfloat4 R = shuffle<0>(V) * m_row[0] + shuffle<1>(V) * m_row[1] +
-               shuffle<2>(V) * m_row[2] + m_row[3];
-    R = R / shuffle<3>(R);
+    vfloat4 R = broadcast_element<0>(V) * m_row[0] + broadcast_element<1>(V) * m_row[1] +
+               broadcast_element<2>(V) * m_row[2] + m_row[3];
+    R = R / broadcast_element<3>(R);
     return vfloat3 (R.xyz0());
 #else
     value_t a, b, c, w;
@@ -8281,8 +8325,8 @@ OIIO_FORCEINLINE vfloat3 matrix44::transformp (const vfloat3 &V) const {
 
 OIIO_FORCEINLINE vfloat3 matrix44::transformv (const vfloat3 &V) const {
 #if OIIO_SIMD_SSE
-    vfloat4 R = shuffle<0>(V) * m_row[0] + shuffle<1>(V) * m_row[1] +
-               shuffle<2>(V) * m_row[2];
+    vfloat4 R = broadcast_element<0>(V) * m_row[0] + broadcast_element<1>(V) * m_row[1] +
+               broadcast_element<2>(V) * m_row[2];
     return vfloat3 (R.xyz0());
 #else
     value_t a, b, c;
@@ -8296,8 +8340,8 @@ OIIO_FORCEINLINE vfloat3 matrix44::transformv (const vfloat3 &V) const {
 OIIO_FORCEINLINE vfloat3 matrix44::transformvT (const vfloat3 &V) const {
 #if OIIO_SIMD_SSE
     matrix44 T = transposed();
-    vfloat4 R = shuffle<0>(V) * T[0] + shuffle<1>(V) * T[1] +
-               shuffle<2>(V) * T[2];
+    vfloat4 R = broadcast_element<0>(V) * T[0] + broadcast_element<1>(V) * T[1] +
+               broadcast_element<2>(V) * T[2];
     return vfloat3 (R.xyz0());
 #else
     value_t a, b, c;
@@ -8311,8 +8355,8 @@ OIIO_FORCEINLINE vfloat3 matrix44::transformvT (const vfloat3 &V) const {
 OIIO_FORCEINLINE vfloat4 operator* (const vfloat4 &V, const matrix44& M)
 {
 #if OIIO_SIMD_SSE
-    return shuffle<0>(V) * M[0] + shuffle<1>(V) * M[1] +
-           shuffle<2>(V) * M[2] + shuffle<3>(V) * M[3];
+    return broadcast_element<0>(V) * M[0] + broadcast_element<1>(V) * M[1] +
+           broadcast_element<2>(V) * M[2] + broadcast_element<3>(V) * M[3];
 #else
     float a, b, c, w;
     a = V[0] * M[0][0] + V[1] * M[1][0] + V[2] * M[2][0] + V[3] * M[3][0];
@@ -9034,14 +9078,19 @@ OIIO_FORCEINLINE vfloat8 shuffle (const vfloat8& a) {
 #endif
 }
 
-template<int i> OIIO_FORCEINLINE vfloat8 shuffle (const vfloat8& a) {
+template<int i> OIIO_FORCEINLINE vfloat8 broadcast_element(const vfloat8& a) {
 #if OIIO_SIMD_AVX >= 2
     return _mm256_permutevar8x32_ps (a, vint8(i));
 #else
-    return shuffle<i,i,i,i,i,i,i,i>(a);
+    return a[i];
 #endif
 }
 
+// DEPRECATED(3.1): old name; use broadcast_element instead
+template<int i> OIIO_FORCEINLINE vfloat8 shuffle(const vfloat8& a) {
+    return broadcast_element<i>(a);
+}
+
 
 template<int i>
 OIIO_FORCEINLINE float extract (const vfloat8& v) {
@@ -9104,9 +9153,9 @@ OIIO_FORCEINLINE vfloat8 vreduce_add (const vfloat8& v) {
     vfloat8 ab_cd_0_0_ef_gh_0_0 = _mm256_hadd_ps(v.simd(), _mm256_setzero_ps());
     vfloat8 abcd_0_0_0_efgh_0_0_0 = _mm256_hadd_ps(ab_cd_0_0_ef_gh_0_0, _mm256_setzero_ps());
     // get efgh in the 0-idx slot
-    vfloat8 efgh = shuffle<4>(abcd_0_0_0_efgh_0_0_0);
+    vfloat8 efgh = broadcast_element<4>(abcd_0_0_0_efgh_0_0_0);
     vfloat8 final_sum = abcd_0_0_0_efgh_0_0_0 + efgh;
-    return shuffle<0>(final_sum);
+    return broadcast_element<0>(final_sum);
 #else
     vfloat4 hadd4 = vreduce_add(v.lo()) + vreduce_add(v.hi());
     return vfloat8(hadd4, hadd4);
@@ -9913,7 +9962,14 @@ vfloat16 shuffle (const vfloat16& a) {
 #endif
 }
 
-template<int i> vfloat16 shuffle (const vfloat16& a) {
+template<int i> vfloat16 broadcast_element(const vfloat16& a) {
+    return a[i];
+}
+
+// DEPRECATED(3.1): old name and nonstandard use
+template<int i>
+OIIO_DEPRECATED("Use broadcast_element (3.1)")
+vfloat16 shuffle(const vfloat16& a) {
     return shuffle<i,i,i,i> (a);
 }
 

src/libOpenImageIO/imagebufalgo_pixelmath.cpp

@@ -1733,7 +1733,7 @@ over_impl_rgbafloat(ImageBuf& R, const ImageBuf& A, const ImageBuf& B, ROI roi,
                 for (int x = 0; x < w; ++x, r += 4, a += 4, b += 4) {
                     vfloat4 a_simd(a);
                     vfloat4 b_simd(b);
-                    vfloat4 alpha           = shuffle<3>(a_simd);
+                    vfloat4 alpha           = broadcast_element<3>(a_simd);
                     vfloat4 one_minus_alpha = one - clamp(alpha, zero, one);
                     vfloat4 result          = a_simd + one_minus_alpha * b_simd;
                     result.store(r);

src/libtexture/texturesys.cpp

@@ -3018,10 +3018,10 @@ TextureSystemImpl::sample_bicubic(
         if (s_onetile & t_onetile) {
             // If we thought it was one tile, realize that it isn't unless
             // it's ascending.
-            s_onetile &= all(stex
-                             == (simd::shuffle<0>(stex) + (*(vint4*)iota)));
-            t_onetile &= all(ttex
-                             == (simd::shuffle<0>(ttex) + (*(vint4*)iota)));
+            s_onetile &= all(
+                stex == (simd::broadcast_element<0>(stex) + (*(vint4*)iota)));
+            t_onetile &= all(
+                ttex == (simd::broadcast_element<0>(ttex) + (*(vint4*)iota)));
         }
         bool onetile = (s_onetile & t_onetile);
         if (onetile & allvalid) {
@@ -3201,15 +3201,17 @@ TextureSystemImpl::sample_bicubic(
         simd::vfloat4 col[4];
         for (int j = 0; j < 4; ++j) {
             simd::vfloat4 lx = lerp(texel_simd[j][0], texel_simd[j][1],
-                                    shuffle<0>(h) /*h0x*/);
+                                    broadcast_element<0>(h) /*h0x*/);
             simd::vfloat4 rx = lerp(texel_simd[j][2], texel_simd[j][3],
-                                    shuffle<1>(h) /*h1x*/);
-            col[j]           = lerp(lx, rx, shuffle<1>(g) /*g1x*/);
+                                    broadcast_element<1>(h) /*h1x*/);
+            col[j]           = lerp(lx, rx, broadcast_element<1>(g) /*g1x*/);
         }
-        simd::vfloat4 ly          = lerp(col[0], col[1], shuffle<2>(h) /*h0y*/);
-        simd::vfloat4 ry          = lerp(col[2], col[3], shuffle<3>(h) /*h1y*/);
+        simd::vfloat4 ly          = lerp(col[0], col[1],
+                                         broadcast_element<2>(h) /*h0y*/);
+        simd::vfloat4 ry          = lerp(col[2], col[3],
+                                         broadcast_element<3>(h) /*h1y*/);
         simd::vfloat4 weight_simd = weight;
-        accum += weight_simd * lerp(ly, ry, shuffle<3>(g) /*g1y*/);
+        accum += weight_simd * lerp(ly, ry, broadcast_element<3>(g) /*g1y*/);
         if (daccumds_) {
             simd::vfloat4 scalex = weight_simd * float(spec.width);
             simd::vfloat4 scaley = weight_simd * float(spec.height);