Auto pulldown and update tc files for xmain-cand branch on 20221103

Auto pulldown and update tc files for xmain-cand branch on 20221103

Author: nstester

MicroBenchmarks/ImageProcessing/Dither/main.cpp

@@ -69,7 +69,7 @@ void BENCHMARK_ORDERED_DITHER(benchmark::State &state) {
   int height = state.range(0);
   int width = state.range(0);
   int m = state.range(1);
-  int n = pow(m, 2);
+  int n = pow((double)m, 2);
   int *outputImage = (int *)malloc(sizeof(int) * height * width);
   int *temp = (int *)malloc(sizeof(int) * height * width);
 

MicroBenchmarks/libs/benchmark/test/benchmark_setup_teardown_test.cc

@@ -10,19 +10,19 @@
 
 // Test that Setup() and Teardown() are called exactly once
 // for each benchmark run (single-threaded).
-namespace single {
+namespace singlethreaded {
 static int setup_call = 0;
 static int teardown_call = 0;
-}  // namespace single
+}  // namespace singlethreaded
 static void DoSetup1(const benchmark::State& state) {
-  ++single::setup_call;
+  ++singlethreaded::setup_call;
 
   // Setup/Teardown should never be called with any thread_idx != 0.
   assert(state.thread_index() == 0);
 }
 
 static void DoTeardown1(const benchmark::State& state) {
-  ++single::teardown_call;
+  ++singlethreaded::teardown_call;
   assert(state.thread_index() == 0);
 }
 
@@ -134,8 +134,8 @@ int main(int argc, char** argv) {
   assert(ret > 0);
 
   // Setup/Teardown is called once for each arg group (1,3,5,7).
-  assert(single::setup_call == 4);
-  assert(single::teardown_call == 4);
+  assert(singlethreaded::setup_call == 4);
+  assert(singlethreaded::teardown_call == 4);
 
   // 3 group of threads calling this function (3,5,10).
   assert(concurrent::setup_call.load(std::memory_order_relaxed) == 3);

MultiSource/Applications/ClamAV/libclamav_readdb.c

@@ -1069,7 +1069,7 @@ static int dirent_compare(const struct dirent *a, const struct dirent *b) {
 	int ret = strcmp(a->d_name, b->d_name);
 	if (ret != 0)
 		return ret;
-#ifdef _AIX
+#if defined(_AIX) || (defined(__sun__) && defined(__svr4__))
        struct stat a_stat;
        struct stat b_stat;
        stat(a->d_name, &a_stat);

MultiSource/Applications/oggenc/oggenc.c

@@ -8,6 +8,7 @@
  * Portions from Vorbize, (c) Kenneth Arnold <[email protected]>
  * and libvorbis examples, (c) Monty <[email protected]>
  */
+#include <alloca.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
@@ -23,8 +24,8 @@
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
-#ifdef __XS1B__
 #include <stdint.h>
+#ifdef __XS1B__
 #include "xcoretestsuite.h"
 #endif
 
@@ -129,9 +130,9 @@ extern int _getopt_internal (int ___argc, char *const *___argv,
 
 /* these are filled in by configure */
 typedef int16_t ogg_int16_t;
-typedef u_int16_t ogg_uint16_t;
+typedef uint16_t ogg_uint16_t;
 typedef int32_t ogg_int32_t;
-typedef u_int32_t ogg_uint32_t;
+typedef uint32_t ogg_uint32_t;
 typedef int64_t ogg_int64_t;
 
 typedef struct {

MultiSource/Applications/viterbi/read_dmatrix.c

@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <string.h>
 #include <memory.h>
 
 #include "common.h"

MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/fmemopen.c

@@ -15,7 +15,7 @@
 // limitations under the License.
 //
 
-#if !defined(__linux__) && !defined(__NetBSD__)
+#if !defined(__linux__) && !defined(__NetBSD__) && !(defined(__sun__) && defined(__svr4__))
 
 #include <stdio.h>
 #include <stdlib.h>

MultiSource/Benchmarks/McCat/05-eks/main.c

@@ -32,12 +32,12 @@
 /*  contains the eigenvalues for each of the matrixes.                  */
 /*                                                                      */
 /************************************************************************/
+#include <stdio.h>
+#include <string.h>
 #include "main.h"
 #include "QRfact.h"
 #include "Triang.h"
 #include "Jacobi.h"
-#include <stdio.h>
-#include <string.h>
 Matrix A,Q,U;
 
 int comp(const double *a,const double *b)

MultiSource/Benchmarks/MiBench/consumer-lame/rtp.c

@@ -4,6 +4,7 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <alloca.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>

MultiSource/Benchmarks/MiBench/office-ispell/term.c

@@ -72,7 +72,7 @@ static char Rcs_Id[] =
 #include "msgs.h"
 #include <signal.h>
 
-#if defined(__GLIBC__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+#if defined(__GLIBC__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || (defined(__sun__) && defined(__svr4__))
 /* Use termios under at least glibc */
 #include <termios.h>
 #define USE_TERMIOS

SYCL/AtomicRef/add_local.cpp

@@ -1,3 +1,6 @@
+// See https://github.com/intel/llvm-test-suite/issues/867 for detailed status
+// UNSUPPORTED: hip
+
 // RUN: %clangxx -fsycl -fsycl-unnamed-lambda -fsycl-targets=%sycl_triple %s -o %t.out
 // RUN: %GPU_RUN_PLACEHOLDER %t.out
 // RUN: %CPU_RUN_PLACEHOLDER %t.out

SYCL/AtomicRef/min_local.cpp

@@ -1,3 +1,6 @@
+// See https://github.com/intel/llvm-test-suite/issues/867 for detailed status
+// UNSUPPORTED: hip
+
 // RUN: %clangxx -fsycl -fsycl-unnamed-lambda -fsycl-targets=%sycl_triple %s -o %t.out
 // RUN: %GPU_RUN_PLACEHOLDER %t.out
 // RUN: %CPU_RUN_PLACEHOLDER %t.out

SYCL/AtomicRef/sub_local.cpp

@@ -1,3 +1,6 @@
+// See https://github.com/intel/llvm-test-suite/issues/867 for detailed status
+// UNSUPPORTED: hip
+
 // RUN: %clangxx -fsycl -fsycl-unnamed-lambda -fsycl-targets=%sycl_triple %s -o %t.out
 // RUN: %GPU_RUN_PLACEHOLDER %t.out
 // RUN: %CPU_RUN_PLACEHOLDER %t.out

SYCL/Basic/accessor/accessor.cpp

@@ -60,6 +60,62 @@ template <typename Acc> struct Wrapper2 {
 
 template <typename Acc> struct Wrapper3 { Wrapper2<Acc> w2; };
 
+template <typename GlobAcc, typename LocAcc>
+void testLocalAccItersImpl(sycl::handler &cgh, GlobAcc &globAcc, LocAcc &locAcc,
+                           bool testConstIter) {
+  if (testConstIter) {
+    cgh.single_task([=]() {
+      size_t Idx = 0;
+      for (auto &It : locAcc) {
+        It = globAcc[Idx++];
+      }
+      Idx = 0;
+      for (auto It = locAcc.cbegin(); It != locAcc.cend(); It++)
+        globAcc[Idx++] = *It * 2 + 1;
+      Idx = locAcc.size() - 1;
+      for (auto It = locAcc.crbegin(); It != locAcc.crend(); It++)
+        globAcc[Idx--] += *It;
+    });
+  } else {
+    cgh.single_task([=]() {
+      size_t Idx = 0;
+      for (auto It = locAcc.begin(); It != locAcc.end(); It++)
+        *It = globAcc[Idx++] * 2;
+      for (auto &It : locAcc) {
+        It++;
+      }
+      for (auto It = locAcc.rbegin(); It != locAcc.rend(); It++) {
+        *It *= 2;
+        *It += 1;
+      }
+      Idx = 0;
+      for (auto &It : locAcc) {
+        globAcc[Idx++] = It;
+      }
+    });
+  }
+}
+
+void testLocalAccIters(std::vector<int> &vec, bool testConstIter = false,
+                       bool test2D = false) {
+  try {
+    sycl::queue queue;
+    sycl::buffer<int, 1> buf(vec.data(), vec.size());
+    queue.submit([&](sycl::handler &cgh) {
+      auto globAcc = buf.get_access<sycl::access::mode::read_write>(cgh);
+      if (test2D) {
+        sycl::local_accessor<int, 2> locAcc(sycl::range<2>{2, 16}, cgh);
+        testLocalAccItersImpl(cgh, globAcc, locAcc, testConstIter);
+      } else {
+        sycl::local_accessor<int, 1> locAcc(32, cgh);
+        testLocalAccItersImpl(cgh, globAcc, locAcc, testConstIter);
+      }
+    });
+  } catch (sycl::exception &e) {
+    std::cout << e.what() << std::endl;
+  }
+}
+
 int main() {
   // Host accessor.
   {
@@ -771,5 +827,40 @@ int main() {
     }
   }
 
+  // Test iterator methods with 1D local_accessor
+  {
+    std::vector<int> v(32);
+    for (int i = 0; i < v.size(); ++i) {
+      v[i] = i;
+    }
+    testLocalAccIters(v);
+    for (int i = 0; i < v.size(); ++i)
+      assert(v[i] == ((i * 2 + 1) * 2 + 1));
+
+    for (int i = 0; i < v.size(); ++i) {
+      v[i] = i;
+    }
+    testLocalAccIters(v, true);
+    for (int i = 0; i < v.size(); ++i)
+      assert(v[i] == ((i * 2 + 1) + i));
+  }
+  // Test iterator methods with 2D local_accessor
+  {
+    std::vector<int> v(32);
+    for (int i = 0; i < v.size(); ++i) {
+      v[i] = i;
+    }
+    testLocalAccIters(v, false, true);
+    for (int i = 0; i < v.size(); ++i)
+      assert(v[i] == ((i * 2 + 1) * 2 + 1));
+
+    for (int i = 0; i < v.size(); ++i) {
+      v[i] = i;
+    }
+    testLocalAccIters(v, true, true);
+    for (int i = 0; i < v.size(); ++i)
+      assert(v[i] == ((i * 2 + 1) + i));
+  }
+
   std::cout << "Test passed" << std::endl;
 }

SYCL/Basic/device-selectors.cpp

@@ -117,5 +117,69 @@ int main() {
   } catch (exception &e) {
   }
 
+  // ------ aspect_selectors --------
+
+  // Unrestrained selection, equivalent to default_selector.
+  device dev0 = device{aspect_selector()};
+  assert(dev0 == default_queue.get_device() &&
+         "unrestrained aspect selector should result in same device as "
+         "default_selector");
+
+  // -- Individual test runs may or may not have desired device available.
+  // Ignore any exception.
+
+  // Pass aspects in a vector.
+  try {
+    device dev1 =
+        device{aspect_selector(std::vector{aspect::cpu, aspect::image})};
+    assert(dev1.is_cpu() && "Incorrect device, expected CPU.");
+    assert(dev1.has(aspect::image) && "Device should support aspect::image.");
+  } catch (exception &e) {
+  }
+
+  // Pass aspects without a vector.
+  try {
+    device dev2 = device{aspect_selector(aspect::gpu, aspect::image)};
+    assert(dev2.is_gpu() && "Incorrect device, expected GPU.");
+    assert(dev2.has(aspect::image) && "Device should support aspect::image.");
+  } catch (exception &e) {
+  }
+
+  // Pass aspects as compile-time parameters
+  try {
+    device dev3 = device{aspect_selector<aspect::cpu, aspect::fp64>()};
+    assert(dev3.is_cpu() && "Incorrect device, expected CPU.");
+    assert(dev3.has(aspect::fp64) && "Device should support aspect::fp64.");
+  } catch (exception &e) {
+  }
+
+  // Pass aspects in an allowlist and a denylist.
+  try {
+    device dev4 = device{aspect_selector(std::vector{aspect::accelerator},
+                                         std::vector{aspect::image})};
+    assert(dev4.is_accelerator() && "Incorrect device, expected accelerator.");
+    assert(!dev4.has(aspect::image) &&
+           "Device should NOT support aspect::image.");
+  } catch (exception &e) {
+  }
+
+  // Validate errors.
+  try {
+    device dev5 = device{aspect_selector<aspect::cpu, aspect::gpu>()};
+    assert(
+        "We should not be here. No known device that is both a CPU and a GPU.");
+  } catch (exception &e) {
+    assert(e.code() == sycl::errc::runtime && "Incorrect error code.");
+  }
+
+  try {
+    device dev6 = device{
+        aspect_selector(std::vector{aspect::cpu}, std::vector{aspect::cpu})};
+    assert("We should not be here. RequireList and DenyList impossible to "
+           "fulfill.");
+  } catch (exception &e) {
+    assert(e.code() == sycl::errc::runtime && "Incorrect error code.");
+  }
+
   return 0;
 }

SYCL/Basic/intel-ext-device.cpp

@@ -122,6 +122,12 @@ int main(int argc, char **argv) {
               }
               std::cout << "\n";
             }
+            if (SYCL_EXT_INTEL_DEVICE_INFO >= 5 &&
+                dev.has(aspect::ext_intel_device_id)) {
+              int deviceID =
+                  dev.get_info<ext::intel::info::device::device_id>();
+              std::cout << "Device ID = " << deviceID << std::endl;
+            }
           } // SYCL_EXT_INTEL_DEVICE_INFO
         }