Merge branch 'master' into sw/exp_to_ext_api

Author: stefanatwork

kernels/geometry/curve_intersector_distance.h

@@ -103,38 +103,49 @@ namespace embree
         const NativeCurve3fa curve3Di(v0,v1,v2,v3);
         const NativeCurve3fa curve3D = enlargeRadiusToMinWidth(context,geom,ray.org,curve3Di);
         const NativeCurve3fa curve2D = curve3D.xfm_pr(pre.ray_space,ray.org);
-      
-        /* evaluate the bezier curve */
-        vboolx valid = vfloatx(step) < vfloatx(float(N));
-        const Vec4vfx p0 = curve2D.template eval0<W>(0,N);
-        const Vec4vfx p1 = curve2D.template eval1<W>(0,N);
-
-        /* approximative intersection with cone */
-        const Vec4vfx v = p1-p0;
-        const Vec4vfx w = -p0;
-        const vfloatx d0 = madd(w.x,v.x,w.y*v.y);
-        const vfloatx d1 = madd(v.x,v.x,v.y*v.y);
-        const vfloatx u = clamp(d0*rcp(d1),vfloatx(zero),vfloatx(one));
-        const Vec4vfx p = madd(u,v,p0);
-        const vfloatx t = p.z*pre.depth_scale;
-        const vfloatx d2 = madd(p.x,p.x,p.y*p.y); 
-        const vfloatx r = p.w;
-        const vfloatx r2 = r*r;
-        valid &= (d2 <= r2) & (vfloatx(ray.tnear()) <= t) & (t <= vfloatx(ray.tfar));
-        if (EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR != 0.0f) 
-          valid &= t > float(EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR)*r*pre.depth_scale; // ignore self intersections
 
-        /* update hit information */
         bool ishit = false;
-        if (unlikely(any(valid))) {
-          DistanceCurveHit<NativeCurve3fa,W> hit(valid,u,0.0f,t,0,N,curve3D);
-          ishit = ishit | epilog(valid,hit);
+        int i = 0;
+
+#if !defined(__SYCL_DEVICE_ONLY__)
+        /* unrolled first iteration: on CPU SIMD this lets the compiler keep
+           the first chunk of segments in registers and skip the loop overhead.
+           On SYCL (W=1) it duplicates code without benefit and just bloats the
+           kernel, so the SYCL path falls straight into the unified loop. */
+        {
+          /* evaluate the bezier curve */
+          vboolx valid = vfloatx(step) < vfloatx(float(N));
+          const Vec4vfx p0 = curve2D.template eval0<W>(0,N);
+          const Vec4vfx p1 = curve2D.template eval1<W>(0,N);
+
+          /* approximative intersection with cone */
+          const Vec4vfx v = p1-p0;
+          const Vec4vfx w = -p0;
+          const vfloatx d0 = madd(w.x,v.x,w.y*v.y);
+          const vfloatx d1 = madd(v.x,v.x,v.y*v.y);
+          const vfloatx u = clamp(d0*rcp(d1),vfloatx(zero),vfloatx(one));
+          const Vec4vfx p = madd(u,v,p0);
+          const vfloatx t = p.z*pre.depth_scale;
+          const vfloatx d2 = madd(p.x,p.x,p.y*p.y);
+          const vfloatx r = p.w;
+          const vfloatx r2 = r*r;
+          valid &= (d2 <= r2) & (vfloatx(ray.tnear()) <= t) & (t <= vfloatx(ray.tfar));
+          if (EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR != 0.0f)
+            valid &= t > float(EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR)*r*pre.depth_scale; // ignore self intersections
+
+          /* update hit information */
+          if (unlikely(any(valid))) {
+            DistanceCurveHit<NativeCurve3fa,W> hit(valid,u,0.0f,t,0,N,curve3D);
+            ishit = ishit | epilog(valid,hit);
+          }
+          i = W;
         }
+#endif
 
-        if (unlikely(W < N)) 
+        if (unlikely(i < N))
         {
           /* process SIMD-size many segments per iteration */
-          for (int i=W; i<N; i+=W)
+          for (; i<N; i+=W)
           {
             /* evaluate the bezier curve */
             vboolx valid = vintx(i)+vintx(step) < vintx(N);

kernels/geometry/curve_intersector_sweep.h

@@ -82,10 +82,16 @@ namespace embree
         const Vec3fa dRdu = /*dQdu*/-dPdu;
         const Vec3fa dRdt = dQdt;//-dPdt;
 
-        const Vec3fa T = normalize(dPdu);
+        /* share a single rsqrt(dot(dPdu,dPdu)) between the normalize() and the
+           1/length(dPdu) needed for cos_err. Saves one transcendental per
+           Jacobian iteration (important on Xe iGPUs where sqrt/rsqrt are
+           ~14-20 cycle latency and there is no ILP to hide them). */
+        const float dPdu2 = dot(dPdu,dPdu);
+        const float rcp_len_dPdu = rsqrt(dPdu2);
+        const Vec3fa T = dPdu * rcp_len_dPdu;
         const Vec3fa dTdu = dnormalize(dPdu,ddPdu);
         //const Vec3fa dTdt = zero;
-        const float cos_err = P_err/length(dPdu);
+        const float cos_err = P_err * rcp_len_dPdu;
 
         /* Error estimate for dot(R,T):
 
@@ -348,8 +354,10 @@ namespace embree
         const Vec3ff dQ2 = abs(3.0f*(P3-P2) - W);
         const Vec3ff max_dQ = max(dQ0,dQ1,dQ2);
         const float m = max(max_dQ.x,max_dQ.y,max_dQ.z); //,max_dQ.w);
-        const float l = length(Vec3f(W));
-        const bool well_behaved = m < 0.2f*l;
+        /* compare squared values to avoid the sqrt in length(W); m is
+           non-negative since computed from abs() above, so this is exact. */
+        const float l2 = dot(Vec3f(W),Vec3f(W));
+        const bool well_behaved = m*m < (0.2f*0.2f)*l2;
 
         if (!well_behaved && stack.depth < max_depth) {
           stack.push();