Updates for OpenCL stability

Author: pvelesko

.github/workflows/check-unit-tests-arm.yml

@@ -1,6 +1,6 @@
 # Workflow syntax:
 # https://help.github.com/en/articles/workflow-syntax-for-github-actions
-name: unit-test-checker-arm
+name: Unit Tests ARM GPUs
 
 on:
   pull_request:

.github/workflows/check-unit-tests-intel.yml

@@ -1,6 +1,6 @@
 # Workflow syntax:
 # https://help.github.com/en/articles/workflow-syntax-for-github-actions
-name: unit-test-checker-intel
+name: Unit Tests Intel GPUs
 
 on:
   pull_request:

HIP

@@ -1,5 +1,9 @@
 # chipStar
 
+![Unit Tests Intel GPUs](https://github.com/CHIP-SPV/chipStar/workflows/Unit%20Tests%20Intel%20GPUs/badge.svg)
+![Unit Tests ARM GPUs](https://github.com/CHIP-SPV/chipStar/workflows/Unit%20Tests%20ARM%20GPUs/badge.svg)
+![Docker Build and Publish](https://github.com/CHIP-SPV/chipStar/workflows/Docker%20Build%20and%20Publish/badge.svg)
+
 chipStar enables compiling and running HIP and CUDA applications on platforms which support
 SPIR-V as the device intermediate representation. It supports
 OpenCL and Level Zero as the low-level runtime alternatives.
@@ -29,6 +33,13 @@ The following libraries have been ported and should work on any platform:
 
 *If there is a library that you need that is not yet supported, please open an issue stating which libraries you require and what application you are trying to build.*
 
+## Applications
+
+chipStar has so far been tested using the following applications:
+- [libCEED](https://github.com/CHIP-SPV/libCEED) Our fork includes some workarounds. 
+- [GAMESS](https://www.msg.chem.iastate.edu/gamess/) Source code is not public.
+- [HcBench](https://github.com/zjin-lcf/HeCBench) CUDA Benchmarks. 
+
 ## Getting Started
 
 Quickest way to get started is by using a prebuilt Docker container. Please refer to [Docker README](docker/docker.md)

README.md

@@ -21,6 +21,7 @@
 parser.add_argument('-d', '--dry-run', '-N', action='store_true', help='dry run')
 parser.add_argument('--regex-include', type=str, nargs='?', default="", help='Tests to be run must also match this regex (known failures will still be excluded)')
 parser.add_argument('--regex-exclude', type=str, nargs='?', default="", help='Specifically exclude tests that match this regex (known failures will still be excluded)')
+parser.add_argument('--test-mode-failures', type=str, choices=['exclude', 'include'], default='exclude', help='Control how to handle test failures: exclude (default) or include')
 
 # --total-runtime cannot be used with --num-tries
 group = parser.add_mutually_exclusive_group()
@@ -112,15 +113,36 @@ def run_cmd(cmd):
 failed_test_list = f"./test_lists/{args.backend.upper()}_{device_type_stripped.upper()}.txt"
 
 def run_tests(num_tries):
-  if len(args.regex_exclude) > 0:
-      args.regex_exclude = f"{args.regex_exclude}|"
-  if len(args.regex_include) > 0:
-      args.regex_include = f"-R {args.regex_include}"
-  # if failed_test_list is not empty, separator is |, otherwise it is empty
-  separator = "|" if os.path.exists(failed_test_list) and os.path.getsize(failed_test_list) > 0 else ""
-  cmd = f"{modules} {env_vars} ctest --output-on-failure --timeout {args.timeout} --repeat until-fail:{num_tries} -j {args.num_threads} {args.regex_include} -E \"{args.regex_exclude}`cat {failed_test_list}`{separator}`cat {all_test_list}`{texture_cmd}\" -O checkpy_{args.backend}_{args.device_type}.txt"
-  res, err = run_cmd(cmd)
-  return res, err
+    if len(args.regex_exclude) > 0:
+        args.regex_exclude = f"{args.regex_exclude}|"
+    if len(args.regex_include) > 0:
+        args.regex_include = f"{args.regex_include}|"
+    
+    # Determine the test mode based on the new argument
+    test_mode = "-E" if args.test_mode_failures == "exclude" else "-R"
+    
+    # if failed_test_list is not empty, separator is |, otherwise it is empty
+    separator = "|" if os.path.exists(failed_test_list) and os.path.getsize(failed_test_list) > 0 else ""
+    
+    cmd = f"{modules} {env_vars} ctest --output-on-failure --timeout {args.timeout} --repeat until-fail:{num_tries} -j {args.num_threads} {test_mode} \"{args.regex_exclude}{args.regex_include}`cat {failed_test_list}`{separator}`cat {all_test_list}`{texture_cmd}{double_cmd}\" -O checkpy_{args.backend}_{args.device_type}.txt"
+    res, err = run_cmd(cmd)
+
+    # If using -R, print the tests that passed
+    if test_mode == "-R":
+        passed_tests = []
+        for line in res.split('\n'):
+            if "Test" in line and "Passed" in line:
+                test_name = line.split(':')[1].strip()
+                passed_tests.append(test_name)
+        
+        if passed_tests:
+            print("The following tests FAILED:")
+            for test in passed_tests:
+                print(f"        {test}")
+        else:
+            print("No tests passed.")
+
+    return res, err
 
 
 # if --total-runtime is set, calculate the number of tries by running run_tests and checking the time

scripts/check.py

@@ -2747,7 +2747,9 @@ hipError_t hipEventSynchronize(hipEvent_t Event) {
   NULLCHECK(Event);
   chipstar::Event *ChipEvent = static_cast<chipstar::Event *>(Event);
 
-  ChipEvent->wait();
+  if (ChipEvent->isRecordingOrRecorded())
+    ChipEvent->wait();
+
   RETURN(hipSuccess);
 
   CHIP_CATCH
@@ -2762,21 +2764,28 @@ hipError_t hipEventElapsedTime(float *Ms, hipEvent_t Start, hipEvent_t Stop) {
   NULLCHECK(Start, Stop);
   chipstar::Event *ChipEventStart = static_cast<chipstar::Event *>(Start);
   chipstar::Event *ChipEventStop = static_cast<chipstar::Event *>(Stop);
+
+  if (ChipEventStart->getFlags().isDisableTiming() ||
+      ChipEventStop->getFlags().isDisableTiming())
+    CHIPERR_LOG_AND_THROW("One of the events has timings disabled. "
+                          "Unable to return elasped time",
+                          hipErrorInvalidHandle);
+
   if (!ChipEventStart->isRecordingOrRecorded() ||
       !ChipEventStop->isRecordingOrRecorded()) {
     CHIPERR_LOG_AND_THROW("One of the events was not recorded",
                           hipErrorInvalidHandle);
   }
-  if (ChipEventStart->getFlags().isDisableTiming() ||
-      ChipEventStop->getFlags().isDisableTiming())
-    CHIPERR_LOG_AND_THROW("One of the events has timings disabled. "
-                          "Unable to return elasped time",
-                          hipErrorInvalidResourceHandle);
+
+  if (!ChipEventStart->getEventStatus() == EVENT_STATUS_RECORDING)
+    RETURN(hipErrorNotReady);
+  if (!ChipEventStop->getEventStatus() == EVENT_STATUS_RECORDING)
+    RETURN(hipErrorNotReady);
 
   *Ms = ChipEventStart->getElapsedTime(ChipEventStop);
-  RETURN(hipSuccess);
 
   CHIP_CATCH
+  RETURN(hipSuccess);
 }
 
 hipError_t hipEventQuery(hipEvent_t Event) {

src/CHIPBindings.cc

@@ -345,14 +345,16 @@ inline hipError_t hip_convert_error(ze_result_t zeStatus, FuncPtr func) {
 #undef CHIPERR_CHECK_LOG_AND_THROW_TABLE
 #define CHIPERR_CHECK_LOG_AND_THROW_TABLE(func, ...)                           \
   do {                                                                         \
-    if (zeStatus != ZE_RESULT_SUCCESS) {                                         \
-      hipError_t err = hip_convert_error(zeStatus, func);                        \
+    if (zeStatus != ZE_RESULT_SUCCESS) {                                       \
+      hipError_t err = hip_convert_error(zeStatus, func);                      \
       if (err == hipErrorTbd) {                                                \
         std::cerr << "Error: Unmapped API or API Error Code encountered at "   \
                   << __FILE__ << ":" << __LINE__ << std::endl;                 \
+        std::cerr << "API call: " << #func << std::endl;                       \
+        std::cerr << "Error code: " << resultToString(zeStatus) << std::endl;  \
         std::abort();                                                          \
       }                                                                        \
-      std::string error_msg = std::string(resultToString(zeStatus));             \
+      std::string error_msg = std::string(resultToString(zeStatus));           \
       std::string custom_msg = std::string(__VA_ARGS__);                       \
       std::string msg_ = error_msg + " " + custom_msg;                         \
       CHIPERR_LOG_AND_THROW(msg_, err);                                        \
@@ -362,8 +364,8 @@ inline hipError_t hip_convert_error(ze_result_t zeStatus, FuncPtr func) {
 #undef CHIPERR_CHECK_LOG_AND_ABORT
 #define CHIPERR_CHECK_LOG_AND_ABORT(...)                                       \
   do {                                                                         \
-    if (zeStatus != ZE_RESULT_SUCCESS) {                                         \
-      std::string error_msg = std::string(resultToString(zeStatus));             \
+    if (zeStatus != ZE_RESULT_SUCCESS) {                                       \
+      std::string error_msg = std::string(resultToString(zeStatus));           \
       std::string custom_msg = std::string(__VA_ARGS__);                       \
       std::string msg_ = error_msg + " " + custom_msg;                         \
       std::cout << msg_ << std::endl;                                          \
@@ -374,8 +376,8 @@ inline hipError_t hip_convert_error(ze_result_t zeStatus, FuncPtr func) {
 #undef CHIPERR_CHECK_LOG_AND_THROW
 #define CHIPERR_CHECK_LOG_AND_THROW(errtype, ...)                              \
   do {                                                                         \
-    if (zeStatus != ZE_RESULT_SUCCESS) {                                         \
-      std::string error_msg = std::string(resultToString(zeStatus));             \
+    if (zeStatus != ZE_RESULT_SUCCESS) {                                       \
+      std::string error_msg = std::string(resultToString(zeStatus));           \
       std::string custom_msg = std::string(__VA_ARGS__);                       \
       std::string msg_ = error_msg + " " + custom_msg;                         \
       CHIPERR_LOG_AND_THROW(msg_, errtype);                                    \

src/backend/Level0/zeHipErrorConversion.hh

@@ -666,8 +666,12 @@ CHIPEventOpenCL::CHIPEventOpenCL(CHIPContextOpenCL *ChipContext,
 uint64_t CHIPEventOpenCL::getFinishTime() {
   int clStatus;
   uint64_t Ret;
+  size_t returnedSize;
   clStatus = clGetEventProfilingInfo(ClEvent, CL_PROFILING_COMMAND_END,
-                                     sizeof(Ret), &Ret, NULL);
+                                     sizeof(Ret), &Ret, &returnedSize);
+  if (returnedSize != sizeof(Ret)) {
+    std::abort();
+  }
 
   if (clStatus != CL_SUCCESS) {
     clStatus = clGetEventInfo(ClEvent, CL_EVENT_COMMAND_EXECUTION_STATUS,
@@ -730,6 +734,8 @@ void CHIPEventOpenCL::recordEventCopy(
   this->ClEvent = Other->ClEvent;
   this->RecordedEvent = Other;
   this->Msg = "recordEventCopy: " + Other->Msg;
+  this->HostTimeStamp =
+      std::chrono::high_resolution_clock::now().time_since_epoch().count();
 }
 
 bool CHIPEventOpenCL::wait() {
@@ -769,10 +775,6 @@ bool CHIPEventOpenCL::updateFinishStatus(bool ThrowErrorIfNotReady) {
 }
 
 float CHIPEventOpenCL::getElapsedTime(chipstar::Event *OtherIn) {
-  // Why do I need to lock the context mutex?
-  // Can I lock the mutex of this and the other event?
-  //
-
   CHIPEventOpenCL *Other = (CHIPEventOpenCL *)OtherIn;
 
   if (this->getContext() != Other->getContext())
@@ -781,8 +783,10 @@ float CHIPEventOpenCL::getElapsedTime(chipstar::Event *OtherIn) {
         "the same context",
         hipErrorTbd);
 
-  this->updateFinishStatus(true);
-  Other->updateFinishStatus(true);
+  if (this->getEventStatus() == EVENT_STATUS_RECORDING)
+    this->updateFinishStatus(false);
+  if (Other->getEventStatus() == EVENT_STATUS_RECORDING)
+    Other->updateFinishStatus(false);
 
   if (!this->isRecordingOrRecorded() || !Other->isRecordingOrRecorded())
     CHIPERR_LOG_AND_THROW("one of the events isn't/hasn't recorded",
@@ -792,23 +796,40 @@ float CHIPEventOpenCL::getElapsedTime(chipstar::Event *OtherIn) {
     CHIPERR_LOG_AND_THROW("one of the events hasn't finished",
                           hipErrorNotReady);
 
-  uint64_t Started = this->getFinishTime();
-  uint64_t Finished = Other->getFinishTime();
+  uint64_t BeginGPU = this->getFinishTime();
+  uint64_t EndGPU = Other->getFinishTime();
+  uint64_t BeginCPU = this->HostTimeStamp;
+  uint64_t EndCPU = Other->HostTimeStamp;
 
-  logTrace("EventElapsedTime: STARTED {} / {} FINISHED {} / {} \n",
-           (void *)this, Started, (void *)Other, Finished);
+  bool ReversedEvents = false;
+  if (EndCPU < BeginCPU) {
+    ReversedEvents = true;
+    std::swap(BeginGPU, EndGPU);
+  }
 
-  // apparently fails for Intel NEO, god knows why
-  // assert(Finished >= Started);
+  // Handle overflow
   int64_t Elapsed;
+  const uint64_t MaxValue = std::numeric_limits<uint64_t>::max();
+  if (EndGPU < BeginGPU) {
+    logError("Overflow detected in CHIPEventOpenCL::getElapsedTime()");
+    logError("BeginGPU: {}, EndGPU: {}", BeginGPU, EndGPU);
+    Elapsed =
+        (MaxValue - BeginGPU) + EndGPU + 1; // +1 to account for wraparound
+  } else {
+    Elapsed = EndGPU - BeginGPU;
+  }
+
   const int64_t NANOSECS = 1000000000;
-  if (Finished < Started)
-    logWarn("Finished < Started\n");
-  Elapsed = Finished - Started;
   int64_t MS = (Elapsed / NANOSECS) * 1000;
   int64_t NS = Elapsed % NANOSECS;
   float FractInMS = ((float)NS) / 1000000.0f;
-  return (float)MS + FractInMS;
+  float Ms = (float)MS + FractInMS;
+
+  Ms = std::abs(Ms);
+  if (ReversedEvents)
+    Ms = -Ms;
+
+  return Ms;
 }
 
 void CHIPEventOpenCL::hostSignal() { UNIMPLEMENTED(); }
@@ -1069,6 +1090,7 @@ struct HipStreamCallbackData {
   void *UserData;
   hipStreamCallback_t Callback;
   std::shared_ptr<chipstar::Event> CallbackFinishEvent;
+  std::shared_ptr<chipstar::Event> CallbackCompleted;
 };
 
 void CL_CALLBACK pfn_notify(cl_event Event, cl_int CommandExecStatus,
@@ -1084,6 +1106,7 @@ void CL_CALLBACK pfn_notify(cl_event Event, cl_int CommandExecStatus,
         std::static_pointer_cast<CHIPEventOpenCL>(Cbo->CallbackFinishEvent)
             ->ClEvent,
         CL_COMPLETE);
+    CHIPERR_CHECK_LOG_AND_THROW_TABLE(clSetUserEventStatus);
   }
   delete Cbo;
 }
@@ -1176,21 +1199,12 @@ void CHIPQueueOpenCL::addCallback(hipStreamCallback_t Callback,
   cl::Context *ClContext_ = ((CHIPContextOpenCL *)ChipContext_)->get();
   cl_int Err;
 
-  std::shared_ptr<chipstar::Event> HoldBackEvent =
-      static_cast<CHIPBackendOpenCL *>(Backend)->createEventShared(
-          ChipContext_);
-
-  std::static_pointer_cast<CHIPEventOpenCL>(HoldBackEvent)->ClEvent =
-      clCreateUserEvent(ClContext_->get(), &Err);
-
-  std::vector<std::shared_ptr<chipstar::Event>> WaitForEvents{HoldBackEvent};
-
   // Enqueue a barrier used to ensure the callback is not called too early,
   // otherwise it would be (at worst) executed in this host thread when
   // setting it, blocking the execution, while the clients might expect
   // parallel execution.
   std::shared_ptr<chipstar::Event> HoldbackBarrierCompletedEv =
-      enqueueBarrier(WaitForEvents);
+      enqueueBarrier(std::vector<std::shared_ptr<chipstar::Event>>{});
 
   // OpenCL event callbacks have undefined execution ordering/finishing
   // guarantees. We need to enforce CUDA ordering using user events.
@@ -1208,10 +1222,10 @@ void CHIPQueueOpenCL::addCallback(hipStreamCallback_t Callback,
   // finishing the user CB's execution.
 
   HipStreamCallbackData *Cb = new HipStreamCallbackData{
-      this, hipSuccess, UserData, Callback, CallbackEvent};
+      this, hipSuccess, UserData, Callback, CallbackEvent, nullptr};
 
   std::vector<std::shared_ptr<chipstar::Event>> WaitForEventsCBB{CallbackEvent};
-  auto CallbackCompleted = enqueueBarrier(WaitForEventsCBB);
+  Cb->CallbackCompleted = enqueueBarrier(WaitForEventsCBB);
 
   // We know that the callback won't be yet launched since it's depending
   // on the barrier which waits for the user event.
@@ -1221,17 +1235,17 @@ void CHIPQueueOpenCL::addCallback(hipStreamCallback_t Callback,
       CL_COMPLETE, pfn_notify, Cb);
   CHIPERR_CHECK_LOG_AND_THROW_TABLE(clSetEventCallback);
 
-  updateLastEvent(CallbackCompleted);
-  get()->flush();
+  updateLastEvent(Cb->CallbackCompleted);
 
   // Now the CB can start executing in the background:
   clSetUserEventStatus(
-      std::static_pointer_cast<CHIPEventOpenCL>(HoldBackEvent)->ClEvent,
+      std::static_pointer_cast<CHIPEventOpenCL>(HoldbackBarrierCompletedEv)
+          ->ClEvent,
       CL_COMPLETE);
-  //   HoldBackEvent->decreaseRefCount("Notified finished.");
+  CHIPERR_CHECK_LOG_AND_THROW_TABLE(clSetUserEventStatus);
 
   return;
-};
+}
 
 std::shared_ptr<chipstar::Event> CHIPQueueOpenCL::enqueueMarkerImpl() {
   std::shared_ptr<chipstar::Event> MarkerEvent =
@@ -1512,7 +1526,7 @@ void CHIPQueueOpenCL::finish() {
   LOCK(Backend->DubiousLockOpenCL)
 #endif
   clStatus = get()->finish();
-  // CHIPERR_CHECK_LOG_AND_ABORT(clStatus, CL_SUCCESS, hipErrorTbd);
+  CHIPERR_CHECK_LOG_AND_THROW_TABLE(clFinish);
 }
 
 std::shared_ptr<chipstar::Event>

src/backend/OpenCL/CHIPBackendOpenCL.cc

@@ -116,6 +116,7 @@ public:
   cl_event ClEvent;
   friend class CHIPEventOpenCL;
   std::shared_ptr<chipstar::Event> RecordedEvent;
+  uint64_t HostTimeStamp;
 
 public:
   CHIPEventOpenCL(CHIPContextOpenCL *ChipContext, cl_event ClEvent,

src/backend/OpenCL/CHIPBackendOpenCL.hh

@@ -164,7 +164,8 @@ const std::unordered_map<void *, cl_hip_error_map_t> CL_HIP_ERROR_MAPS = {
     {(void *)&clFinish,
      {{CL_SUCCESS, hipSuccess},
       {CL_INVALID_COMMAND_QUEUE, hipErrorInvalidResourceHandle},
-      {CL_OUT_OF_HOST_MEMORY, hipErrorOutOfMemory}}},
+      {CL_OUT_OF_HOST_MEMORY, hipErrorOutOfMemory},
+      {CL_OUT_OF_RESOURCES, hipErrorOutOfMemory}}},
 
     {(void *)&clFlush,
      {{CL_SUCCESS, hipSuccess},