Simplify code and reduce code size by removing IRQwait

miosix/kernel/pthread_private.h

@@ -54,8 +54,8 @@ static inline void IRQdoMutexLock(pthread_mutex_t *mutex,
     }
 
     //This check is very important. Without this attempting to lock the same
-    //mutex twice won't cause a deadlock because the Thread::IRQwait() is
-    //enclosed in a while(owner!=p) which is immeditely false.
+    //mutex twice won't cause a deadlock because the wait is enclosed in a
+    //while(owner!=p) which is immeditely false.
     if(mutex->owner==p)
     {
         if(mutex->recursive>=0)
@@ -77,17 +77,8 @@ static inline void IRQdoMutexLock(pthread_mutex_t *mutex,
         mutex->last=&waiting;
     }
 
-    //The while is necessary because some other thread might call wakeup()
-    //on this thread. So the thread can wakeup also for other reasons not
-    //related to the mutex becoming free
-    while(mutex->owner!=p)
-    {
-        Thread::IRQwait();//Returns immediately
-        {
-            FastInterruptEnableLock eLock(d);
-            Thread::yield(); //Now the IRQwait becomes effective
-        }
-    }
+    //The while is necessary to protect against spurious wakeups
+    while(mutex->owner!=p) Thread::IRQenableIrqAndWait(d);
 }
 
 /**
@@ -113,8 +104,8 @@ static inline void IRQdoMutexLockToDepth(pthread_mutex_t *mutex,
     }
 
     //This check is very important. Without this attempting to lock the same
-    //mutex twice won't cause a deadlock because the Thread::IRQwait() is
-    //enclosed in a while(owner!=p) which is immeditely false.
+    //mutex twice won't cause a deadlock because the wait is enclosed in a
+    //while(owner!=p) which is immeditely false.
     if(mutex->owner==p)
     {
         if(mutex->recursive>=0)
@@ -136,17 +127,8 @@ static inline void IRQdoMutexLockToDepth(pthread_mutex_t *mutex,
         mutex->last=&waiting;
     }
 
-    //The while is necessary because some other thread might call wakeup()
-    //on this thread. So the thread can wakeup also for other reasons not
-    //related to the mutex becoming free
-    while(mutex->owner!=p)
-    {
-        Thread::IRQwait();//Returns immediately
-        {
-            FastInterruptEnableLock eLock(d);
-            Thread::yield(); //Now the IRQwait becomes effective
-        }
-    }
+    //The while is necessary to protect against spurious wakeups
+    while(mutex->owner!=p) Thread::IRQenableIrqAndWait(d);
     if(mutex->recursive>=0) mutex->recursive=depth;
 }
 

miosix/kernel/queue.h

 /***************************************************************************
- *   Copyright (C) 2014 by Terraneo Federico                               *
+ *   Copyright (C) 2014 - 2023 by Terraneo Federico                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -25,8 +25,7 @@
  *   along with this program; if not, see <http://www.gnu.org/licenses/>   *
  ***************************************************************************/
 
-#ifndef QUEUE_H
-#define	QUEUE_H
+#pragma once
 
 #include "kernel.h"
 #include "error.h"
@@ -57,7 +56,7 @@ public:
     /**
      * Constructor, create a new empty queue.
      */
-    Queue() : waiting(0), numElem(0), putPos(0), getPos(0) {}
+    Queue() : waiting(nullptr), numElem(0), putPos(0), getPos(0) {}
 
     /**
      * \return true if the queue is empty
@@ -178,7 +177,7 @@ private:
     {
         if(!waiting) return;
         waiting->IRQwakeup();//Wakeup eventual waiting thread
-        waiting=0;
+        waiting=nullptr;
     }
 
     //Queue data
@@ -197,11 +196,7 @@ void Queue<T,len>::waitUntilNotEmpty()
     while(isEmpty())
     {
         waiting=Thread::IRQgetCurrentThread();
-        Thread::IRQwait();
-        {
-            FastInterruptEnableLock eLock(dLock);
-            Thread::yield();
-        }
+        Thread::IRQenableIrqAndWait(dLock);
         IRQwakeWaitingThread();
     }
 }
@@ -214,11 +209,7 @@ void Queue<T,len>::waitUntilNotFull()
     while(isFull())
     {
         waiting=Thread::IRQgetCurrentThread();
-        Thread::IRQwait();
-        {
-            FastInterruptEnableLock eLock(dLock);
-            Thread::yield();
-        }
+        Thread::IRQenableIrqAndWait(dLock);
         IRQwakeWaitingThread();
     }
 }
@@ -231,11 +222,7 @@ void Queue<T,len>::get(T& elem)
     while(isEmpty())
     {
         waiting=Thread::IRQgetCurrentThread();
-        Thread::IRQwait();
-        {
-            FastInterruptEnableLock eLock(dLock);
-            Thread::yield();
-        }
+        Thread::IRQenableIrqAndWait(dLock);
         IRQwakeWaitingThread();
     }
     numElem--;
@@ -251,11 +238,7 @@ void Queue<T,len>::put(const T& elem)
     while(isFull())
     {
         waiting=Thread::IRQgetCurrentThread();
-        Thread::IRQwait();
-        {
-            FastInterruptEnableLock eLock(dLock);
-            Thread::yield();
-        }
+        Thread::IRQenableIrqAndWait(dLock);
         IRQwakeWaitingThread();
     }
     numElem++;
@@ -550,5 +533,3 @@ template<typename T, unsigned int size> class BufferQueue<T,size,1> {};
  */
 
 } //namespace miosix
-
-#endif //QUEUE_H

miosix/kernel/sync.cpp

@@ -61,8 +61,8 @@ void Mutex::PKlock(PauseKernelLock& dLock)
     }
 
     //This check is very important. Without this attempting to lock the same
-    //mutex twice won't cause a deadlock because the Thread::IRQwait() is
-    //enclosed in a while(owner!=p) which is immeditely false.
+    //mutex twice won't cause a deadlock because the wait is enclosed in a
+    //while(owner!=p) which is immeditely false.
     if(owner==p)
     {
         if(recursiveDepth>=0)
@@ -93,24 +93,8 @@ void Mutex::PKlock(PauseKernelLock& dLock)
         }
     }
 
-    //The while is necessary because some other thread might call wakeup()
-    //on this thread. So the thread can wakeup also for other reasons not
-    //related to the mutex becoming free
-    while(owner!=p)
-    {
-        //Wait can only be called with kernel started, while IRQwait can
-        //only be called with interupts disabled, so that's why interrupts
-        //are disabled
-        {
-            FastInterruptDisableLock l;
-            Thread::IRQwait();//Return immediately
-        }
-        {
-            RestartKernelLock eLock(dLock);
-            //Now the IRQwait becomes effective
-            Thread::yield();
-        }
-    }
+    //The while is necessary to protect against spurious wakeups
+    while(owner!=p) Thread::PKrestartKernelAndWait(dLock);
 }
 
 void Mutex::PKlockToDepth(PauseKernelLock& dLock, unsigned int depth)
@@ -130,8 +114,8 @@ void Mutex::PKlockToDepth(PauseKernelLock& dLock, unsigned int depth)
     }
 
     //This check is very important. Without this attempting to lock the same
-    //mutex twice won't cause a deadlock because the Thread::IRQwait() is
-    //enclosed in a while(owner!=p) which is immeditely false.
+    //mutex twice won't cause a deadlock because the wait is enclosed in a
+    //while(owner!=p) which is immeditely false.
     if(owner==p)
     {
         if(recursiveDepth>=0)
@@ -162,24 +146,8 @@ void Mutex::PKlockToDepth(PauseKernelLock& dLock, unsigned int depth)
         }
     }
 
-    //The while is necessary because some other thread might call wakeup()
-    //on this thread. So the thread can wakeup also for other reasons not
-    //related to the mutex becoming free
-    while(owner!=p)
-    {
-        //Wait can only be called with kernel started, while IRQwait can
-        //only be called with interupts disabled, so that's why interrupts
-        //are disabled
-        {
-            FastInterruptDisableLock l;
-            Thread::IRQwait();//Return immediately
-        }
-        {
-            RestartKernelLock eLock(dLock);
-            //Now the IRQwait becomes effective
-            Thread::yield();
-        }
-    }
+    //The while is necessary to protect against spurious wakeups
+    while(owner!=p) Thread::PKrestartKernelAndWait(dLock);
     if(recursiveDepth>=0) recursiveDepth=depth;
 }