From 64ce35dd87b426c96eb4af8e81c026ce814ada77 Mon Sep 17 00:00:00 2001
From: Jamie Reece Wilson <me@reece.sx>
Date: Sat, 2 Dec 2023 03:39:41 +0000
Subject: [PATCH] [*] Cont work on WaitMultipleLoopSources's yield time

---
 Source/IO/Loop/Loop.cpp | 83 +++++++++++++++++++++++++++++++++--------
 1 file changed, 67 insertions(+), 16 deletions(-)

diff --git a/Source/IO/Loop/Loop.cpp b/Source/IO/Loop/Loop.cpp
index 491f40ba..da01de83 100644
--- a/Source/IO/Loop/Loop.cpp
+++ b/Source/IO/Loop/Loop.cpp
@@ -91,7 +91,7 @@ namespace Aurora::IO::Loop
     AUKN_SYM bool WaitMultipleLoopSources(const AuList<AuSPtr<Loop::ILoopSource>> &lsList,
                                           AuList<AuSPtr<Loop::ILoopSource>> &signaled,
                                           bool bAny,
-                                          AuOptionalEx<AuUInt32> uTimeoutMS)
+                                          AuOptionalEx<AuUInt32> optTimeoutMS)
     {
         signaled.clear();
         AuList<AuUInt32> reverseList;
@@ -110,9 +110,9 @@ namespace Aurora::IO::Loop
             }
 
             bool bStatus {};
-            if (uTimeoutMS)
+            if (optTimeoutMS)
             {
-                bStatus = pSource->WaitOn(uTimeoutMS.value());
+                bStatus = pSource->WaitOn(optTimeoutMS.value());
             }
             else
             {
@@ -127,10 +127,11 @@ namespace Aurora::IO::Loop
             return bStatus;
         }
 
-        auto uTimeoutEnd = uTimeoutMS ?
-            AuTime::SteadyClockNS() + AuMSToNS<AuUInt64>(uTimeoutMS) :
+        AuUInt64 uTimeoutEnd = optTimeoutMS.has_value() && optTimeoutMS.value() ?
+            AuTime::SteadyClockNS() + AuMSToNS<AuUInt64>(optTimeoutMS) :
             0;
-        
+        bool bZeroTick { optTimeoutMS && optTimeoutMS.value() == 0 };
+
         AU_DEBUG_MEMCRUNCH;
 
         signaled.reserve(lsList.size());
@@ -146,7 +147,22 @@ namespace Aurora::IO::Loop
 
             if (entryZero)
             {
-                if (!entryZero->WaitOn(uTimeoutMS))
+                bool bStatus {};
+
+                if (!optTimeoutMS || optTimeoutMS.value() == 0)
+                {
+                    bStatus = entryZero->WaitOn(0);
+                }
+                else if (bZeroTick)
+                {
+                    bStatus = entryZero->IsSignaled();
+                }
+                else if (optTimeoutMS)
+                {
+                    bStatus = entryZero->WaitOn(optTimeoutMS.value());
+                }
+         
+                if (!bStatus)
                 {
                     goto next;
                 }
@@ -168,19 +184,37 @@ namespace Aurora::IO::Loop
                         auto uStartTime = Time::SteadyClockNS();
                         if (uStartTime >= uTimeoutEnd)
                         {
+                        #if 0
                             break;
+                        #else
+                            bZeroTick = true;
+                        #endif
                         }
 
                         uTimeoutMS = AuNSToMS<AuInt64>(uTimeoutEnd - uStartTime);
                         if (!uTimeoutMS)
                         {
+                        #if 0
                             break;
+                        #else
+                            bZeroTick = true;
+                        #endif
                         }
                     }
 
-                    if (!lsList[i]->WaitOn(uTimeoutMS))
+                    if (bZeroTick)
                     {
-                        break;
+                        if (!lsList[i]->IsSignaled())
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (!lsList[i]->WaitOn(uTimeoutMS))
+                        {
+                            break;
+                        }
                     }
 
                     reverseList.push_back(i);
@@ -247,7 +281,8 @@ namespace Aurora::IO::Loop
                 }
             };
 
-            if (gRuntimeConfig.threadingConfig.bPlatformIsSMPProcessorOptimized)
+            if (gRuntimeConfig.threadingConfig.bPlatformIsSMPProcessorOptimized &&
+                !bZeroTick)
             {
                 AuThreadPrimitives::DoTryIf([&]()
                 {
@@ -255,24 +290,40 @@ namespace Aurora::IO::Loop
                     return lsList2.size() != lsList.size() || 
                         !bAnyFound;
                 });
-            }
 
-            if (bAnyFound || !gRuntimeConfig.threadingConfig.bPlatformIsSMPProcessorOptimized)
+                if (bAnyFound)
+                {
+                    DoTheThing();
+                }
+            }
+            else
             {
                 DoTheThing();
             }
 
             if (lsList2.size())
             {
-                bool bZeroTick { };
-                if ((bZeroTick = bool(signalTemp.size())))
+                bZeroTick |= bool(signalTemp.size());
+                AuUInt32 uTimeoutMS {};
+                
+                if (uTimeoutEnd)
                 {
-                    uTimeoutMS = 1;
+                    auto uStartTime = Time::SteadyClockNS();
+                    if (uStartTime >= uTimeoutEnd)
+                    {
+                        bZeroTick = true;
+                    }
+
+                    uTimeoutMS = AuNSToMS<AuInt64>(uTimeoutEnd - uStartTime);
+                    if (!uTimeoutMS)
+                    {
+                        bZeroTick = true;
+                    }
                 }
 
             #if defined(AURORA_IS_MODERNNT_DERIVED)
                 signaled = WaitMultipleOrObjects(lsList2, bZeroTick, uTimeoutMS);
-                bTimedout = uTimeoutMS && !bZeroTick ?
+                bTimedout = uTimeoutEnd && uTimeoutMS && !bZeroTick ?
                     Time::SteadyClockNS() >= uTimeoutEnd :
                     false;
             #else