afw_lock.h

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * Adaptive Framework Lock Support
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
#ifndef __AFW_LOCK_H__
#define __AFW_LOCK_H__
 
#include "afw_interface.h"
 
AFW_BEGIN_DECLARES
 
typedef enum {
    afw_lock_type_global_mutex,
    afw_lock_type_process_mutex,
    afw_lock_type_thread_mutex,
    afw_lock_type_thread_recursive_mutex,
    afw_lock_type_thread_read_write
} afw_lock_type_t;
 
 
struct afw_lock_s {
    const afw_utf8_t *lock_id;
    const afw_utf8_t *brief;
    const afw_utf8_t *description;
    const afw_utf8_t *flag_id_debug;
    afw_size_t flag_index_debug;
    union {
 
        apr_thread_mutex_t *mutex;
 
        apr_thread_rwlock_t *rwlock;
    };
    afw_lock_type_t lock_type;
};
 
 
struct afw_lock_rw_s {
    struct afw_lock_s lock;
};
 
 
AFW_DECLARE(const afw_lock_t *)
afw_lock_create(
    const afw_utf8_t *lock_id,
    const afw_utf8_t *brief,
    const afw_utf8_t *description,
    afw_boolean_t insure_recursive_lock,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_lock_t *)
afw_lock_create_and_register(
    const afw_utf8_t *lock_id,
    const afw_utf8_t *brief,
    const afw_utf8_t *description,
    afw_boolean_t insure_recursive_lock,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_lock_t *)
afw_lock_create_environment_lock(
    const afw_utf8_t *lock_id,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_obtain(const afw_lock_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_obtain_debug(const afw_lock_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_obtain(instance,xctx) \
    afw_lock_obtain_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
AFW_DECLARE(void)
afw_lock_release(const afw_lock_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_release_debug(const afw_lock_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_release(instance,xctx) \
    afw_lock_release_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
#define AFW_LOCK_BEGIN(instance) \
const afw_lock_t *this_LOCK = instance; \
afw_lock_obtain(this_LOCK, xctx); \
AFW_TRY
 
 
#define AFW_LOCK_END \
AFW_FINALLY { \
    afw_lock_release(this_LOCK, xctx); \
} \
AFW_ENDTRY
 
 
 
AFW_DECLARE(const afw_lock_rw_t *)
afw_lock_create_rw(
    const afw_utf8_t *lock_id,
    const afw_utf8_t *brief,
    const afw_utf8_t *description,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_lock_rw_t *)
afw_lock_create_rw_and_register(
    const afw_utf8_t *lock_id,
    const afw_utf8_t *brief,
    const afw_utf8_t *description,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_lock_read_obtain(const afw_lock_rw_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_read_obtain_debug(const afw_lock_rw_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_read_obtain(instance,xctx) \
    afw_lock_read_obtain_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
AFW_DECLARE(void)
afw_lock_read_release(const afw_lock_rw_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_read_release_debug(const afw_lock_rw_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_read_release(instance,xctx) \
    afw_lock_read_release_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
#define AFW_LOCK_READ_BEGIN(instance) \
const afw_lock_rw_t *this_LOCK = instance; \
    afw_lock_read_obtain(this_LOCK, xctx); \
AFW_TRY
 
 
#define AFW_LOCK_READ_END \
AFW_FINALLY { \
    afw_lock_read_release(this_LOCK, xctx); \
} \
AFW_ENDTRY
 
 
 
AFW_DECLARE(void)
afw_lock_write_obtain(const afw_lock_rw_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_write_obtain_debug(const afw_lock_rw_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_write_obtain(instance,xctx) \
    afw_lock_write_obtain_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
AFW_DECLARE(void)
afw_lock_write_release(const afw_lock_rw_t *instance, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_lock_write_release_debug(const afw_lock_rw_t *instance,
    afw_xctx_t *xctx, const afw_utf8_z_t *source_z);
 
 
#ifdef AFW_LOCK_DEBUG
#define afw_lock_write_release(instance,xctx) \
    afw_lock_write_release_debug(instance, xctx, AFW__FILE_LINE__)
#endif
 
 
#define AFW_LOCK_WRITE_BEGIN(instance) \
const afw_lock_rw_t *this_LOCK = instance; \
    afw_lock_write_obtain(this_LOCK, xctx); \
AFW_TRY
 
 
#define AFW_LOCK_WRITE_END \
AFW_FINALLY { \
    afw_lock_write_release(this_LOCK, xctx); \
} \
AFW_ENDTRY
 
AFW_END_DECLARES
 
#endif /* __AFW_LOCK_H__ */