[SYCL] Updating tests for SYCL2020 errc conformance (#857)

in intel/llvm#5582 we are adding an update that ensures
that the errc of any exception is correct as specified in the
SYCL2020 spec. Here we are updating and expanding the
tests to accompany

Signed-off-by: Chris Perkins chris.perkins@intel.com

Author: cperkinsintel

SYCL/Basic/accessor/accessor.cpp

@@ -657,5 +657,53 @@ int main() {
       return 1;
     }
   }
+
+  // exceptions with illegal ranges or no_init
+  {
+    const size_t bufSize = 10;
+    std::vector<int> res(bufSize);
+    sycl::range<1> r(bufSize);
+    sycl::buffer<int, 1> b(res.data(), r);
+    sycl::range<1> illegalR(bufSize + 1);
+    sycl::id<1> offset(bufSize);
+
+    // illegal ranges
+    try {
+      auto acc = b.get_access<sycl::access::mode::read_write>(illegalR, offset);
+      assert(false && "operation should not have succeeded");
+    } catch (sycl::exception &e) {
+      assert(e.code() == sycl::errc::invalid && "errc should be errc::invalid");
+    }
+    try {
+      sycl::queue q;
+      q.submit([&](sycl::handler &cgh) {
+        auto acc = b.get_access<sycl::access::mode::read_write>(cgh, illegalR);
+      });
+      q.wait_and_throw();
+      assert(false &&
+             "we should not be here. operation should not have succeeded");
+    } catch (sycl::exception &e) {
+      assert(e.code() == sycl::errc::invalid && "errc should be errc::invalid");
+    }
+
+    // no_init incompatible with read_only
+    try {
+      sycl::host_accessor out{b, sycl::read_only, sycl::no_init};
+      assert(false && "operation should have failed");
+    } catch (sycl::exception &e) {
+      assert(e.code() == sycl::errc::invalid && "errc should be errc::invalid");
+    }
+    try {
+      sycl::queue q;
+      q.submit([&](sycl::handler &cgh) {
+        sycl::accessor out{b, cgh, sycl::read_only, sycl::no_init};
+      });
+      q.wait_and_throw();
+      assert(false && "we should not be here. operation should have failed");
+    } catch (sycl::exception &e) {
+      assert(e.code() == sycl::errc::invalid && "errc should be errc::invalid");
+    }
+  }
+
   std::cout << "Test passed" << std::endl;
 }

SYCL/Basic/buffer/buffer.cpp

@@ -394,7 +394,7 @@ int main() {
       myQueue.submit([&](handler &cgh) {
         accessor<int, 2, access::mode::write, access::target::device,
                  access::placeholder::false_t>
-            B(Buffer, cgh, range<2>(20, 20), id<2>(10, 10));
+            B(Buffer, cgh, range<2>(10, 10), id<2>(10, 10));
         cgh.parallel_for<class bufferByRangeOffset>(
             range<2>{10, 5}, [=](id<2> index) { B[index] = 1; });
       });

SYCL/Basic/buffer/buffer_full_copy.cpp

@@ -220,12 +220,39 @@ void check_copy_host_to_device(cl::sycl::queue &Queue) {
   }
 }
 
+void check_exception_code() {
+  sycl::queue q;
+
+  const size_t bufSize = 10;
+  std::vector<int> res(bufSize);
+  // std::iota(res.begin(), res.end(), 1);
+  sycl::range<1> r(bufSize);
+  sycl::buffer<int, 1> b(res.data(), r);
+  sycl::range<1> smallRange(bufSize / 2);
+  sycl::id<1> offset(bufSize);
+
+  try {
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor src(b, cgh);
+      sycl::accessor destToSmall(b, cgh, smallRange);
+      cgh.copy(src, destToSmall);
+    });
+    q.wait_and_throw();
+
+    assert(false &&
+           "copy with too small Dest arg should have thrown an exception");
+  } catch (sycl::exception e) {
+    assert(e.code() == sycl::errc::invalid);
+  }
+}
+
 int main() {
   try {
     cl::sycl::queue Queue;
     check_copy_host_to_device(Queue);
     check_copy_device_to_host(Queue);
     check_fill(Queue);
+    check_exception_code();
   } catch (cl::sycl::exception &ex) {
     std::cerr << ex.what() << std::endl;
     return 1;

SYCL/Basic/buffer/subbuffer.cpp

@@ -3,6 +3,9 @@
 // RUN: %CPU_RUN_PLACEHOLDER %t.out
 // RUN: %GPU_RUN_PLACEHOLDER %t.out
 // RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+// UNSUPPORTED: (opencl && gpu)
+
 //
 //==---------- subbuffer.cpp --- sub-buffer basic test ---------------------==//
 //
@@ -71,26 +74,34 @@ void check1DSubBuffer(cl::sycl::queue &q) {
   size *= 2;
 
   std::size_t offset = size / 2, subbuf_size = 10, offset_inside_subbuf = 3,
-              subbuffer_access_range = 10;
+              subbuffer_access_range = subbuf_size - offset_inside_subbuf; // 7.
   std::vector<int> vec(size);
   std::vector<int> vec2(subbuf_size, 0);
   std::iota(vec.begin(), vec.end(), 0);
 
+  std::cout << "buffer size: " << size << ", subbuffer start: " << offset
+            << std::endl;
+
   try {
     cl::sycl::buffer<int, 1> buf(vec.data(), size);
     cl::sycl::buffer<int, 1> buf2(vec2.data(), subbuf_size);
+    // subbuffer is 10 elements, starting at midpoint. (typically 32)
     cl::sycl::buffer<int, 1> subbuf(buf, cl::sycl::id<1>(offset),
                                     cl::sycl::range<1>(subbuf_size));
 
+    // test offset accessor against a subbuffer
     q.submit([&](cl::sycl::handler &cgh) {
+      // accessor starts at the third element of the subbuffer
+      // and can read for 7 more (ie to the end of the subbuffer)
       auto acc = subbuf.get_access<cl::sycl::access::mode::read_write>(
           cgh, cl::sycl::range<1>(subbuffer_access_range),
           cl::sycl::id<1>(offset_inside_subbuf));
-      cgh.parallel_for<class foobar>(
-          cl::sycl::range<1>(subbuffer_access_range - offset_inside_subbuf),
-          [=](cl::sycl::id<1> i) { acc[i] *= -1; });
+      // subrange is made negative. ( 32 33 34 -35 -36 -37 -38 -39 -40 -41)
+      cgh.parallel_for<class foobar>(cl::sycl::range<1>(subbuffer_access_range),
+                                     [=](cl::sycl::id<1> i) { acc[i] *= -1; });
     });
 
+    // copy results of last operation back to buf2/vec2
     q.submit([&](cl::sycl::handler &cgh) {
       auto acc_sub = subbuf.get_access<cl::sycl::access::mode::read>(cgh);
       auto acc_buf = buf2.get_access<cl::sycl::access::mode::write>(cgh);
@@ -99,27 +110,48 @@ void check1DSubBuffer(cl::sycl::queue &q) {
           [=](cl::sycl::id<1> i) { acc_buf[i] = acc_sub[i]; });
     });
 
+    // multiple entire subbuffer by 10.
+    // now original buffer will be
+    // (..29 30 31 | 320 330 340 -350 -360 -370 -380 -390 -400 -410 | 42 43 44
+    // ...)
     q.submit([&](cl::sycl::handler &cgh) {
       auto acc_sub = subbuf.get_access<cl::sycl::access::mode::read_write>(
-          cgh, cl::sycl::range<1>(subbuffer_access_range));
+          cgh, cl::sycl::range<1>(subbuf_size));
       cgh.parallel_for<class foobar_1>(
-          cl::sycl::range<1>(subbuffer_access_range),
+          cl::sycl::range<1>(subbuf_size),
           [=](cl::sycl::id<1> i) { acc_sub[i] *= 10; });
     });
     q.wait_and_throw();
 
+    // buffers go out of scope. data must be copied back to vector no later than
+    // this.
   } catch (const cl::sycl::exception &e) {
     std::cerr << e.what() << std::endl;
     assert(false && "Exception was caught");
   }
 
+  // check buffer data in the area of the subbuffer
+  // OCL:GPU confused   =>  320 330 340 -350 -360 -370 -380 39   40   41
+  // every other device =>  320 330 340 -350 -360 -370 -380 -390 -400 -410
   for (int i = offset; i < offset + subbuf_size; ++i)
     assert(vec[i] == (i < offset + offset_inside_subbuf ? i * 10 : i * -10) &&
-           "Invalid result in 1d sub buffer");
+           "Invalid result in buffer overlapped by 1d sub buffer");
+
+  // check buffer data in the area OUTSIDE the subbuffer
+  for (int i = 0; i < size; i++) {
+    if (i < offset)
+      assert(vec[i] == i && "data preceding subbuffer incorrectly altered");
+
+    if (i > offset + subbuf_size)
+      assert(vec[i] == i && "data following subbuffer incorrectly altered");
+  }
 
+  // check the copy of the subbuffer data after the first operation
+  // OCL:GPU        => 32 33 34 -35 -36 -37 -38 0   0   0
+  // everyone else  => 32 33 34 -35 -36 -37 -38 -39 -40 -41
   for (int i = 0; i < subbuf_size; ++i)
     assert(vec2[i] == (i < 3 ? (offset + i) : (offset + i) * -1) &&
-           "Invalid result in 1d sub buffer");
+           "Invalid result in captured 1d sub buffer, vec2");
 }
 
 void checkExceptions() {

SYCL/Basic/interop/get_native_ze.cpp

@@ -32,5 +32,14 @@ int main() {
   ze_result_t Err = zeKernelGetProperties(Handle, &KernelProperties);
   assert(Err == ZE_RESULT_SUCCESS);
 
+  // SYCL2020 4.5.1.2 - verify exception errc
+  try {
+    // this test is L0 only, so we ask for an unavailable backend.
+    auto BE2 = sycl::get_native<sycl::backend::opencl>(Q);
+    assert(false && "we should not be here.");
+  } catch (sycl::exception e) {
+    assert(e.code() == sycl::errc::backend_mismatch && "wrong error code");
+  }
+
   return 0;
 }

SYCL/Basic/partition_supported.cpp

@@ -75,6 +75,24 @@ int main() {
         return -1;
       }
     }
+    auto maxUnits = dev.get_info<sycl::info::device::max_compute_units>();
+    try {
+      std::vector<sycl::device> v = dev.create_sub_devices<
+          sycl::info::partition_property::partition_equally>(maxUnits + 1);
+      std::cerr << "create_sub_devices with more than max_compute_units should "
+                   "have thrown an error"
+                << std::endl;
+      return -1;
+    } catch (sycl::exception &ex) {
+      if (ex.code() != sycl::errc::invalid) {
+        std::cerr << "while an exception was correctly thrown, it has the "
+                     "wrong error code"
+                     "we should have received"
+                  << sycl::errc::invalid << "but instead got"
+                  << ex.code().value() << std::endl;
+        return -1;
+      }
+    }
   } else {
     try {
       auto subDevices = dev.create_sub_devices<
@@ -85,6 +103,12 @@ int main() {
                 << std::endl;
       return -1;
     } catch (const cl::sycl::feature_not_supported &e) {
+      if (e.code() != sycl::errc::feature_not_supported) {
+        std::cerr
+            << "error code should be errc::feature_not_supported instead of "
+            << e.code().value() << std::endl;
+        return -1;
+      }
     } catch (...) {
       std::cerr << "device::create_sub_device(info::partition_affinity_domain) "
                    "should have thrown cl::sycl::feature_not_supported"

SYCL/Basic/queue/queue.cpp

@@ -124,9 +124,11 @@ int main() {
       context Context(deviceA);
       queue Queue(Context, deviceB);
       assert(Context == Queue.get_context());
-    } catch (std::exception &e) {
-      std::cout << "Exception check passed: " << e.what() << std::endl;
-      GotException = true;
+    } catch (sycl::exception &e) {
+      if (e.code() == sycl::errc::invalid) {
+        std::cout << "Exception check passed: " << e.what() << std::endl;
+        GotException = true;
+      }
     }
     assert(GotException);
   }