eventual.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"
 
int ABT_eventual_create(int nbytes, ABT_eventual *neweventual)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(neweventual);
 
    /* Check if the size of ABT_eventual_memory is okay. */
    ABTI_STATIC_ASSERT(sizeof(ABTI_eventual) <= sizeof(ABT_eventual_memory));
 
    int abt_errno;
    ABTI_eventual *p_eventual;
    ABTI_CHECK_TRUE(nbytes >= 0, ABT_ERR_INV_ARG);
    size_t arg_nbytes = nbytes;
 
    abt_errno = ABTU_malloc(sizeof(ABTI_eventual), (void **)&p_eventual);
    ABTI_CHECK_ERROR(abt_errno);
 
    ABTD_spinlock_clear(&p_eventual->lock);
    p_eventual->ready = ABT_FALSE;
    p_eventual->nbytes = arg_nbytes;
    if (arg_nbytes == 0) {
        p_eventual->value = NULL;
    } else {
        abt_errno = ABTU_malloc(arg_nbytes, &p_eventual->value);
        if (ABTI_IS_ERROR_CHECK_ENABLED && abt_errno != ABT_SUCCESS) {
            ABTU_free(p_eventual);
            ABTI_HANDLE_ERROR(abt_errno);
        }
    }
    ABTI_waitlist_init(&p_eventual->waitlist);
 
    *neweventual = ABTI_eventual_get_handle(p_eventual);
    return ABT_SUCCESS;
}
 
int ABT_eventual_free(ABT_eventual *eventual)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(eventual);
 
    ABTI_eventual *p_eventual = ABTI_eventual_get_ptr(*eventual);
    ABTI_CHECK_NULL_EVENTUAL_PTR(p_eventual);
 
    /* The lock needs to be acquired to safely free the eventual structure.
     * However, we do not have to unlock it because the entire structure is
     * freed here. */
    ABTD_spinlock_acquire(&p_eventual->lock);
    ABTI_UB_ASSERT(ABTI_waitlist_is_empty(&p_eventual->waitlist));
 
    if (p_eventual->value)
        ABTU_free(p_eventual->value);
    ABTU_free(p_eventual);
 
    *eventual = ABT_EVENTUAL_NULL;
    return ABT_SUCCESS;
}
 
int ABT_eventual_wait(ABT_eventual eventual, void **value)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_eventual *p_eventual = ABTI_eventual_get_ptr(eventual);
    ABTI_CHECK_NULL_EVENTUAL_PTR(p_eventual);
 
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* This routine cannot be called by a tasklet. */
    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_EVENTUAL);
    }
#endif
 
    ABTD_spinlock_acquire(&p_eventual->lock);
    if (p_eventual->ready == ABT_FALSE) {
        ABTI_waitlist_wait_and_unlock(&p_local, &p_eventual->waitlist,
                                      &p_eventual->lock,
                                      ABT_SYNC_EVENT_TYPE_EVENTUAL,
                                      (void *)p_eventual);
    } else {
        ABTD_spinlock_release(&p_eventual->lock);
    }
    /* This value is updated outside the critical section, but it is okay since
     * the "pointer" to the memory buffer is constant and there is no way to
     * avoid updating this memory buffer by ABT_eventual_set() etc. */
    if (value)
        *value = p_eventual->value;
    return ABT_SUCCESS;
}
 
int ABT_eventual_test(ABT_eventual eventual, void **value, ABT_bool *is_ready)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(is_ready);
 
    ABTI_eventual *p_eventual = ABTI_eventual_get_ptr(eventual);
    ABTI_CHECK_NULL_EVENTUAL_PTR(p_eventual);
    ABT_bool flag = ABT_FALSE;
 
    ABTD_spinlock_acquire(&p_eventual->lock);
    if (p_eventual->ready != ABT_FALSE) {
        if (value)
            *value = p_eventual->value;
        flag = ABT_TRUE;
    }
    ABTD_spinlock_release(&p_eventual->lock);
 
    *is_ready = flag;
    return ABT_SUCCESS;
}
 
int ABT_eventual_set(ABT_eventual eventual, void *value, int nbytes)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(value || nbytes <= 0);
 
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_eventual *p_eventual = ABTI_eventual_get_ptr(eventual);
    ABTI_CHECK_NULL_EVENTUAL_PTR(p_eventual);
    ABTI_CHECK_TRUE(nbytes >= 0, ABT_ERR_INV_ARG);
    size_t arg_nbytes = nbytes;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x */
    ABTI_CHECK_TRUE(arg_nbytes <= p_eventual->nbytes, ABT_ERR_INV_EVENTUAL);
#else
    /* Argobots 2.0 */
    ABTI_CHECK_TRUE(arg_nbytes <= p_eventual->nbytes, ABT_ERR_INV_ARG);
#endif
 
    ABTD_spinlock_acquire(&p_eventual->lock);
 
    ABT_bool ready = p_eventual->ready;
    if (ready == ABT_FALSE) {
        if (p_eventual->value)
            memcpy(p_eventual->value, value, arg_nbytes);
        p_eventual->ready = ABT_TRUE;
        /* Wake up all waiting ULTs */
        ABTI_waitlist_broadcast(p_local, &p_eventual->waitlist);
        ABTD_spinlock_release(&p_eventual->lock);
    } else {
        ABTD_spinlock_release(&p_eventual->lock);
        /* It has been ready.  Error. */
        ABTI_HANDLE_ERROR(ABT_ERR_EVENTUAL);
    }
 
    return ABT_SUCCESS;
}
 
int ABT_eventual_reset(ABT_eventual eventual)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_eventual *p_eventual = ABTI_eventual_get_ptr(eventual);
    ABTI_CHECK_NULL_EVENTUAL_PTR(p_eventual);
 
    ABTD_spinlock_acquire(&p_eventual->lock);
    ABTI_UB_ASSERT(ABTI_waitlist_is_empty(&p_eventual->waitlist));
    p_eventual->ready = ABT_FALSE;
    ABTD_spinlock_release(&p_eventual->lock);
    return ABT_SUCCESS;
}