shced:sem: replace mutex with spinlock

The overhead of spinlok is less than mutext (mutex need to call
enter_critical section.)
After this patch, `down_write_trylock` and `down_read_trylock` can be
use in interrupt context.

The instruction is protected with mutex only one instruction so using
spinlock is better.

Signed-off-by: TaiJu Wu <[email protected]>

Author: TaiJuWu

include/nuttx/rwsem.h

@@ -25,15 +25,18 @@
  * Included Files
  ****************************************************************************/
 
-#include <nuttx/mutex.h>
+#include <nuttx/semaphore.h>
+#include <nuttx/spinlock.h>
 
 /****************************************************************************
  * Public Type Definitions
  ****************************************************************************/
 
 typedef struct
 {
-  mutex_t protected; /* Protecting Locks for Read/Write Locked Tables */
+#ifdef CONFIG_SPINLOCK
+  spinlock_t protected;
+#endif
   sem_t   waiting;   /* Reader/writer Waiting queue */
   int     waiter;    /* Waiter Count */
   int     writer;    /* Writer Count */

sched/semaphore/sem_rw.c

@@ -23,6 +23,20 @@
  ****************************************************************************/
 
 #include <nuttx/rwsem.h>
+#include <nuttx/irq.h>
+#include <assert.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#undef spin_lock_irqsave
+#undef spin_unlock_irqrestore
+
+#if !defined(CONFIG_SPINLOCK) || !defined(CONFIG_SMP)
+  #define spin_lock_irqsave(lock) up_irq_save()
+  #define spin_unlock_irqrestore(lock, flags) up_irq_restore(flags)
+#endif
 
 /****************************************************************************
  * Private Functions
@@ -61,11 +75,11 @@ static inline void up_wait(FAR rw_semaphore_t *rwsem)
 
 int down_read_trylock(FAR rw_semaphore_t *rwsem)
 {
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   if (rwsem->writer > 0)
     {
-      nxmutex_unlock(&rwsem->protected);
+      spin_unlock_irqrestore(&rwsem->protected, flags);
       return 0;
     }
 
@@ -75,7 +89,7 @@ int down_read_trylock(FAR rw_semaphore_t *rwsem)
 
   rwsem->reader++;
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 
   return 1;
 }
@@ -97,14 +111,14 @@ void down_read(FAR rw_semaphore_t *rwsem)
    * block and wait for the write-lock to be unlocked.
    */
 
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   while (rwsem->writer > 0)
     {
       rwsem->waiter++;
-      nxmutex_unlock(&rwsem->protected);
+      spin_unlock_irqrestore(&rwsem->protected, flags);
       nxsem_wait(&rwsem->waiting);
-      nxmutex_lock(&rwsem->protected);
+      flags = spin_lock_irqsave(&rwsem->protected);
       rwsem->waiter--;
     }
 
@@ -114,7 +128,7 @@ void down_read(FAR rw_semaphore_t *rwsem)
 
   rwsem->reader++;
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 }
 
 /****************************************************************************
@@ -130,7 +144,7 @@ void down_read(FAR rw_semaphore_t *rwsem)
 
 void up_read(FAR rw_semaphore_t *rwsem)
 {
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   DEBUGASSERT(rwsem->reader > 0);
 
@@ -141,7 +155,7 @@ void up_read(FAR rw_semaphore_t *rwsem)
       up_wait(rwsem);
     }
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 }
 
 /****************************************************************************
@@ -160,19 +174,19 @@ void up_read(FAR rw_semaphore_t *rwsem)
 
 int down_write_trylock(FAR rw_semaphore_t *rwsem)
 {
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   if (rwsem->writer > 0 || rwsem->reader > 0)
     {
-      nxmutex_unlock(&rwsem->protected);
+      spin_unlock_irqrestore(&rwsem->protected, flags);
       return 0;
     }
 
   /* The check passes, then we just need the writer reference + 1 */
 
   rwsem->writer++;
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 
   return 1;
 }
@@ -190,22 +204,22 @@ int down_write_trylock(FAR rw_semaphore_t *rwsem)
 
 void down_write(FAR rw_semaphore_t *rwsem)
 {
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   while (rwsem->reader > 0 || rwsem->writer > 0)
     {
       rwsem->waiter++;
-      nxmutex_unlock(&rwsem->protected);
+      spin_unlock_irqrestore(&rwsem->protected, flags);
       nxsem_wait(&rwsem->waiting);
-      nxmutex_lock(&rwsem->protected);
+      flags = spin_lock_irqsave(&rwsem->protected);
       rwsem->waiter--;
     }
 
   /* The check passes, then we just need the writer reference + 1 */
 
   rwsem->writer++;
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 }
 
 /****************************************************************************
@@ -221,15 +235,15 @@ void down_write(FAR rw_semaphore_t *rwsem)
 
 void up_write(FAR rw_semaphore_t *rwsem)
 {
-  nxmutex_lock(&rwsem->protected);
+  irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
 
   DEBUGASSERT(rwsem->writer > 0);
 
   rwsem->writer--;
 
   up_wait(rwsem);
 
-  nxmutex_unlock(&rwsem->protected);
+  spin_unlock_irqrestore(&rwsem->protected, flags);
 }
 
 /****************************************************************************
@@ -253,16 +267,13 @@ int init_rwsem(FAR rw_semaphore_t *rwsem)
 
   /* Initialize structure information */
 
-  ret = nxmutex_init(&rwsem->protected);
-  if (ret < 0)
-    {
-      return ret;
-    }
+#ifdef CONFIG_SPINLOCK
+  spin_lock_init(&rwsem->protected);
+#endif
 
   ret = nxsem_init(&rwsem->waiting, 0, 0);
   if (ret < 0)
     {
-      nxmutex_destroy(&rwsem->protected);
       return ret;
     }
 
@@ -292,6 +303,5 @@ void destroy_rwsem(FAR rw_semaphore_t *rwsem)
   DEBUGASSERT(rwsem->waiter == 0 && rwsem->reader == 0 &&
               rwsem->writer == 0);
 
-  nxmutex_destroy(&rwsem->protected);
   nxsem_destroy(&rwsem->waiting);
 }