[SYCL] Fix SYCL internal enumerators conflict with user defined macro (#1188)

Enum variables were too commonly used by users.
This kind of conflicts cannot be avoided 100%, but
we can minimize the chance by using the prefix SYCL_

Signed-off-by: Byoungro So <[email protected]>

Author: bso-intel

sycl/source/detail/scheduler/commands.cpp

@@ -172,7 +172,7 @@ bool Command::enqueue(EnqueueResultT &EnqueueResult, BlockingT Blocking) {
   if (MIsBlockable && !MCanEnqueue) {
     // Exit if enqueue type is not blocking
     if (!Blocking) {
-      EnqueueResult = EnqueueResultT(EnqueueResultT::BLOCKED, this);
+      EnqueueResult = EnqueueResultT(EnqueueResultT::SyclEnqueueBlocked, this);
       return false;
     }
     static bool ThrowOnBlock = getenv("SYCL_THROW_ON_BLOCK") != nullptr;
@@ -196,7 +196,8 @@ bool Command::enqueue(EnqueueResultT &EnqueueResult, BlockingT Blocking) {
   cl_int Res = enqueueImp();
 
   if (CL_SUCCESS != Res)
-    EnqueueResult = EnqueueResultT(EnqueueResultT::FAILED, this, Res);
+    EnqueueResult =
+        EnqueueResultT(EnqueueResultT::SyclEnqueueFailed, this, Res);
   else
     // Consider the command is successfully enqueued if return code is
     // CL_SUCCESS

sycl/source/detail/scheduler/commands.hpp

@@ -38,8 +38,8 @@ enum BlockingT { NON_BLOCKING = 0, BLOCKING };
 
 // The struct represents the result of command enqueueing
 struct EnqueueResultT {
-  enum ResultT { SUCCESS, BLOCKED, FAILED };
-  EnqueueResultT(ResultT Result = SUCCESS, Command *Cmd = nullptr,
+  enum ResultT { SyclEnqueueSuccess, SyclEnqueueBlocked, SyclEnqueueFailed };
+  EnqueueResultT(ResultT Result = SyclEnqueueSuccess, Command *Cmd = nullptr,
                  cl_int ErrCode = CL_SUCCESS)
       : MResult(Result), MCmd(Cmd), MErrCode(ErrCode) {}
   // Indicates result of enqueueing

sycl/source/detail/scheduler/graph_processor.cpp

@@ -41,7 +41,7 @@ void Scheduler::GraphProcessor::waitForEvent(EventImplPtr Event) {
   assert(Cmd && "Event has no associated command?");
   EnqueueResultT Res;
   bool Enqueued = enqueueCommand(Cmd, Res, BLOCKING);
-  if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+  if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
     // TODO: Reschedule commands.
     throw runtime_error("Enqueue process failed.");
 
@@ -66,12 +66,12 @@ bool Scheduler::GraphProcessor::enqueueCommand(Command *Cmd,
         enqueueCommand(Dep.MDepCommand, EnqueueResult, Blocking);
     if (!Enqueued)
       switch (EnqueueResult.MResult) {
-      case EnqueueResultT::FAILED:
+      case EnqueueResultT::SyclEnqueueFailed:
       default:
         // Exit immediately if a command fails to avoid enqueueing commands
         // result of which will be discarded.
         return false;
-      case EnqueueResultT::BLOCKED:
+      case EnqueueResultT::SyclEnqueueBlocked:
         // If some dependency is blocked from enqueueing remember that, but
         // try to enqueue other dependencies(that can be ready for
         // enqueueing).

sycl/source/detail/scheduler/scheduler.cpp

@@ -30,22 +30,22 @@ void Scheduler::waitForRecordToFinish(MemObjRecord *Record) {
   for (Command *Cmd : Record->MReadLeaves) {
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
-    if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
       throw runtime_error("Enqueue process failed.");
     GraphProcessor::waitForEvent(Cmd->getEvent());
   }
   for (Command *Cmd : Record->MWriteLeaves) {
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
-    if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
       throw runtime_error("Enqueue process failed.");
     GraphProcessor::waitForEvent(Cmd->getEvent());
   }
   for (AllocaCommandBase *AllocaCmd : Record->MAllocaCommands) {
     Command *ReleaseCmd = AllocaCmd->getReleaseCmd();
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(ReleaseCmd, Res);
-    if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
       throw runtime_error("Enqueue process failed.");
     GraphProcessor::waitForEvent(ReleaseCmd->getEvent());
   }
@@ -70,7 +70,7 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
     // TODO: Check if lazy mode.
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(NewCmd, Res);
-    if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
       throw runtime_error("Enqueue process failed.");
   }
 
@@ -91,7 +91,7 @@ EventImplPtr Scheduler::addCopyBack(Requirement *Req) {
   try {
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(NewCmd, Res);
-    if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
       throw runtime_error("Enqueue process failed.");
   } catch (...) {
     NewCmd->getQueue()->reportAsyncException(std::current_exception());
@@ -155,7 +155,7 @@ EventImplPtr Scheduler::addHostAccessor(Requirement *Req,
     return nullptr;
   EnqueueResultT Res;
   bool Enqueued = GraphProcessor::enqueueCommand(NewCmd, Res);
-  if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+  if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
     throw runtime_error("Enqueue process failed.");
   return NewCmd->getEvent();
 }
@@ -167,7 +167,7 @@ void Scheduler::releaseHostAccessor(Requirement *Req) {
     for (Command *Cmd : Leaves) {
       EnqueueResultT Res;
       bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
-      if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
+      if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
         throw runtime_error("Enqueue process failed.");
     }
   };

sycl/test/regression/macro_conflict.cpp

@@ -0,0 +1,12 @@
+// RUN: %clangxx -fsyntax-only -Xclang -verify %s -o %t.out
+// expected-no-diagnostics
+//
+//===----------------------------------------------------------------------===//
+// This test checks if the user-defined macros SUCCESS is
+// conflicting with the symbols defined in SYCL header files.
+// This test only checks compilation error, so the main function is omitted.
+//===----------------------------------------------------------------------===//
+
+#define SUCCESS 0
+
+#include <CL/sycl.hpp>

sycl/test/scheduler/BlockedCommands.cpp

@@ -54,7 +54,7 @@ int main() {
       return 1;
     }
 
-    if (detail::EnqueueResultT::BLOCKED != Res.MResult) {
+    if (detail::EnqueueResultT::SyclEnqueueBlocked != Res.MResult) {
       std::cerr << "Result of enqueueing blocked command should be BLOCKED"
                 << std::endl;
       return 1;
@@ -73,7 +73,7 @@ int main() {
       return 1;
     }
 
-    if (detail::EnqueueResultT::FAILED != Res.MResult) {
+    if (detail::EnqueueResultT::SyclEnqueueFailed != Res.MResult) {
       std::cerr << "The command is expected to fail to enqueue." << std::endl;
       return 1;
     }
@@ -96,7 +96,8 @@ int main() {
     bool Enqueued =
         TestScheduler::enqueueCommand(&FakeCmd, Res, detail::BLOCKING);
 
-    if (!Enqueued || detail::EnqueueResultT::SUCCESS != Res.MResult) {
+    if (!Enqueued ||
+        detail::EnqueueResultT::SyclEnqueueSuccess != Res.MResult) {
       std::cerr << "The command is expected to be successfully enqueued."
                 << std::endl;
       return 1;