Revise DLFTT mutex locking protocol

Signed-off-by: Quincey Koziol <[email protected]>
qkoziol · Dec 6, 2024 · e42efba · e42efba
1 parent 23398a6
commit e42efba
Show file tree

Hide file tree

Showing 3 changed files with 120 additions and 13 deletions.
diff --git a/src/H5TSdlftt_mutex.c b/src/H5TSdlftt_mutex.c
@@ -77,7 +77,8 @@ H5TS_dlftt_mutex_init(H5TS_dlftt_mutex_t *mutex)
 
     if (H5_UNLIKELY(H5TS_mutex_init(&mutex->mtx, H5TS_MUTEX_TYPE_PLAIN)) < 0)
         HGOTO_DONE(FAIL);
-    mutex->dlftt = 0;
+    mutex->bypass = false;
+    mutex->rc = 0;
 
 done:
     FUNC_LEAVE_NOAPI_NAMECHECK_ONLY(ret_value)

diff --git a/src/H5TSdlftt_mutex.h b/src/H5TSdlftt_mutex.h
@@ -64,23 +64,78 @@ H5_DLL herr_t H5TS__get_dlftt(unsigned *dlftt);
  *
  * Purpose:     Acquires the lock on a mutex, obeying the "DLFTT" protocol
  *
+ * Note:     	Algorithm flowchart:
+ *
+ *          .─────────.
+ *         (   Start   )
+ *          `─────────'          Acquire DLFTT Mutex
+ *               │               -------------------
+ *               ▼
+ *               Λ
+ *              ╱ ╲
+ *             ╱   ╲
+ *            ╱     ╲
+ *           ╱       ╲
+ *          ╱         ╲    N    ┌────────────────┐
+ *         ▕  bypass?  ▏───────▶│Get DLFTT value │────────┐
+ *          ╲         ╱         └────────────────┘        │
+ *           ╲       ╱                                    │
+ *            ╲     ╱                                     ▼
+ *             ╲   ╱                                      Λ
+ *              ╲ ╱                                      ╱ ╲
+ *               V                                      ╱   ╲
+ *            Y  │                                     ╱     ╲
+ *               ▼                                    ╱       ╲
+ *        ┌────────────┐     ┌───────────────┐   Y   ╱         ╲
+ *        │ ++refcount │◀────│ bypass = true │◀─────▕ DLFTT > 0?▏
+ *        └────────────┘     └───────────────┘       ╲         ╱
+ *               │                                    ╲       ╱
+ *               │                                     ╲     ╱
+ *               │                                      ╲   ╱
+ *               │                                       ╲ ╱
+ *               │                                        V
+ *               │                                     N  │
+ *               │                                        ▼
+ *               │                  .─.            ┌────────────┐
+ *               └────────────────▶( X )◀──────────│ Lock mutex │
+ *                                  `─'            └────────────┘
+ *                                   │
+ *                                   ▼
+ *                              .─────────.
+ *                             (    End    )
+ *                              `─────────'
+ *
  * Return:      Non-negative on success / Negative on failure
  *
  *--------------------------------------------------------------------------
  */
 static inline herr_t
 H5TS_dlftt_mutex_acquire(H5TS_dlftt_mutex_t *mtx)
 {
-    /* Query the DLFTT value */
-    if (H5_UNLIKELY(H5TS__get_dlftt(&mtx->dlftt) < 0))
-        return FAIL;
-
-    /* Don't acquire the mutex if locking is disabled */
-    if (0 == mtx->dlftt)
-        /* Acquire the mutex */
-        if (H5_UNLIKELY(H5TS_mutex_lock(&mtx->mtx) < 0))
+    /* Check whether we are bypassing locking the mutex */
+    if (mtx->bypass)
+        /* Increment refcount */
+        mtx->rc++;
+    else {
+        unsigned     dlftt = 0;
+
+        /* Query the DLFTT value */
+        if (H5_UNLIKELY(H5TS__get_dlftt(&dlftt) < 0))
             return FAIL;
 
+        /* Acquire the mutex if locking is not disabled */
+        if (0 == dlftt) {
+            /* Acquire the mutex */
+            if (H5_UNLIKELY(H5TS_mutex_lock(&mtx->mtx) < 0))
+                return FAIL;
+        } /* end if */
+        else {
+            /* Indicate that lock should be bypassed */
+            mtx->bypass = true;
+            mtx->rc = 1;
+        } /* end else */
+    } /* end else */
+
     return SUCCEED;
 } /* end H5TS_dlftt_mutex_acquire() */
 
@@ -89,18 +144,68 @@ H5TS_dlftt_mutex_acquire(H5TS_dlftt_mutex_t *mtx)
  *
  * Purpose:     Releases the lock on a mutex, obeying the "DLFTT" protocol
  *
+ * Note:     	Algorithm flowchart:
+ *
+ *          .─────────.
+ *         (   Start   )
+ *          `─────────'
+ *               │                Release DLFTT Mutex
+ *               ▼                -------------------
+ *               Λ
+ *              ╱ ╲
+ *             ╱   ╲
+ *            ╱     ╲
+ *           ╱       ╲
+ *          ╱         ╲  Y ┌────────────┐
+ *         ▕  bypass?  ▏──▶│ --refcount │
+ *          ╲         ╱    └────────────┘
+ *           ╲       ╱            │
+ *            ╲     ╱             ▼
+ *             ╲   ╱              Λ
+ *              ╲ ╱              ╱ ╲
+ *               V              ╱   ╲
+ *             N │             ╱     ╲
+ *               ▼            ╱       ╲
+ *        ┌────────────┐     ╱refcount ╲  Y ┌───────────────┐
+ *        │Unlock mutex│    ▕   == 0?   ▏──▶│bypass = false │
+ *        └────────────┘     ╲         ╱    └───────────────┘
+ *               │            ╲       ╱             │
+ *               │             ╲     ╱              │
+ *               │              ╲   ╱               │
+ *               │               ╲ ╱                │
+ *               │                V                 │
+ *               │              N │                 │
+ *               │                ▼                 │
+ *               │               .─.                │
+ *               └─────────────▶( X )◀──────────────┘
+ *                               `─'
+ *                                │
+ *                                ▼
+ *                           .─────────.
+ *                          (    End    )
+ *                           `─────────'
+ *
  * Return:      Non-negative on success / Negative on failure
  *
  *--------------------------------------------------------------------------
  */
 static inline herr_t
 H5TS_dlftt_mutex_release(H5TS_dlftt_mutex_t *mtx)
 {
-    /* Don't release the mutex if locking is disabled */
-    if (0 == mtx->dlftt)
+    /* Check if we are bypassing the lock currently */
+    if (mtx->bypass) {
+        /* Decrement refcount */
+        mtx->rc--;
+
+        /* Check for done bypassing */
+        if (0 == mtx->rc)
+            mtx->bypass = false;
+    } /* end if */
+    else {
         /* Release the mutex */
         if (H5_UNLIKELY(H5TS_mutex_unlock(&mtx->mtx) < 0))
             return FAIL;
+    } /* end else */
 
     return SUCCEED;
 } /* end H5TS_dlftt_mutex_release() */
diff --git a/src/H5TSprivate.h b/src/H5TSprivate.h
@@ -308,8 +308,9 @@ typedef atomic_flag H5TS_spinlock_t;
 
 /* Mutex that efficiently obeys the "DLFTT" locking protocol */
 typedef struct H5TS_dlftt_mutex_t {
-    H5TS_mutex_t mtx;
-    unsigned     dlftt;
+    H5TS_mutex_t mtx;   /* Underlying mutex */
+    bool bypass;        /* Whether locking is being bypassed (due to DLFTT protocol) */
+    unsigned rc;        /* Refcount of locks bypassed */
 } H5TS_dlftt_mutex_t;
 
 /*****************************/