cond.c

Go to the documentation of this file.

/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 * See COPYRIGHT in top-level directory.
 */
 
#include "abti.h"
#include <sys/time.h>
 
static inline double convert_timespec_to_sec(const struct timespec *p_ts);
 
int ABT_cond_create(ABT_cond *newcond)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(newcond);
 
    /* Check if the size of ABT_cond_memory is okay. */
    ABTI_STATIC_ASSERT(sizeof(ABTI_cond) <= sizeof(ABT_cond_memory));
 
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x sets newcond to NULL on error. */
    *newcond = ABT_COND_NULL;
#endif
    ABTI_cond *p_newcond;
    int abt_errno = ABTU_malloc(sizeof(ABTI_cond), (void **)&p_newcond);
    ABTI_CHECK_ERROR(abt_errno);
 
    ABTI_cond_init(p_newcond);
    /* Return value */
    *newcond = ABTI_cond_get_handle(p_newcond);
    return ABT_SUCCESS;
}
 
int ABT_cond_free(ABT_cond *cond)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(cond);
 
    ABT_cond h_cond = *cond;
    ABTI_cond *p_cond = ABTI_cond_get_ptr(h_cond);
    ABTI_CHECK_NULL_COND_PTR(p_cond);
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* This check will be removed in Argobots 2.0 */
    ABTI_CHECK_TRUE(ABTI_waitlist_is_empty(&p_cond->waitlist), ABT_ERR_COND);
#else
    ABTI_UB_ASSERT(ABTI_waitlist_is_empty(&p_cond->waitlist));
#endif
 
    ABTI_cond_fini(p_cond);
    ABTU_free(p_cond);
    /* Return value */
    *cond = ABT_COND_NULL;
    return ABT_SUCCESS;
}
 
int ABT_cond_wait(ABT_cond cond, ABT_mutex mutex)
{
    ABTI_local *p_local = ABTI_local_get_local();
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x does not allow a tasklet to call this routine. */
    if (ABTI_IS_ERROR_CHECK_ENABLED && p_local) {
        ABTI_xstream *p_local_xstream = ABTI_local_get_xstream(p_local);
        ABTI_CHECK_TRUE(p_local_xstream->p_thread->type &
                            ABTI_THREAD_TYPE_YIELDABLE,
                        ABT_ERR_COND);
    }
#endif
    ABTI_cond *p_cond = ABTI_cond_get_ptr(cond);
    ABTI_CHECK_NULL_COND_PTR(p_cond);
    ABTI_mutex *p_mutex = ABTI_mutex_get_ptr(mutex);
    ABTI_CHECK_NULL_MUTEX_PTR(p_mutex);
 
    /* Check if a given mutex is valid. */
    /* p_mutex must be locked. */
    ABTI_UB_ASSERT(ABTI_mutex_is_locked(p_mutex));
    /* If p_mutex is recursive, the caller of this function must be an owner. */
    ABTI_UB_ASSERT(!((p_mutex->attrs & ABTI_MUTEX_ATTR_RECURSIVE) &&
                     p_mutex->owner_id != ABTI_self_get_thread_id(p_local)));
    /* If p_mutex is recursive, p_mutex must not be locked more than once. */
    ABTI_UB_ASSERT(!((p_mutex->attrs & ABTI_MUTEX_ATTR_RECURSIVE) &&
                     p_mutex->nesting_cnt > 1));
 
    int abt_errno = ABTI_cond_wait(&p_local, p_cond, p_mutex);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
}
 
int ABT_cond_timedwait(ABT_cond cond, ABT_mutex mutex,
                       const struct timespec *abstime)
{
    ABTI_UB_ASSERT(abstime);
 
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_cond *p_cond = ABTI_cond_get_ptr(cond);
    ABTI_CHECK_NULL_COND_PTR(p_cond);
    ABTI_mutex *p_mutex = ABTI_mutex_get_ptr(mutex);
    ABTI_CHECK_NULL_MUTEX_PTR(p_mutex);
 
    /* Check if a given mutex is valid. */
    /* p_mutex must be locked. */
    ABTI_UB_ASSERT(ABTI_mutex_is_locked(p_mutex));
    /* If p_mutex is recursive, the caller of this function must be an owner. */
    ABTI_UB_ASSERT(!((p_mutex->attrs & ABTI_MUTEX_ATTR_RECURSIVE) &&
                     p_mutex->owner_id != ABTI_self_get_thread_id(p_local)));
    /* If p_mutex is recursive, p_mutex must not be locked more than once. */
    ABTI_UB_ASSERT(!((p_mutex->attrs & ABTI_MUTEX_ATTR_RECURSIVE) &&
                     p_mutex->nesting_cnt > 1));
 
    double tar_time = convert_timespec_to_sec(abstime);
 
    ABTI_thread thread;
    thread.type = ABTI_THREAD_TYPE_EXT;
    ABTD_atomic_relaxed_store_int(&thread.state, ABT_THREAD_STATE_BLOCKED);
 
    ABTD_spinlock_acquire(&p_cond->lock);
 
    if (p_cond->p_waiter_mutex == NULL) {
        p_cond->p_waiter_mutex = p_mutex;
    } else {
        if (p_cond->p_waiter_mutex != p_mutex) {
            ABTD_spinlock_release(&p_cond->lock);
            ABTI_HANDLE_ERROR(ABT_ERR_INV_MUTEX);
        }
    }
 
    /* Unlock the mutex that the calling ULT is holding */
    ABTI_mutex_unlock(p_local, p_mutex);
    ABT_bool is_timedout =
        ABTI_waitlist_wait_timedout_and_unlock(&p_local, &p_cond->waitlist,
                                               &p_cond->lock, tar_time,
                                               ABT_SYNC_EVENT_TYPE_COND,
                                               (void *)p_cond);
    /* Lock the mutex again */
    ABTI_mutex_lock(&p_local, p_mutex);
    return is_timedout ? ABT_ERR_COND_TIMEDOUT : ABT_SUCCESS;
}
 
int ABT_cond_signal(ABT_cond cond)
{
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_cond *p_cond = ABTI_cond_get_ptr(cond);
    ABTI_CHECK_NULL_COND_PTR(p_cond);
 
    ABTD_spinlock_acquire(&p_cond->lock);
    ABTI_waitlist_signal(p_local, &p_cond->waitlist);
    ABTD_spinlock_release(&p_cond->lock);
 
    return ABT_SUCCESS;
}
 
int ABT_cond_broadcast(ABT_cond cond)
{
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_cond *p_cond = ABTI_cond_get_ptr(cond);
    ABTI_CHECK_NULL_COND_PTR(p_cond);
 
    ABTI_cond_broadcast(p_local, p_cond);
    return ABT_SUCCESS;
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
static inline double convert_timespec_to_sec(const struct timespec *p_ts)
{
    double secs;
    secs = ((double)p_ts->tv_sec) + 1.0e-9 * ((double)p_ts->tv_nsec);
    return secs;
}