[SYCL][LIT] Enable test for non-OpenCL

Rewrite parallel_for_range.cpp test to work with non-OpenCL PI backends
that behave like OpenCL 1.2.

Level0 testing times out on Windows, mark `windows` as unsupported.

Signed-off-by: Bjoern Knafla <[email protected]>

Author: bjoernknafla

sycl/test/basic_tests/parallel_for_range.cpp

@@ -1,5 +1,6 @@
-// XFAIL: cuda || level_zero
-// CUDA exposes broken hierarchical parallelism.
+// XFAIL: level_zero
+// UNSUPPORTED: windows
+// Level0 testing times out on Windows.
 
 // RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple  %s -o %t.out
 // RUN: %CPU_RUN_PLACEHOLDER %t.out
@@ -29,106 +30,111 @@ int main() {
   string_class DeviceVendorName = D.get_info<info::device::vendor>();
   auto DeviceType = D.get_info<info::device::device_type>();
 
-  // parallel_for, (16, 16, 16) global, (8, 8, 8) local, reqd_wg_size(4, 4, 4)
-  // -> fail
-  try {
-    Q.submit([&](handler &CGH) {
-      CGH.parallel_for<class ReqdWGSizeNegativeA>(
-          nd_range<3>(range<3>(16, 16, 16), range<3>(8, 8, 8)),
-          [=](nd_item<3>) { reqd_wg_size_helper(); });
-    });
-    Q.wait_and_throw();
-    std::cerr << "Test case ReqdWGSizeNegativeA failed: no exception has been "
-                 "thrown\n";
-    return 1; // We shouldn't be here, exception is expected
-  } catch (nd_range_error &E) {
-    if (string_class(E.what()).find(
-            "Specified local size doesn't match the required work-group size "
-            "specified in the program source") == string_class::npos) {
-      std::cerr
-          << "Test case ReqdWGSizeNegativeA failed: unexpected exception: "
-          << E.what() << std::endl;
-      return 1;
-    }
-  } catch (runtime_error &E) {
-    std::cerr << "Test case ReqdWGSizeNegativeA failed: unexpected exception: "
-              << E.what() << std::endl;
-    return 1;
-  } catch (...) {
-    std::cerr << "Test case ReqdWGSizeNegativeA failed: something unexpected "
-                 "has been caught"
-              << std::endl;
-    return 1;
-  }
-
   string_class OCLVersionStr = D.get_info<info::device::version>();
-  assert(OCLVersionStr.size() >= 10 &&
+  const bool OCLBackend = (OCLVersionStr.find("OpenCL") != string_class::npos);
+  assert((!OCLBackend || (OCLVersionStr.size() >= 10)) &&
          "Unexpected device version string"); // strlen("OpenCL X.Y")
   const char *OCLVersion = &OCLVersionStr[7]; // strlen("OpenCL ")
-  if (OCLVersion[0] == '1' || (OCLVersion[0] == '2' && OCLVersion[2] == '0')) {
-    // parallel_for, (16, 16, 16) global, null local, reqd_wg_size(4, 4, 4) //
+
+  // reqd_work_group_size is OpenCL specific.
+  if (OCLBackend) {
+    if (OCLVersion[0] == '1' || (OCLVersion[0] == '2' && OCLVersion[2] == '0')) {
+    // parallel_for, (16, 16, 16) global, (8, 8, 8) local, reqd_wg_size(4, 4, 4)
     // -> fail
     try {
       Q.submit([&](handler &CGH) {
-        CGH.parallel_for<class ReqdWGSizeNegativeB>(
-            range<3>(16, 16, 16), [=](item<3>) { reqd_wg_size_helper(); });
+        CGH.parallel_for<class ReqdWGSizeNegativeA>(
+            nd_range<3>(range<3>(16, 16, 16), range<3>(8, 8, 8)),
+            [=](nd_item<3>) { reqd_wg_size_helper(); });
       });
       Q.wait_and_throw();
-      std::cerr
-          << "Test case ReqdWGSizeNegativeB failed: no exception has been "
-             "thrown\n";
+      std::cerr << "Test case ReqdWGSizeNegativeA failed: no exception has been "
+                   "thrown\n";
       return 1; // We shouldn't be here, exception is expected
     } catch (nd_range_error &E) {
       if (string_class(E.what()).find(
-              "OpenCL 1.x and 2.0 requires to pass local size argument even if "
-              "required work-group size was specified in the program source") ==
-          string_class::npos) {
+              "Specified local size doesn't match the required work-group size "
+              "specified in the program source") == string_class::npos) {
         std::cerr
-            << "Test case ReqdWGSizeNegativeB failed: unexpected exception: "
+            << "Test case ReqdWGSizeNegativeA failed: unexpected exception: "
             << E.what() << std::endl;
         return 1;
       }
     } catch (runtime_error &E) {
-      std::cerr
-          << "Test case ReqdWGSizeNegativeB failed: unexpected exception: "
-          << E.what() << std::endl;
+      std::cerr << "Test case ReqdWGSizeNegativeA failed: unexpected exception: "
+                << E.what() << std::endl;
       return 1;
     } catch (...) {
-      std::cerr << "Test case ReqdWGSizeNegativeB failed: something unexpected "
+      std::cerr << "Test case ReqdWGSizeNegativeA failed: something unexpected "
                    "has been caught"
                 << std::endl;
       return 1;
     }
-  }
 
-  // Positive test-cases that should pass on any underlying OpenCL runtime
-
-  // parallel_for, (8, 8, 8) global, (4, 4, 4) local, reqd_wg_size(4, 4, 4) ->
-  // pass
-  try {
-    Q.submit([&](handler &CGH) {
-      CGH.parallel_for<class ReqdWGSizePositiveA>(
-          nd_range<3>(range<3>(8, 8, 8), range<3>(4, 4, 4)),
-          [=](nd_item<3>) { reqd_wg_size_helper(); });
-    });
-    Q.wait_and_throw();
-  } catch (nd_range_error &E) {
-    std::cerr << "Test case ReqdWGSizePositiveA failed: unexpected exception: "
-              << E.what() << std::endl;
-    return 1;
-  } catch (runtime_error &E) {
-    std::cerr << "Test case ReqdWGSizePositiveA failed: unexpected exception: "
+      // parallel_for, (16, 16, 16) global, null local, reqd_wg_size(4, 4, 4) //
+      // -> fail
+      try {
+        Q.submit([&](handler &CGH) {
+          CGH.parallel_for<class ReqdWGSizeNegativeB>(
+              range<3>(16, 16, 16), [=](item<3>) { reqd_wg_size_helper(); });
+        });
+        Q.wait_and_throw();
+        std::cerr
+            << "Test case ReqdWGSizeNegativeB failed: no exception has been "
+               "thrown\n";
+        return 1; // We shouldn't be here, exception is expected
+      } catch (nd_range_error &E) {
+        if (string_class(E.what()).find(
+                "OpenCL 1.x and 2.0 requires to pass local size argument even if "
+                "required work-group size was specified in the program source") ==
+            string_class::npos) {
+          std::cerr
+              << "Test case ReqdWGSizeNegativeB failed: unexpected exception: "
               << E.what() << std::endl;
-    return 1;
-  } catch (...) {
-    std::cerr << "Test case ReqdWGSizePositiveA failed: something unexpected "
-                 "has been caught"
-              << std::endl;
-    return 1;
-  }
+          return 1;
+        }
+      } catch (runtime_error &E) {
+        std::cerr
+            << "Test case ReqdWGSizeNegativeB failed: unexpected exception: "
+            << E.what() << std::endl;
+        return 1;
+      } catch (...) {
+        std::cerr << "Test case ReqdWGSizeNegativeB failed: something unexpected "
+                     "has been caught"
+                  << std::endl;
+        return 1;
+      }
+    }
 
-  if (OCLVersion[0] == '1') {
-    // OpenCL 1.x
+    // Positive test-cases that should pass on any underlying OpenCL runtime
+
+    // parallel_for, (8, 8, 8) global, (4, 4, 4) local, reqd_wg_size(4, 4, 4) ->
+    // pass
+    try {
+      Q.submit([&](handler &CGH) {
+        CGH.parallel_for<class ReqdWGSizePositiveA>(
+            nd_range<3>(range<3>(8, 8, 8), range<3>(4, 4, 4)),
+            [=](nd_item<3>) { reqd_wg_size_helper(); });
+      });
+      Q.wait_and_throw();
+    } catch (nd_range_error &E) {
+      std::cerr << "Test case ReqdWGSizePositiveA failed: unexpected exception: "
+                << E.what() << std::endl;
+      return 1;
+    } catch (runtime_error &E) {
+      std::cerr << "Test case ReqdWGSizePositiveA failed: unexpected exception: "
+                << E.what() << std::endl;
+      return 1;
+    } catch (...) {
+      std::cerr << "Test case ReqdWGSizePositiveA failed: something unexpected "
+                   "has been caught"
+                << std::endl;
+      return 1;
+    }
+  } // if  (OCLBackend)
+
+  if (!OCLBackend || (OCLVersion[0] == '1')) {
+    // OpenCL 1.x or non-OpenCL backends which behave like OpenCl 1.2 in SYCL.
 
     // CL_INVALID_WORK_GROUP_SIZE if local_work_size is specified and
     // number of workitems specified by global_work_size is not evenly
@@ -227,7 +233,8 @@ int main() {
         return 1; // We shouldn't be here, exception is expected
       }
     } catch (nd_range_error &E) {
-      if (string_class(E.what()).find("Local workgroup size cannot be greater than global range in any dimension") == string_class::npos) {
+      if ((string_class(E.what()).find("Local workgroup size cannot be greater than global range in any dimension") == string_class::npos) &&
+          (string_class(E.what()).find("Non-uniform work-groups are not supported by the target device") == string_class::npos)) {
         std::cerr
             << "Test case OpenCL1XNegativeA2 failed: unexpected exception: "
             << E.what() << std::endl;
@@ -264,7 +271,8 @@ int main() {
         return 1; // We shouldn't be here, exception is expected
       }
     } catch (nd_range_error &E) {
-      if (string_class(E.what()).find("Local workgroup size cannot be greater than global range in any dimension") == string_class::npos) {
+      if ((string_class(E.what()).find("Local workgroup size cannot be greater than global range in any dimension") == string_class::npos) &&
+          (string_class(E.what()).find("Non-uniform work-groups are not supported by the target device") == string_class::npos)) {
         std::cerr
             << "Test case OpenCL1XNegativeB2 failed: unexpected exception: "
             << E.what() << std::endl;
@@ -299,9 +307,10 @@ int main() {
                    "thrown\n";
       return 1; // We shouldn't be here, exception is expected
     } catch (nd_range_error &E) {
-      if (string_class(E.what()).find(
+      if ((string_class(E.what()).find(
               "Total number of work-items in a work-group cannot exceed " +
-              std::to_string(MaxDeviceWGSize)) == string_class::npos) {
+              std::to_string(MaxDeviceWGSize)) == string_class::npos) &&
+          (string_class(E.what()).find("Non-uniform work-groups are not supported by the target device") == string_class::npos)) {
         std::cerr
             << "Test case OpenCL1XNegativeC failed: unexpected exception: "
             << E.what() << std::endl;
@@ -317,7 +326,7 @@ int main() {
                 << std::endl;
       return 1;
     }
-  } else if (OCLVersion[0] == '2') {
+  } else if (OCLBackend && (OCLVersion[0] == '2')) {
     // OpenCL 2.x
 
     // OpenCL 2.x: