changed the enum variable per Alexey's request

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::SYCL_BLOCKED, this);
+      EnqueueResult = EnqueueResultT(EnqueueResultT::SYCL_ENQUEUE_BLOCKED, this);
       return false;
     }
     static bool ThrowOnBlock = getenv("SYCL_THROW_ON_BLOCK") != nullptr;
@@ -196,7 +196,7 @@ bool Command::enqueue(EnqueueResultT &EnqueueResult, BlockingT Blocking) {
   cl_int Res = enqueueImp();
 
   if (CL_SUCCESS != Res)
-    EnqueueResult = EnqueueResultT(EnqueueResultT::SYCL_FAILED, this, Res);
+    EnqueueResult = EnqueueResultT(EnqueueResultT::SYCL_ENQUEUE_FAILED, this, Res);
   else
     // Consider the command is successfully enqueued if return code is
     // CL_SUCCESS

sycl/source/detail/scheduler/commands.hpp

@@ -39,7 +39,7 @@ enum BlockingT { NON_BLOCKING = 0, BLOCKING };
 // The struct represents the result of command enqueueing
 struct EnqueueResultT {
   enum ResultT { SYCL_ENQUEUE_SUCCESS, SYCL_ENQUEUE_BLOCKED, SYCL_ENQUEUE_FAILED };
-  EnqueueResultT(ResultT Result = SYCL_SUCCESS, Command *Cmd = nullptr,
+  EnqueueResultT(ResultT Result = SYCL_ENQUEUE_SUCCESS, 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::SYCL_FAILED == Res.MResult)
+  if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == 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::SYCL_FAILED:
+      case EnqueueResultT::SYCL_ENQUEUE_FAILED:
       default:
         // Exit immediately if a command fails to avoid enqueueing commands
         // result of which will be discarded.
         return false;
-      case EnqueueResultT::SYCL_BLOCKED:
+      case EnqueueResultT::SYCL_ENQUEUE_BLOCKED:
         // 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::SYCL_FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == 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::SYCL_FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == 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::SYCL_FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == 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::SYCL_FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == 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::SYCL_FAILED == Res.MResult)
+    if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == Res.MResult)
       throw runtime_error("Enqueue process failed.");
   } catch (...) {
     NewCmd->getQueue()->reportAsyncException(std::current_exception());
@@ -151,7 +151,7 @@ EventImplPtr Scheduler::addHostAccessor(Requirement *Req,
     return nullptr;
   EnqueueResultT Res;
   bool Enqueued = GraphProcessor::enqueueCommand(NewCmd, Res);
-  if (!Enqueued && EnqueueResultT::SYCL_FAILED == Res.MResult)
+  if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == Res.MResult)
     throw runtime_error("Enqueue process failed.");
   return NewCmd->getEvent();
 }
@@ -163,7 +163,7 @@ void Scheduler::releaseHostAccessor(Requirement *Req) {
     for (Command *Cmd : Leaves) {
       EnqueueResultT Res;
       bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
-      if (!Enqueued && EnqueueResultT::SYCL_FAILED == Res.MResult)
+      if (!Enqueued && EnqueueResultT::SYCL_ENQUEUE_FAILED == Res.MResult)
         throw runtime_error("Enqueue process failed.");
     }
   };

sycl/test/regression/macro_conflict.cpp

@@ -7,8 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #define SUCCESS 0
-#define FAIL 1
-#define BLOCKED 2
 
 #include <CL/sycl.hpp>