treewide: use C++ exceptions properly

Since the codebase is designed around proper C++ idioms such as RAII, it
makes sense to only use C++ exceptions internally instead of mixing
exceptions and error codes. The exceptions are now caught at top level
to preserve compatibility with the existing error code-based API.

Note that we deliberately do not catch C++ runtime errors (such as
`std::bad_alloc`) nor logic errors (aka failed assertions) because no
actual handling can ever happen for such errors.

However, in the C interface we do catch _all_ exceptions (...) and
convert them into a wild-card error code.

1 files changed, 47 insertions, 57 deletions

diff --git a/src/routines/level1/xdot.cpp b/src/routines/level1/xdot.cpp
index bafea157..e0d297f8 100644
--- a/src/routines/level1/xdot.cpp
+++ b/src/routines/level1/xdot.cpp
@@ -32,69 +32,59 @@ Xdot<T>::Xdot(Queue &queue, EventPointer event, const std::string &name):
 
 // The main routine
 template <typename T>
-StatusCode Xdot<T>::DoDot(const size_t n,
-                          const Buffer<T> &dot_buffer, const size_t dot_offset,
-                          const Buffer<T> &x_buffer, const size_t x_offset, const size_t x_inc,
-                          const Buffer<T> &y_buffer, const size_t y_offset, const size_t y_inc,
-                          const bool do_conjugate) {
+void Xdot<T>::DoDot(const size_t n,
+                    const Buffer<T> &dot_buffer, const size_t dot_offset,
+                    const Buffer<T> &x_buffer, const size_t x_offset, const size_t x_inc,
+                    const Buffer<T> &y_buffer, const size_t y_offset, const size_t y_inc,
+                    const bool do_conjugate) {
 
   // Makes sure all dimensions are larger than zero
-  if (n == 0) { return StatusCode::kInvalidDimension; }
+  if (n == 0) { throw BLASError(StatusCode::kInvalidDimension); }
 
   // Tests the vectors for validity
-  auto status = TestVectorX(n, x_buffer, x_offset, x_inc);
-  if (ErrorIn(status)) { return status; }
-  status = TestVectorY(n, y_buffer, y_offset, y_inc);
-  if (ErrorIn(status)) { return status; }
-  status = TestVectorScalar(1, dot_buffer, dot_offset);
-  if (ErrorIn(status)) { return status; }
+  TestVectorX(n, x_buffer, x_offset, x_inc);
+  TestVectorY(n, y_buffer, y_offset, y_inc);
+  TestVectorScalar(1, dot_buffer, dot_offset);
 
   // Retrieves the Xdot kernels from the compiled binary
-  try {
-    const auto program = GetProgramFromCache(context_, PrecisionValue<T>(), routine_name_);
-    auto kernel1 = Kernel(program, "Xdot");
-    auto kernel2 = Kernel(program, "XdotEpilogue");
-
-    // Creates the buffer for intermediate values
-    auto temp_size = 2*db_["WGS2"];
-    auto temp_buffer = Buffer<T>(context_, temp_size);
-
-    // Sets the kernel arguments
-    kernel1.SetArgument(0, static_cast<int>(n));
-    kernel1.SetArgument(1, x_buffer());
-    kernel1.SetArgument(2, static_cast<int>(x_offset));
-    kernel1.SetArgument(3, static_cast<int>(x_inc));
-    kernel1.SetArgument(4, y_buffer());
-    kernel1.SetArgument(5, static_cast<int>(y_offset));
-    kernel1.SetArgument(6, static_cast<int>(y_inc));
-    kernel1.SetArgument(7, temp_buffer());
-    kernel1.SetArgument(8, static_cast<int>(do_conjugate));
-
-    // Event waiting list
-    auto eventWaitList = std::vector<Event>();
-
-    // Launches the main kernel
-    auto global1 = std::vector<size_t>{db_["WGS1"]*temp_size};
-    auto local1 = std::vector<size_t>{db_["WGS1"]};
-    auto kernelEvent = Event();
-    status = RunKernel(kernel1, queue_, device_, global1, local1, kernelEvent.pointer());
-    if (ErrorIn(status)) { return status; }
-    eventWaitList.push_back(kernelEvent);
-
-    // Sets the arguments for the epilogue kernel
-    kernel2.SetArgument(0, temp_buffer());
-    kernel2.SetArgument(1, dot_buffer());
-    kernel2.SetArgument(2, static_cast<int>(dot_offset));
-
-    // Launches the epilogue kernel
-    auto global2 = std::vector<size_t>{db_["WGS2"]};
-    auto local2 = std::vector<size_t>{db_["WGS2"]};
-    status = RunKernel(kernel2, queue_, device_, global2, local2, event_, eventWaitList);
-    if (ErrorIn(status)) { return status; }
-
-    // Succesfully finished the computation
-    return StatusCode::kSuccess;
-  } catch (...) { return StatusCode::kInvalidKernel; }
+  const auto program = GetProgramFromCache(context_, PrecisionValue<T>(), routine_name_);
+  auto kernel1 = Kernel(program, "Xdot");
+  auto kernel2 = Kernel(program, "XdotEpilogue");
+
+  // Creates the buffer for intermediate values
+  auto temp_size = 2*db_["WGS2"];
+  auto temp_buffer = Buffer<T>(context_, temp_size);
+
+  // Sets the kernel arguments
+  kernel1.SetArgument(0, static_cast<int>(n));
+  kernel1.SetArgument(1, x_buffer());
+  kernel1.SetArgument(2, static_cast<int>(x_offset));
+  kernel1.SetArgument(3, static_cast<int>(x_inc));
+  kernel1.SetArgument(4, y_buffer());
+  kernel1.SetArgument(5, static_cast<int>(y_offset));
+  kernel1.SetArgument(6, static_cast<int>(y_inc));
+  kernel1.SetArgument(7, temp_buffer());
+  kernel1.SetArgument(8, static_cast<int>(do_conjugate));
+
+  // Event waiting list
+  auto eventWaitList = std::vector<Event>();
+
+  // Launches the main kernel
+  auto global1 = std::vector<size_t>{db_["WGS1"]*temp_size};
+  auto local1 = std::vector<size_t>{db_["WGS1"]};
+  auto kernelEvent = Event();
+  RunKernel(kernel1, queue_, device_, global1, local1, kernelEvent.pointer());
+  eventWaitList.push_back(kernelEvent);
+
+  // Sets the arguments for the epilogue kernel
+  kernel2.SetArgument(0, temp_buffer());
+  kernel2.SetArgument(1, dot_buffer());
+  kernel2.SetArgument(2, static_cast<int>(dot_offset));
+
+  // Launches the epilogue kernel
+  auto global2 = std::vector<size_t>{db_["WGS2"]};
+  auto local2 = std::vector<size_t>{db_["WGS2"]};
+  RunKernel(kernel2, queue_, device_, global2, local2, event_, eventWaitList);
 }
 
 // =================================================================================================