sched.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"

#ifdef ABT_CONFIG_USE_DEBUG_LOG
static inline uint64_t ABTI_sched_get_new_id(void);
#endif

int ABT_sched_create(ABT_sched_def *def, int num_pools, ABT_pool *pools,
                     ABT_sched_config config, ABT_sched *newsched)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched *p_sched;

    ABTI_CHECK_TRUE(newsched != NULL, ABT_ERR_SCHED);
    /* TODO: the default value of automatic is different from
     * ABT_sched_create_basic(). Make it consistent. */
    const ABT_bool def_automatic = ABT_FALSE;
    abt_errno = ABTI_sched_create(def, num_pools, pools, config, def_automatic,
                                  &p_sched);
    ABTI_CHECK_ERROR(abt_errno);

    /* Return value */
    *newsched = ABTI_sched_get_handle(p_sched);

fn_exit:
    return abt_errno;

fn_fail:
    *newsched = ABT_SCHED_NULL;
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_create_basic(ABT_sched_predef predef, int num_pools,
                           ABT_pool *pools, ABT_sched_config config,
                           ABT_sched *newsched)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched *p_newsched;
    abt_errno =
        ABTI_sched_create_basic(predef, num_pools, pools, config, &p_newsched);
    ABTI_CHECK_ERROR(abt_errno);
    *newsched = ABTI_sched_get_handle(p_newsched);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    *newsched = ABT_SCHED_NULL;
    goto fn_exit;
}

int ABT_sched_free(ABT_sched *sched)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_local *p_local = ABTI_local_get_local();
    ABTI_sched *p_sched = ABTI_sched_get_ptr(*sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    /* Free the scheduler */
    abt_errno = ABTI_sched_free(p_local, p_sched);
    ABTI_CHECK_ERROR(abt_errno);

    /* Return value */
    *sched = ABT_SCHED_NULL;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_get_num_pools(ABT_sched sched, int *num_pools)
{
    int abt_errno = ABT_SUCCESS;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    *num_pools = p_sched->num_pools;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_get_pools(ABT_sched sched, int max_pools, int idx,
                        ABT_pool *pools)
{
    int abt_errno = ABT_SUCCESS;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    ABTI_CHECK_TRUE(idx + max_pools <= p_sched->num_pools, ABT_ERR_SCHED);

    int p;
    for (p = idx; p < idx + max_pools; p++) {
        pools[p - idx] = p_sched->pools[p];
    }

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_finish(ABT_sched sched)
{
    int abt_errno = ABT_SUCCESS;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    ABTI_sched_finish(p_sched);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_exit(ABT_sched sched)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    ABTI_sched_exit(p_sched);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_has_to_stop(ABT_sched sched, ABT_bool *stop)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_local *p_local = ABTI_local_get_local();

    *stop = ABT_FALSE;

    /* When this routine is called by an external thread, e.g., pthread */
    if (p_local == NULL) {
        abt_errno = ABT_ERR_INV_XSTREAM;
        goto fn_exit;
    }

    ABTI_xstream *p_xstream = p_local->p_xstream;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    *stop = ABTI_sched_has_to_stop(&p_local, p_sched, p_xstream);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

ABT_bool ABTI_sched_has_to_stop(ABTI_local **pp_local, ABTI_sched *p_sched,
                                ABTI_xstream *p_xstream)
{
    ABT_bool stop = ABT_FALSE;
    size_t size;

    /* Check exit request */
    if (ABTD_atomic_acquire_load_uint32(&p_sched->request) &
        ABTI_SCHED_REQ_EXIT) {
        ABTI_spinlock_acquire(&p_xstream->sched_lock);
        p_sched->state = ABT_SCHED_STATE_TERMINATED;
        stop = ABT_TRUE;
        goto fn_exit;
    }

    size = ABTI_sched_get_effective_size(*pp_local, p_sched);
    if (size == 0) {
        if (ABTD_atomic_acquire_load_uint32(&p_sched->request) &
            ABTI_SCHED_REQ_FINISH) {
            /* Check join request */
            /* We need to lock in case someone wants to migrate to this
             * scheduler */
            ABTI_spinlock_acquire(&p_xstream->sched_lock);
            size = ABTI_sched_get_effective_size(*pp_local, p_sched);
            if (size == 0) {
                p_sched->state = ABT_SCHED_STATE_TERMINATED;
                stop = ABT_TRUE;
            } else {
                ABTI_spinlock_release(&p_xstream->sched_lock);
            }
        } else if (p_sched->used == ABTI_SCHED_IN_POOL) {
            /* If the scheduler is a stacked one, we have to escape from the
             * scheduling function. The scheduler will be stopped if it is a
             * tasklet type. However, if the scheduler is a ULT type, we
             * context switch to the parent scheduler. */
            if (p_sched->type == ABT_SCHED_TYPE_TASK) {
                p_sched->state = ABT_SCHED_STATE_TERMINATED;
                stop = ABT_TRUE;
            } else {
                ABTI_ASSERT(p_sched->type == ABT_SCHED_TYPE_ULT);
                ABTI_sched *p_par_sched;
                p_par_sched = ABTI_xstream_get_parent_sched(p_xstream);
                ABTI_thread_context_switch_sched_to_sched(pp_local, p_sched,
                                                          p_par_sched);
            }
        }
    }

fn_exit:
    return stop;
}

int ABT_sched_set_data(ABT_sched sched, void *data)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);
    p_sched->data = data;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_get_data(ABT_sched sched, void **data)
{
    int abt_errno = ABT_SUCCESS;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    *data = p_sched->data;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_get_size(ABT_sched sched, size_t *size)
{
    int abt_errno = ABT_SUCCESS;
    size_t pool_size = 0;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    pool_size = ABTI_sched_get_size(p_sched);

fn_exit:
    *size = pool_size;
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

size_t ABTI_sched_get_size(ABTI_sched *p_sched)
{
    size_t pool_size = 0;
    int p;

    for (p = 0; p < p_sched->num_pools; p++) {
        ABTI_pool *p_pool = ABTI_pool_get_ptr(p_sched->pools[p]);
        pool_size += ABTI_pool_get_size(p_pool);
    }

    return pool_size;
}

int ABT_sched_get_total_size(ABT_sched sched, size_t *size)
{
    int abt_errno = ABT_SUCCESS;
    size_t pool_size = 0;

    ABTI_sched *p_sched = ABTI_sched_get_ptr(sched);
    ABTI_CHECK_NULL_SCHED_PTR(p_sched);

    pool_size = ABTI_sched_get_total_size(p_sched);

fn_exit:
    *size = pool_size;
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

size_t ABTI_sched_get_total_size(ABTI_sched *p_sched)
{
    size_t pool_size = 0;
    int p;

    for (p = 0; p < p_sched->num_pools; p++) {
        ABTI_pool *p_pool = ABTI_pool_get_ptr(p_sched->pools[p]);
        pool_size += ABTI_pool_get_total_size(p_pool);
    }

    return pool_size;
}

/* Compared to \c ABTI_sched_get_total_size, ABTI_sched_get_effective_size does
 * not count the number of blocked ULTs if a pool has more than one consumer or
 * the caller ES is not the latest consumer. This is necessary when the ES
 * associated with the target scheduler has to be joined and the pool is shared
 * between different schedulers associated with different ESs. */
size_t ABTI_sched_get_effective_size(ABTI_local *p_local, ABTI_sched *p_sched)
{
    size_t pool_size = 0;
    int p;

#ifndef ABT_CONFIG_DISABLE_POOL_CONSUMER_CHECK
    ABTI_native_thread_id self_id = ABTI_self_get_native_thread_id(p_local);
#endif

    for (p = 0; p < p_sched->num_pools; p++) {
        ABT_pool pool = p_sched->pools[p];
        ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
        pool_size += ABTI_pool_get_size(p_pool);
        pool_size += ABTD_atomic_acquire_load_int32(&p_pool->num_migrations);
        switch (p_pool->access) {
            case ABT_POOL_ACCESS_PRIV:
                pool_size +=
                    ABTD_atomic_acquire_load_int32(&p_pool->num_blocked);
                break;
            case ABT_POOL_ACCESS_SPSC:
            case ABT_POOL_ACCESS_MPSC:
            case ABT_POOL_ACCESS_SPMC:
            case ABT_POOL_ACCESS_MPMC:
#ifdef ABT_CONFIG_DISABLE_POOL_CONSUMER_CHECK
                if (ABTD_atomic_acquire_load_int32(&p_pool->num_scheds) == 1) {
                    pool_size +=
                        ABTD_atomic_acquire_load_int32(&p_pool->num_blocked);
                }
#else
                if (ABTD_atomic_acquire_load_int32(&p_pool->num_scheds) == 1 &&
                    p_pool->consumer_id == self_id) {
                    pool_size +=
                        ABTD_atomic_acquire_load_int32(&p_pool->num_blocked);
                }
#endif
                break;
            default:
                break;
        }
    }

    return pool_size;
}

/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/

void ABTI_sched_finish(ABTI_sched *p_sched)
{
    ABTI_sched_set_request(p_sched, ABTI_SCHED_REQ_FINISH);
}

void ABTI_sched_exit(ABTI_sched *p_sched)
{
    ABTI_sched_set_request(p_sched, ABTI_SCHED_REQ_EXIT);
}

int ABTI_sched_create(ABT_sched_def *def, int num_pools, ABT_pool *pools,
                      ABT_sched_config config, ABT_bool automatic,
                      ABTI_sched **pp_newsched)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched *p_sched;
    int p;

    p_sched = (ABTI_sched *)ABTU_malloc(sizeof(ABTI_sched));

    /* Copy of the contents of pools */
    ABT_pool *pool_list;
    pool_list = (ABT_pool *)ABTU_malloc(num_pools * sizeof(ABT_pool));
    for (p = 0; p < num_pools; p++) {
        if (pools[p] == ABT_POOL_NULL) {
            ABTI_pool *p_newpool;
            abt_errno =
                ABTI_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPSC,
                                       ABT_TRUE, &p_newpool);
            ABTI_CHECK_ERROR(abt_errno);
            pool_list[p] = ABTI_pool_get_handle(p_newpool);
        } else {
            pool_list[p] = pools[p];
        }
    }

    /* Check if the pools are available */
    for (p = 0; p < num_pools; p++) {
        ABTI_pool_retain(ABTI_pool_get_ptr(pool_list[p]));
    }

    p_sched->used = ABTI_SCHED_NOT_USED;
    p_sched->automatic = automatic;
    p_sched->kind = ABTI_sched_get_kind(def);
    p_sched->state = ABT_SCHED_STATE_READY;
    ABTD_atomic_relaxed_store_uint32(&p_sched->request, 0);
    p_sched->pools = pool_list;
    p_sched->num_pools = num_pools;
    p_sched->type = def->type;
    p_sched->p_thread = NULL;
    p_sched->p_task = NULL;
    p_sched->p_ctx = NULL;

    p_sched->init = def->init;
    p_sched->run = def->run;
    p_sched->free = def->free;
    p_sched->get_migr_pool = def->get_migr_pool;

#ifdef ABT_CONFIG_USE_DEBUG_LOG
    p_sched->id = ABTI_sched_get_new_id();
#endif
    LOG_EVENT("[S%" PRIu64 "] created\n", p_sched->id);

    /* Return value */
    ABT_sched newsched = ABTI_sched_get_handle(p_sched);

    /* Specific initialization */
    p_sched->init(newsched, config);
    *pp_newsched = p_sched;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABTI_sched_create_basic(ABT_sched_predef predef, int num_pools,
                            ABT_pool *pools, ABT_sched_config config,
                            ABTI_sched **pp_newsched)
{
    int abt_errno = ABT_SUCCESS;
    ABT_pool_access access;
    ABT_pool_kind kind = ABT_POOL_FIFO;
    ABT_bool automatic;

    /* We set the access to the default one */
    access = ABT_POOL_ACCESS_MPSC;
    /* TODO: the default value is different from ABT_sched_create().
     * Make it consistent. */
    automatic = ABT_TRUE;
    /* We read the config and set the configured parameters */
    abt_errno = ABTI_sched_config_read_global(config, &access, &automatic);
    ABTI_CHECK_ERROR(abt_errno);

    /* A pool array is provided, predef has to be compatible */
    if (pools != NULL) {
        /* Copy of the contents of pools */
        ABT_pool *pool_list;
        pool_list = (ABT_pool *)ABTU_malloc(num_pools * sizeof(ABT_pool));
        int p;
        for (p = 0; p < num_pools; p++) {
            if (pools[p] == ABT_POOL_NULL) {
                ABTI_pool *p_newpool;
                abt_errno = ABTI_pool_create_basic(ABT_POOL_FIFO, access,
                                                   ABT_TRUE, &p_newpool);
                ABTI_CHECK_ERROR(abt_errno);
                pool_list[p] = ABTI_pool_get_handle(p_newpool);
            } else {
                pool_list[p] = pools[p];
            }
        }

        /* Creation of the scheduler */
        switch (predef) {
            case ABT_SCHED_DEFAULT:
            case ABT_SCHED_BASIC:
                abt_errno =
                    ABTI_sched_create(ABTI_sched_get_basic_def(), num_pools,
                                      pool_list, ABT_SCHED_CONFIG_NULL,
                                      automatic, pp_newsched);
                break;
            case ABT_SCHED_BASIC_WAIT:
                abt_errno = ABTI_sched_create(ABTI_sched_get_basic_wait_def(),
                                              num_pools, pool_list,
                                              ABT_SCHED_CONFIG_NULL, automatic,
                                              pp_newsched);
                break;
            case ABT_SCHED_PRIO:
                abt_errno =
                    ABTI_sched_create(ABTI_sched_get_prio_def(), num_pools,
                                      pool_list, ABT_SCHED_CONFIG_NULL,
                                      automatic, pp_newsched);
                break;
            case ABT_SCHED_RANDWS:
                abt_errno =
                    ABTI_sched_create(ABTI_sched_get_randws_def(), num_pools,
                                      pool_list, ABT_SCHED_CONFIG_NULL,
                                      automatic, pp_newsched);
                break;
            default:
                abt_errno = ABT_ERR_INV_SCHED_PREDEF;
                break;
        }
        ABTI_CHECK_ERROR(abt_errno);
        ABTU_free(pool_list);
    }

    /* No pool array is provided, predef has to be compatible */
    else {
        /* Set the number of pools */
        switch (predef) {
            case ABT_SCHED_DEFAULT:
            case ABT_SCHED_BASIC:
                num_pools = 1;
                break;
            case ABT_SCHED_BASIC_WAIT:
                /* FIFO_WAIT is default pool for use with BASIC_WAIT sched */
                kind = ABT_POOL_FIFO_WAIT;
                num_pools = 1;
                break;
            case ABT_SCHED_PRIO:
                num_pools = ABTI_SCHED_NUM_PRIO;
                break;
            case ABT_SCHED_RANDWS:
                num_pools = 1;
                break;
            default:
                abt_errno = ABT_ERR_INV_SCHED_PREDEF;
                ABTI_CHECK_ERROR(abt_errno);
                break;
        }

        /* Creation of the pools */
        /* To avoid the malloc overhead, we use a stack array. */
        ABT_pool pool_list[ABTI_SCHED_NUM_PRIO];
        int p;
        for (p = 0; p < num_pools; p++) {
            ABTI_pool *p_newpool;
            abt_errno =
                ABTI_pool_create_basic(kind, access, ABT_TRUE, &p_newpool);
            ABTI_CHECK_ERROR(abt_errno);
            pool_list[p] = ABTI_pool_get_handle(p_newpool);
        }

        /* Creation of the scheduler */
        switch (predef) {
            case ABT_SCHED_DEFAULT:
            case ABT_SCHED_BASIC:
                abt_errno = ABTI_sched_create(ABTI_sched_get_basic_def(),
                                              num_pools, pool_list, config,
                                              automatic, pp_newsched);
                break;
            case ABT_SCHED_BASIC_WAIT:
                abt_errno = ABTI_sched_create(ABTI_sched_get_basic_wait_def(),
                                              num_pools, pool_list, config,
                                              automatic, pp_newsched);
                break;
            case ABT_SCHED_PRIO:
                abt_errno = ABTI_sched_create(ABTI_sched_get_prio_def(),
                                              num_pools, pool_list, config,
                                              automatic, pp_newsched);
                break;
            case ABT_SCHED_RANDWS:
                abt_errno = ABTI_sched_create(ABTI_sched_get_randws_def(),
                                              num_pools, pool_list, config,
                                              automatic, pp_newsched);
                break;
            default:
                abt_errno = ABT_ERR_INV_SCHED_PREDEF;
                ABTI_CHECK_ERROR(abt_errno);
                break;
        }
    }
    ABTI_CHECK_ERROR(abt_errno);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABTI_sched_free(ABTI_local *p_local, ABTI_sched *p_sched)
{
    int abt_errno = ABT_SUCCESS;
    int p;

    /* If sched is currently used, free is not allowed. */
    if (p_sched->used != ABTI_SCHED_NOT_USED) {
        abt_errno = ABT_ERR_SCHED;
        goto fn_fail;
    }

    /* If sched is a default provided one, it should free its pool here.
     * Otherwise, freeing the pool is the user's responsibility. */
    for (p = 0; p < p_sched->num_pools; p++) {
        ABTI_pool *p_pool = ABTI_pool_get_ptr(p_sched->pools[p]);
        int32_t num_scheds = ABTI_pool_release(p_pool);
        if (p_pool->automatic == ABT_TRUE && num_scheds == 0) {
            ABTI_CHECK_NULL_POOL_PTR(p_pool);
            ABTI_pool_free(p_pool);
        }
    }
    ABTU_free(p_sched->pools);

    /* Free the associated work unit */
    if (p_sched->type == ABT_SCHED_TYPE_ULT) {
        if (p_sched->p_thread) {
            if (p_sched->p_thread->type == ABTI_THREAD_TYPE_MAIN_SCHED) {
                ABTI_thread_free_main_sched(p_local, p_sched->p_thread);
            } else {
                ABTI_thread_free(p_local, p_sched->p_thread);
            }
        }
    } else if (p_sched->type == ABT_SCHED_TYPE_TASK) {
        if (p_sched->p_task) {
            ABTI_task_free(p_local, p_sched->p_task);
        }
    }

    LOG_EVENT("[S%" PRIu64 "] freed\n", p_sched->id);

    p_sched->free(ABTI_sched_get_handle(p_sched));
    p_sched->data = NULL;

    ABTU_free(p_sched);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

/* Get the pool suitable for receiving a migrating ULT */
int ABTI_sched_get_migration_pool(ABTI_sched *p_sched, ABTI_pool *source_pool,
                                  ABTI_pool **pp_pool)
{
    int abt_errno = ABT_SUCCESS;
    ABT_sched sched = ABTI_sched_get_handle(p_sched);
    ABTI_pool *p_pool;

    ABTI_CHECK_TRUE(p_sched->state != ABT_SCHED_STATE_TERMINATED,
                    ABT_ERR_INV_SCHED);

    /* Find a pool */
    /* If get_migr_pool is not defined, we pick the first pool */
    if (p_sched->get_migr_pool == NULL) {
        if (p_sched->num_pools == 0)
            p_pool = NULL;
        else
            p_pool = ABTI_pool_get_ptr(p_sched->pools[0]);
    } else
        p_pool = ABTI_pool_get_ptr(p_sched->get_migr_pool(sched));

    /* Check the pool */
    if (ABTI_pool_accept_migration(p_pool, source_pool) == ABT_TRUE) {
        *pp_pool = p_pool;
    } else {
        ABTI_CHECK_TRUE(0, ABT_ERR_INV_POOL_ACCESS);
    }

fn_exit:
    return abt_errno;

fn_fail:
    *pp_pool = NULL;
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

ABTI_sched_kind ABTI_sched_get_kind(ABT_sched_def *def)
{
    return (ABTI_sched_kind)def;
}

void ABTI_sched_print(ABTI_sched *p_sched, FILE *p_os, int indent,
                      ABT_bool print_sub)
{
    char *prefix = ABTU_get_indent_str(indent);

    if (p_sched == NULL) {
        fprintf(p_os, "%s== NULL SCHED ==\n", prefix);
        goto fn_exit;
    }

    ABTI_sched_kind kind;
    char *kind_str, *type, *state, *used;
    char *pools_str;
    int i;
    size_t size, pos;

    kind = p_sched->kind;
    if (kind == ABTI_sched_get_kind(ABTI_sched_get_basic_def())) {
        kind_str = "BASIC";
    } else if (kind == ABTI_sched_get_kind(ABTI_sched_get_basic_wait_def())) {
        kind_str = "BASIC_WAIT";
    } else if (kind == ABTI_sched_get_kind(ABTI_sched_get_prio_def())) {
        kind_str = "PRIO";
    } else {
        kind_str = "USER";
    }

    switch (p_sched->type) {
        case ABT_SCHED_TYPE_ULT:
            type = "ULT";
            break;
        case ABT_SCHED_TYPE_TASK:
            type = "TASKLET";
            break;
        default:
            type = "UNKNOWN";
            break;
    }
    switch (p_sched->state) {
        case ABT_SCHED_STATE_READY:
            state = "READY";
            break;
        case ABT_SCHED_STATE_RUNNING:
            state = "RUNNING";
            break;
        case ABT_SCHED_STATE_STOPPED:
            state = "STOPPED";
            break;
        case ABT_SCHED_STATE_TERMINATED:
            state = "TERMINATED";
            break;
        default:
            state = "UNKNOWN";
            break;
    }
    switch (p_sched->used) {
        case ABTI_SCHED_NOT_USED:
            used = "NOT_USED";
            break;
        case ABTI_SCHED_MAIN:
            used = "MAIN";
            break;
        case ABTI_SCHED_IN_POOL:
            used = "IN_POOL";
            break;
        default:
            used = "UNKNOWN";
            break;
    }

    size = sizeof(char) * (p_sched->num_pools * 20 + 4);
    pools_str = (char *)ABTU_calloc(size, 1);
    pools_str[0] = '[';
    pools_str[1] = ' ';
    pos = 2;
    for (i = 0; i < p_sched->num_pools; i++) {
        ABTI_pool *p_pool = ABTI_pool_get_ptr(p_sched->pools[i]);
        sprintf(&pools_str[pos], "%p ", (void *)p_pool);
        pos = strlen(pools_str);
    }
    pools_str[pos] = ']';

    fprintf(p_os,
            "%s== SCHED (%p) ==\n"
#ifdef ABT_CONFIG_USE_DEBUG_LOG
            "%sid       : %" PRIu64 "\n"
#endif
            "%skind     : %" PRIxPTR " (%s)\n"
            "%stype     : %s\n"
            "%sstate    : %s\n"
            "%sused     : %s\n"
            "%sautomatic: %s\n"
            "%srequest  : 0x%x\n"
            "%snum_pools: %d\n"
            "%spools    : %s\n"
            "%ssize     : %zu\n"
            "%stot_size : %zu\n"
            "%sdata     : %p\n",
            prefix, (void *)p_sched,
#ifdef ABT_CONFIG_USE_DEBUG_LOG
            prefix, p_sched->id,
#endif
            prefix, p_sched->kind, kind_str, prefix, type, prefix, state,
            prefix, used, prefix,
            (p_sched->automatic == ABT_TRUE) ? "TRUE" : "FALSE", prefix,
            ABTD_atomic_acquire_load_uint32(&p_sched->request), prefix,
            p_sched->num_pools, prefix, pools_str, prefix,
            ABTI_sched_get_size(p_sched), prefix,
            ABTI_sched_get_total_size(p_sched), prefix, p_sched->data);
    ABTU_free(pools_str);

    if (print_sub == ABT_TRUE) {
        for (i = 0; i < p_sched->num_pools; i++) {
            ABTI_pool *p_pool = ABTI_pool_get_ptr(p_sched->pools[i]);
            ABTI_pool_print(p_pool, p_os, indent + 2);
        }
    }

fn_exit:
    fflush(p_os);
    ABTU_free(prefix);
}

static ABTD_atomic_uint64 g_sched_id = ABTD_ATOMIC_UINT64_STATIC_INITIALIZER(0);
void ABTI_sched_reset_id(void)
{
    ABTD_atomic_relaxed_store_uint64(&g_sched_id, 0);
}

/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/

#ifdef ABT_CONFIG_USE_DEBUG_LOG
static inline uint64_t ABTI_sched_get_new_id(void)
{
    return ABTD_atomic_fetch_add_uint64(&g_sched_id, 1);
}
#endif