Better lock

Core/Lock.cpp

@@ -16,43 +16,90 @@ extern "C" void DeadLockHandler(LockClass *Lock)
     warn("Potential deadlock in lock '%s' held by '%s' (%ld) [%#lx-%ld] [%ld->%ld]",
          Lock->GetLockData()->AttemptingToGet,
          Lock->GetLockData()->CurrentHolder,
-         DeadLocks++,
+         DeadLocks,
          Lock->GetLockData()->LockData,
          Lock->GetLockData()->Count,
          CCore,
          Lock->GetLockData()->Core);
 
-    if (TaskManager)
+    // warn("Potential deadlock in lock ' ' held by ' ' (%ld) %ld", DeadLocks, CCore);
-        TaskManager->Schedule();
 
     // TODO: Print on screen too.
+
+    DeadLocks++;
+
+    if (TaskManager)
+        TaskManager->Schedule();
+}
+
+void LockClass::DeadLock(SpinLockData Lock)
+{
+    CPUData *CoreData = GetCurrentCPU();
+    long CCore = 0xdead;
+    if (CoreData != nullptr)
+        CCore = CoreData->ID;
+    warn("Potential deadlock in lock '%s' held by '%s'! %ld locks in queue. Core %ld is being held by %ld. (%ld times happened)",
+         Lock.AttemptingToGet, Lock.CurrentHolder,
+         Lock.Count, CCore, Lock.Core,
+         this->DeadLocks);
+
+    // TODO: Print on screen too.
+
+    this->DeadLocks++;
+
+    if (TaskManager)
+        TaskManager->Schedule();
 }
 
 int LockClass::Lock(const char *FunctionName)
 {
+    // LockData.AttemptingToGet = FunctionName;
+    // SpinLock_Lock(&LockData.LockData);
+    // LockData.Count++;
+    // LockData.CurrentHolder = FunctionName;
+    // CPUData *CoreData = GetCurrentCPU();
+    // if (CoreData != nullptr)
+    // LockData.Core = CoreData->ID;
+    // __sync_synchronize();
+
+    // while (!__sync_bool_compare_and_swap(&IsLocked, false, true))
+    //     CPU::Pause();
+    // __sync_synchronize();
+
     LockData.AttemptingToGet = FunctionName;
-    SpinLock_Lock(&LockData.LockData);
+Retry:
-    LockData.CurrentHolder = FunctionName;
+    unsigned int i = 0;
+    while (__atomic_exchange_n(&IsLocked, true, __ATOMIC_ACQUIRE) && ++i < 0x10000000)
+        CPU::Pause();
+    if (i >= 0x10000000)
+    {
+        DeadLock(LockData);
+        goto Retry;
+    }
     LockData.Count++;
+    LockData.CurrentHolder = FunctionName;
     CPUData *CoreData = GetCurrentCPU();
     if (CoreData != nullptr)
         LockData.Core = CoreData->ID;
-    CPU::MemBar::Barrier();
+    __sync_synchronize();
 
-    // while (!__sync_bool_compare_and_swap(&IsLocked, false, true))
-    // CPU::Pause();
-    // __sync_synchronize();
     return 0;
 }
 
 int LockClass::Unlock()
 {
-    SpinLock_Unlock(&LockData.LockData);
+    // SpinLock_Unlock(&LockData.LockData);
-    LockData.Count--;
+    // LockData.Count--;
-    CPU::MemBar::Barrier();
+    // __sync_synchronize();
 
     // __sync_synchronize();
     // __atomic_store_n(&IsLocked, false, __ATOMIC_SEQ_CST);
     // IsLocked = false;
+
+    __sync_synchronize();
+    __atomic_store_n(&IsLocked, false, __ATOMIC_RELEASE);
+    LockData.Count--;
+    IsLocked = false;
+
     return 0;
 }

include/lock.hpp

@@ -23,10 +23,12 @@ class LockClass
         uint64_t Count = 0;
         long Core = 0;
     };
+    void DeadLock(SpinLockData Lock);
 
 private:
     SpinLockData LockData;
-    // bool IsLocked = false;
+    bool IsLocked = false;
+    unsigned long DeadLocks = 0;
 
 public:
     SpinLockData *GetLockData() { return &LockData; }