adapt to sycl 2020 exceptions

Author: pwisniewskimobica

sycl/source/backend.cpp

@@ -38,8 +38,7 @@ static const PluginPtr &getPlugin(backend Backend) {
   case backend::ext_oneapi_cuda:
     return pi::getPlugin<backend::ext_oneapi_cuda>();
   default:
-    throw sycl::runtime_error{"getPlugin: Unsupported backend",
-                              PI_ERROR_INVALID_OPERATION};
+    throw sycl::exception(sycl::errc::runtime, "getPlugin: Unsupported backend");
   }
 }
 
@@ -196,21 +195,15 @@ make_kernel_bundle(pi_native_handle NativeHandle, const context &TargetContext,
     case (PI_PROGRAM_BINARY_TYPE_COMPILED_OBJECT):
     case (PI_PROGRAM_BINARY_TYPE_LIBRARY):
       if (State == bundle_state::input)
-        // TODO SYCL2020 exception
-        throw sycl::runtime_error(errc::invalid,
-                                  "Program and kernel_bundle state mismatch",
-                                  PI_ERROR_INVALID_VALUE);
+        throw sycl::exception(sycl::errc::runtime, "Program and kernel_bundle state mismatch");
       if (State == bundle_state::executable)
         Plugin->call<errc::build, PiApiKind::piProgramLink>(
             ContextImpl->getHandleRef(), 1, &Dev, nullptr, 1, &PiProgram,
             nullptr, nullptr, &PiProgram);
       break;
     case (PI_PROGRAM_BINARY_TYPE_EXECUTABLE):
       if (State == bundle_state::input || State == bundle_state::object)
-        // TODO SYCL2020 exception
-        throw sycl::runtime_error(errc::invalid,
-                                  "Program and kernel_bundle state mismatch",
-                                  PI_ERROR_INVALID_VALUE);
+        throw sycl::exception(sycl::errc::runtime, "Program and kernel_bundle state mismatch");
       break;
     }
   }
@@ -264,9 +257,7 @@ kernel make_kernel(const context &TargetContext,
   pi::PiProgram PiProgram = nullptr;
   if (Backend == backend::ext_oneapi_level_zero) {
     if (KernelBundleImpl->size() != 1)
-      throw sycl::runtime_error{
-          "make_kernel: kernel_bundle must have single program image",
-          PI_ERROR_INVALID_PROGRAM};
+      throw sycl::exception(sycl::errc::runtime, "make_kernel: kernel_bundle must have single program image");
 
     const device_image<bundle_state::executable> &DeviceImage =
         *KernelBundle.begin();

sycl/source/detail/allowlist.cpp

@@ -72,11 +72,11 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
   const char DelimiterBtwDeviceDescs = '|';
 
   if (AllowListRaw.find(DelimiterBtwKeyAndValue, KeyStart) == std::string::npos)
-    throw sycl::runtime_error("SYCL_DEVICE_ALLOWLIST has incorrect format. For "
-                              "details, please refer to "
-                              "https://github.com/intel/llvm/blob/sycl/sycl/"
-                              "doc/EnvironmentVariables.md",
-                              PI_ERROR_INVALID_VALUE);
+    throw sycl::exception(sycl::errc::runtime,
+                          "SYCL_DEVICE_ALLOWLIST has incorrect format. For "
+                          "details, please refer to "
+                          "https://github.com/intel/llvm/blob/sycl/sycl/"
+                          "doc/EnvironmentVariables.md");
 
   const std::string &DeprecatedKeyNameDeviceName = DeviceNameKeyName;
   const std::string &DeprecatedKeyNamePlatformName = PlatformNameKeyName;
@@ -95,12 +95,11 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
     if (std::find(SupportedAllowListKeyNames.begin(),
                   SupportedAllowListKeyNames.end(),
                   Key) == SupportedAllowListKeyNames.end()) {
-      throw sycl::runtime_error(
+      throw sycl::exception(sycl::errc::runtime,
           "Unrecognized key in SYCL_DEVICE_ALLOWLIST. For details, please "
           "refer to "
           "https://github.com/intel/llvm/blob/sycl/sycl/doc/"
-          "EnvironmentVariables.md",
-          PI_ERROR_INVALID_VALUE);
+          "EnvironmentVariables.md");
     }
 
     if (Key == DeprecatedKeyNameDeviceName) {
@@ -149,13 +148,12 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
                 break;
               }
             if (!ValueIsValid)
-              throw sycl::runtime_error(
+              throw sycl::exception( sycl::errc::runtime,
                   "Value " + Value + " for key " + Key +
                       " is not valid in "
                       "SYCL_DEVICE_ALLOWLIST. For details, please refer to "
                       "https://github.com/intel/llvm/blob/sycl/sycl/doc/"
-                      "EnvironmentVariables.md",
-                  PI_ERROR_INVALID_VALUE);
+                      "EnvironmentVariables.md");
           }
         };
 
@@ -168,14 +166,14 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
         if (Key == DeviceVendorIdKeyName) {
           // DeviceVendorId should have hex format
           if (!std::regex_match(Value, std::regex("0[xX][0-9a-fA-F]+"))) {
-            throw sycl::runtime_error(
+            throw sycl::exception(
+                sycl::errc::runtime,
                 "Value " + Value + " for key " + Key +
                     " is not valid in "
                     "SYCL_DEVICE_ALLOWLIST. It should have the hex format. For "
                     "details, please refer to "
                     "https://github.com/intel/llvm/blob/sycl/sycl/doc/"
-                    "EnvironmentVariables.md",
-                PI_ERROR_INVALID_VALUE);
+                    "EnvironmentVariables.md");
           }
         }
       }
@@ -187,11 +185,11 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
         // TODO: can be changed to string_view::starts_with after switching
         // DPC++ RT to C++20
         if (Prefix != AllowListRaw.substr(ValueStart, Prefix.length())) {
-          throw sycl::runtime_error("Key " + Key +
-                                        " of SYCL_DEVICE_ALLOWLIST should have "
-                                        "value which starts with " +
-                                        Prefix,
-                                    PI_ERROR_INVALID_VALUE);
+          throw sycl::exception(sycl::errc::runtime,
+                                "Key " + Key +
+                                    " of SYCL_DEVICE_ALLOWLIST should have "
+                                    "value which starts with " +
+                                    Prefix);
         }
         // cut off prefix from the value
         ValueStart += Prefix.length();
@@ -205,12 +203,11 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
           // if it is the last iteration and next 2 symbols are not a postfix,
           // throw exception
           if (ValueEnd == AllowListRaw.length() - Postfix.length())
-            throw sycl::runtime_error(
-                "Key " + Key +
-                    " of SYCL_DEVICE_ALLOWLIST should have "
-                    "value which ends with " +
-                    Postfix,
-                PI_ERROR_INVALID_VALUE);
+            throw sycl::exception(sycl::errc::runtime,
+                                  "Key " + Key +
+                                      " of SYCL_DEVICE_ALLOWLIST should have "
+                                      "value which ends with " +
+                                      Postfix);
         }
         size_t NextExpectedDelimiterPos = ValueEnd + Postfix.length();
         // if it is not the end of the string, check that symbol next to a
@@ -219,13 +216,13 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
             (AllowListRaw[NextExpectedDelimiterPos] !=
              DelimiterBtwItemsInDeviceDesc) &&
             (AllowListRaw[NextExpectedDelimiterPos] != DelimiterBtwDeviceDescs))
-          throw sycl::runtime_error(
+          throw sycl::exception(
+              sycl::errc::runtime,
               "Unexpected symbol on position " +
                   std::to_string(NextExpectedDelimiterPos) + ": " +
                   AllowListRaw[NextExpectedDelimiterPos] +
                   ". Should be either " + DelimiterBtwItemsInDeviceDesc +
-                  " or " + DelimiterBtwDeviceDescs,
-              PI_ERROR_INVALID_VALUE);
+                  " or " + DelimiterBtwDeviceDescs);
 
         if (AllowListRaw[NextExpectedDelimiterPos] == DelimiterBtwDeviceDescs)
           ShouldAllocateNewDeviceDescMap = true;
@@ -241,10 +238,9 @@ AllowListParsedT parseAllowList(const std::string &AllowListRaw) {
       // add key and value to the map
       DeviceDescMap.emplace(Key, Value);
     } else
-      throw sycl::runtime_error("Re-definition of key " + Key +
-                                    " is not allowed in "
-                                    "SYCL_DEVICE_ALLOWLIST",
-                                PI_ERROR_INVALID_VALUE);
+      throw sycl::exception(sycl::errc::runtime, "Re-definition of key " + Key +
+                                                     " is not allowed in "
+                                                     "SYCL_DEVICE_ALLOWLIST");
 
     KeyStart = ValueEnd;
     if (KeyStart != std::string::npos)

sycl/source/detail/event_impl.cpp

@@ -127,21 +127,15 @@ event_impl::event_impl(RT::PiEvent Event, const context &SyclContext)
       MIsFlushed(true), MState(HES_Complete) {
 
   if (MContext->is_host()) {
-    throw sycl::invalid_parameter_error(
-        "The syclContext must match the OpenCL context associated with the "
-        "clEvent.",
-        PI_ERROR_INVALID_CONTEXT);
+    throw sycl::exception(sycl::errc::invalid, "The syclContext must match the OpenCL context associated with the clEvent.");
   }
 
   RT::PiContext TempContext;
   getPlugin()->call<PiApiKind::piEventGetInfo>(MEvent, PI_EVENT_INFO_CONTEXT,
                                                sizeof(RT::PiContext),
                                                &TempContext, nullptr);
   if (MContext->getHandleRef() != TempContext) {
-    throw sycl::invalid_parameter_error(
-        "The syclContext must match the OpenCL context associated with the "
-        "clEvent.",
-        PI_ERROR_INVALID_CONTEXT);
+    throw sycl::exception(sycl::errc::invalid, "The syclContext must match the OpenCL context associated with the clEvent.");
   }
 }
 
@@ -157,7 +151,7 @@ event_impl::event_impl(const QueueImplPtr &Queue)
     if (Queue->has_property<property::queue::enable_profiling>()) {
       MHostProfilingInfo.reset(new HostProfilingInfo());
       if (!MHostProfilingInfo)
-        throw runtime_error("Out of host memory", PI_ERROR_OUT_OF_HOST_MEMORY);
+        throw sycl::exception(sycl::errc::runtime, "Out of host memory");
     }
     return;
   }
@@ -287,8 +281,7 @@ event_impl::get_profiling_info<info::event_profiling::command_start>() {
     return 0;
   }
   if (!MHostProfilingInfo)
-    throw invalid_object_error("Profiling info is not available.",
-                               PI_ERROR_PROFILING_INFO_NOT_AVAILABLE);
+    throw sycl::exception(0,sycl::errc::invalid, "Profiling info is not available.");
   return MHostProfilingInfo->getStartTime();
 }
 
@@ -302,8 +295,7 @@ uint64_t event_impl::get_profiling_info<info::event_profiling::command_end>() {
     return 0;
   }
   if (!MHostProfilingInfo)
-    throw invalid_object_error("Profiling info is not available.",
-                               PI_ERROR_PROFILING_INFO_NOT_AVAILABLE);
+    throw sycl::exception(sycl::errc::invalid, "Profiling info is not available.");
   return MHostProfilingInfo->getEndTime();
 }
 

sycl/source/detail/scheduler/commands.cpp

@@ -1526,8 +1526,7 @@ AllocaCommandBase *ExecCGCommand::getAllocaForReq(Requirement *Req) {
     if (Dep.MDepRequirement == Req)
       return Dep.MAllocaCmd;
   }
-  throw runtime_error("Alloca for command not found",
-                      PI_ERROR_INVALID_OPERATION);
+  throw sycl::exception(sycl::errc::runtime,"Alloca for command not found");
 }
 
 std::vector<std::shared_ptr<const void>>
@@ -2230,10 +2229,10 @@ static pi_result SetKernelParamsAndLaunch(
     }
     case kernel_param_kind_t::kind_specialization_constants_buffer: {
       if (Queue->is_host()) {
-        throw sycl::feature_not_supported(
+        throw sycl::exception(
+            sycl::errc::feature_not_supported,
             "SYCL2020 specialization constants are not yet supported on host "
-            "device",
-            PI_ERROR_INVALID_OPERATION);
+            "device");
       }
       assert(DeviceImageImpl != nullptr);
       RT::PiMem SpecConstsBuffer = DeviceImageImpl->get_spec_const_buffer_ref();
@@ -2245,7 +2244,7 @@ static pi_result SetKernelParamsAndLaunch(
       break;
     }
     case kernel_param_kind_t::kind_invalid:
-      throw runtime_error("Invalid kernel param kind", PI_ERROR_INVALID_VALUE);
+      throw sycl::exception(sycl::errc::runtime, "Invalid kernel param kind");
       break;
     }
   };
@@ -2492,8 +2491,8 @@ pi_int32 ExecCGCommand::enqueueImp() {
   switch (MCommandGroup->getType()) {
 
   case CG::CGTYPE::UpdateHost: {
-    throw runtime_error("Update host should be handled by the Scheduler.",
-                        PI_ERROR_INVALID_OPERATION);
+    throw sycl::exception(sycl::errc::runtime,
+                          "Update host should be handled by the Scheduler.");
   }
   case CG::CGTYPE::CopyAccToPtr: {
     CGCopy *Copy = (CGCopy *)MCommandGroup.get();
@@ -2631,13 +2630,13 @@ pi_int32 ExecCGCommand::enqueueImp() {
 
     switch (Error) {
     case PI_ERROR_INVALID_OPERATION:
-      throw sycl::runtime_error(
-          "Device doesn't support run_on_host_intel tasks.", Error);
+      throw sycl::exception(sycl::errc::runtime,
+          "Device doesn't support run_on_host_intel tasks.");
     case PI_SUCCESS:
       return Error;
     default:
-      throw sycl::runtime_error("Enqueueing run_on_host_intel task has failed.",
-                                Error);
+      throw sycl::exception(sycl::errc::runtime,
+                            "Enqueueing run_on_host_intel task has failed.");
     }
   }
   case CG::CGTYPE::Kernel: {
@@ -2795,7 +2794,7 @@ pi_int32 ExecCGCommand::enqueueImp() {
         break;
       }
       default:
-        throw runtime_error("Unsupported arg type", PI_ERROR_INVALID_VALUE);
+        throw sycl::exception(sycl::errc::runtime, "Unsupported arg type");
       }
     }
 
@@ -2822,9 +2821,9 @@ pi_int32 ExecCGCommand::enqueueImp() {
         assert(false &&
                "Can't get memory object due to no allocation available");
 
-        throw runtime_error(
-            "Can't get memory object due to no allocation available",
-            PI_ERROR_INVALID_MEM_OBJECT);
+        throw sycl::exception(
+            sycl::errc::runtime,
+            "Can't get memory object due to no allocation available");
       };
       std::for_each(std::begin(HandlerReq), std::end(HandlerReq), ReqToMemConv);
       std::sort(std::begin(ReqToMem), std::end(ReqToMem));
@@ -2902,7 +2901,7 @@ pi_int32 ExecCGCommand::enqueueImp() {
                                     typeSize, RawEvents, Event, read);
   }
   case CG::CGTYPE::None:
-    throw runtime_error("CG type not implemented.", PI_ERROR_INVALID_OPERATION);
+    throw sycl::exception(sycl::errc::runtime, "CG type not implemented.");
   }
   return PI_ERROR_INVALID_OPERATION;
 }

sycl/source/exception.cpp

@@ -79,7 +79,7 @@ bool exception::has_context() const noexcept { return (MContext != nullptr); }
 
 context exception::get_context() const {
   if (!has_context())
-    throw invalid_object_error();
+    throw sycl::exception(sycl::errc::invalid);
 
   return *MContext;
 }