/src/hdf5/src/H5TSrwlock.h

Source
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
 * terms governing use, modification, and redistribution, is contained in    *
 * the LICENSE file, which can be found at the root of the source code       *
 * distribution tree, or in https://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * Purpose: This file contains support for non-recursive R/W locks, equivalent
 *        to the pthread 'pthread_rwlock_t' type and capabilities.
 *
 * Note:  Because this threadsafety framework operates outside the library,
 *        it does not use the error stack (although it does use error macros
 *        that don't push errors on a stack) and only uses the "namecheck only"
 *        FUNC_ENTER_* / FUNC_LEAVE_* macros.
 */

/****************/
/* Module Setup */
/****************/

/***********/
/* Headers */
/***********/

/****************/
/* Local Macros */
/****************/

/******************/
/* Local Typedefs */
/******************/

/********************/
/* Local Prototypes */
/********************/

/*********************/
/* Package Variables */
/*********************/

/*****************************/
/* Library Private Variables */
/*****************************/

/*******************/
/* Local Variables */
/*******************/

#ifdef H5_HAVE_C11_THREADS
/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdlock
 *
 * Purpose:  Acquire a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
        return FAIL;

    /* Check for writers */
    if (lock->writers || lock->write_waiters) {
        /* Read waiting */
        lock->read_waiters++;

        /* Wait for writers */
        do {
            if (H5_UNLIKELY(thrd_success != cnd_wait(&lock->read_cv, &lock->mutex))) {
                mtx_unlock(&lock->mutex);
                return FAIL;
            }
        } while (lock->writers || lock->write_waiters);

        /* Read not waiting any longer */
        lock->read_waiters--;
    }

    /* Increment # of readers */
    lock->readers++;

    /* Release mutex */
    if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdunlock
 *
 * Purpose:  Release a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
        return FAIL;

    /* Decrement # of readers */
    lock->readers--;

    /* Check for waiting writers when last readers */
    if (lock->write_waiters && 0 == lock->readers)
        if (H5_UNLIKELY(cnd_signal(&lock->write_cv) != thrd_success)) {
            mtx_unlock(&lock->mutex);
            return FAIL;
        }

    /* Release mutex */
    if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdunlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrlock
 *
 * Purpose:  Acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
        return FAIL;

    /* Check for readers or other writers */
    if (lock->readers || lock->writers) {
        /* Write waiting */
        lock->write_waiters++;

        /* Wait for mutex */
        do {
            if (H5_UNLIKELY(thrd_success != cnd_wait(&lock->write_cv, &lock->mutex))) {
                mtx_unlock(&lock->mutex);
                return FAIL;
            }
        } while (lock->readers || lock->writers);

        /* Write not waiting any longer */
        lock->write_waiters--;
    }

    /* Increment # of writers */
    lock->writers++;

    /* Release mutex */
    if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_trywrlock
 *
 * Purpose:  Attempt to acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_trywrlock(H5TS_rwlock_t *lock, bool *acquired)
{
    int ret;

    /* Check argument */
    if (H5_UNLIKELY(NULL == lock || NULL == acquired))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(thrd_error == (ret = mtx_lock(&lock->mutex))))
        return FAIL;
    if (thrd_busy == ret) {
        /* We did not acquire the lock */
        *acquired = false;
        return SUCCEED;
    }

    /* Check for readers or other writers */
    if (lock->readers || lock->writers)
        /* We did not acquire the lock */
        *acquired = false;
    else {
        /* Increment # of writers */
        lock->writers++;

        /* We acquired the lock */
        *acquired = true;
    }

    /* Release mutex */
    if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_trywrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrunlock
 *
 * Purpose:  Release a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
        return FAIL;

    /* Decrement # of writers */
    lock->writers--;

    /* Check for waiting writers */
    if (lock->write_waiters) {
        if (H5_UNLIKELY(cnd_signal(&lock->write_cv) != thrd_success)) {
            mtx_unlock(&lock->mutex);
            return FAIL;
        }
    }
    else if (lock->read_waiters)
        if (H5_UNLIKELY(cnd_broadcast(&lock->read_cv) != thrd_success)) {
            mtx_unlock(&lock->mutex);
            return FAIL;
        }

    /* Release mutex */
    if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrunlock() */

#else
#ifdef H5_HAVE_WIN_THREADS
/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdlock
 *
 * Purpose:  Acquire a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    AcquireSRWLockShared(lock);

    return SUCCEED;
} /* end H5TS_rwlock_rdlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdunlock
 *
 * Purpose:  Release a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    ReleaseSRWLockShared(lock);

    return SUCCEED;
} /* end H5TS_rwlock_rdunlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrlock
 *
 * Purpose:  Acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    AcquireSRWLockExclusive(lock);

    return SUCCEED;
} /* end H5TS_rwlock_wrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_trywrlock
 *
 * Purpose:  Attempt to acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_trywrlock(H5TS_rwlock_t *lock, bool *acquired)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock || NULL == acquired))
        return FAIL;

    if (TryAcquireSRWLockExclusive(lock))
        *acquired = true;
    else
        *acquired = false;

    return SUCCEED;
} /* end H5TS_rwlock_trywrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrunlock
 *
 * Purpose:  Release a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    ReleaseSRWLockExclusive(lock);

    return SUCCEED;
} /* end H5TS_rwlock_wrunlock() */

#elif defined(__MACH__)
/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdlock
 *
 * Purpose:  Acquire a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
        return FAIL;

    /* Check for writers */
    if (lock->writers || lock->write_waiters) {
        /* Read waiting */
        lock->read_waiters++;

        /* Wait for writers */
        do {
            if (H5_UNLIKELY(pthread_cond_wait(&lock->read_cv, &lock->mutex))) {
                pthread_mutex_unlock(&lock->mutex);
                return FAIL;
            }
        } while (lock->writers || lock->write_waiters);

        /* Read not waiting any longer */
        lock->read_waiters--;
    }

    /* Increment # of readers */
    lock->readers++;

    /* Release mutex */
    if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdunlock
 *
 * Purpose:  Release a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
        return FAIL;

    /* Decrement # of readers */
    lock->readers--;

    /* Check for waiting writers when last readers */
    if (lock->write_waiters && 0 == lock->readers)
        if (H5_UNLIKELY(pthread_cond_signal(&lock->write_cv))) {
            pthread_mutex_unlock(&lock->mutex);
            return FAIL;
        }

    /* Release mutex */
    if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdunlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrlock
 *
 * Purpose:  Acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
        return FAIL;

    /* Check for readers or other writers */
    if (lock->readers || lock->writers) {
        /* Write waiting */
        lock->write_waiters++;

        /* Wait for mutex */
        do {
            if (H5_UNLIKELY(pthread_cond_wait(&lock->write_cv, &lock->mutex))) {
                pthread_mutex_unlock(&lock->mutex);
                return FAIL;
            }
        } while (lock->readers || lock->writers);

        /* Write not waiting any longer */
        lock->write_waiters--;
    }

    /* Increment # of writers */
    lock->writers++;

    /* Release mutex */
    if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_trywrlock
 *
 * Purpose:  Attempt to acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_trywrlock(H5TS_rwlock_t *lock, bool *acquired)
{
    int rc;

    /* Check argument */
    if (H5_UNLIKELY(NULL == lock || NULL == acquired))
        return FAIL;

    /* Acquire the lock's mutex */
    rc = pthread_mutex_trylock(&lock->mutex);
    if (EBUSY == rc) {
        /* We did not acquire the lock */
        *acquired = false;
        return SUCCEED;
    }
    else if (0 != rc)
        return FAIL;

    /* Check for readers or other writers */
    if (lock->readers || lock->writers)
        /* We did not acquire the lock */
        *acquired = false;
    else {
        /* Increment # of writers */
        lock->writers++;

        /* We acquired the lock */
        *acquired = true;
    }

    /* Release mutex */
    if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_trywrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrunlock
 *
 * Purpose:  Release a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    /* Acquire the lock's mutex */
    if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
        return FAIL;

    /* Decrement # of writers */
    lock->writers--;

    /* Check for waiting writers */
    if (lock->write_waiters) {
        if (H5_UNLIKELY(pthread_cond_signal(&lock->write_cv))) {
            pthread_mutex_unlock(&lock->mutex);
            return FAIL;
        }
    }
    else if (lock->read_waiters)
        if (H5_UNLIKELY(pthread_cond_broadcast(&lock->read_cv))) {
            pthread_mutex_unlock(&lock->mutex);
            return FAIL;
        }

    /* Release mutex */
    if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrunlock() */

#else
/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdlock
 *
 * Purpose:  Acquire a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    if (H5_UNLIKELY(pthread_rwlock_rdlock(lock)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdunlock
 *
 * Purpose:  Release a read lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    if (H5_UNLIKELY(pthread_rwlock_unlock(lock)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_rdunlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_wrlock
 *
 * Purpose:  Acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    if (H5_UNLIKELY(pthread_rwlock_wrlock(lock)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_trywrlock
 *
 * Purpose:  Attempt to acquire a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5TS_rwlock_trywrlock(H5TS_rwlock_t *lock, bool *acquired)
{
    int ret;

    /* Check argument */
    if (H5_UNLIKELY(NULL == lock || NULL == acquired))
        return FAIL;

    ret = pthread_rwlock_trywrlock(lock);
    if (EBUSY == ret)
        *acquired = false; /* We did not acquire the lock */
    else if (H5_UNLIKELY(0 != ret))
        return FAIL;
    else
        *acquired = true; /* We acquired the lock */

    return SUCCEED;
} /* end H5TS_rwlock_trywrlock() */

/*-------------------------------------------------------------------------
 * Function: H5TS_rwlock_rdunlock
 *
 * Purpose:  Release a write lock
 *
 * Return:   Non-negative on success / Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static inline herr_t
H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
{
    /* Check argument */
    if (H5_UNLIKELY(NULL == lock))
        return FAIL;

    if (H5_UNLIKELY(pthread_rwlock_unlock(lock)))
        return FAIL;

    return SUCCEED;
} /* end H5TS_rwlock_wrunlock() */
#endif
#endif

Coverage Report

Created: 2026-01-10 06:50

Line	Count	Source
1		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2		* Copyright by The HDF Group. *
3		* All rights reserved. *
4		* *
5		* This file is part of HDF5. The full HDF5 copyright notice, including *
6		* terms governing use, modification, and redistribution, is contained in *
7		* the LICENSE file, which can be found at the root of the source code *
8		* distribution tree, or in https://www.hdfgroup.org/licenses. *
9		* If you do not have access to either file, you may request a copy from *
10		* help@hdfgroup.org. *
11		* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
12
13		/*
14		* Purpose: This file contains support for non-recursive R/W locks, equivalent
15		* to the pthread 'pthread_rwlock_t' type and capabilities.
16		*
17		* Note: Because this threadsafety framework operates outside the library,
18		* it does not use the error stack (although it does use error macros
19		* that don't push errors on a stack) and only uses the "namecheck only"
20		* FUNC_ENTER_* / FUNC_LEAVE_* macros.
21		*/
22
23		/****************/
24		/* Module Setup */
25		/****************/
26
27		/***********/
28		/* Headers */
29		/***********/
30
31		/****************/
32		/* Local Macros */
33		/****************/
34
35		/******************/
36		/* Local Typedefs */
37		/******************/
38
39		/********************/
40		/* Local Prototypes */
41		/********************/
42
43		/*********************/
44		/* Package Variables */
45		/*********************/
46
47		/*****************************/
48		/* Library Private Variables */
49		/*****************************/
50
51		/*******************/
52		/* Local Variables */
53		/*******************/
54
55		#ifdef H5_HAVE_C11_THREADS
56		/*-------------------------------------------------------------------------
57		* Function: H5TS_rwlock_rdlock
58		*
59		* Purpose: Acquire a read lock
60		*
61		* Return: Non-negative on success / Negative on failure
62		*
63		*-------------------------------------------------------------------------
64		*/
65		static inline herr_t
66		H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
67		{
68		/* Check argument */
69		if (H5_UNLIKELY(NULL == lock))
70		return FAIL;
71
72		/* Acquire the lock's mutex */
73		if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
74		return FAIL;
75
76		/* Check for writers */
77		if (lock->writers \|\| lock->write_waiters) {
78		/* Read waiting */
79		lock->read_waiters++;
80
81		/* Wait for writers */
82		do {
83		if (H5_UNLIKELY(thrd_success != cnd_wait(&lock->read_cv, &lock->mutex))) {
84		mtx_unlock(&lock->mutex);
85		return FAIL;
86		}
87		} while (lock->writers \|\| lock->write_waiters);
88
89		/* Read not waiting any longer */
90		lock->read_waiters--;
91		}
92
93		/* Increment # of readers */
94		lock->readers++;
95
96		/* Release mutex */
97		if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
98		return FAIL;
99
100		return SUCCEED;
101		} /* end H5TS_rwlock_rdlock() */
102
103		/*-------------------------------------------------------------------------
104		* Function: H5TS_rwlock_rdunlock
105		*
106		* Purpose: Release a read lock
107		*
108		* Return: Non-negative on success / Negative on failure
109		*
110		*-------------------------------------------------------------------------
111		*/
112		static inline herr_t
113		H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
114		{
115		/* Check argument */
116		if (H5_UNLIKELY(NULL == lock))
117		return FAIL;
118
119		/* Acquire the lock's mutex */
120		if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
121		return FAIL;
122
123		/* Decrement # of readers */
124		lock->readers--;
125
126		/* Check for waiting writers when last readers */
127		if (lock->write_waiters && 0 == lock->readers)
128		if (H5_UNLIKELY(cnd_signal(&lock->write_cv) != thrd_success)) {
129		mtx_unlock(&lock->mutex);
130		return FAIL;
131		}
132
133		/* Release mutex */
134		if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
135		return FAIL;
136
137		return SUCCEED;
138		} /* end H5TS_rwlock_rdunlock() */
139
140		/*-------------------------------------------------------------------------
141		* Function: H5TS_rwlock_wrlock
142		*
143		* Purpose: Acquire a write lock
144		*
145		* Return: Non-negative on success / Negative on failure
146		*
147		*-------------------------------------------------------------------------
148		*/
149		static inline herr_t
150		H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
151		{
152		/* Check argument */
153		if (H5_UNLIKELY(NULL == lock))
154		return FAIL;
155
156		/* Acquire the lock's mutex */
157		if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
158		return FAIL;
159
160		/* Check for readers or other writers */
161		if (lock->readers \|\| lock->writers) {
162		/* Write waiting */
163		lock->write_waiters++;
164
165		/* Wait for mutex */
166		do {
167		if (H5_UNLIKELY(thrd_success != cnd_wait(&lock->write_cv, &lock->mutex))) {
168		mtx_unlock(&lock->mutex);
169		return FAIL;
170		}
171		} while (lock->readers \|\| lock->writers);
172
173		/* Write not waiting any longer */
174		lock->write_waiters--;
175		}
176
177		/* Increment # of writers */
178		lock->writers++;
179
180		/* Release mutex */
181		if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
182		return FAIL;
183
184		return SUCCEED;
185		} /* end H5TS_rwlock_wrlock() */
186
187		/*-------------------------------------------------------------------------
188		* Function: H5TS_rwlock_trywrlock
189		*
190		* Purpose: Attempt to acquire a write lock
191		*
192		* Return: Non-negative on success / Negative on failure
193		*
194		*-------------------------------------------------------------------------
195		*/
196		static inline herr_t
197		H5TS_rwlock_trywrlock(H5TS_rwlock_t lock, bool acquired)
198		{
199		int ret;
200
201		/* Check argument */
202		if (H5_UNLIKELY(NULL == lock \|\| NULL == acquired))
203		return FAIL;
204
205		/* Acquire the lock's mutex */
206		if (H5_UNLIKELY(thrd_error == (ret = mtx_lock(&lock->mutex))))
207		return FAIL;
208		if (thrd_busy == ret) {
209		/* We did not acquire the lock */
210		*acquired = false;
211		return SUCCEED;
212		}
213
214		/* Check for readers or other writers */
215		if (lock->readers \|\| lock->writers)
216		/* We did not acquire the lock */
217		*acquired = false;
218		else {
219		/* Increment # of writers */
220		lock->writers++;
221
222		/* We acquired the lock */
223		*acquired = true;
224		}
225
226		/* Release mutex */
227		if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
228		return FAIL;
229
230		return SUCCEED;
231		} /* end H5TS_rwlock_trywrlock() */
232
233		/*-------------------------------------------------------------------------
234		* Function: H5TS_rwlock_wrunlock
235		*
236		* Purpose: Release a write lock
237		*
238		* Return: Non-negative on success / Negative on failure
239		*
240		*-------------------------------------------------------------------------
241		*/
242		static inline herr_t
243		H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
244		{
245		/* Check argument */
246		if (H5_UNLIKELY(NULL == lock))
247		return FAIL;
248
249		/* Acquire the lock's mutex */
250		if (H5_UNLIKELY(mtx_lock(&lock->mutex) != thrd_success))
251		return FAIL;
252
253		/* Decrement # of writers */
254		lock->writers--;
255
256		/* Check for waiting writers */
257		if (lock->write_waiters) {
258		if (H5_UNLIKELY(cnd_signal(&lock->write_cv) != thrd_success)) {
259		mtx_unlock(&lock->mutex);
260		return FAIL;
261		}
262		}
263		else if (lock->read_waiters)
264		if (H5_UNLIKELY(cnd_broadcast(&lock->read_cv) != thrd_success)) {
265		mtx_unlock(&lock->mutex);
266		return FAIL;
267		}
268
269		/* Release mutex */
270		if (H5_UNLIKELY(mtx_unlock(&lock->mutex) != thrd_success))
271		return FAIL;
272
273		return SUCCEED;
274		} /* end H5TS_rwlock_wrunlock() */
275
276		#else
277		#ifdef H5_HAVE_WIN_THREADS
278		/*-------------------------------------------------------------------------
279		* Function: H5TS_rwlock_rdlock
280		*
281		* Purpose: Acquire a read lock
282		*
283		* Return: Non-negative on success / Negative on failure
284		*
285		*-------------------------------------------------------------------------
286		*/
287		static inline herr_t
288		H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
289		{
290		/* Check argument */
291		if (H5_UNLIKELY(NULL == lock))
292		return FAIL;
293
294		AcquireSRWLockShared(lock);
295
296		return SUCCEED;
297		} /* end H5TS_rwlock_rdlock() */
298
299		/*-------------------------------------------------------------------------
300		* Function: H5TS_rwlock_rdunlock
301		*
302		* Purpose: Release a read lock
303		*
304		* Return: Non-negative on success / Negative on failure
305		*
306		*-------------------------------------------------------------------------
307		*/
308		static inline herr_t
309		H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
310		{
311		/* Check argument */
312		if (H5_UNLIKELY(NULL == lock))
313		return FAIL;
314
315		ReleaseSRWLockShared(lock);
316
317		return SUCCEED;
318		} /* end H5TS_rwlock_rdunlock() */
319
320		/*-------------------------------------------------------------------------
321		* Function: H5TS_rwlock_wrlock
322		*
323		* Purpose: Acquire a write lock
324		*
325		* Return: Non-negative on success / Negative on failure
326		*
327		*-------------------------------------------------------------------------
328		*/
329		static inline herr_t
330		H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
331		{
332		/* Check argument */
333		if (H5_UNLIKELY(NULL == lock))
334		return FAIL;
335
336		AcquireSRWLockExclusive(lock);
337
338		return SUCCEED;
339		} /* end H5TS_rwlock_wrlock() */
340
341		/*-------------------------------------------------------------------------
342		* Function: H5TS_rwlock_trywrlock
343		*
344		* Purpose: Attempt to acquire a write lock
345		*
346		* Return: Non-negative on success / Negative on failure
347		*
348		*-------------------------------------------------------------------------
349		*/
350		static inline herr_t
351		H5TS_rwlock_trywrlock(H5TS_rwlock_t lock, bool acquired)
352		{
353		/* Check argument */
354		if (H5_UNLIKELY(NULL == lock \|\| NULL == acquired))
355		return FAIL;
356
357		if (TryAcquireSRWLockExclusive(lock))
358		*acquired = true;
359		else
360		*acquired = false;
361
362		return SUCCEED;
363		} /* end H5TS_rwlock_trywrlock() */
364
365		/*-------------------------------------------------------------------------
366		* Function: H5TS_rwlock_wrunlock
367		*
368		* Purpose: Release a write lock
369		*
370		* Return: Non-negative on success / Negative on failure
371		*
372		*-------------------------------------------------------------------------
373		*/
374		static inline herr_t
375		H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
376		{
377		/* Check argument */
378		if (H5_UNLIKELY(NULL == lock))
379		return FAIL;
380
381		ReleaseSRWLockExclusive(lock);
382
383		return SUCCEED;
384		} /* end H5TS_rwlock_wrunlock() */
385
386		#elif defined(__MACH__)
387		/*-------------------------------------------------------------------------
388		* Function: H5TS_rwlock_rdlock
389		*
390		* Purpose: Acquire a read lock
391		*
392		* Return: Non-negative on success / Negative on failure
393		*
394		*-------------------------------------------------------------------------
395		*/
396		static inline herr_t
397		H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
398		{
399		/* Check argument */
400		if (H5_UNLIKELY(NULL == lock))
401		return FAIL;
402
403		/* Acquire the lock's mutex */
404		if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
405		return FAIL;
406
407		/* Check for writers */
408		if (lock->writers \|\| lock->write_waiters) {
409		/* Read waiting */
410		lock->read_waiters++;
411
412		/* Wait for writers */
413		do {
414		if (H5_UNLIKELY(pthread_cond_wait(&lock->read_cv, &lock->mutex))) {
415		pthread_mutex_unlock(&lock->mutex);
416		return FAIL;
417		}
418		} while (lock->writers \|\| lock->write_waiters);
419
420		/* Read not waiting any longer */
421		lock->read_waiters--;
422		}
423
424		/* Increment # of readers */
425		lock->readers++;
426
427		/* Release mutex */
428		if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
429		return FAIL;
430
431		return SUCCEED;
432		} /* end H5TS_rwlock_rdlock() */
433
434		/*-------------------------------------------------------------------------
435		* Function: H5TS_rwlock_rdunlock
436		*
437		* Purpose: Release a read lock
438		*
439		* Return: Non-negative on success / Negative on failure
440		*
441		*-------------------------------------------------------------------------
442		*/
443		static inline herr_t
444		H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
445		{
446		/* Check argument */
447		if (H5_UNLIKELY(NULL == lock))
448		return FAIL;
449
450		/* Acquire the lock's mutex */
451		if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
452		return FAIL;
453
454		/* Decrement # of readers */
455		lock->readers--;
456
457		/* Check for waiting writers when last readers */
458		if (lock->write_waiters && 0 == lock->readers)
459		if (H5_UNLIKELY(pthread_cond_signal(&lock->write_cv))) {
460		pthread_mutex_unlock(&lock->mutex);
461		return FAIL;
462		}
463
464		/* Release mutex */
465		if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
466		return FAIL;
467
468		return SUCCEED;
469		} /* end H5TS_rwlock_rdunlock() */
470
471		/*-------------------------------------------------------------------------
472		* Function: H5TS_rwlock_wrlock
473		*
474		* Purpose: Acquire a write lock
475		*
476		* Return: Non-negative on success / Negative on failure
477		*
478		*-------------------------------------------------------------------------
479		*/
480		static inline herr_t
481		H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
482		{
483		/* Check argument */
484		if (H5_UNLIKELY(NULL == lock))
485		return FAIL;
486
487		/* Acquire the lock's mutex */
488		if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
489		return FAIL;
490
491		/* Check for readers or other writers */
492		if (lock->readers \|\| lock->writers) {
493		/* Write waiting */
494		lock->write_waiters++;
495
496		/* Wait for mutex */
497		do {
498		if (H5_UNLIKELY(pthread_cond_wait(&lock->write_cv, &lock->mutex))) {
499		pthread_mutex_unlock(&lock->mutex);
500		return FAIL;
501		}
502		} while (lock->readers \|\| lock->writers);
503
504		/* Write not waiting any longer */
505		lock->write_waiters--;
506		}
507
508		/* Increment # of writers */
509		lock->writers++;
510
511		/* Release mutex */
512		if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
513		return FAIL;
514
515		return SUCCEED;
516		} /* end H5TS_rwlock_wrlock() */
517
518		/*-------------------------------------------------------------------------
519		* Function: H5TS_rwlock_trywrlock
520		*
521		* Purpose: Attempt to acquire a write lock
522		*
523		* Return: Non-negative on success / Negative on failure
524		*
525		*-------------------------------------------------------------------------
526		*/
527		static inline herr_t
528		H5TS_rwlock_trywrlock(H5TS_rwlock_t lock, bool acquired)
529		{
530		int rc;
531
532		/* Check argument */
533		if (H5_UNLIKELY(NULL == lock \|\| NULL == acquired))
534		return FAIL;
535
536		/* Acquire the lock's mutex */
537		rc = pthread_mutex_trylock(&lock->mutex);
538		if (EBUSY == rc) {
539		/* We did not acquire the lock */
540		*acquired = false;
541		return SUCCEED;
542		}
543		else if (0 != rc)
544		return FAIL;
545
546		/* Check for readers or other writers */
547		if (lock->readers \|\| lock->writers)
548		/* We did not acquire the lock */
549		*acquired = false;
550		else {
551		/* Increment # of writers */
552		lock->writers++;
553
554		/* We acquired the lock */
555		*acquired = true;
556		}
557
558		/* Release mutex */
559		if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
560		return FAIL;
561
562		return SUCCEED;
563		} /* end H5TS_rwlock_trywrlock() */
564
565		/*-------------------------------------------------------------------------
566		* Function: H5TS_rwlock_wrunlock
567		*
568		* Purpose: Release a write lock
569		*
570		* Return: Non-negative on success / Negative on failure
571		*
572		*-------------------------------------------------------------------------
573		*/
574		static inline herr_t
575		H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
576		{
577		/* Check argument */
578		if (H5_UNLIKELY(NULL == lock))
579		return FAIL;
580
581		/* Acquire the lock's mutex */
582		if (H5_UNLIKELY(pthread_mutex_lock(&lock->mutex)))
583		return FAIL;
584
585		/* Decrement # of writers */
586		lock->writers--;
587
588		/* Check for waiting writers */
589		if (lock->write_waiters) {
590		if (H5_UNLIKELY(pthread_cond_signal(&lock->write_cv))) {
591		pthread_mutex_unlock(&lock->mutex);
592		return FAIL;
593		}
594		}
595		else if (lock->read_waiters)
596		if (H5_UNLIKELY(pthread_cond_broadcast(&lock->read_cv))) {
597		pthread_mutex_unlock(&lock->mutex);
598		return FAIL;
599		}
600
601		/* Release mutex */
602		if (H5_UNLIKELY(pthread_mutex_unlock(&lock->mutex)))
603		return FAIL;
604
605		return SUCCEED;
606		} /* end H5TS_rwlock_wrunlock() */
607
608		#else
609		/*-------------------------------------------------------------------------
610		* Function: H5TS_rwlock_rdlock
611		*
612		* Purpose: Acquire a read lock
613		*
614		* Return: Non-negative on success / Negative on failure
615		*
616		*-------------------------------------------------------------------------
617		*/
618		static inline herr_t
619		H5TS_rwlock_rdlock(H5TS_rwlock_t *lock)
620	0	{
621	0	/* Check argument */
622	0	if (H5_UNLIKELY(NULL == lock))
623	0	return FAIL;
624	0
625	0	if (H5_UNLIKELY(pthread_rwlock_rdlock(lock)))
626	0	return FAIL;
627	0
628	0	return SUCCEED;
629	0	} /* end H5TS_rwlock_rdlock() */ Unexecuted instantiation: H5Eint.c:H5TS_rwlock_rdlock Unexecuted instantiation: H5.c:H5TS_rwlock_rdlock
630
631		/*-------------------------------------------------------------------------
632		* Function: H5TS_rwlock_rdunlock
633		*
634		* Purpose: Release a read lock
635		*
636		* Return: Non-negative on success / Negative on failure
637		*
638		*-------------------------------------------------------------------------
639		*/
640		static inline herr_t
641		H5TS_rwlock_rdunlock(H5TS_rwlock_t *lock)
642	0	{
643	0	/* Check argument */
644	0	if (H5_UNLIKELY(NULL == lock))
645	0	return FAIL;
646	0
647	0	if (H5_UNLIKELY(pthread_rwlock_unlock(lock)))
648	0	return FAIL;
649	0
650	0	return SUCCEED;
651	0	} /* end H5TS_rwlock_rdunlock() */ Unexecuted instantiation: H5Eint.c:H5TS_rwlock_rdunlock Unexecuted instantiation: H5.c:H5TS_rwlock_rdunlock
652
653		/*-------------------------------------------------------------------------
654		* Function: H5TS_rwlock_wrlock
655		*
656		* Purpose: Acquire a write lock
657		*
658		* Return: Non-negative on success / Negative on failure
659		*
660		*-------------------------------------------------------------------------
661		*/
662		static inline herr_t
663		H5TS_rwlock_wrlock(H5TS_rwlock_t *lock)
664	0	{
665	0	/* Check argument */
666	0	if (H5_UNLIKELY(NULL == lock))
667	0	return FAIL;
668	0
669	0	if (H5_UNLIKELY(pthread_rwlock_wrlock(lock)))
670	0	return FAIL;
671	0
672	0	return SUCCEED;
673	0	} /* end H5TS_rwlock_wrlock() */ Unexecuted instantiation: H5Eint.c:H5TS_rwlock_wrlock Unexecuted instantiation: H5.c:H5TS_rwlock_wrlock
674
675		/*-------------------------------------------------------------------------
676		* Function: H5TS_rwlock_trywrlock
677		*
678		* Purpose: Attempt to acquire a write lock
679		*
680		* Return: Non-negative on success / Negative on failure
681		*
682		*-------------------------------------------------------------------------
683		*/
684		herr_t
685		H5TS_rwlock_trywrlock(H5TS_rwlock_t lock, bool acquired)
686	0	{
687	0	int ret;
688	0
689	0	/* Check argument */
690	0	if (H5_UNLIKELY(NULL == lock \|\| NULL == acquired))
691	0	return FAIL;
692	0
693	0	ret = pthread_rwlock_trywrlock(lock);
694	0	if (EBUSY == ret)
695	0	acquired = false; / We did not acquire the lock */
696	0	else if (H5_UNLIKELY(0 != ret))
697	0	return FAIL;
698	0	else
699	0	acquired = true; / We acquired the lock */
700	0
701	0	return SUCCEED;
702	0	} /* end H5TS_rwlock_trywrlock() */ Unexecuted instantiation: H5Eint.c:H5TS_rwlock_trywrlock Unexecuted instantiation: H5.c:H5TS_rwlock_trywrlock
703
704		/*-------------------------------------------------------------------------
705		* Function: H5TS_rwlock_rdunlock
706		*
707		* Purpose: Release a write lock
708		*
709		* Return: Non-negative on success / Negative on failure
710		*
711		*-------------------------------------------------------------------------
712		*/
713		static inline herr_t
714		H5TS_rwlock_wrunlock(H5TS_rwlock_t *lock)
715	0	{
716	0	/* Check argument */
717	0	if (H5_UNLIKELY(NULL == lock))
718	0	return FAIL;
719	0
720	0	if (H5_UNLIKELY(pthread_rwlock_unlock(lock)))
721	0	return FAIL;
722	0
723	0	return SUCCEED;
724	0	} /* end H5TS_rwlock_wrunlock() */ Unexecuted instantiation: H5Eint.c:H5TS_rwlock_wrunlock Unexecuted instantiation: H5.c:H5TS_rwlock_wrunlock
725		#endif
726		#endif