Replace calls to opal atomic by Qthreads synchronization

Author: janciesko

opal/mca/threads/qthreads/threads_qthreads_mutex.h

@@ -20,6 +20,7 @@
  *
  * Copyright (c) 2020      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2021      Argonne National Laboratory.  All rights reserved.
+ * Copyright (c) 2022      Sandia National Laboratories.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -42,46 +43,68 @@
 
 BEGIN_C_DECLS
 
-typedef opal_atomic_lock_t opal_thread_internal_mutex_t;
+typedef aligned_t qtheads_lock_t;
+typedef qtheads_lock_t opal_thread_internal_mutex_t;
 
 #define OPAL_THREAD_INTERNAL_MUTEX_INITIALIZER           OPAL_ATOMIC_LOCK_INIT
 #define OPAL_THREAD_INTERNAL_RECURSIVE_MUTEX_INITIALIZER OPAL_ATOMIC_LOCK_INIT
 
 static inline int opal_thread_internal_mutex_init(opal_thread_internal_mutex_t *p_mutex,
                                                   bool recursive)
 {
-    opal_atomic_lock_init(p_mutex, 0);
+    opal_threads_ensure_init_qthreads();
+#if OPAL_ENABLE_DEBUG
+    int ret = qthread_fill(p_mutex, recursive); //set here that this is recursive or not
+    if (QTHREAD_SUCCESS != ret) {
+        opal_output(0, "opal_thread_internal_mutex_init()");
+    }
+#else
+    qthread_fill(p_mutex, recursive); //set here that this is recursive or not
+#endif
+
     return OPAL_SUCCESS;
 }
 
 static inline void opal_thread_internal_mutex_lock(opal_thread_internal_mutex_t *p_mutex)
 {
     opal_threads_ensure_init_qthreads();
-
-    int ret = opal_atomic_trylock(p_mutex);
-    while (0 != ret) {
-        qthread_yield();
-        ret = opal_atomic_trylock(p_mutex);
+#if OPAL_ENABLE_DEBUG
+    int ret = qthread_lock(p_mutex);
+    if (QTHREAD_SUCCESS != ret) {
+        opal_output(0, "opal_thread_internal_mutex_init()");
     }
+#else
+    qthread_lock(p_mutex);
+#endif
 }
 
 static inline int opal_thread_internal_mutex_trylock(opal_thread_internal_mutex_t *p_mutex)
 {
     opal_threads_ensure_init_qthreads();
-
-    int ret = opal_atomic_trylock(p_mutex);
-    if (0 != ret) {
-        /* Yield to avoid a deadlock. */
-        qthread_yield();
+    int ret = qthread_trylock(p_mutex);
+    if (QTHREAD_OPFAIL == ret) {
+        return 1;
+    } else if (QTHREAD_SUCCESS != ret) {
+#if OPAL_ENABLE_DEBUG
+        opal_output(0, "opal_thread_internal_mutex_trylock()");
+#endif
+        return 1;
+    } else {
+        return 0;
     }
-    return ret;
 }
 
 static inline void opal_thread_internal_mutex_unlock(opal_thread_internal_mutex_t *p_mutex)
 {
     opal_threads_ensure_init_qthreads();
-
-    opal_atomic_unlock(p_mutex);
+#if OPAL_ENABLE_DEBUG
+    int ret = qthread_unlock(p_mutex);
+    if (QTHREAD_SUCCESS != ret) {
+        opal_output(0, "opal_thread_internal_mutex_unlock()");
+    }
+#else
+    qthread_unlock(p_mutex);
+#endif
     /* For fairness of locking. */
     qthread_yield();
 }
@@ -97,7 +120,7 @@ typedef struct opal_thread_cond_waiter_t {
 } opal_thread_cond_waiter_t;
 
 typedef struct {
-    opal_atomic_lock_t m_lock;
+    qtheads_lock_t m_lock;
     opal_thread_cond_waiter_t *m_waiter_head;
     opal_thread_cond_waiter_t *m_waiter_tail;
 } opal_thread_internal_cond_t;
@@ -109,7 +132,7 @@ typedef struct {
 
 static inline int opal_thread_internal_cond_init(opal_thread_internal_cond_t *p_cond)
 {
-    opal_atomic_lock_init(&p_cond->m_lock, 0);
+    qthread_lock(&p_cond->m_lock);
     p_cond->m_waiter_head = NULL;
     p_cond->m_waiter_tail = NULL;
     return OPAL_SUCCESS;
@@ -121,24 +144,23 @@ static inline void opal_thread_internal_cond_wait(opal_thread_internal_cond_t *p
     opal_threads_ensure_init_qthreads();
     /* This thread is taking "lock", so only this thread can access this
      * condition variable.  */
-    opal_atomic_lock(&p_cond->m_lock);
+    qthread_lock(&p_cond->m_lock);
     opal_thread_cond_waiter_t waiter = {0, NULL};
     if (NULL == p_cond->m_waiter_head) {
         p_cond->m_waiter_tail = &waiter;
     } else {
         p_cond->m_waiter_head->m_prev = &waiter;
     }
     p_cond->m_waiter_head = &waiter;
-    opal_atomic_unlock(&p_cond->m_lock);
-
-    while (1) {
-        opal_thread_internal_mutex_unlock(p_mutex);
+    qthread_unlock(&p_cond->m_lock);
+    while (1) {       
+        opal_thread_internal_mutex_lock(p_mutex);
         qthread_yield();
         opal_thread_internal_mutex_lock(p_mutex);
         /* Check if someone woke me up. */
-        opal_atomic_lock(&p_cond->m_lock);
+        qthread_lock(&p_cond->m_lock);
         int signaled = waiter.m_signaled;
-        opal_atomic_unlock(&p_cond->m_lock);
+        qthread_unlock(&p_cond->m_lock);
         if (1 == signaled) {
             break;
         }
@@ -148,7 +170,7 @@ static inline void opal_thread_internal_cond_wait(opal_thread_internal_cond_t *p
 
 static inline void opal_thread_internal_cond_broadcast(opal_thread_internal_cond_t *p_cond)
 {
-    opal_atomic_lock(&p_cond->m_lock);
+    qthread_lock(&p_cond->m_lock);
     while (NULL != p_cond->m_waiter_tail) {
         opal_thread_cond_waiter_t *p_cur_tail = p_cond->m_waiter_tail;
         p_cond->m_waiter_tail = p_cur_tail->m_prev;
@@ -157,12 +179,12 @@ static inline void opal_thread_internal_cond_broadcast(opal_thread_internal_cond
     }
     /* No waiters. */
     p_cond->m_waiter_head = NULL;
-    opal_atomic_unlock(&p_cond->m_lock);
+    qthread_unlock(&p_cond->m_lock);
 }
 
 static inline void opal_thread_internal_cond_signal(opal_thread_internal_cond_t *p_cond)
 {
-    opal_atomic_lock(&p_cond->m_lock);
+    qthread_lock(&p_cond->m_lock);
     if (NULL != p_cond->m_waiter_tail) {
         opal_thread_cond_waiter_t *p_cur_tail = p_cond->m_waiter_tail;
         p_cond->m_waiter_tail = p_cur_tail->m_prev;
@@ -172,7 +194,7 @@ static inline void opal_thread_internal_cond_signal(opal_thread_internal_cond_t
             p_cond->m_waiter_head = NULL;
         }
     }
-    opal_atomic_unlock(&p_cond->m_lock);
+    qthread_unlock(&p_cond->m_lock);
 }
 
 static inline void opal_thread_internal_cond_destroy(opal_thread_internal_cond_t *p_cond)