Make H5FL package threadsafe

src/CMakeLists.txt

@@ -648,6 +648,7 @@ set (H5TS_SOURCES
     ${HDF5_SRC_DIR}/H5TSbarrier.c
     ${HDF5_SRC_DIR}/H5TSc11.c
     ${HDF5_SRC_DIR}/H5TScond.c
+    ${HDF5_SRC_DIR}/H5TSdlftt_mutex.c
     ${HDF5_SRC_DIR}/H5TSint.c
     ${HDF5_SRC_DIR}/H5TSkey.c
     ${HDF5_SRC_DIR}/H5TSmutex.c

src/H5.c

@@ -254,6 +254,10 @@ H5_init_library(void)
      *   default FAPL.
      *
      */
+#ifdef H5_HAVE_CONCURRENCY
+    if (H5FL_init() < 0)
+        HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize free list interface");
+#endif
     if (H5E_init() < 0)
         HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize error interface");
     if (H5FD_init() < 0)

src/H5FLprivate.h

@@ -24,6 +24,7 @@
 /* Public headers needed by this file */
 
 /* Private headers needed by this file */
+#include "H5TSprivate.h" /* Threadsafety                             */
 
 /* Macros for turning off free lists in the library */
 /*#define H5_NO_FREE_LISTS*/
@@ -46,7 +47,11 @@ typedef struct H5FL_reg_node_t {
 
 /* Data structure for free list of blocks */
 typedef struct H5FL_reg_head_t {
-    bool             init;      /* Whether the free list has been initialized */
+    H5_global_t dlcp_info; /* Information for init */
+                           /* (MUST be first field in structure) */
+#ifdef H5_HAVE_CONCURRENCY
+    H5TS_dlftt_mutex_t mutex;   /* Guard access to this free list */
+#endif                          /* H5_HAVE_CONCURRENCY */
     unsigned         allocated; /* Number of blocks allocated */
     unsigned         onlist;    /* Number of blocks on free list */
     const char      *name;      /* Name of the type */
@@ -60,7 +65,7 @@ typedef struct H5FL_reg_head_t {
 #define H5FL_REG_NAME(t) H5_##t##_reg_free_list
 #ifndef H5_NO_REG_FREE_LISTS
 /* Common macros for H5FL_DEFINE & H5FL_DEFINE_STATIC */
-#define H5FL_DEFINE_COMMON(t) H5FL_reg_head_t H5FL_REG_NAME(t) = {0, 0, 0, #t, sizeof(t), NULL}
+#define H5FL_DEFINE_COMMON(t) H5FL_reg_head_t H5FL_REG_NAME(t) = {.name = #t, .size = sizeof(t)}
 
 /* Declare a free list to manage objects of type 't' */
 #define H5FL_DEFINE(t) H5_DLL H5FL_DEFINE_COMMON(t)
@@ -117,12 +122,16 @@ typedef struct H5FL_blk_node_t {
 
 /* Data structure for priority queue of native block free lists */
 typedef struct H5FL_blk_head_t {
-    bool             init;      /* Whether the free list has been initialized */
+    H5_global_t dlcp_info; /* Information for init */
+                           /* (MUST be first field in structure) */
+#ifdef H5_HAVE_CONCURRENCY
+    H5TS_dlftt_mutex_t mutex;   /* Guard access to this free list */
+#endif                          /* H5_HAVE_CONCURRENCY */
     unsigned         allocated; /* Total number of blocks allocated */
     unsigned         onlist;    /* Total number of blocks on free list */
     size_t           list_mem;  /* Total amount of memory in blocks on free list */
     const char      *name;      /* Name of the type */
-    H5FL_blk_node_t *head;      /* Pointer to first free list in queue */
+    H5FL_blk_node_t *pq;        /* Pointer to first free list in queue */
 } H5FL_blk_head_t;
 
 /*
@@ -131,7 +140,7 @@ typedef struct H5FL_blk_head_t {
 #define H5FL_BLK_NAME(t) H5_##t##_blk_free_list
 #ifndef H5_NO_BLK_FREE_LISTS
 /* Common macro for H5FL_BLK_DEFINE & H5FL_BLK_DEFINE_STATIC */
-#define H5FL_BLK_DEFINE_COMMON(t) H5FL_blk_head_t H5FL_BLK_NAME(t) = {0, 0, 0, 0, #t "_blk", NULL}
+#define H5FL_BLK_DEFINE_COMMON(t) H5FL_blk_head_t H5FL_BLK_NAME(t) = {.name = #t "_blk"}
 
 /* Declare a free list to manage objects of type 't' */
 #define H5FL_BLK_DEFINE(t) H5_DLL H5FL_BLK_DEFINE_COMMON(t)
@@ -190,7 +199,11 @@ typedef struct H5FL_arr_node_t {
 
 /* Data structure for free list of array blocks */
 typedef struct H5FL_arr_head_t {
-    bool             init;      /* Whether the free list has been initialized */
+    H5_global_t dlcp_info; /* Information for init */
+                           /* (MUST be first field in structure) */
+#ifdef H5_HAVE_CONCURRENCY
+    H5TS_dlftt_mutex_t mutex;   /* Guard access to this free list */
+#endif                          /* H5_HAVE_CONCURRENCY */
     unsigned         allocated; /* Total number of blocks allocated */
     size_t           list_mem;  /* Amount of memory in block on free list */
     const char      *name;      /* Name of the type */
@@ -207,7 +220,8 @@ typedef struct H5FL_arr_head_t {
 #ifndef H5_NO_ARR_FREE_LISTS
 /* Common macro for H5FL_ARR_DEFINE & H5FL_ARR_DEFINE_STATIC (and H5FL_BARR variants) */
 #define H5FL_ARR_DEFINE_COMMON(b, t, m)                                                                      \
-    H5FL_arr_head_t H5FL_ARR_NAME(t) = {0, 0, 0, #t "_arr", m + 1, b, sizeof(t), NULL}
+    H5FL_arr_head_t H5FL_ARR_NAME(t) = {                                                                     \
+        .name = #t "_arr", .maxelem = m + 1, .base_size = b, .elem_size = sizeof(t)}
 
 /* Declare a free list to manage arrays of type 't' */
 #define H5FL_ARR_DEFINE(t, m) H5_DLL H5FL_ARR_DEFINE_COMMON(0, t, m)
@@ -266,8 +280,7 @@ typedef struct H5FL_seq_head_t {
 #define H5FL_SEQ_NAME(t) H5_##t##_seq_free_list
 #ifndef H5_NO_SEQ_FREE_LISTS
 /* Common macro for H5FL_SEQ_DEFINE & H5FL_SEQ_DEFINE_STATIC */
-#define H5FL_SEQ_DEFINE_COMMON(t)                                                                            \
-    H5FL_seq_head_t H5FL_SEQ_NAME(t) = {{0, 0, 0, 0, #t "_seq", NULL}, sizeof(t)}
+#define H5FL_SEQ_DEFINE_COMMON(t) H5FL_seq_head_t H5FL_SEQ_NAME(t) = {{.name = #t "_seq"}, .size = sizeof(t)}
 
 /* Declare a free list to manage sequences of type 't' */
 #define H5FL_SEQ_DEFINE(t) H5_DLL H5FL_SEQ_DEFINE_COMMON(t)
@@ -309,7 +322,9 @@ typedef struct H5FL_fac_node_t    H5FL_fac_node_t;
 
 /* Data structure for free list block factory */
 typedef struct H5FL_fac_head_t {
-    bool                init;      /* Whether the free list has been initialized */
+#ifdef H5_HAVE_CONCURRENCY
+    H5TS_dlftt_mutex_t mutex;      /* Guard access to this factory */
+#endif                             /* H5_HAVE_CONCURRENCY */
     unsigned            allocated; /* Number of blocks allocated */
     unsigned            onlist;    /* Number of blocks on free list */
     size_t              size;      /* Size of the blocks in the list */
@@ -375,6 +390,9 @@ H5_DLL void            *H5FL_fac_free(H5FL_fac_head_t *head, void *obj);
 H5_DLL herr_t           H5FL_fac_term(H5FL_fac_head_t *head);
 
 /* General free list routines */
+#ifdef H5_HAVE_CONCURRENCY
+H5_DLL herr_t H5FL_init(void);
+#endif /* H5_HAVE_CONCURRENCY */
 H5_DLL herr_t H5FL_garbage_coll(void);
 H5_DLL herr_t H5FL_set_free_list_limits(int reg_global_lim, int reg_list_lim, int arr_global_lim,
                                         int arr_list_lim, int blk_global_lim, int blk_list_lim,

src/H5TSatomic.c

@@ -158,6 +158,57 @@ H5TS_atomic_destroy_uint(H5TS_atomic_uint_t *obj)
     FUNC_LEAVE_NOAPI_VOID_NAMECHECK_ONLY
 } /* end H5TS_atomic_destroy_uint() */
 
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_init_size_t
+ *
+ * Purpose:     Initializes an atomic 'size_t' variable object with a value.
+ *
+ * Note:        Per the C11 standard, this function is not atomic and
+ *              concurrent execution from multiple threads is a data race.
+ *
+ * Return:      None
+ *
+ *--------------------------------------------------------------------------
+ */
+void
+H5TS_atomic_init_size_t(H5TS_atomic_size_t *obj, size_t desired)
+{
+    FUNC_ENTER_NOAPI_NAMECHECK_ONLY
+
+        /* Initialize mutex that protects the "atomic" value */
+        (void)
+    H5TS_mutex_init(&obj->mutex, H5TS_MUTEX_TYPE_PLAIN);
+
+    /* Set the value */
+    obj->value = desired;
+
+    FUNC_LEAVE_NOAPI_VOID_NAMECHECK_ONLY
+} /* end H5TS_atomic_init_size_t() */
+
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_destroy_size_t
+ *
+ * Purpose:     Destroys / releases resources for an atomic 'size_t' variable
+ *
+ * Note:        No equivalent in the C11 atomics, but needed here, to destroy
+ *              the mutex used to protect the atomic value.
+ *
+ * Return:      None
+ *
+ *--------------------------------------------------------------------------
+ */
+void
+H5TS_atomic_destroy_size_t(H5TS_atomic_size_t *obj)
+{
+    FUNC_ENTER_NOAPI_NAMECHECK_ONLY
+
+        /* Destroy mutex that protects the "atomic" value */
+        (void)
+    H5TS_mutex_destroy(&obj->mutex);
+
+    FUNC_LEAVE_NOAPI_VOID_NAMECHECK_ONLY
+} /* end H5TS_atomic_destroy_size_t() */
+
 /*--------------------------------------------------------------------------
  * Function:    H5TS_atomic_init_voidp
  *

src/H5TSatomic.h

@@ -277,6 +277,118 @@ H5TS_atomic_fetch_sub_uint(H5TS_atomic_uint_t *obj, unsigned arg)
     return ret_value;
 } /* end H5TS_atomic_fetch_sub_uint() */
 
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_load_size_t
+ *
+ * Purpose:     Retrieves the value of atomic 'size_t' variable object.
+ *
+ * Return:      Value of the atomic 'size_t'
+ *
+ *--------------------------------------------------------------------------
+ */
+static inline size_t
+H5TS_atomic_load_size_t(H5TS_atomic_size_t *obj)
+{
+    size_t ret_value;
+
+    /* Lock mutex that protects the "atomic" value */
+    H5TS_mutex_lock(&obj->mutex);
+
+    /* Get the value */
+    ret_value = obj->value;
+
+    /* Release the object's mutex */
+    H5TS_mutex_unlock(&obj->mutex);
+
+    return ret_value;
+} /* end H5TS_atomic_load_size_t() */
+
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_store_size_t
+ *
+ * Purpose:     Atomically replaces the value of the atomic 'size_t' variable
+ *
+ * Return:      None
+ *
+ *--------------------------------------------------------------------------
+ */
+static inline void
+H5TS_atomic_store_size_t(H5TS_atomic_size_t *obj, size_t desired)
+{
+    /* Lock mutex that protects the "atomic" value */
+    H5TS_mutex_lock(&obj->mutex);
+
+    /* Set the value */
+    obj->value = desired;
+
+    /* Release the object's mutex */
+    H5TS_mutex_unlock(&obj->mutex);
+
+    return;
+} /* end H5TS_atomic_store_size_t() */
+
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_fetch_add_size_t
+ *
+ * Purpose:     Atomically replaces the value of an atomic 'size_t' variable with the
+ *              result of addition of the 'arg' to the old value of the
+ *              atomic variable.
+ *
+ * Return:      Returns the value of the atomic variable held previously
+ *
+ *--------------------------------------------------------------------------
+ */
+static inline size_t
+H5TS_atomic_fetch_add_size_t(H5TS_atomic_size_t *obj, size_t arg)
+{
+    size_t ret_value;
+
+    /* Lock mutex that protects the "atomic" value */
+    H5TS_mutex_lock(&obj->mutex);
+
+    /* Get the current value */
+    ret_value = obj->value;
+
+    /* Increment the value */
+    obj->value += arg;
+
+    /* Release the object's mutex */
+    H5TS_mutex_unlock(&obj->mutex);
+
+    return ret_value;
+} /* end H5TS_atomic_fetch_add_size_t() */
+
+/*--------------------------------------------------------------------------
+ * Function:    H5TS_atomic_fetch_sub_size_t
+ *
+ * Purpose:     Atomically replaces the value of an atomic 'size_t' variable with the
+ *              result of subtracting the 'arg' from the old value of the
+ *              atomic variable.
+ *
+ * Return:      Returns the value of the atomic variable held previously
+ *
+ *--------------------------------------------------------------------------
+ */
+static inline size_t
+H5TS_atomic_fetch_sub_size_t(H5TS_atomic_size_t *obj, size_t arg)
+{
+    size_t ret_value;
+
+    /* Lock mutex that protects the "atomic" value */
+    H5TS_mutex_lock(&obj->mutex);
+
+    /* Get the current value */
+    ret_value = obj->value;
+
+    /* Decrement the value */
+    obj->value -= arg;
+
+    /* Release the object's mutex */
+    H5TS_mutex_unlock(&obj->mutex);
+
+    return ret_value;
+} /* end H5TS_atomic_fetch_sub_size_t() */
+
 /*--------------------------------------------------------------------------
  * Function:    H5TS_atomic_exchange_voidp
  *