barrier.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_barrier_create(uint32_t num_waiters, ABT_barrier *newbarrier)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(newbarrier);
 
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x sets newbarrier to NULL on error. */
    *newbarrier = ABT_BARRIER_NULL;
#endif
    int abt_errno;
    ABTI_barrier *p_newbarrier;
    ABTI_CHECK_TRUE(num_waiters != 0, ABT_ERR_INV_ARG);
    size_t arg_num_waiters = num_waiters;
 
    abt_errno = ABTU_malloc(sizeof(ABTI_barrier), (void **)&p_newbarrier);
    ABTI_CHECK_ERROR(abt_errno);
 
    ABTD_spinlock_clear(&p_newbarrier->lock);
    p_newbarrier->num_waiters = arg_num_waiters;
    p_newbarrier->counter = 0;
    ABTI_waitlist_init(&p_newbarrier->waitlist);
    /* Return value */
    *newbarrier = ABTI_barrier_get_handle(p_newbarrier);
    return ABT_SUCCESS;
}
 
int ABT_barrier_reinit(ABT_barrier barrier, uint32_t num_waiters)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_barrier *p_barrier = ABTI_barrier_get_ptr(barrier);
    ABTI_CHECK_NULL_BARRIER_PTR(p_barrier);
    ABTI_UB_ASSERT(p_barrier->counter == 0);
    ABTI_CHECK_TRUE(num_waiters != 0, ABT_ERR_INV_ARG);
    size_t arg_num_waiters = num_waiters;
 
    /* Only when num_waiters is different from p_barrier->num_waiters, we
     * change p_barrier. */
    if (arg_num_waiters != p_barrier->num_waiters) {
        /* We can reuse waiters and waiter_type arrays */
        p_barrier->num_waiters = arg_num_waiters;
    }
    return ABT_SUCCESS;
}
 
int ABT_barrier_free(ABT_barrier *barrier)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(barrier);
 
    ABT_barrier h_barrier = *barrier;
    ABTI_barrier *p_barrier = ABTI_barrier_get_ptr(h_barrier);
    ABTI_CHECK_NULL_BARRIER_PTR(p_barrier);
 
    /* The lock needs to be acquired to safely free the barrier structure.
     * However, we do not have to unlock it because the entire structure is
     * freed here. */
    ABTD_spinlock_acquire(&p_barrier->lock);
 
    /* p_barrier->counter must be checked after taking a lock. */
    ABTI_UB_ASSERT(p_barrier->counter == 0);
 
    ABTU_free(p_barrier);
 
    /* Return value */
    *barrier = ABT_BARRIER_NULL;
    return ABT_SUCCESS;
}
 
int ABT_barrier_wait(ABT_barrier barrier)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_barrier *p_barrier = ABTI_barrier_get_ptr(barrier);
    ABTI_CHECK_NULL_BARRIER_PTR(p_barrier);
 
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Calling a barrier on a tasklet is not allowed. */
    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_BARRIER);
    }
#endif
 
    ABTD_spinlock_acquire(&p_barrier->lock);
 
    ABTI_ASSERT(p_barrier->counter < p_barrier->num_waiters);
    p_barrier->counter++;
 
    /* If we do not have all the waiters yet */
    if (p_barrier->counter < p_barrier->num_waiters) {
        ABTI_waitlist_wait_and_unlock(&p_local, &p_barrier->waitlist,
                                      &p_barrier->lock,
                                      ABT_SYNC_EVENT_TYPE_BARRIER,
                                      (void *)p_barrier);
    } else {
        ABTI_waitlist_broadcast(p_local, &p_barrier->waitlist);
        /* Reset counter */
        p_barrier->counter = 0;
        ABTD_spinlock_release(&p_barrier->lock);
    }
    return ABT_SUCCESS;
}
 
int ABT_barrier_get_num_waiters(ABT_barrier barrier, uint32_t *num_waiters)
{
    ABTI_UB_ASSERT(ABTI_initialized());
    ABTI_UB_ASSERT(num_waiters);
 
    ABTI_barrier *p_barrier = ABTI_barrier_get_ptr(barrier);
    ABTI_CHECK_NULL_BARRIER_PTR(p_barrier);
 
    *num_waiters = p_barrier->num_waiters;
    return ABT_SUCCESS;
}