[SYCL] Update lgamma_r host implementation to independent of a system.

::lgamma_r is not standard C++ math functions and may not be
supported in some compilers/OS so it was replaced.

Signed-off-by: Alexey Voronov <[email protected]>

Author: alexeyvoronov-intel

sycl/source/detail/builtins.cpp

@@ -409,6 +409,12 @@ template <typename T> T inline __fract(T x, T *iptr) {
   return std::fmin(x - f, nextafter(T(1.0), T(0.0)));
 }
 
+template <typename T> inline T __lgamma_r(T x, s::cl_int *signp) {
+  T g = std::tgamma(x);
+  *signp = std::signbit(g) ? -1 : 1;
+  return std::log(std::abs(g));
+}
+
 template <typename T> inline T __mad(T a, T b, T c) { return (a * b) + c; }
 
 template <typename T> inline T __maxmag(T x, T y) {
@@ -1167,13 +1173,13 @@ MAKE_1V(lgamma, s::cl_half, s::cl_half)
 
 // lgamma_r
 cl_float lgamma_r(s::cl_float x, s::cl_int *signp) __NOEXC {
-  return ::lgamma_r(x, signp);
+  return __lgamma_r(x, signp);
 }
 cl_double lgamma_r(s::cl_double x, s::cl_int *signp) __NOEXC {
-  return ::lgamma_r(x, signp);
+  return __lgamma_r(x, signp);
 }
 cl_half lgamma_r(s::cl_half x, s::cl_int *signp) __NOEXC {
-  return ::lgamma_r(x, signp);
+  return __lgamma_r(x, signp);
 }
 MAKE_1V_2P(lgamma_r, s::cl_float, s::cl_float, s::cl_int)
 MAKE_1V_2P(lgamma_r, s::cl_double, s::cl_double, s::cl_int)

sycl/test/built-ins/scalar_math.cpp

@@ -540,6 +540,86 @@ int main() {
     assert(i == 1.0f);
   }
 
+  // lgamma with private memory
+  {
+    s::cl_float r{ 0 };
+    {
+      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgammaF1>([=]() {
+          AccR[0] = s::lgamma(s::cl_float{ 10.f });
+        });
+      });
+    }
+    assert(r > 12.8017f && r < 12.8019f); // ~12.8018
+  }
+
+  // lgamma with private memory
+  {
+    s::cl_float r{ 0 };
+    {
+      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgammaF1_neg>([=]() {
+          AccR[0] = s::lgamma(s::cl_float{ -2.4f });
+        });
+      });
+    }
+    assert(r > 0.1024f && r < 0.1026f); // ~0.102583
+  }
+
+  // lgamma_r with private memory
+  {
+    s::cl_float r{ 0 };
+    s::cl_int i{ 999 };
+    {
+      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<s::cl_int, 1> BufI(&i, s::range<1>(1),
+                                   { s::property::buffer::use_host_ptr() });
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        auto AccI = BufI.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgamma_rF1PI1>([=]() {
+          s::cl_int temp(0.0);
+          s::private_ptr<s::cl_int> Iptr(&temp);
+          AccR[0] = s::lgamma_r(s::cl_float{ 10.f }, Iptr);
+          AccI[0] = *Iptr;
+        });
+      });
+    }
+    assert(r > 12.8017f && r < 12.8019f); // ~12.8018
+    assert(i == 1);                       // tgamma of 10 is ~362880.0
+  }
+
+  // lgamma_r with private memory
+  {
+    s::cl_float r{ 0 };
+    s::cl_int i{ 999 };
+    {
+      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<s::cl_int, 1> BufI(&i, s::range<1>(1),
+                                   { s::property::buffer::use_host_ptr() });
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        auto AccI = BufI.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgamma_rF1PI1_neg>([=]() {
+          s::cl_int temp(0.0);
+          s::private_ptr<s::cl_int> Iptr(&temp);
+          AccR[0] = s::lgamma_r(s::cl_float{ -2.4f }, Iptr);
+          AccI[0] = *Iptr;
+        });
+      });
+    }
+    assert(r > 0.1024f && r < 0.1026f); // ~0.102583
+    assert(i == -1); // tgamma of -2.4 is ~-1.1080299470333461
+  }
+
   // nan
   {
     s::cl_double r{ 0 };

sycl/test/built-ins/vector_math.cpp

@@ -150,5 +150,57 @@ int main() {
     assert(i2 == 2.0f);
   }
 
+  // lgamma with private memory
+  {
+    s::cl_float2 r{ 0, 0 };
+    {
+      s::buffer<s::cl_float2, 1> BufR(&r, s::range<1>(1));
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgamma_rF2>([=]() {
+          AccR[0] = s::lgamma(s::cl_float2{ 10.f, -2.4f });
+        });
+      });
+    }
+
+    s::cl_float r1 = r.x();
+    s::cl_float r2 = r.y();
+
+    assert(r1 > 12.8017f && r1 < 12.8019f); // ~12.8018
+    assert(r2 > 0.1024f && r2 < 0.1026f);   // ~0.102583
+  }
+
+  // lgamma_r with private memory
+  {
+    s::cl_float2 r{ 0, 0 };
+    s::cl_int2 i{ 0, 0 };
+    {
+      s::buffer<s::cl_float2, 1> BufR(&r, s::range<1>(1));
+      s::buffer<s::cl_int2, 1> BufI(&i, s::range<1>(1));
+      s::queue myQueue;
+      myQueue.submit([&](s::handler &cgh) {
+        auto AccR = BufR.get_access<s::access::mode::read_write>(cgh);
+        auto AccI = BufI.get_access<s::access::mode::read_write>(cgh);
+        cgh.single_task<class lgamma_rF2PF2>([=]() {
+          s::cl_int2 temp(0.0);
+          s::private_ptr<s::cl_int2> Iptr(&temp);
+          AccR[0] = s::lgamma_r(s::cl_float2{ 10.f, -2.4f }, Iptr);
+          AccI[0] = *Iptr;
+        });
+      });
+    }
+
+    s::cl_float r1 = r.x();
+    s::cl_float r2 = r.y();
+    s::cl_int i1 = i.x();
+    s::cl_int i2 = i.y();
+
+    assert(r1 > 12.8017f && r1 < 12.8019f); // ~12.8018
+    assert(r2 > 0.1024f && r2 < 0.1026f);   // ~0.102583
+    assert(i1 == 1);                        // tgamma of 10 is ~362880.0
+    assert(i2 == -1); // tgamma of -2.4 is ~-1.1080299470333461
+  }
+
   return 0;
 }