Update wait-throw

Author: davschneller

interfaces/sycl/Copy.cpp

@@ -4,23 +4,26 @@
 
 #include "SyclWrappedAPI.h"
 
+#include "Internals.h"
+
 #include <algorithm>
 #include <math.h>
 
 using namespace device;
+using namespace device::internals;
 
 void ConcreteAPI::copyTo(void *dst, const void *src, size_t size) {
   this->currentStatistics().explicitlyTransferredDataToDeviceBytes += size;
-  this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }).wait_and_throw();
+  waitCheck(this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }));
 }
 
 void ConcreteAPI::copyFrom(void *dst, const void *src, size_t size) {
   this->currentStatistics().explicitlyTransferredDataToHostBytes += size;
-  this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }).wait_and_throw();
+  waitCheck(this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }));
 }
 
 void ConcreteAPI::copyBetween(void *dst, const void *src, size_t size) {
-  this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }).wait_and_throw();
+  waitCheck(this->currentDefaultQueue().submit([&](sycl::handler &cgh) { cgh.memcpy(dst, src, size); }));
 }
 
 void ConcreteAPI::copy2dArrayTo(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height) {

interfaces/sycl/DeviceCircularQueueBuffer.cpp

@@ -7,8 +7,12 @@
 #include "SyclWrappedAPI.h"
 #include "utils/logger.h"
 
+#include "Internals.h"
+
 #include <sycl/sycl.hpp>
 
+using namespace device::internals;
+
 namespace device {
 
 // very inconvenient, but AdaptiveCpp doesn't allow much freedom when constructing a property_list
@@ -23,7 +27,7 @@ QueueWrapper::QueueWrapper(const sycl::device& dev, const std::function<void(syc
 }
 
 void QueueWrapper::synchronize() {
-  queue.wait_and_throw();
+  waitCheck(queue);
 }
 void QueueWrapper::dependency(QueueWrapper& other) {
   // improvising... Adding an empty event here, mimicking a CUDA-like event dependency
@@ -130,7 +134,7 @@ void DeviceCircularQueueBuffer::joinQueueDepencency() {
 }
 
 void DeviceCircularQueueBuffer::syncQueueWithHost(sycl::queue *queuePtr) {
-  queuePtr->wait_and_throw();
+  waitCheck(*queuePtr);
 }
 
 void DeviceCircularQueueBuffer::syncAllQueuesWithHost() {
@@ -139,7 +143,7 @@ void DeviceCircularQueueBuffer::syncAllQueuesWithHost() {
     q.synchronize();
   }
   for (auto* q : this->externalQueues) {
-    q->wait_and_throw();
+    waitCheck(*q);
   }
 }
 

interfaces/sycl/Events.cpp

@@ -4,6 +4,8 @@
 
 #include "SyclWrappedAPI.h"
 
+#include "Internals.h"
+
 #include <algorithm>
 #include <cassert>
 #include <optional>
@@ -13,6 +15,7 @@
 #endif // ONEAPI_UNDERHOOD
 
 using namespace device;
+using namespace device::internals;
 
 namespace {
 struct Event {
@@ -32,7 +35,7 @@ void ConcreteAPI::destroyEvent(void* eventPtr) {
 void ConcreteAPI::syncEventWithHost(void* eventPtr) {
   auto* event = static_cast<Event*>(eventPtr);
   if (event->syclEvent) {
-    event->syclEvent.value().wait_and_throw();
+    waitCheck(event->syclEvent.value());
   }
 }
 

interfaces/sycl/Internals.h

@@ -10,11 +10,25 @@
 #include <sycl/sycl.hpp>
 #include <string>
 
+#include "utils/logger.h"
 
 namespace device {
 namespace internals {
 constexpr static int DefaultBlockDim = 1024;
 
+template<typename T>
+void waitCheck(T&& result) {
+  try {
+    std::forward<T>(result).wait_and_throw();
+  }
+  catch (const sycl::exception& exc) {
+    logError() << "SYCL API error:" << std::string(exc.what());
+  }
+  catch (const std::exception& exc) {
+    logError() << "SYCL API/C++ error:" << std::string(exc.what());
+  }
+}
+
 /*
  * Computes the execution range for a 1D range kernel given a target work group size and a total size.
  * The method determines how many work groups are needed to handle the total size given the local execution size

interfaces/sycl/Memory.cpp

@@ -5,13 +5,16 @@
 #include "SyclWrappedAPI.h"
 #include <iostream>
 
+#include "Internals.h"
+
 using namespace device;
+using namespace device::internals;
 
 void *ConcreteAPI::allocGlobMem(size_t size, bool compress) {
   auto *ptr = malloc_device(size, this->currentDefaultQueue());
   this->currentStatistics().allocatedMemBytes += size;
   this->currentMemoryToSizeMap().insert({ptr, size});
-  this->currentDefaultQueue().wait();
+  waitCheck(this->currentDefaultQueue());
   return ptr;
 }
 
@@ -20,15 +23,15 @@ void *ConcreteAPI::allocUnifiedMem(size_t size, bool compress, Destination hint)
   this->currentStatistics().allocatedUnifiedMemBytes += size;
   this->currentStatistics().allocatedMemBytes += size;
   this->currentMemoryToSizeMap().insert({ptr, size});
-  this->currentDefaultQueue().wait();
+  waitCheck(this->currentDefaultQueue());
   return ptr;
 }
 
 void *ConcreteAPI::allocPinnedMem(size_t size, bool compress, Destination hint) {
   auto *ptr = malloc_host(size, this->currentDefaultQueue());
   this->currentStatistics().allocatedMemBytes += size;
   this->currentMemoryToSizeMap().insert({ptr, size});
-  this->currentDefaultQueue().wait();
+  waitCheck(this->currentDefaultQueue());
   return ptr;
 }
 
@@ -45,7 +48,7 @@ void ConcreteAPI::freeMem(void *devPtr) {
     this->currentStatistics().deallocatedMemBytes += this->currentMemoryToSizeMap().at(devPtr);
     this->currentMemoryToSizeMap().erase(devPtr);
     free(devPtr, this->currentDefaultQueue().get_context());
-    this->currentDefaultQueue().wait();
+    waitCheck(currentDefaultQueue());
   }
 }
 

interfaces/sycl/SyclWrappedAPI.h

@@ -174,16 +174,6 @@ class ConcreteAPI : public AbstractAPI {
 
   void initDevices();
 
-  template<typename T>
-  void waitCheck(T&& result) {
-    try {
-      std::forward<T>(result).wait_and_throw();
-    }
-    catch (const std::exception& exc) {
-      logError() << "SYCL API error:" << std::string(exc.what());
-    }
-  }
-
   std::string getCurrentDeviceInfoAsText();
   std::string getDeviceInfoAsTextInternal(sycl::device& dev);